CServer.h

/*
 * synergy -- mouse and keyboard sharing utility
 * Copyright (C) 2012 Bolton Software Ltd.
 * Copyright (C) 2002 Chris Schoeneman
 * 
 * This package is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * found in the file COPYING that should have accompanied this file.
 * 
 * This package 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, see <http://www.gnu.org/licenses/>.
 */

#ifndef CSERVER_H
#define CSERVER_H

#include "CConfig.h"
#include "CClipboard.h"
#include "ClipboardTypes.h"
#include "KeyTypes.h"
#include "MouseTypes.h"
#include "CEvent.h"
#include "CStopwatch.h"
#include "stdmap.h"
#include "stdset.h"
#include "stdvector.h"
#include "INode.h"

class CBaseClientProxy;
class CEventQueueTimer;
class CPrimaryClient;
class CInputFilter;
class CScreen;


class CServer : public INode {
public:
    class CLockCursorToScreenInfo {
    public:
        enum State { kOff, kOn, kToggle };

        static CLockCursorToScreenInfo* alloc(State state = kToggle);

    public:
        State           m_state;
    };

    class CSwitchToScreenInfo {
    public:
        static CSwitchToScreenInfo* alloc(const CString& screen);

    public:
        // this is a C-string;  this type is a variable size structure
        char            m_screen[1];
    };

    class CSwitchInDirectionInfo {
    public:
        static CSwitchInDirectionInfo* alloc(EDirection direction);

    public:
        EDirection      m_direction;
    };

    class CScreenConnectedInfo {
    public:
        CScreenConnectedInfo(CString screen) : m_screen(screen) { }

    public:
        CString         m_screen; // was char[1]
    };

    class CKeyboardBroadcastInfo {
    public:
        enum State { kOff, kOn, kToggle };

        static CKeyboardBroadcastInfo* alloc(State state = kToggle);
        static CKeyboardBroadcastInfo* alloc(State state,
                                            const CString& screens);

    public:
        State           m_state;
        char            m_screens[1];
    };

    CServer(const CConfig& config, CPrimaryClient* primaryClient, CScreen* screen);
    ~CServer();
    
#ifdef TEST_ENV
    CServer() { }
#endif




    bool                setConfig(const CConfig&);


    void                adoptClient(CBaseClientProxy* client);


    void                disconnect();

    void                gameDeviceTimingResp(UInt16 freq);

    void                gameDeviceFeedback(GameDeviceID id, UInt16 m1, UInt16 m2);





    UInt32              getNumClients() const;


    void                getClients(std::vector<CString>& list) const;


    static CEvent::Type getErrorEvent();


    static CEvent::Type getConnectedEvent();


    static CEvent::Type getDisconnectedEvent();


    static CEvent::Type getSwitchToScreenEvent();


    static CEvent::Type getSwitchInDirectionEvent();


    static CEvent::Type getKeyboardBroadcastEvent();


    static CEvent::Type getLockCursorToScreenEvent();


    static CEvent::Type getScreenSwitchedEvent();


private:
    // get canonical name of client
    CString             getName(const CBaseClientProxy*) const;

    // get the sides of the primary screen that have neighbors
    UInt32              getActivePrimarySides() const;

    // returns true iff mouse should be locked to the current screen
    // according to this object only, ignoring what the primary client
    // says.
    bool                isLockedToScreenServer() const;

    // returns true iff mouse should be locked to the current screen
    // according to this object or the primary client.
    bool                isLockedToScreen() const;

    // returns the jump zone of the client
    SInt32              getJumpZoneSize(CBaseClientProxy*) const;

    // change the active screen
    void                switchScreen(CBaseClientProxy*,
                            SInt32 x, SInt32 y, bool forScreenSaver);

    // jump to screen
    void                jumpToScreen(CBaseClientProxy*);

    // convert pixel position to fraction, using x or y depending on the
    // direction.
    float               mapToFraction(CBaseClientProxy*, EDirection,
                            SInt32 x, SInt32 y) const;

    // convert fraction to pixel position, writing only x or y depending
    // on the direction.
    void                mapToPixel(CBaseClientProxy*, EDirection, float f,
                            SInt32& x, SInt32& y) const;

    // returns true if the client has a neighbor anywhere along the edge
    // indicated by the direction.
    bool                hasAnyNeighbor(CBaseClientProxy*, EDirection) const;

    // lookup neighboring screen, mapping the coordinate independent of
    // the direction to the neighbor's coordinate space.
    CBaseClientProxy*   getNeighbor(CBaseClientProxy*, EDirection,
                            SInt32& x, SInt32& y) const;

