uSynergy.h

Go to the documentation of this file.

/*
uSynergy client -- Interface for the embedded Synergy client library
  version 1.0.0, July 7th, 2012
 
Copyright (C) 2012 Synergy Si Ltd.
Copyright (c) 2012 Alex Evans
 
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
 
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
 
   1. The origin of this software must not be misrepresented; you must not
   claim that you wrote the original software. If you use this software
   in a product, an acknowledgment in the product documentation would be
   appreciated but is not required.
 
   2. Altered source versions must be plainly marked as such, and must not be
   misrepresented as being the original software.
 
   3. This notice may not be removed or altered from any source
   distribution.
*/
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
 
//---------------------------------------------------------------------------------------------------------------------
//      Configuration
//---------------------------------------------------------------------------------------------------------------------
 
 
 
#if defined(USYNERGY_LITTLE_ENDIAN) && defined(USYNERGY_BIG_ENDIAN)
        /* Ambiguous: both endians specified */
        #error "Can't define both USYNERGY_LITTLE_ENDIAN and USYNERGY_BIG_ENDIAN"
#elif !defined(USYNERGY_LITTLE_ENDIAN) && !defined(USYNERGY_BIG_ENDIAN)
        /* Attempt to auto detect */
        #if defined(__LITTLE_ENDIAN__) || defined(LITTLE_ENDIAN) || (_BYTE_ORDER == _LITTLE_ENDIAN)
                #define USYNERGY_LITTLE_ENDIAN
        #elif defined(__BIG_ENDIAN__) || defined(BIG_ENDIAN) || (_BYTE_ORDER == _BIG_ENDIAN)
                #define USYNERGY_BIG_ENDIAN
        #else
                #error "Can't detect endian-nes, please defined either USYNERGY_LITTLE_ENDIAN or USYNERGY_BIG_ENDIAN";
        #endif
#else
        /* User-specified endian-nes, nothing to do for us */
#endif
 
 
 
//---------------------------------------------------------------------------------------------------------------------
//      Types and Constants
//---------------------------------------------------------------------------------------------------------------------
 
 
 
typedef int                     uSynergyBool;
#define                         USYNERGY_FALSE                                  0                               /* False value */
#define                         USYNERGY_TRUE                                   1                               /* True value */
 
 
typedef struct { int ignored; } *                                       uSynergyCookie;
 
 
 
enum uSynergyClipboardFormat
{
        USYNERGY_CLIPBOARD_FORMAT_TEXT                                  = 0,                    /* Text format, UTF-8, newline is LF */
        USYNERGY_CLIPBOARD_FORMAT_BITMAP                                = 1,                    /* Bitmap format, BMP 24/32bpp, BI_RGB */
        USYNERGY_CLIPBOARD_FORMAT_HTML                                  = 2,                    /* HTML format, HTML fragment, UTF-8, newline is LF */
};
 
 
 
#define                         USYNERGY_NUM_JOYSTICKS                  4                               /* Maximum number of supported joysticks */
 
#define                         USYNERGY_PROTOCOL_MAJOR                 1                               /* Major protocol version */
#define                         USYNERGY_PROTOCOL_MINOR                 4                               /* Minor protocol version */
 
#define                         USYNERGY_IDLE_TIMEOUT                   2000                    /* Timeout in milliseconds before reconnecting */
 
#define                         USYNERGY_TRACE_BUFFER_SIZE              1024                    /* Maximum length of traced message */
#define                         USYNERGY_REPLY_BUFFER_SIZE              1024                    /* Maximum size of a reply packet */
#define                         USYNERGY_RECEIVE_BUFFER_SIZE    4096                    /* Maximum size of an incoming packet */
 
 
 
#define                         USYNERGY_MODIFIER_SHIFT                 0x0001                  /* Shift key modifier */
#define                         USYNERGY_MODIFIER_CTRL                  0x0002                  /* Ctrl key modifier */
#define                         USYNERGY_MODIFIER_ALT                   0x0004                  /* Alt key modifier */
#define                         USYNERGY_MODIFIER_META                  0x0008                  /* Meta key modifier */
#define                         USYNERGY_MODIFIER_WIN                   0x0010                  /* Windows key modifier */
#define                         USYNERGY_MODIFIER_ALT_GR                0x0020                  /* AltGr key modifier */
#define                         USYNERGY_MODIFIER_LEVEL5LOCK    0x0040                  /* Level5Lock key modifier */
#define                         USYNERGY_MODIFIER_CAPSLOCK              0x1000                  /* CapsLock key modifier */
#define                         USYNERGY_MODIFIER_NUMLOCK               0x2000                  /* NumLock key modifier */
#define                         USYNERGY_MODIFIER_SCROLLOCK             0x4000                  /* ScrollLock key modifier */
 
 
 
 
//---------------------------------------------------------------------------------------------------------------------
//      Functions and Callbacks
//---------------------------------------------------------------------------------------------------------------------
 
 
 
typedef uSynergyBool (*uSynergyConnectFunc)(uSynergyCookie cookie);
 
 
 
typedef uSynergyBool (*uSynergySendFunc)(uSynergyCookie cookie, const uint8_t *buffer, int length);
 
 
 
typedef uSynergyBool (*uSynergyReceiveFunc)(uSynergyCookie cookie, uint8_t *buffer, int maxLength, int* outLength);
 
 
 
