int get_connections(HWND hDlg, TCP_RECEIVEOBJ * st)
{
char writebuf[100],szdata[100];
char readbuf[readbuflength];
int result,x;
st->clear_buffer();
strcpy(writebuf,"status\n");
result = SDLNet_TCP_Send(st->sock, writebuf, strlen(writebuf));
add_to_listbox(hDlg,IDC_LIST, "sending:STATUS");
st->read_tcp(readbuf, sizeof(readbuf)-1);
x=get_int(readbuf,0,&result);
if (result!=200) { add_to_listbox(hDlg,IDC_LIST,"Could not get Status.");return(FALSE);}
add_to_listbox(hDlg,IDC_LIST, "OK");
x=get_int(readbuf,x,&result);
SendDlgItemMessage(hDlg,IDC_SELECTCOMBO,CB_RESETCONTENT,0,0);
while (readbuf[x])
{
x=get_int(readbuf,x,&result);
if (readbuf[x])
{
int pos;
sprintf(szdata,"%d",result);
pos=strlen(szdata);
while ((readbuf[x])&&(readbuf[x]!=10)&&(readbuf[x]!=13)) szdata[pos++]=readbuf[x++];
szdata[pos]=0;
if (strstr(szdata,"EEG"))
{
SendDlgItemMessage(hDlg,IDC_SELECTCOMBO,CB_ADDSTRING,0,(LPARAM) (LPSTR) szdata);
SendDlgItemMessage(hDlg,IDC_SELECTCOMBO,CB_SETITEMDATA,
(WPARAM) SendDlgItemMessage(hDlg,IDC_SELECTCOMBO,CB_GETCOUNT,0,0)-1,
(LPARAM) result) ;
}
}
}
if (SendDlgItemMessage(hDlg,IDC_SELECTCOMBO,CB_GETCOUNT,0,0)>0)
{
SetDlgItemText(hDlg, IDC_SELECTCOMBO, "select Stream");
EnableWindow(GetDlgItem(hDlg, IDC_SELECTCOMBO), TRUE);
}
else
{
SetDlgItemText(hDlg, IDC_SELECTCOMBO, "no Stream available");
EnableWindow(GetDlgItem(hDlg, IDC_SELECTCOMBO), FALSE);
}
return(TRUE);
}
void EDF_READEROBJ::session_stop(void)
{
if (edffile!=INVALID_HANDLE_VALUE) state=1; else state=0;
if (hDlg==ghWndToolbox)
{
update_state(hDlg,state);
add_to_listbox(hDlg,IDC_LIST, "File-Read paused");
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE);
}
}
void EDF_READEROBJ::work(void)
{
int x;
// short actval;
double actval;
char szdata[100];
double fact;
DWORD dwRead;
if ((outports==0)||(state!=2)||(edffile==INVALID_HANDLE_VALUE)) return;
if ((TIMING.packetcounter<offset)||(TIMING.packetcounter>sessionlength)) return;
if (sampos<header.samplespersegment-1)
{
for (x=0; x<outports; x++)
{
actval=channel[x].buffer[sampos];
if (channel[x].samples==1) actval=channel[x].buffer[0];
fact=(channel[x].physmax-channel[x].physmin)/(double)(channel[x].digmax-channel[x].digmin);
actval-=channel[x].digmin;
// actval=(int)(actval*fact);
actval=actval*fact;
pass_values(x,(float)actval+channel[x].physmin);
}
sampos++;
packetcount++;
if (((int)(packetcount/1000))*1000==packetcount)
{
sprintf(szdata,"%d Packets read\n",packetcount);
if (hDlg==ghWndToolbox)
add_to_listbox(hDlg,IDC_LIST, szdata);
}
}
else
{
sampos=0;
for (x=0; x<outports; x++)
{
ReadFile(edffile,channel[x].buffer,(DWORD)(2*channel[x].samples),&dwRead,NULL);
if (dwRead<(DWORD)2*channel[x].samples)
{
// session_pos(0);
packetcount=0;
sampos=header.samplespersegment;
x=outports;
}
}
}
}
void EDF_READEROBJ::session_start(void)
{
if ((edffile!=INVALID_HANDLE_VALUE)&&(outports>0))
{
state=2;
if (hDlg==ghWndToolbox)
{
update_state(hDlg,state);
add_to_listbox(hDlg,IDC_LIST, "File-Read started.");
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), FALSE);
}
}
}
void update_state(HWND hDlg, int state)
{
switch (state)
{
case 0:
add_to_listbox(hDlg,IDC_LIST, "No File opened.");
EnableWindow(GetDlgItem(hDlg, IDC_SELECT), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), FALSE);
break;
case 1:
add_to_listbox(hDlg,IDC_LIST, " File Open.");
EnableWindow(GetDlgItem(hDlg, IDC_SELECT), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE);
break;
case 2:
add_to_listbox(hDlg,IDC_LIST, "Reading Values from File.");
EnableWindow(GetDlgItem(hDlg, IDC_SELECT), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE);
break;
}
}
void EDF_READEROBJ::session_reset(void)
{
if (edffile!=INVALID_HANDLE_VALUE)
{
state=1;
SetFilePointer(edffile,256+header.channels*256,NULL,FILE_BEGIN);
if (hDlg==ghWndToolbox)
{
update_state(hDlg,state);
add_to_listbox(hDlg,IDC_LIST, "File-Read stopped");
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE);
}
} else state=0;
}
void TCP_RECEIVEOBJ::work(void)
{
int x;
if ((outports==0)||(watching==FALSE)) return;
if (watch_tcp(watchbuf,sizeof(watchbuf))==TCP_ERROR)
{ if (hDlg==ghWndToolbox) add_to_listbox(hDlg,IDC_LIST, "--WATCH-ERROR---");
}
if (bufend!=bufstart)
{
for (x=0;x<outports;x++)
pass_values(x,(float)channel[x].buffer[bufstart]);
if (++bufstart>=samplebuflen) bufstart=0;
//bufstart=bufend;
}
if ((!TIMING.dialog_update) && (hDlg==ghWndToolbox))
{
SetDlgItemInt(hDlg, IDC_STATUS, syncloss, 0);
}
}
LRESULT CALLBACK EdfReaderDlgHandler( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam )
{
EDF_READEROBJ * st;
int x;
static int actchn;
char strfloat[21];
st = (EDF_READEROBJ *) actobject;
if ((st==NULL)||(st->type!=OB_EDF_READER)) return(FALSE);
switch( message )
{
case WM_INITDIALOG:
actchn=0;
update_header(hDlg,&st->header);
update_channelcombo(hDlg, st->channel, st->header.channels);
update_channel(hDlg,st->channel,actchn);
update_state(hDlg,st->state);
sprintf(strfloat,"%.2f",(float)st->offset/(float)PACKETSPERSECOND);
SetDlgItemText(hDlg,IDC_OFFSET,strfloat);
if (st->edffile!=INVALID_HANDLE_VALUE)
SetDlgItemText(hDlg, IDC_EDFFILE, st->filename);
else
SetDlgItemText(hDlg, IDC_EDFFILE, "none");
return TRUE;
case WM_CLOSE:
EndDialog(hDlg, LOWORD(wParam));
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_SELECT:
st->filename[0]=0;
if ((st->edffile=open_edf_file(&st->header,st->channel,st->filename))==INVALID_HANDLE_VALUE) st->state=0;
else if (st->header.channels==0)
{
SendMessage(hDlg,WM_COMMAND,IDC_CLOSE,0);
report("EDF-File contained no channel inforamtion, file closed.");
st->state=0;
}
else st->state=1;
update_state(hDlg,st->state);
if (!st->state) break;
st->calc_session_length();
get_session_length();
//set_session_pos(0);
st->session_pos(0);
st->packetcount=0;
st->sampos=0;
if (st->outports!=st->header.channels)
{
for (x=0;x<MAX_CONNECTS;x++)
{
st->out[x].from_port=-1;
st->out[x].to_port=-1;
st->out[x].to_object=-1;
}
for (x=0;x<MAX_PORTS;x++)
st->out_ports[x].out_name[0]=0;
}
st->outports=st->header.channels;
st->height=CON_START+st->outports*CON_HEIGHT+5;
update_header(hDlg,&st->header);
update_channelcombo(hDlg, st->channel, st->header.channels);
update_channel(hDlg,st->channel,actchn);
st->get_captions();
update_dimensions();
SetDlgItemText(hDlg, IDC_EDFFILE, st->filename);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_SELECT), FALSE);
InvalidateRect(ghWndDesign,NULL,TRUE);
break;
case IDC_CLOSE:
st->state=0;
update_state(hDlg,st->state);
SetDlgItemText(hDlg, IDC_EDFFILE, "none");
add_to_listbox(hDlg,IDC_LIST, "file closed.");
strcpy(st->filename,"none");
if (st->edffile==INVALID_HANDLE_VALUE) break;
CloseHandle(st->edffile);
st->edffile=INVALID_HANDLE_VALUE;
get_session_length();
InvalidateRect(ghWndDesign,NULL,TRUE);
break;
case IDC_APPLYOFFSET:
GetDlgItemText(hDlg, IDC_OFFSET, strfloat, 20);
st->offset = (int)((float)atof(strfloat) * (float) PACKETSPERSECOND);
st->calc_session_length();
get_session_length();
break;
case IDC_CHANNELCOMBO:
if (HIWORD(wParam)==CBN_SELCHANGE)
{
get_channel(hDlg, st->channel, actchn);
actchn=SendMessage(GetDlgItem(hDlg, IDC_CHANNELCOMBO), CB_GETCURSEL , 0, 0);
update_channel(hDlg, st->channel,actchn);
}
break;
}
return TRUE;
case WM_SIZE:
case WM_MOVE: update_toolbox_position(hDlg);
break;
return TRUE;
}
return FALSE;
}
LRESULT CALLBACK TcpReceiveDlgHandler( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam )
{
TCP_RECEIVEOBJ * st;
char writebuf[100],szdata[100];
char readbuf[readbuflength];
int result;
static int actchn;
st = (TCP_RECEIVEOBJ *) actobject;
if ((st==NULL)||(st->type!=OB_TCP_RECEIVER)) return(FALSE);
switch( message )
{
case WM_INITDIALOG:
SetDlgItemText(hDlg, IDC_HOST, st->host);
EnableWindow(GetDlgItem(hDlg, IDC_SELECTCOMBO), FALSE);
actchn=0;
update_header(hDlg,&st->header);
update_channelcombo(hDlg, st->channel, st->header.channels);
update_channel(hDlg,st->channel,actchn);
if (st->sock)
{
char actsession[30];
EnableWindow(GetDlgItem(hDlg, IDC_CONNECT), FALSE);
if (st->watching)
{
add_to_listbox(hDlg,IDC_LIST, "Watching Values from Server.");
EnableWindow(GetDlgItem(hDlg, IDC_WATCH), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_STOP), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), FALSE);
}
else
{
add_to_listbox(hDlg,IDC_LIST, "Socket connected.");
if (st->streamnum>=0) EnableWindow(GetDlgItem(hDlg, IDC_WATCH), TRUE);
else { EnableWindow(GetDlgItem(hDlg, IDC_WATCH), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_SELECTCOMBO), TRUE); }
EnableWindow(GetDlgItem(hDlg, IDC_STOP), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE);
get_connections(hDlg,st);
}
if (st->streamnum>=0)
{ sprintf(actsession,"%d:EEG",st->streamnum);
SetDlgItemText(hDlg, IDC_SELECTCOMBO, actsession);
}
}
else
{
add_to_listbox(hDlg,IDC_LIST, "No Socket connected.");
EnableWindow(GetDlgItem(hDlg, IDC_CONNECT), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_WATCH), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_STOP), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), FALSE);
}
return TRUE;
case WM_CLOSE:
EndDialog(hDlg, LOWORD(wParam));
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_CONNECT:
GetDlgItemText(hDlg, IDC_HOST, st->host, sizeof(st->host));
if ((strlen(st->host)<8)||(!st->connect()))
{
add_to_listbox(hDlg,IDC_LIST, "Could not connect to Server");
break;
}
SendDlgItemMessage(hDlg,IDC_LIST, LB_ADDSTRING, 0, (LPARAM) "Socket connection successful.");
strcpy(writebuf,"display\n");
result = SDLNet_TCP_Send(st->sock, writebuf, strlen(writebuf));
add_to_listbox(hDlg,IDC_LIST, "sending:DISPLAY");
st->read_tcp(readbuf, readbuflength);
strncpy(szdata,readbuf,6);szdata[6]=0;
if (strcmp(szdata,"200 OK")) { add_to_listbox(hDlg,IDC_LIST,"Could not select Display-mode"); break;}
add_to_listbox(hDlg,IDC_LIST, "OK");
if (!st->sock) { add_to_listbox(hDlg,IDC_LIST,"Socket not connected"); break;}
if (!get_connections(hDlg,st))
{
add_to_listbox(hDlg,IDC_LIST, "No Sessions available.");
st->reset();
InvalidateRect(ghWndMain,NULL,TRUE);
break;
}
EnableWindow(GetDlgItem(hDlg, IDC_CONNECT), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_STOP), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE);
break;
case IDC_SELECTCOMBO:
if (HIWORD(wParam)!=CBN_SELCHANGE) break;
if (!st->sock)
{
add_to_listbox(hDlg,IDC_LIST, "No Channels available.");
st->streamnum=-1;
st->out[0].from_port=-1;
st->outports=0;
break;
}
st->streamnum=SendDlgItemMessage(hDlg,IDC_SELECTCOMBO,CB_GETITEMDATA,
(WPARAM) SendDlgItemMessage(hDlg,IDC_SELECTCOMBO, CB_GETCURSEL , 0, 0), 0);
st->clear_buffer();
// SELECT SESSION
sprintf(writebuf,"getheader %d\n",st->streamnum);
result = SDLNet_TCP_Send(st->sock, writebuf, strlen(writebuf));
add_to_listbox(hDlg,IDC_LIST, "sending:GETHEADER");
st->read_tcp(readbuf, sizeof(readbuf)-1);
strncpy(szdata,readbuf,6); szdata[6]=0;
if (strcmp(szdata,"200 OK")) { add_to_listbox(hDlg,IDC_LIST,"Could not get EDF-header.");break;}
add_to_listbox(hDlg,IDC_LIST, "OK");
strcpy(st->edfheader,readbuf+8);
// report(st->edfheader);
EnableWindow(GetDlgItem(hDlg, IDC_SELECTCOMBO), FALSE);
st->syncloss=0;
add_to_listbox(hDlg,IDC_LIST, "Parsing Header");
parse_edf_header(&st->header,st->channel, st->edfheader);
add_to_listbox(hDlg,IDC_LIST, "clear OK");
st->outports=st->header.channels;
st->height=CON_START+st->outports*CON_HEIGHT+5;
st->get_captions();
update_header(hDlg,&st->header);
update_channelcombo(hDlg, st->channel, st->header.channels);
update_channel(hDlg,st->channel,actchn);
add_to_listbox(hDlg,IDC_LIST, "OK");
EnableWindow(GetDlgItem(hDlg, IDC_WATCH), TRUE);
InvalidateRect(ghWndDesign,NULL,TRUE);
break;
case IDC_WATCH:
if ((st->outports>0)&&(st->sock))
{
add_to_listbox(hDlg,IDC_LIST, "sending:WATCH");
st->clear_buffer();
st->syncloss=0;
result=st->start_watching();
if (result!=200) { add_to_listbox(hDlg,IDC_LIST,"Could not enter Watch-Mode"); break;}
add_to_listbox(hDlg,IDC_LIST, "OK");
EnableWindow(GetDlgItem(hDlg, IDC_WATCH), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), FALSE);
// EnableWindow(GetDlgItem(hDlg, IDC_SELECTCOMBO), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_STOP), TRUE);
if (!GLOBAL.running) start_timer();
} else add_to_listbox(hDlg,IDC_LIST, "No Channels available.");
break;
case IDC_EMPTY:
st->bufstart=st->bufend;
add_to_listbox(hDlg,IDC_LIST, "buffer cleared.");
break;
case IDC_STOP:
add_to_listbox(hDlg,IDC_LIST, "sending:UNWATCH");
st->unwatch();
EnableWindow(GetDlgItem(hDlg, IDC_WATCH), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_STOP), FALSE);
// EnableWindow(GetDlgItem(hDlg, IDC_SELECTCOMBO), TRUE);
break;
case IDC_CLOSE:
add_to_listbox(hDlg,IDC_LIST, "sending:CLOSE");
st->reset();
EnableWindow(GetDlgItem(hDlg, IDC_CONNECT), TRUE);
// EnableWindow(GetDlgItem(hDlg, IDC_SELECTCOMBO), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_WATCH), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_CLOSE), FALSE);
InvalidateRect(ghWndDesign,NULL,TRUE);
break;
case IDC_CHANNELCOMBO:
if (HIWORD(wParam)==CBN_SELCHANGE)
{
get_channel(hDlg, st->channel, actchn);
actchn=SendMessage(GetDlgItem(hDlg, IDC_CHANNELCOMBO), CB_GETCURSEL , 0, 0);
update_channel(hDlg, st->channel,actchn);
}
break;
}
return TRUE;
case WM_SIZE:
case WM_MOVE: update_toolbox_position(hDlg);
break;
return TRUE;
}
return FALSE;
}
int TCP_RECEIVEOBJ::watch_tcp(char * readbuf, int size)
{
int len,x,socks_ready,b,temp;
int stream,channels;
char szdata[200];
float fact;
readbuf[0]=0;
if ((socks_ready=SDLNet_CheckSockets(set, 0)) == -1)
{ cout << "TCP Check Socket error"; return(TCP_ERROR); }
if (SDLNet_SocketReady(sock))
{
if ((len = SDLNet_TCP_Recv(sock, readbuf, size)) <= 0) return(TCP_ERROR);
readbuf[len] = '\0';
len=0;
while (readbuf[len])
{
switch (state)
{
case 0: if (readbuf[len++]=='!') {state=1; ppos=0;}
break;
case 1: if ((readbuf[len]==10)||(readbuf[len]==13)) state=2;
else packet[ppos++]=readbuf[len];
len++;
break;
case 2: packetcount++;
if (++bufend>=samplebuflen) bufend=0;
if (bufend==bufstart)
{
if (hDlg==ghWndToolbox)
add_to_listbox(hDlg,IDC_LIST, "TCP-buffer overrun");
if (++bufstart>=samplebuflen) bufstart=0;
}
packet[ppos]=0;
ppos=get_int(packet,0,&stream);
ppos=get_int(packet,ppos,&temp);
packetnum++; if (packetnum==64) packetnum=0;
if (packetnum !=temp) {syncloss++; GLOBAL.syncloss++; packetnum=temp;}
ppos=get_int(packet,ppos,&channels);
if (channels==outports)
{
for (x=0;x<channels;x++)
{
ppos=get_int(packet,ppos,&b);
fact=(channel[x].physmax-channel[x].physmin)/(float)(channel[x].digmax-channel[x].digmin);
b-=channel[x].digmin;
channel[x].buffer[bufend]=(short)((float)b*fact+(float)channel[x].physmin);
}
}
else if (hDlg==ghWndToolbox)
add_to_listbox(hDlg,IDC_LIST, "channel count error");
if (((int)(packetcount/1000))*1000==packetcount)
{
int buflen;
if (bufstart<=bufend) buflen=bufend-bufstart; else buflen=bufend-bufstart+watchbuflength;
sprintf(szdata,"%d Packets read, the buffer holds %d Packets\n",packetcount, buflen);
//cout << szdata;
if (hDlg==ghWndToolbox)
add_to_listbox(hDlg,IDC_LIST, szdata);
}
state=0;
break;
default: state=0;
break;
}
}
}
return (TCP_OK);
}