    // lookup neighboring screen.  given a position relative to the
    // source screen, find the screen we should move onto and where.
    // if the position is sufficiently far from the source then we
    // cross multiple screens.  if there is no suitable screen then
    // return NULL and x,y are not modified.
    CBaseClientProxy*   mapToNeighbor(CBaseClientProxy*, EDirection,
                            SInt32& x, SInt32& y) const;

    // adjusts x and y or neither to avoid ending up in a jump zone
    // after entering the client in the given direction.
    void                avoidJumpZone(CBaseClientProxy*, EDirection,
                            SInt32& x, SInt32& y) const;

    // test if a switch is permitted.  this includes testing user
    // options like switch delay and tracking any state required to
    // implement them.  returns true iff a switch is permitted.
    bool                isSwitchOkay(CBaseClientProxy* dst, EDirection,
                            SInt32 x, SInt32 y, SInt32 xActive, SInt32 yActive);

    // update switch state due to a mouse move at \p x, \p y that
    // doesn't switch screens.
    void                noSwitch(SInt32 x, SInt32 y);

    // stop switch timers
    void                stopSwitch();

    // start two tap switch timer
    void                startSwitchTwoTap();

    // arm the two tap switch timer if \p x, \p y is outside the tap zone
    void                armSwitchTwoTap(SInt32 x, SInt32 y);

    // stop the two tap switch timer
    void                stopSwitchTwoTap();

    // returns true iff the two tap switch timer is started
    bool                isSwitchTwoTapStarted() const;

    // returns true iff should switch because of two tap
    bool                shouldSwitchTwoTap() const;

    // start delay switch timer
    void                startSwitchWait(SInt32 x, SInt32 y);

    // stop delay switch timer
    void                stopSwitchWait();

    // returns true iff the delay switch timer is started
    bool                isSwitchWaitStarted() const;

    // returns the corner (EScreenSwitchCornerMasks) where x,y is on the
    // given client.  corners have the given size.
    UInt32              getCorner(CBaseClientProxy*,
                            SInt32 x, SInt32 y, SInt32 size) const;

    // stop relative mouse moves
    void                stopRelativeMoves();

    // send screen options to \c client
    void                sendOptions(CBaseClientProxy* client) const;

    // process options from configuration
    void                processOptions();

    // event handlers
    void                handleShapeChanged(const CEvent&, void*);
    void                handleClipboardGrabbed(const CEvent&, void*);
    void                handleClipboardChanged(const CEvent&, void*);
    void                handleKeyDownEvent(const CEvent&, void*);
    void                handleKeyUpEvent(const CEvent&, void*);
    void                handleKeyRepeatEvent(const CEvent&, void*);
    void                handleButtonDownEvent(const CEvent&, void*);
    void                handleButtonUpEvent(const CEvent&, void*);
    void                handleMotionPrimaryEvent(const CEvent&, void*);
    void                handleMotionSecondaryEvent(const CEvent&, void*);
    void                handleWheelEvent(const CEvent&, void*);
    void                handleGameDeviceButtons(const CEvent&, void*);
    void                handleGameDeviceSticks(const CEvent&, void*);
    void                handleGameDeviceTriggers(const CEvent&, void*);
    void                handleGameDeviceTimingReq(const CEvent&, void*);
    void                handleScreensaverActivatedEvent(const CEvent&, void*);
    void                handleScreensaverDeactivatedEvent(const CEvent&, void*);
    void                handleSwitchWaitTimeout(const CEvent&, void*);
    void                handleClientDisconnected(const CEvent&, void*);
    void                handleClientCloseTimeout(const CEvent&, void*);
    void                handleSwitchToScreenEvent(const CEvent&, void*);
    void                handleSwitchInDirectionEvent(const CEvent&, void*);
    void                handleKeyboardBroadcastEvent(const CEvent&,void*);
    void                handleLockCursorToScreenEvent(const CEvent&, void*);
    void                handleFakeInputBeginEvent(const CEvent&, void*);
    void                handleFakeInputEndEvent(const CEvent&, void*);