typedef void            (*uSynergySleepFunc)(uSynergyCookie cookie, int timeMs);
 
 
 
typedef uint32_t        (*uSynergyGetTimeFunc)();
 
 
 
typedef void            (*uSynergyTraceFunc)(uSynergyCookie cookie, const char *text);
 
 
 
typedef void            (*uSynergyScreenActiveCallback)(uSynergyCookie cookie, uSynergyBool active);
 
 
 
typedef void            (*uSynergyMouseCallback)(uSynergyCookie cookie, uint16_t x, uint16_t y, int16_t wheelX, int16_t wheelY, uSynergyBool buttonLeft, uSynergyBool buttonRight, uSynergyBool buttonMiddle);
 
 
 
typedef void            (*uSynergyKeyboardCallback)(uSynergyCookie cookie, uint16_t key, uint16_t modifiers, uSynergyBool down, uSynergyBool repeat);
 
 
 
typedef void            (*uSynergyJoystickCallback)(uSynergyCookie cookie, uint8_t joyNum, uint16_t buttons, int8_t leftStickX, int8_t leftStickY, int8_t rightStickX, int8_t rightStickY);
 
 
 
typedef void            (*uSynergyClipboardCallback)(uSynergyCookie cookie, enum uSynergyClipboardFormat format, const uint8_t *data, uint32_t size);
 
 
 
//---------------------------------------------------------------------------------------------------------------------
//      Context
//---------------------------------------------------------------------------------------------------------------------
 
 
 
typedef struct
{
        /* Mandatory configuration data, filled in by client */
        uSynergyConnectFunc                             m_connectFunc;                                                                  /* Connect function */
        uSynergySendFunc                                m_sendFunc;                                                                             /* Send data function */
        uSynergyReceiveFunc                             m_receiveFunc;                                                                  /* Receive data function */
        uSynergySleepFunc                               m_sleepFunc;                                                                    /* Thread sleep function */
        uSynergyGetTimeFunc                             m_getTimeFunc;                                                                  /* Get current time function */
        const char*                                             m_clientName;                                                                   /* Name of Synergy Screen / Client */
        uint16_t                                                m_clientWidth;                                                                  /* Width of screen */
        uint16_t                                                m_clientHeight;                                                                 /* Height of screen */
 
        /* Optional configuration data, filled in by client */
        uSynergyCookie                                  m_cookie;                                                                               /* Cookie pointer passed to callback functions (can be NULL) */
        uSynergyTraceFunc                               m_traceFunc;                                                                    /* Function for tracing status (can be NULL) */
        uSynergyScreenActiveCallback    m_screenActiveCallback;                                                 /* Callback for entering and leaving screen */
        uSynergyMouseCallback                   m_mouseCallback;                                                                /* Callback for mouse events */
        uSynergyKeyboardCallback                m_keyboardCallback;                                                             /* Callback for keyboard events */
        uSynergyJoystickCallback                m_joystickCallback;                                                             /* Callback for joystick events */
        uSynergyClipboardCallback               m_clipboardCallback;                                                    /* Callback for clipboard events */
 
        /* State data, used internall by client, initialized by uSynergyInit() */
        uSynergyBool                                    m_connected;                                                                    /* Is our socket connected? */
        uSynergyBool                                    m_hasReceivedHello;                                                             /* Have we received a 'Hello' from the server? */
        uSynergyBool                                    m_isCaptured;                                                                   /* Is Synergy active (i.e. this client is receiving input messages?) */
        uint32_t                                                m_lastMessageTime;                                                              /* Time at which last message was received */
        uint32_t                                                m_sequenceNumber;                                                               /* Packet sequence number */
        uint8_t                                                 m_receiveBuffer[USYNERGY_RECEIVE_BUFFER_SIZE];  /* Receive buffer */
        int                                                             m_receiveOfs;                                                                   /* Receive buffer offset */
        uint8_t                                                 m_replyBuffer[USYNERGY_REPLY_BUFFER_SIZE];              /* Reply buffer */
        uint8_t*                                                m_replyCur;                                                                             /* Write offset into reply buffer */
        uint16_t                                                m_mouseX;                                                                               /* Mouse X position */
        uint16_t                                                m_mouseY;                                                                               /* Mouse Y position */
        int16_t                                                 m_mouseWheelX;                                                                  /* Mouse wheel X position */
        int16_t                                                 m_mouseWheelY;                                                                  /* Mouse wheel Y position */
        uSynergyBool                                    m_mouseButtonLeft;                                                              /* Mouse left button */
        uSynergyBool                                    m_mouseButtonRight;                                                             /* Mouse right button */
        uSynergyBool                                    m_mouseButtonMiddle;                                                    /* Mouse middle button */
        int8_t                                                  m_joystickSticks[USYNERGY_NUM_JOYSTICKS][4];    /* Joystick stick position in 2 axes for 2 sticks */
        uint16_t                                                m_joystickButtons[USYNERGY_NUM_JOYSTICKS];              /* Joystick button state */
} uSynergyContext;
 
 
 
//---------------------------------------------------------------------------------------------------------------------
//      Interface
//---------------------------------------------------------------------------------------------------------------------
 
 
 
extern void             uSynergyInit(uSynergyContext *context);
 
 
 
extern void             uSynergyUpdate(uSynergyContext *context);
 
 
 
extern void             uSynergySendClipboard(uSynergyContext *context, const char *text);
 
 
 
#ifdef __cplusplus
};
#endif