1 /*

     2     TUIO C++ Library - part of the reacTIVision project

     3     http://reactivision.sourceforge.net/

     4 

     5     Copyright (c) 2005-2008 Martin Kaltenbrunner <mkalten@iua.upf.edu>

     6 

     7     This program is free software; you can redistribute it and/or modify

     8     it under the terms of the GNU General Public License as published by

     9     the Free Software Foundation; either version 2 of the License, or

    10     (at your option) any later version.

    11 

    12     This program is distributed in the hope that it will be useful,

    13     but WITHOUT ANY WARRANTY; without even the implied warranty of

    14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15     GNU General Public License for more details.

    16 

    17     You should have received a copy of the GNU General Public License

    18     along with this program; if not, write to the Free Software

    19     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    20 */

    21 

    22 /*

    23     Modified by alexandre.bastien@iri.centrepompidou.fr to manage TUIO strings.

    24 */

    25 

    26 #include "TuioClient.h"

    27 

    28 #ifndef WIN32

    29 static void* ThreadFunc( void* obj )

    30 #else

    31 static DWORD WINAPI ThreadFunc( LPVOID obj )

    32 #endif

    33 {

    34     static_cast<TuioClient*>(obj)->socket->Run();

    35     return 0;

    36 };

    37 

    38 using namespace std;

    39     

    40 TuioClient::TuioClient() {

    41     TuioClient(3333);

    42 }

    43 

    44 TuioClient::TuioClient(int port) {

    45     try {

    46         socket = new UdpListeningReceiveSocket(IpEndpointName( IpEndpointName::ANY_ADDRESS, port ), this );

    47     } catch (std::exception &e) { 

    48         std::cout << "could not bind to UDP port " << port << std::endl;

    49         socket = NULL;

    50     }

    51     

    52     if (socket!=NULL) {

    53         if (!socket->IsBound()) {

    54             delete socket;

    55             socket = NULL;

    56         } else std::cout << "listening to TUIO messages on UDP port " << port << std::endl;

    57     }

    58 

    59     locked = false;

    60     running = false;

    61     currentFrame = lastFrame = maxFingerID = maxStringID = -1;

    62 }

    63 

    64 TuioClient::~TuioClient() {

    65     delete socket;

    66 }

    67 

    68 void TuioClient::ProcessBundle( const ReceivedBundle& b, const IpEndpointName& remoteEndpoint) {

    69     for( ReceivedBundle::const_iterator i = b.ElementsBegin(); i != b.ElementsEnd(); ++i ){

    70         if( i->IsBundle() )

    71             ProcessBundle( ReceivedBundle(*i), remoteEndpoint);

    72         else

    73             ProcessMessage( ReceivedMessage(*i), remoteEndpoint);

    74     }

    75 }

    76 

    77 void TuioClient::ProcessMessage( const ReceivedMessage& msg, const IpEndpointName& remoteEndpoint)

    78 {

    79     try

    80     {

    81         ReceivedMessageArgumentStream args = msg.ArgumentStream();

    82         ReceivedMessage::const_iterator arg = msg.ArgumentsBegin();

    83 

    84         if( strcmp( msg.AddressPattern(), "/tuio/2Dobj" ) == 0 )

    85         {

    86             const char* cmd;

    87             args >> cmd;

    88             

    89             if( strcmp( cmd, "set" ) == 0 )

    90             {

    91                 if ((currentFrame<lastFrame) && (currentFrame>0)) return;

    92 

    93                 int32 s_id, f_id;

    94                 float xpos, ypos, angle, xspeed, yspeed, rspeed, maccel, raccel;

    95 

    96                 args >> s_id >> f_id >> xpos >> ypos >> angle >> xspeed >> yspeed >> rspeed >> maccel >> raccel >> EndMessage;

    97 

    98                 std::list<TuioObject*>::iterator tobj;

    99                 for (tobj=objectList.begin(); tobj!= objectList.end(); tobj++)

   100                     if((*tobj)->getSessionID()==(long)s_id) break;

   101 

   102                 if (tobj == objectList.end())

   103                 {

   104 

   105                     TuioObject *addObject = new TuioObject((long)s_id,(int)f_id,xpos,ypos,angle);

   106                     objectList.push_back(addObject);

   107                     

   108                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   109                         (*listener)->addTuioObject(addObject);

   110 

   111                 }

   112                 else if ( ((*tobj)->getX()!=xpos) || ((*tobj)->getY()!=ypos) || ((*tobj)->getAngle()!=angle) || ((*tobj)->getXSpeed()!=xspeed) || ((*tobj)->getYSpeed()!=yspeed) || ((*tobj)->getRotationSpeed()!=rspeed) || ((*tobj)->getMotionAccel()!=maccel) || ((*tobj)->getRotationAccel()!=raccel) )

   113                 {

   114                     (*tobj)->update(xpos,ypos,angle,xspeed,yspeed,rspeed,maccel,raccel);

   115 

   116                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   117                         (*listener)->updateTuioObject((*tobj));

   118                 }

   119             }

   120             else if( strcmp( cmd, "alive" ) == 0 )

   121             {

   122                 if ((currentFrame<lastFrame) && (currentFrame>0)) return;

   123 

   124                 int32 s_id;

   125                 while(!args.Eos())

   126                 {

   127                     args >> s_id;

   128                     objectBuffer.push_back((long)s_id);

   129                     std::list<long>::iterator iter;

   130                     iter = find(aliveObjectList.begin(), aliveObjectList.end(), (long)s_id); 

   131                     if (iter != aliveObjectList.end()) aliveObjectList.erase(iter);

   132                 }

   133                 args >> EndMessage;

   134                 

   135                 std::list<long>::iterator alive_iter;

   136                 for (alive_iter=aliveObjectList.begin(); alive_iter != aliveObjectList.end(); alive_iter++)

   137                 {

   138                     std::list<TuioObject*>::iterator tobj;

   139                     for (tobj=objectList.begin(); tobj!=objectList.end(); tobj++)

   140                     {

   141                         TuioObject *deleteObject = (*tobj);

   142                         if(deleteObject->getSessionID()==*alive_iter)

   143                         {

   144                             deleteObject->remove();

   145                             for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   146                                 (*listener)->removeTuioObject(deleteObject);

   147                             objectList.erase(tobj);

   148                             delete deleteObject;

   149                             break;

   150                         }

   151                     }

   152                 }

   153                 aliveObjectList = objectBuffer;

   154                 objectBuffer.clear();

   155             }

   156             else if( strcmp( cmd, "fseq" ) == 0 )

   157             {

   158                 if(currentFrame>0) lastFrame = currentFrame;

   159                 args >> currentFrame  >> EndMessage;

   160 

   161                 if ((currentFrame>=lastFrame) || (currentFrame<0))

   162                 {

   163                     long currentTime = lastTime;

   164                     if (currentFrame>lastFrame)

   165                     {

   166                         currentTime = getCurrentTime()-startTime;

   167                         lastTime = currentTime;

   168                     }

   169                     

   170                     for (std::list<TuioObject*>::iterator refreshObject=objectList.begin(); refreshObject!=objectList.end(); refreshObject++)

   171                         if ((*refreshObject)->getUpdateTime()==TUIO_UNDEFINED) (*refreshObject)->setUpdateTime(currentTime);

   172                     

   173                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener!=listenerList.end(); listener++)

   174                         (*listener)->refresh(currentTime);

   175                 }

   176             }

   177         }

   178         else if( strcmp( msg.AddressPattern(), "/tuio/3Dcur" ) == 0 )

   179         {

   180             const char* cmd;

   181             args >> cmd;

   182             

   183             if( strcmp( cmd, "set" ) == 0 )

   184             {

   185                 if ((currentFrame<lastFrame) && (currentFrame>0)) return;

   186 

   187                 int32 s_id;

   188                 float xpos, ypos, zpos, xspeed, yspeed, maccel;

   189                 //Modifié par alexandre.bastien@iri.centrepompidou.fr

   190                 args >> s_id >> xpos >> ypos >> zpos >> xspeed >> yspeed >> maccel >> EndMessage;

   191                 std::list<TuioCursor*>::iterator tcur;

   192                 for (tcur=cursorList.begin(); tcur != cursorList.end(); tcur++)

   193                     if((*tcur)->getSessionID()==(long)s_id) break;

   194 

   195                 if (tcur == cursorList.end())

   196                 {

   197                     int f_id = (int)cursorList.size();

   198                     if ((int)(cursorList.size())<=maxFingerID)

   199                     {

   200                         std::list<TuioCursor*>::iterator closestCursor = freeCursorList.begin();

   201                         //Modifié par alexandre.bastien@iri.centrepompidou.fr

   202                         for(std::list<TuioCursor*>::iterator testCursor = freeCursorList.begin();testCursor!= freeCursorList.end(); testCursor++)

   203                         {

   204                             if((*testCursor)->getDistance(xpos,ypos,zpos)<(*closestCursor)->getDistance(xpos,ypos,zpos)) closestCursor = testCursor;

   205                         }

   206                         f_id = (*closestCursor)->getFingerID();

   207                         freeCursorList.erase(closestCursor);

   208                         delete *closestCursor;

   209                     }

   210                     else maxFingerID = f_id;    

   211                     //Modifié par alexandre.bastien@iri.centrepompidou.fr

   212                     TuioCursor *addCursor = new TuioCursor((long)s_id,f_id,xpos,ypos,zpos);

   213                     cursorList.push_back(addCursor);

   214                     

   215                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   216                         (*listener)->addTuioCursor(addCursor);

   217                     

   218                 //Modifié par alexandre.bastien@iri.centrepompidou.fr

   219                 }

   220                 else if ( ((*tcur)->getX()!=xpos) || ((*tcur)->getY()!=ypos) || ((*tcur)->getZ()!=zpos) || ((*tcur)->getXSpeed()!=xspeed) || ((*tcur)->getYSpeed()!=yspeed) || ((*tcur)->getMotionAccel()!=maccel) )

   221                 {

   222                     (*tcur)->update(xpos,ypos,zpos,xspeed,yspeed,maccel);

   223                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   224                         (*listener)->updateTuioCursor((*tcur));

   225                 }

   226             }

   227             else if( strcmp( cmd, "alive" ) == 0 )

   228             {

   229                 if ((currentFrame<lastFrame) && (currentFrame>0)) return;

   230 

   231                 int32 s_id;

   232                 while(!args.Eos())

   233                 {

   234                     args >> s_id;

   235                     cursorBuffer.push_back((long)s_id);

   236                     std::list<long>::iterator iter;

   237                     iter = find(aliveCursorList.begin(), aliveCursorList.end(), (long)s_id); 

   238                     if (iter != aliveCursorList.end()) aliveCursorList.erase(iter);

   239                 }

   240                 args >> EndMessage;

   241                 std::list<long>::iterator alive_iter;

   242                 for (alive_iter=aliveCursorList.begin(); alive_iter != aliveCursorList.end(); alive_iter++)

   243                 {

   244                     std::list<TuioCursor*>::iterator tcur;

   245                     for (tcur=cursorList.begin(); tcur != cursorList.end(); tcur++)

   246                     {

   247                         TuioCursor *deleteCursor = (*tcur);

   248                         if(deleteCursor->getSessionID()==*alive_iter)

   249                         {

   250                             cursorList.erase(tcur);

   251                             deleteCursor->remove();

   252                             for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   253                                 (*listener)->removeTuioCursor(deleteCursor);

   254                             

   255                             if (deleteCursor->getFingerID()==maxFingerID)

   256                             {

   257                                 maxFingerID = -1;

   258                                 delete deleteCursor;

   259                                 

   260                                 if (cursorList.size()>0)

   261                                 {

   262                                     std::list<TuioCursor*>::iterator clist;

   263                                     for (clist=cursorList.begin(); clist != cursorList.end(); clist++)

   264                                     {

   265                                         int f_id = (*clist)->getFingerID();

   266                                         if (f_id>maxFingerID) maxFingerID=f_id;

   267                                     }

   268                                     std::list<TuioCursor*>::iterator flist;

   269                                     for (flist=freeCursorList.begin(); flist != freeCursorList.end(); flist++)

   270                                     {

   271                                         TuioCursor *freeCursor = (*flist);

   272                                         if (freeCursor->getFingerID()>maxFingerID) delete freeCursor;

   273                                         else freeCursorBuffer.push_back(freeCursor);

   274                                     }

   275                                     freeCursorList = freeCursorBuffer;

   276                                     freeCursorBuffer.clear();

   277                                 }

   278                             }

   279                             else if (deleteCursor->getFingerID()<maxFingerID) freeCursorList.push_back(deleteCursor);

   280                             break;

   281                         }

   282                     }

   283                 }

   284                 aliveCursorList = cursorBuffer;

   285                 cursorBuffer.clear();

   286             }

   287             else if( strcmp( cmd, "fseq" ) == 0 )

   288             {

   289                 if(currentFrame>0) lastFrame = currentFrame;

   290                 args >> currentFrame  >> EndMessage;

   291 

   292                 if ((currentFrame>=lastFrame) || (currentFrame<0))

   293                 {

   294                     long currentTime = lastTime;

   295                     if (currentFrame>lastFrame)

   296                     {

   297                         currentTime = getCurrentTime()-startTime;

   298                         lastTime = currentTime;

   299                     }

   300                     for (std::list<TuioCursor*>::iterator refreshCursor=cursorList.begin(); refreshCursor!=cursorList.end(); refreshCursor++)

   301                         if ((*refreshCursor)->getUpdateTime()==TUIO_UNDEFINED) (*refreshCursor)->setUpdateTime(currentTime);

   302 

   303                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   304                         (*listener)->refresh(currentTime);

   305                 }

   306             }

   307         }

   308         else if( strcmp( msg.AddressPattern(), "/tuio/_siP" ) == 0 )

   309         {

   310             const char* cmd;

   311             args >> cmd;

   312             

   313             if( strcmp( cmd, "set" ) == 0 )

   314             {

   315                 if ((currentFrame<lastFrame) && (currentFrame>0)) return;

   316 

   317                 int32 s_id;

   318                 const char* code;

   319                 args >> s_id >> code >> EndMessage;

   320                 std::list<TuioString*>::iterator tstr;

   321                 for (tstr=stringList.begin(); tstr != stringList.end(); tstr++)

   322                     if((*tstr)->getSessionID()==(long)s_id) break;

   323 

   324                 if (tstr == stringList.end())

   325                 {

   326                     int s_id = (int)stringList.size();//

   327                     if ((int)(stringList.size())<=maxStringID)//

   328                     {//

   329                         std::list<TuioString*>::iterator closestString = freeStringList.begin();//

   330                         //Modifié par alexandre.bastien@iri.centrepompidou.fr

   331 

   332                         //for(std::list<TuioString*>::iterator testString = freeStringList.begin();testString!= freeStringList.end(); testString++)

   333                         //{

   334                             //if((*testString)->getDistance(xpos,ypos,zpos)<(*closestCursor)->getDistance(xpos,ypos,zpos)) closestCursor = testCursor;

   335                         //}

   336                         s_id = (*closestString)->getStringID();//

   337                         freeStringList.erase(closestString);//

   338                         delete *closestString;//

   339                     }//

   340                     else maxStringID = s_id;//

   341                     //Modifié par alexandre.bastien@iri.centrepompidou.fr

   342                     TuioString *addString = new TuioString((long)s_id,-1,code);

   343                     stringList.push_back(addString);

   344                     

   345                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   346                         (*listener)->addTuioString(addString);

   347                     

   348                 //Modifié par alexandre.bastien@iri.centrepompidou.fr

   349                 }

   350                 else if ( ((*tstr)->getCode()!=code) )

   351                 {

   352                     (*tstr)->update(code);

   353                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   354                         (*listener)->updateTuioString((*tstr));

   355                 }

   356             }

   357             else if( strcmp( cmd, "alive" ) == 0 )

   358             {

   359                 if ((currentFrame<lastFrame) && (currentFrame>0)) return;

   360 

   361                 int32 s_id;

   362                 while(!args.Eos())

   363                 {

   364                     args >> s_id;

   365                     stringBuffer.push_back((long)s_id);

   366                     std::list<long>::iterator iter;

   367                     iter = find(aliveStringList.begin(), aliveStringList.end(), (long)s_id); 

   368                     if (iter != aliveStringList.end()) aliveStringList.erase(iter);

   369                 }

   370                 args >> EndMessage;

   371                 std::list<long>::iterator alive_iter;

   372                 for (alive_iter=aliveStringList.begin(); alive_iter != aliveStringList.end(); alive_iter++)

   373                 {

   374                     std::list<TuioString*>::iterator tstr;

   375                     for (tstr=stringList.begin(); tstr != stringList.end(); tstr++)

   376                     {

   377                         TuioString *deleteString = (*tstr);

   378                         if(deleteString->getSessionID()==*alive_iter)

   379                         {

   380                             stringList.erase(tstr);

   381                             deleteString->remove();

   382                             for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   383                                 (*listener)->removeTuioString(deleteString);

   384                             

   385                             if (deleteString->getStringID()==maxStringID)//

   386                             {//

   387                                 maxStringID = -1;//

   388                                 delete deleteString;

   389                                 

   390                                 if (stringList.size()>0)

   391                                 {

   392                                     std::list<TuioString*>::iterator clist;//

   393                                     for (clist=stringList.begin(); clist != stringList.end(); clist++)//

   394                                     {//

   395                                         int s_id = (*clist)->getStringID();//

   396                                         if (s_id>maxStringID) maxStringID=s_id;//

   397                                     }//

   398                                     std::list<TuioString*>::iterator flist;

   399                                     for (flist=freeStringList.begin(); flist != freeStringList.end(); flist++)

   400                                     {

   401                                         TuioString *freeString = (*flist);

   402                                         if (freeString->getStringID()>maxStringID) delete freeString;//

   403                                         else freeStringBuffer.push_back(freeString);//

   404                                         freeStringBuffer.push_back(freeString);

   405                                     }

   406                                     freeStringList = freeStringBuffer;

   407                                     freeStringBuffer.clear();

   408                                 }

   409                             }//

   410                             else if (deleteString->getStringID()<maxStringID) freeStringList.push_back(deleteString);//

   411                             break;

   412                         }

   413                     }

   414                 }

   415                 aliveStringList = stringBuffer;

   416                 stringBuffer.clear();

   417             }

   418             else if( strcmp( cmd, "fseq" ) == 0 )

   419             {

   420                 if(currentFrame>0) lastFrame = currentFrame;

   421                 args >> currentFrame  >> EndMessage;

   422 

   423                 if ((currentFrame>=lastFrame) || (currentFrame<0))

   424                 {

   425                     long currentTime = lastTime;

   426                     if (currentFrame>lastFrame)

   427                     {

   428                         currentTime = getCurrentTime()-startTime;

   429                         lastTime = currentTime;

   430                     }

   431                     for (std::list<TuioString*>::iterator refreshString=stringList.begin(); refreshString!=stringList.end(); refreshString++)

   432                         if ((*refreshString)->getUpdateTime()==TUIO_UNDEFINED) (*refreshString)->setUpdateTime(currentTime);

   433 

   434                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   435                         (*listener)->refresh(currentTime);

   436                 }

   437             }

   438         }

   439         //Ajouté par alexandre.bastien@iri.centrepompidou.fr

   440         /*else if( strcmp( msg.AddressPattern(), "/tuio/_siP" ) == 0 )

   441         {

   442             const char* cmd;

   443             args >> cmd;

   444             

   445             if( strcmp( cmd, "set" ) == 0 )

   446             {

   447                 if ((currentFrame<lastFrame) && (currentFrame>0)) return;

   448                 int32 s_id;

   449                 const char* code;

   450                 args >> s_id >> code >> EndMessage;

   451                 std::list<TuioString*>::iterator tstr;

   452                 for (tstr=stringList.begin(); tstr != stringList.end(); tstr++)

   453                     if((*tstr)->getSessionID()==(long)s_id) break;

   454 

   455                 if (tstr == stringList.end())

   456                 {

   457                     TuioString *addString = new TuioString((long)s_id,code);

   458                     stringList.push_back(addString);

   459                     

   460                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   461                         (*listener)->addTuioString(addString);

   462                     

   463                     

   464                 }

   465                 else if ( ((*tstr)->getCode()!=code) )

   466                 {

   467                     (*tstr)->update(code);

   468                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   469                         (*listener)->updateTuioString((*tstr));

   470                 }

   471             }

   472             else if( strcmp( cmd, "alive" ) == 0 )

   473             {

   474                 if ((currentFrame<lastFrame) && (currentFrame>0)) return;

   475                     

   476                 int32 s_id;

   477                 while(!args.Eos())

   478                 {

   479                     args >> s_id;

   480                     stringBuffer.push_back((long)s_id);

   481                     std::list<long>::iterator iter;

   482                     iter = find(aliveStringList.begin(), aliveStringList.end(), (long)s_id); 

   483                     if (iter != aliveStringList.end()) aliveStringList.erase(iter);

   484                 }

   485                 args >> EndMessage;

   486                 

   487                 std::list<long>::iterator alive_iter;

   488                 for (alive_iter=aliveStringList.begin(); alive_iter != aliveStringList.end(); alive_iter++)

   489                 {

   490                     std::list<TuioString*>::iterator tstr;

   491                     for (tstr=stringList.begin(); tstr != stringList.end(); tstr++)

   492                     {

   493                         TuioString *deleteString = (*tstr);

   494                         if(deleteString->getSessionID()==*alive_iter)

   495                         {

   496                             stringList.erase(tstr);

   497                             deleteString->remove();

   498                             for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   499                                 (*listener)->removeTuioString(deleteString);

   500                                 

   501                             if (stringList.size()>0)

   502                             {

   503                                 std::list<TuioString*>::iterator flist;

   504                                 for (flist=freeStringList.begin(); flist != freeStringList.end(); flist++)

   505                                 {

   506                                     TuioString *freeString = (*flist);

   507                                 }

   508                                 freeStringList = freeStringBuffer;

   509                                 freeStringBuffer.clear();

   510                             }

   511                         }

   512                         break;

   513                     }

   514                 }

   515                 aliveStringList = stringBuffer;

   516                 stringBuffer.clear();

   517             }

   518             else if( strcmp( cmd, "fseq" ) == 0 )

   519             {

   520                 if(currentFrame>0) lastFrame = currentFrame;

   521                 args >> currentFrame  >> EndMessage;

   522 

   523                 if ((currentFrame>=lastFrame) || (currentFrame<0))

   524                 {

   525                     long currentTime = lastTime;

   526                     if (currentFrame>lastFrame)

   527                     {

   528                         currentTime = getCurrentTime()-startTime;

   529                         lastTime = currentTime;

   530                     }

   531                     

   532                     for (std::list<TuioString*>::iterator refreshString=stringList.begin(); refreshString!=stringList.end(); refreshString++)

   533                         if ((*refreshString)->getUpdateTime()==TUIO_UNDEFINED) (*refreshString)->setUpdateTime(currentTime);

   534 

   535                     for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)

   536                         (*listener)->refresh(currentTime);

   537                 }

   538             }

   539         }*/

   540     }

   541     catch( Exception& e )

   542     {

   543         std::cout << "error while parsing message: "<< msg.AddressPattern() << ": " << e.what() << "\n";

   544     }

   545 }

   546 

   547 void TuioClient::ProcessPacket( const char *data, int size, const IpEndpointName& remoteEndpoint ) {

   548     if (listenerList.size()==0) return;

   549     ReceivedPacket p( data, size );

   550     if(p.IsBundle()) ProcessBundle( ReceivedBundle(p), remoteEndpoint);

   551         else ProcessMessage( ReceivedMessage(p), remoteEndpoint);

   552 }

   553 

   554 void TuioClient::start(bool lk) {

   555 

   556     if (socket==NULL) return;

   557 

   558     locked = lk;

   559     if (!locked) {

   560         #ifndef WIN32

   561         pthread_create(&thread , NULL, ThreadFunc, this);

   562         #else

   563         DWORD threadId;

   564         thread = CreateThread( 0, 0, ThreadFunc, this, 0, &threadId );

   565         #endif

   566     } else socket->Run();

   567     

   568     startTime = getCurrentTime();

   569     lastTime = 0;

   570 

   571     running = true;

   572 }

   573 

   574 void TuioClient::stop() {

   575 

   576     if (socket==NULL) return;

   577     socket->Break();

   578 

   579     if (!locked) {

   580         #ifdef WIN32

   581         if( thread ) CloseHandle( thread );

   582         #endif

   583         thread = 0;

   584         locked = false;

   585     }

   586     running = false;

   587 }

   588 

   589 void TuioClient::addTuioListener(TuioListener *listener) {

   590     listenerList.push_back(listener);

   591 }

   592 

   593 void TuioClient::removeTuioListener(TuioListener *listener) {

   594     std::list<TuioListener*>::iterator result = find(listenerList.begin(),listenerList.end(),listener);

   595     if (result!=listenerList.end()) listenerList.remove(listener);

   596 }

   597 

   598 TuioObject* TuioClient::getTuioObject(long s_id) {

   599     for (std::list<TuioObject*>::iterator iter=objectList.begin(); iter != objectList.end(); iter++)

   600         if((*iter)->getSessionID()==s_id) return (*iter);

   601         

   602     return NULL;

   603 }

   604 

   605 TuioCursor* TuioClient::getTuioCursor(long s_id) {

   606     for (std::list<TuioCursor*>::iterator iter=cursorList.begin(); iter != cursorList.end(); iter++)

   607         if((*iter)->getSessionID()==s_id) return (*iter);

   608         

   609     return NULL;

   610 }

   611 

   612 TuioString* TuioClient::getTuioString(long s_id) {

   613     for (std::list<TuioString*>::iterator iter=stringList.begin(); iter != stringList.end(); iter++)

   614         if((*iter)->getSessionID()==s_id) return (*iter);

   615         

   616     return NULL;

   617 }

   618 

   619 std::list<TuioObject*> TuioClient::getTuioObjects() {

   620     return objectList;

   621 }

   622 

   623 std::list<TuioCursor*> TuioClient::getTuioCursors() {

   624     return cursorList;

   625 }

   626 

   627 std::list<TuioString*> TuioClient::getTuioStrings() {

   628     return stringList;

   629 }

   630 

   631 long TuioClient::getCurrentTime() {

   632     

   633     #ifdef WIN32

   634         long timestamp = GetTickCount();

   635     #else

   636         struct timeval tv;

   637         struct timezone tz;

   638         gettimeofday(&tv,&tz);

   639         long timestamp = (tv.tv_sec*1000)+(tv.tv_usec/1000);

   640     #endif

   641         

   642         return timestamp;

   643 }