    // event processing
    void                onClipboardChanged(CBaseClientProxy* sender,
                            ClipboardID id, UInt32 seqNum);
    void                onScreensaver(bool activated);
    void                onKeyDown(KeyID, KeyModifierMask, KeyButton,
                            const char* screens);
    void                onKeyUp(KeyID, KeyModifierMask, KeyButton,
                            const char* screens);
    void                onKeyRepeat(KeyID, KeyModifierMask, SInt32, KeyButton);
    void                onMouseDown(ButtonID);
    void                onMouseUp(ButtonID);
    bool                onMouseMovePrimary(SInt32 x, SInt32 y);
    void                onMouseMoveSecondary(SInt32 dx, SInt32 dy);
    void                onMouseWheel(SInt32 xDelta, SInt32 yDelta);
    void                onGameDeviceButtons(GameDeviceID id, GameDeviceButton buttons);
    void                onGameDeviceSticks(GameDeviceID id, SInt16 x1, SInt16 y1, SInt16 x2, SInt16 y2);
    void                onGameDeviceTriggers(GameDeviceID id, UInt8 t1, UInt8 t2);
    void                onGameDeviceTimingReq();

    // add client to list and attach event handlers for client
    bool                addClient(CBaseClientProxy*);

    // remove client from list and detach event handlers for client
    bool                removeClient(CBaseClientProxy*);

    // close a client
    void                closeClient(CBaseClientProxy*, const char* msg);

    // close clients not in \p config
    void                closeClients(const CConfig& config);

    // close all clients whether they've completed the handshake or not,
    // except the primary client
    void                closeAllClients();

    // remove clients from internal state
    void                removeActiveClient(CBaseClientProxy*);
    void                removeOldClient(CBaseClientProxy*);

    // force the cursor off of \p client
    void                forceLeaveClient(CBaseClientProxy* client);
    
public:
    bool                m_mock;

private:
    class CClipboardInfo {
    public:
        CClipboardInfo();

    public:
        CClipboard      m_clipboard;
        CString         m_clipboardData;
        CString         m_clipboardOwner;
        UInt32          m_clipboardSeqNum;
    };

    // the primary screen client
    CPrimaryClient*     m_primaryClient;

    // all clients (including the primary client) indexed by name
    typedef std::map<CString, CBaseClientProxy*> CClientList;
    typedef std::set<CBaseClientProxy*> CClientSet;
    CClientList         m_clients;
    CClientSet          m_clientSet;

    // all old connections that we're waiting to hangup
    typedef std::map<CBaseClientProxy*, CEventQueueTimer*> COldClients;
    COldClients         m_oldClients;

    // the client with focus
    CBaseClientProxy*   m_active;

    // the sequence number of enter messages
    UInt32              m_seqNum;

    // current mouse position (in absolute screen coordinates) on
    // whichever screen is active
    SInt32              m_x, m_y;

    // last mouse deltas.  this is needed to smooth out double tap
    // on win32 which reports bogus mouse motion at the edge of
    // the screen when using low level hooks, synthesizing motion
    // in the opposite direction the mouse actually moved.
    SInt32              m_xDelta, m_yDelta;
    SInt32              m_xDelta2, m_yDelta2;

    // current configuration
    CConfig             m_config;

    // input filter (from m_config);
    CInputFilter*       m_inputFilter;

    // clipboard cache
    CClipboardInfo      m_clipboards[kClipboardEnd];

    // state saved when screen saver activates
    CBaseClientProxy*   m_activeSaver;
    SInt32              m_xSaver, m_ySaver;

    // common state for screen switch tests.  all tests are always
    // trying to reach the same screen in the same direction.
    EDirection          m_switchDir;
    CBaseClientProxy*   m_switchScreen;

    // state for delayed screen switching
    double              m_switchWaitDelay;
    CEventQueueTimer*   m_switchWaitTimer;
    SInt32              m_switchWaitX, m_switchWaitY;

    // state for double-tap screen switching
    double              m_switchTwoTapDelay;
    CStopwatch          m_switchTwoTapTimer;
    bool                m_switchTwoTapEngaged;
    bool                m_switchTwoTapArmed;
    SInt32              m_switchTwoTapZone;

    // modifiers needed before switching
    bool                m_switchNeedsShift;
    bool                m_switchNeedsControl;
    bool                m_switchNeedsAlt;
    
    // relative mouse move option
    bool                m_relativeMoves;

    // flag whether or not we have broadcasting enabled and the screens to
    // which we should send broadcasted keys.
    bool                m_keyboardBroadcasting;
    CString             m_keyboardBroadcastingScreens;

    // screen locking (former scroll lock)
    bool                m_lockedToScreen;

    // server screen
    CScreen*            m_screen;

    static CEvent::Type s_errorEvent;
    static CEvent::Type s_connectedEvent;
    static CEvent::Type s_disconnectedEvent;
    static CEvent::Type s_switchToScreen;
    static CEvent::Type s_switchInDirection;
    static CEvent::Type s_keyboardBroadcast;
    static CEvent::Type s_lockCursorToScreen;
    static CEvent::Type s_screenSwitched;
};

#endif