TIL/TIL_DeepSocketListener.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Ian Kerr
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        TIL_DeepSocketListener.h ( TIL Library, C++)
 *
 * COMMENTS:    This class uses TIL_DeepSocketHandler to read a deep
 *              raster from a socket in a separate thread.  All methods
 *              must be called from the main thread.
 */

#ifndef __TIL_DeepSocketListener__
#define __TIL_DeepSocketListener__

#include "TIL_API.h"
#include <UT/UT_Lock.h>

class TIL_DeepSocketHandler;
class TIL_DeepRaster;
class TIL_DeepRasterReader;
class UT_Thread;

class TIL_API TIL_DeepSocketListener {
public:
    /// Calls terminate().
    ~TIL_DeepSocketListener();

    /// Create an instance of TIL_DeepSocketListener.
    /// socket - the socket over which the deep raster will be sent.
    ///          This instance will delete the socket when it is
    ///          finished with it.
    /// reader - the deep raster reader to use.  This is allocated and
    ///          freed by the caller.
    static
    TIL_DeepSocketListener      *create(UT_NetSocket *socket,
                                        TIL_DeepRasterReader *reader);

    void                         setMousePosition(int x, int y);

    /// Start/stop listening on the socket provided to create().
    /// start() returns false if the socket is shut down.  Successive
    /// calls to either method have no effect.
    bool                         start();
    void                         stop();

    /// Stop listening (calls stop()) and kill the socket connection.
    /// Consecutive calls have no effect.  Once terminated, start() and
    /// stop() have no effect.
    void                         terminate(bool kill_proc = false);

    /// Return true when the socket has been closed
    bool                         isComplete() const
                                 { return !myHandler->getSocket(); }

    /// Since the deep socket listener will run in a separate thread, it's
    /// necessary to lock around operations that are accessing any shared
    /// data in a thread-unsafe fashion.
    UT_Lock                     &getLock()      { return myLock; }

private:
     TIL_DeepSocketListener(UT_NetSocket *socket, pid_t pid,
                            TIL_DeepRasterReader *reader);

     static void                *doListenThread(void *data);

     UT_Thread                  *myThread;
     TIL_DeepRasterReader       *myReader;
     TIL_DeepSocketHandler      *myHandler;
     UT_Lock                     myLock;
     bool                        myListening;
};

#endif

---