TuioServer.h

Go to the documentation of this file.

/*
 TUIO Server Component - part of the reacTIVision project
 http://reactivision.sourceforge.net/
 
 Copyright (c) 2005-2009 Martin Kaltenbrunner <mkalten@iua.upf.edu>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef INCLUDED_TuioServer_H
#define INCLUDED_TuioServer_H

#ifndef WIN32
#include <pthread.h>
#include <sys/time.h>
#else
#include <windows.h>
#endif

#include <iostream>
#include <list>
#include <algorithm>

#include "osc/OscOutboundPacketStream.h"
#include "ip/NetworkingUtils.h"
#include "ip/UdpSocket.h"

#include "TuioObject.h"
#include "TuioCursor.h"

#define IP_MTU_SIZE 1500
#define MAX_UDP_SIZE 65536
#define MIN_UDP_SIZE 576
#define OBJ_MESSAGE_SIZE 108    // setMessage + seqMessage size
#define CUR_MESSAGE_SIZE 88

namespace TUIO {
        class TuioServer { 
                
        public:

                TuioServer();

                TuioServer(const char *host, int port);

                TuioServer(const char *host, int port, int size);

                ~TuioServer();
                
                TuioObject* addTuioObject(int sym, float xp, float yp, float a);

                void updateTuioObject(TuioObject *tobj, float xp, float yp, float a);

                void removeTuioObject(TuioObject *tobj);

                void addExternalTuioObject(TuioObject *tobj);

                void updateExternalTuioObject(TuioObject *tobj);

                void removeExternalTuioObject(TuioObject *tobj);
                
                TuioCursor* addTuioCursor(float xp, float yp);

                void updateTuioCursor(TuioCursor *tcur, float xp, float yp);

                void removeTuioCursor(TuioCursor *tcur);

                void addExternalTuioCursor(TuioCursor *tcur);

                void updateExternalTuioCursor(TuioCursor *tcur);

                void removeExternalTuioCursor(TuioCursor *tcur);
                
                void initFrame(TuioTime ttime);
                
                void commitFrame();

                long getSessionID();

                long getFrameID();
                
                TuioTime getFrameTime();

                void sendFullMessages();                

                void enablePeriodicMessages(int interval=1);

                void disablePeriodicMessages();

                void enableFullUpdate()  {
                        full_update = true;
                }
                
                void disableFullUpdate() {
                        full_update = false;
                }
                
                bool periodicMessagesEnabled() {
                        return periodic_update;
                }
        
                int getUpdateInterval() {
                        return update_interval;
                }
                
                std::list<TuioObject*> getUntouchedObjects();

                std::list<TuioCursor*> getUntouchedCursors();
                
                void stopUntouchedMovingObjects();

                void stopUntouchedMovingCursors();
                
                void removeUntouchedStoppedObjects();

                void removeUntouchedStoppedCursors();

                std::list<TuioObject*> getTuioObjects();
                
                
                std::list<TuioCursor*> getTuioCursors();
                
                TuioObject* getTuioObject(long s_id);
                
                TuioCursor* getTuioCursor(long s_id);

                TuioObject* getClosestTuioObject(float xp, float yp);
                
                TuioCursor* getClosestTuioCursor(float xp, float yp);
                
                bool isConnected() { return connected; }
                
                void setVerbose(bool verbose) { this->verbose=verbose; }
                
        private:
                std::list<TuioObject*> objectList;
                std::list<TuioCursor*> cursorList;
                
                int maxCursorID;
                std::list<TuioCursor*> freeCursorList;
                std::list<TuioCursor*> freeCursorBuffer;
                
                UdpTransmitSocket *socket;      
                osc::OutboundPacketStream  *oscPacket;
                char *oscBuffer; 
                osc::OutboundPacketStream  *fullPacket;
                char *fullBuffer; 
                
                void initialize(const char *host, int port, int size);

                void sendEmptyCursorBundle();
                void startCursorBundle();
                void addCursorMessage(TuioCursor *tcur);
                void sendCursorBundle(long fseq);
                
                void sendEmptyObjectBundle();
                void startObjectBundle();
                void addObjectMessage(TuioObject *tobj);
                void sendObjectBundle(long fseq);
                
                bool full_update;
                int update_interval;
                bool periodic_update;

                long currentFrame;
                TuioTime currentFrameTime;
                bool updateObject, updateCursor;
                long lastCursorUpdate, lastObjectUpdate;

                long sessionID;
                bool verbose;

#ifndef WIN32
                pthread_t thread;
#else
                HANDLE thread;
#endif  
                bool connected;
        };
};
#endif /* INCLUDED_TuioServer_H */