From 62519b19fe460af5f188674893e561879515cd14 Mon Sep 17 00:00:00 2001 From: crs Date: Mon, 10 Jun 2002 22:06:45 +0000 Subject: [PATCH] indentation and other formatting changes. also cleaned up #includes. --- base/BasicTypes.h | 1 - base/CFunctionJob.cpp | 7 +- base/CLog.cpp | 7 +- base/CLog.h | 4 +- base/CString.cpp | 41 +-- base/CString.h | 43 +-- base/TMethodJob.h | 9 +- base/XBase.cpp | 31 ++- base/XBase.h | 2 +- base/common.h | 2 + base/stdistream.h | 3 + base/stdostream.h | 2 + client/CClient.cpp | 117 +++++--- client/CClient.h | 5 +- client/CMSWindowsSecondaryScreen.cpp | 287 ++++++++++++------- client/CMSWindowsSecondaryScreen.h | 7 +- client/CXWindowsSecondaryScreen.cpp | 268 +++++++++++------- client/CXWindowsSecondaryScreen.h | 9 +- client/client.cpp | 120 +++++--- http/CHTTPProtocol.cpp | 93 ++++--- http/CHTTPProtocol.h | 16 +- http/XHTTP.cpp | 47 ++-- http/XHTTP.h | 1 - io/CBufferedInputStream.cpp | 48 ++-- io/CBufferedInputStream.h | 2 +- io/CBufferedOutputStream.cpp | 38 ++- io/CBufferedOutputStream.h | 2 +- io/CInputStreamFilter.cpp | 12 +- io/COutputStreamFilter.cpp | 12 +- io/CStreamBuffer.cpp | 24 +- io/IInputStream.h | 1 - io/IOutputStream.h | 1 - io/XIO.cpp | 16 +- io/XIO.h | 1 - mt/CCondVar.cpp | 76 +++-- mt/CCondVar.h | 22 +- mt/CLock.cpp | 8 +- mt/CLock.h | 2 - mt/CMutex.cpp | 35 ++- mt/CMutex.h | 2 - mt/CThread.cpp | 63 +++-- mt/CThread.h | 2 - mt/CThreadRep.cpp | 173 ++++++++---- mt/CTimerThread.cpp | 5 +- mt/CTimerThread.h | 2 - mt/XThread.h | 2 - net/CNetwork.cpp | 127 ++++++--- net/CNetworkAddress.cpp | 35 ++- net/CNetworkAddress.h | 1 - net/CTCPListenSocket.cpp | 13 +- net/CTCPSocket.cpp | 45 ++- net/CTCPSocket.h | 1 - net/IListenSocket.h | 2 - net/ISocket.h | 3 - net/Makefile | 1 + net/XNetwork.cpp | 28 +- net/XNetwork.h | 3 +- net/XSocket.cpp | 40 ++- net/XSocket.h | 2 +- platform/CMSWindowsClipboard.cpp | 62 +++-- platform/CMSWindowsScreen.cpp | 68 +++-- platform/CMSWindowsScreen.h | 3 +- platform/CUnixPlatform.cpp | 110 ++++---- platform/CUnixPlatform.h | 10 +- platform/CWin32Platform.cpp | 150 ++++++---- platform/CWin32Platform.h | 14 +- platform/CXWindowsClipboard.cpp | 343 ++++++++++++++--------- platform/CXWindowsClipboard.h | 31 +-- platform/CXWindowsScreen.cpp | 143 ++++++---- platform/CXWindowsScreen.h | 7 +- platform/CXWindowsUtil.cpp | 83 ++++-- platform/CXWindowsUtil.h | 16 +- platform/IPlatform.h | 13 +- server/CConfig.cpp | 128 ++++++--- server/CConfig.h | 12 +- server/CHTTPServer.cpp | 131 ++++++--- server/CHTTPServer.h | 2 +- server/CMSWindowsPrimaryScreen.cpp | 194 ++++++++----- server/CMSWindowsPrimaryScreen.h | 8 +- server/CServer.cpp | 344 +++++++++++++++-------- server/CServer.h | 38 ++- server/CServerProtocol.cpp | 43 +-- server/CServerProtocol.h | 9 +- server/CServerProtocol1_0.cpp | 101 ++++--- server/CServerProtocol1_0.h | 2 +- server/CSynergyHook.cpp | 86 ++++-- server/CSynergyHook.h | 2 +- server/CXWindowsPrimaryScreen.cpp | 401 +++++++++++++++------------ server/CXWindowsPrimaryScreen.h | 5 +- server/server.cpp | 128 ++++++--- synergy/CClipboard.cpp | 60 ++-- synergy/CClipboard.h | 19 +- synergy/CInputPacketStream.cpp | 32 ++- synergy/COutputPacketStream.cpp | 18 +- synergy/CProtocolUtil.cpp | 46 ++- synergy/CProtocolUtil.h | 6 +- synergy/CTCPSocketFactory.cpp | 6 +- synergy/IClipboard.h | 3 +- synergy/IPrimaryScreen.h | 1 - synergy/ISecondaryScreen.h | 3 +- synergy/IServerProtocol.h | 7 +- synergy/ISocketFactory.h | 1 - synergy/XScreen.cpp | 3 +- synergy/XSynergy.cpp | 40 ++- 104 files changed, 3089 insertions(+), 1815 deletions(-) diff --git a/base/BasicTypes.h b/base/BasicTypes.h index b21eba8f..f71d15b4 100644 --- a/base/BasicTypes.h +++ b/base/BasicTypes.h @@ -58,7 +58,6 @@ typedef unsigned char UInt8; typedef unsigned short UInt16; typedef unsigned int UInt32; typedef unsigned long long UInt64; - #endif #endif // CONFIG_PLATFORM_WIN32 diff --git a/base/CFunctionJob.cpp b/base/CFunctionJob.cpp index 50a55100..7558c911 100644 --- a/base/CFunctionJob.cpp +++ b/base/CFunctionJob.cpp @@ -5,13 +5,14 @@ // CFunctionJob::CFunctionJob(void (*func)(void*), void* arg) : - m_func(func), - m_arg(arg) + m_func(func), + m_arg(arg) { // do nothing } -void CFunctionJob::run() +void +CFunctionJob::run() { if (m_func != NULL) { m_func(m_arg); diff --git a/base/CLog.cpp b/base/CLog.cpp index d36ae24d..a35ca588 100644 --- a/base/CLog.cpp +++ b/base/CLog.cpp @@ -1,8 +1,7 @@ #include "CLog.h" -#include -#include -#include -#include +#include +#include +#include #if defined(CONFIG_PLATFORM_WIN32) #define WIN32_LEAN_AND_MEAN diff --git a/base/CLog.h b/base/CLog.h index 22a34357..0a790929 100644 --- a/base/CLog.h +++ b/base/CLog.h @@ -2,7 +2,7 @@ #define CLOG_H #include "BasicTypes.h" -#include +#include class CLog { public: @@ -24,7 +24,7 @@ public: // type of lock/unlock function typedef void (*Lock)(bool lock); - // + // print a log message static void print(const char*, ...); static void printt(const char* file, int line, const char*, ...); diff --git a/base/CString.cpp b/base/CString.cpp index e174cad0..2ef952ee 100644 --- a/base/CString.cpp +++ b/base/CString.cpp @@ -1,30 +1,33 @@ #include "CString.h" -#include +#include #include // // CStringUtil::CaselessCmp // -bool CStringUtil::CaselessCmp::cmpEqual( - const CString::value_type& a, - const CString::value_type& b) +bool +CStringUtil::CaselessCmp::cmpEqual( + const CString::value_type& a, + const CString::value_type& b) { - // FIXME -- use std::tolower + // FIXME -- use std::tolower but not in all versions of libstdc++ return tolower(a) == tolower(b); } -bool CStringUtil::CaselessCmp::cmpLess( - const CString::value_type& a, - const CString::value_type& b) +bool +CStringUtil::CaselessCmp::cmpLess( + const CString::value_type& a, + const CString::value_type& b) { - // FIXME -- use std::tolower + // FIXME -- use std::tolower but not in all versions of libstdc++ return tolower(a) < tolower(b); } -bool CStringUtil::CaselessCmp::less( - const CString& a, - const CString& b) +bool +CStringUtil::CaselessCmp::less( + const CString& a, + const CString& b) { return std::lexicographical_compare( a.begin(), a.end(), @@ -32,16 +35,18 @@ bool CStringUtil::CaselessCmp::less( &CStringUtil::CaselessCmp::cmpLess); } -bool CStringUtil::CaselessCmp::equal( - const CString& a, - const CString& b) +bool +CStringUtil::CaselessCmp::equal( + const CString& a, + const CString& b) { return !(less(a, b) || less(b, a)); } -bool CStringUtil::CaselessCmp::operator()( - const CString& a, - const CString& b) const +bool +CStringUtil::CaselessCmp::operator()( + const CString& a, + const CString& b) const { return less(a, b); } diff --git a/base/CString.h b/base/CString.h index 10664e30..78fd9ad2 100644 --- a/base/CString.h +++ b/base/CString.h @@ -1,48 +1,15 @@ #ifndef CSTRING_H #define CSTRING_H -#include "common.h" #include "stdpre.h" #include #include "stdpost.h" -#if defined(_MSC_VER) -#pragma warning(push, 4) -#pragma warning(disable: 4097) // typedef-name used as synonym -#endif - -#ifndef CSTRING_DEF_CTOR -#define CSTRING_ALLOC1 -#define CSTRING_ALLOC2 -#define CSTRING_DEF_CTOR CString() : _Myt() { } -#endif - // use to get appropriate type for string constants. it depends on // the internal representation type of CString. #define _CS(_x) _x -class CString : public std::string { -public: - typedef char _e; - typedef _e CharT; - typedef std::allocator<_e> _a; - typedef std::string _Myt; - typedef const_iterator _It; - - // same constructors as base class - CSTRING_DEF_CTOR - CString(const _Myt& _x) : _Myt(_x) { } - CString(const _Myt& _x, size_type _p, size_type _m CSTRING_ALLOC1) : - _Myt(_x, _p, _m CSTRING_ALLOC2) { } - CString(const _e *_s, size_type _n CSTRING_ALLOC1) : - _Myt(_s, _n CSTRING_ALLOC2) { } - CString(const _e *_s CSTRING_ALLOC1) : - _Myt(_s CSTRING_ALLOC2) { } - CString(size_type _n, _e _c CSTRING_ALLOC1) : - _Myt(_n, _c CSTRING_ALLOC2) { } - CString(_It _f, _It _l CSTRING_ALLOC1) : - _Myt(_f, _l CSTRING_ALLOC2) { } -}; +typedef std::string CString; class CStringUtil { public: @@ -52,15 +19,11 @@ public: static bool less(const CString&, const CString&); static bool equal(const CString&, const CString&); static bool cmpLess(const CString::value_type&, - const CString::value_type&); + const CString::value_type&); static bool cmpEqual(const CString::value_type&, - const CString::value_type&); + const CString::value_type&); }; }; -#if defined(_MSC_VER) -#pragma warning(pop) -#endif - #endif diff --git a/base/TMethodJob.h b/base/TMethodJob.h index f9514bf2..59a22208 100644 --- a/base/TMethodJob.h +++ b/base/TMethodJob.h @@ -20,16 +20,17 @@ private: template inline TMethodJob::TMethodJob(T* object, void (T::*method)(void*), void* arg) : - m_object(object), - m_method(method), - m_arg(arg) + m_object(object), + m_method(method), + m_arg(arg) { // do nothing } template inline -void TMethodJob::run() +void +TMethodJob::run() { if (m_object != NULL) { (m_object->*m_method)(m_arg); diff --git a/base/XBase.cpp b/base/XBase.cpp index bc2db608..c23a77ee 100644 --- a/base/XBase.cpp +++ b/base/XBase.cpp @@ -1,5 +1,5 @@ #include "XBase.h" -#include +#include // win32 wants a const char* argument to std::exception c'tor #if defined(CONFIG_PLATFORM_WIN32) @@ -15,12 +15,16 @@ // XBase // -XBase::XBase() : exception(STDEXCEPTARG), m_what() +XBase::XBase() : + exception(STDEXCEPTARG), + m_what() { // do nothing } -XBase::XBase(const CString& msg) : exception(STDEXCEPTARG), m_what(msg) +XBase::XBase(const CString& msg) : + exception(STDEXCEPTARG), + m_what(msg) { // do nothing } @@ -30,7 +34,8 @@ XBase::~XBase() // do nothing } -const char* XBase::what() const +const char* +XBase::what() const { if (m_what.empty()) { m_what = getWhat(); @@ -38,8 +43,10 @@ const char* XBase::what() const return m_what.c_str(); } -CString XBase::format(const char* /*id*/, - const char* fmt, ...) const throw() +CString +XBase::format( + const char* /*id*/, + const char* fmt, ...) const throw() { // FIXME -- use id to lookup formating string // FIXME -- format string with arguments @@ -51,22 +58,26 @@ CString XBase::format(const char* /*id*/, // MXErrno // -MXErrno::MXErrno() : m_errno(errno) +MXErrno::MXErrno() : + m_errno(errno) { // do nothing } -MXErrno::MXErrno(int err) : m_errno(err) +MXErrno::MXErrno(int err) : + m_errno(err) { // do nothing } -int MXErrno::getErrno() const +int +MXErrno::getErrno() const { return m_errno; } -const char* MXErrno::getErrstr() const +const char* +MXErrno::getErrstr() const { return strerror(m_errno); } diff --git a/base/XBase.h b/base/XBase.h index c654de6e..1e4c208c 100644 --- a/base/XBase.h +++ b/base/XBase.h @@ -21,7 +21,7 @@ protected: // look up a message and format it virtual CString format(const char* id, - const char* defaultFormat, ...) const throw(); + const char* defaultFormat, ...) const throw(); private: mutable CString m_what; diff --git a/base/common.h b/base/common.h index c29d7543..e31a1b73 100644 --- a/base/common.h +++ b/base/common.h @@ -42,4 +42,6 @@ #define NULL 0 #endif +#include + #endif diff --git a/base/stdistream.h b/base/stdistream.h index 1cbbdcbd..440a33fe 100644 --- a/base/stdistream.h +++ b/base/stdistream.h @@ -2,11 +2,14 @@ #if !defined(CONFIG_PLATFORM_LINUX) #include #else +// some versions of libstdc++ don't have +// FIXME -- only include iostream for versions that don't have istream #include #endif #include "stdpost.h" #if defined(CONFIG_PLATFORM_WIN32) && defined(_MSC_VER) +// istream has no overloads for __int* types inline std::istream& operator>>(std::istream& s, SInt8& i) { return s >> (signed char&)i; } diff --git a/base/stdostream.h b/base/stdostream.h index 11a1b361..fd434281 100644 --- a/base/stdostream.h +++ b/base/stdostream.h @@ -2,6 +2,8 @@ #if !defined(CONFIG_PLATFORM_LINUX) #include #else +// some versions of libstdc++ don't have +// FIXME -- only include iostream for versions that don't have ostream #include #endif #include "stdpost.h" diff --git a/client/CClient.cpp b/client/CClient.cpp index 3d0e4d89..394efdf0 100644 --- a/client/CClient.cpp +++ b/client/CClient.cpp @@ -1,19 +1,19 @@ #include "CClient.h" +#include "CClipboard.h" #include "CInputPacketStream.h" #include "COutputPacketStream.h" #include "CProtocolUtil.h" -#include "CClipboard.h" #include "ISecondaryScreen.h" #include "ProtocolTypes.h" -#include "CLock.h" -#include "CLog.h" -#include "CThread.h" -#include "CTimerThread.h" -#include "TMethodJob.h" #include "XScreen.h" #include "XSynergy.h" +#include "XSocket.h" +#include "CLock.h" +#include "CThread.h" +#include "CTimerThread.h" #include "XThread.h" -#include +#include "CLog.h" +#include "TMethodJob.h" #include // hack to work around operator=() bug in STL in g++ prior to v3 @@ -28,15 +28,16 @@ // CClient // -CClient::CClient(const CString& clientName) : - m_name(clientName), - m_input(NULL), - m_output(NULL), - m_screen(NULL), - m_camp(false), - m_active(false), - m_seqNum(0), - m_ignoreMove(false) +CClient::CClient( + const CString& clientName) : + m_name(clientName), + m_input(NULL), + m_output(NULL), + m_screen(NULL), + m_camp(false), + m_active(false), + m_seqNum(0), + m_ignoreMove(false) { // do nothing } @@ -46,12 +47,16 @@ CClient::~CClient() // do nothing } -void CClient::camp(bool on) +void +CClient::camp( + bool on) { m_camp = on; } -bool CClient::run(const CNetworkAddress& serverAddress) +bool +CClient::run( + const CNetworkAddress& serverAddress) { CThread* thread = NULL; try { @@ -128,12 +133,15 @@ bool CClient::run(const CNetworkAddress& serverAddress) } } -void CClient::quit() +void +CClient::quit() { m_screen->stop(); } -void CClient::onClipboardChanged(ClipboardID id) +void +CClient::onClipboardChanged( + ClipboardID id) { log((CLOG_DEBUG "sending clipboard %d changed", id)); CLock lock(&m_mutex); @@ -169,7 +177,8 @@ void CClient::onClipboardChanged(ClipboardID id) } } -void CClient::onResolutionChanged() +void +CClient::onResolutionChanged() { log((CLOG_DEBUG "resolution changed")); @@ -183,7 +192,8 @@ void CClient::onResolutionChanged() } #include "CTCPSocket.h" // FIXME -void CClient::runSession(void*) +void +CClient::runSession(void*) { log((CLOG_DEBUG "starting client \"%s\"", m_name.c_str())); @@ -401,7 +411,8 @@ void CClient::runSession(void*) #elif defined(CONFIG_PLATFORM_UNIX) #include "CXWindowsSecondaryScreen.h" #endif -void CClient::openSecondaryScreen() +void +CClient::openSecondaryScreen() { assert(m_screen == NULL); @@ -428,7 +439,8 @@ void CClient::openSecondaryScreen() m_screen->open(this); } -void CClient::closeSecondaryScreen() +void +CClient::closeSecondaryScreen() { assert(m_screen != NULL); @@ -447,7 +459,8 @@ void CClient::closeSecondaryScreen() m_screen = NULL; } -void CClient::onEnter() +void +CClient::onEnter() { SInt16 x, y; UInt16 mask; @@ -460,7 +473,8 @@ void CClient::onEnter() m_screen->enter(x, y, static_cast(mask)); } -void CClient::onLeave() +void +CClient::onLeave() { log((CLOG_DEBUG1 "recv leave")); @@ -504,7 +518,8 @@ void CClient::onLeave() } } -void CClient::onGrabClipboard() +void +CClient::onGrabClipboard() { ClipboardID id; UInt32 seqNum; @@ -524,7 +539,8 @@ void CClient::onGrabClipboard() m_screen->grabClipboard(id); } -void CClient::onScreenSaver() +void +CClient::onScreenSaver() { SInt8 on; { @@ -535,13 +551,15 @@ void CClient::onScreenSaver() // FIXME } -void CClient::onQueryInfo() +void +CClient::onQueryInfo() { CLock lock(&m_mutex); onQueryInfoNoLock(); } -void CClient::onQueryInfoNoLock() +void +CClient::onQueryInfoNoLock() { SInt32 x, y, w, h; m_screen->getMousePos(&x, &y); @@ -552,14 +570,16 @@ void CClient::onQueryInfoNoLock() CProtocolUtil::writef(m_output, kMsgDInfo, w, h, zoneSize, x, y); } -void CClient::onInfoAcknowledgment() +void +CClient::onInfoAcknowledgment() { log((CLOG_DEBUG1 "recv info acknowledgment")); CLock lock(&m_mutex); m_ignoreMove = false; } -void CClient::onSetClipboard() +void +CClient::onSetClipboard() { ClipboardID id; CString data; @@ -584,7 +604,8 @@ void CClient::onSetClipboard() m_screen->setClipboard(id, &clipboard); } -void CClient::onKeyDown() +void +CClient::onKeyDown() { UInt16 id, mask; { @@ -596,7 +617,8 @@ void CClient::onKeyDown() static_cast(mask)); } -void CClient::onKeyRepeat() +void +CClient::onKeyRepeat() { UInt16 id, mask, count; { @@ -609,7 +631,8 @@ void CClient::onKeyRepeat() count); } -void CClient::onKeyUp() +void +CClient::onKeyUp() { UInt16 id, mask; { @@ -621,7 +644,8 @@ void CClient::onKeyUp() static_cast(mask)); } -void CClient::onMouseDown() +void +CClient::onMouseDown() { SInt8 id; { @@ -632,7 +656,8 @@ void CClient::onMouseDown() m_screen->mouseDown(static_cast(id)); } -void CClient::onMouseUp() +void +CClient::onMouseUp() { SInt8 id; { @@ -643,7 +668,8 @@ void CClient::onMouseUp() m_screen->mouseUp(static_cast(id)); } -void CClient::onMouseMove() +void +CClient::onMouseMove() { bool ignore; SInt16 x, y; @@ -658,7 +684,8 @@ void CClient::onMouseMove() } } -void CClient::onMouseWheel() +void +CClient::onMouseWheel() { SInt16 delta; { @@ -669,7 +696,8 @@ void CClient::onMouseWheel() m_screen->mouseWheel(delta); } -void CClient::onErrorIncompatible() +void +CClient::onErrorIncompatible() { SInt32 major, minor; CLock lock(&m_mutex); @@ -677,17 +705,20 @@ void CClient::onErrorIncompatible() log((CLOG_ERR "server has incompatible version %d.%d", major, minor)); } -void CClient::onErrorBusy() +void +CClient::onErrorBusy() { log((CLOG_ERR "server already has a connected client with name \"%s\"", m_name.c_str())); } -void CClient::onErrorUnknown() +void +CClient::onErrorUnknown() { log((CLOG_ERR "server refused client with name \"%s\"", m_name.c_str())); } -void CClient::onErrorBad() +void +CClient::onErrorBad() { log((CLOG_ERR "server disconnected due to a protocol error")); } diff --git a/client/CClient.h b/client/CClient.h index 992d51c9..d2dacc07 100644 --- a/client/CClient.h +++ b/client/CClient.h @@ -1,11 +1,10 @@ #ifndef CCLIENT_H #define CCLIENT_H -#include "CMutex.h" -#include "CString.h" -#include "BasicTypes.h" #include "ClipboardTypes.h" #include "IClipboard.h" +#include "CMutex.h" +#include "CString.h" class CNetworkAddress; class IInputStream; diff --git a/client/CMSWindowsSecondaryScreen.cpp b/client/CMSWindowsSecondaryScreen.cpp index 4cc19a4f..895ae78f 100644 --- a/client/CMSWindowsSecondaryScreen.cpp +++ b/client/CMSWindowsSecondaryScreen.cpp @@ -1,27 +1,26 @@ #include "CMSWindowsSecondaryScreen.h" -#include "CMSWindowsClipboard.h" #include "CClient.h" -#include "CPlatform.h" #include "CClipboard.h" -#include "CLock.h" -#include "CLog.h" -#include "CThread.h" +#include "CMSWindowsClipboard.h" +#include "CPlatform.h" #include "XScreen.h" -#include -#include +#include "CLock.h" +#include "CThread.h" +#include "CLog.h" +#include // // CMSWindowsSecondaryScreen // CMSWindowsSecondaryScreen::CMSWindowsSecondaryScreen() : - m_client(NULL), - m_threadID(0), - m_desk(NULL), - m_deskName(), - m_window(NULL), - m_active(false), - m_nextClipboardWindow(NULL) + m_client(NULL), + m_threadID(0), + m_desk(NULL), + m_deskName(), + m_window(NULL), + m_active(false), + m_nextClipboardWindow(NULL) { m_is95Family = CPlatform::isWindows95Family(); @@ -35,7 +34,8 @@ CMSWindowsSecondaryScreen::~CMSWindowsSecondaryScreen() assert(m_window == NULL); } -void CMSWindowsSecondaryScreen::run() +void +CMSWindowsSecondaryScreen::run() { // must call run() from same thread as open() assert(m_threadID == GetCurrentThreadId()); @@ -61,12 +61,15 @@ void CMSWindowsSecondaryScreen::run() } } -void CMSWindowsSecondaryScreen::stop() +void +CMSWindowsSecondaryScreen::stop() { doStop(); } -void CMSWindowsSecondaryScreen::open(CClient* client) +void +CMSWindowsSecondaryScreen::open( + CClient* client) { assert(m_client == NULL); assert(client != NULL); @@ -82,15 +85,17 @@ void CMSWindowsSecondaryScreen::open(CClient* client) updateModifiers(); // assume primary has all clipboards - for (ClipboardID id = 0; id < kClipboardEnd; ++id) + for (ClipboardID id = 0; id < kClipboardEnd; ++id) { grabClipboard(id); + } // hide the cursor m_active = true; leave(); } -void CMSWindowsSecondaryScreen::close() +void +CMSWindowsSecondaryScreen::close() { assert(m_client != NULL); @@ -101,8 +106,11 @@ void CMSWindowsSecondaryScreen::close() m_client = NULL; } -void CMSWindowsSecondaryScreen::enter( - SInt32 x, SInt32 y, KeyModifierMask mask) +void +CMSWindowsSecondaryScreen::enter( + SInt32 x, + SInt32 y, + KeyModifierMask mask) { CLock lock(&m_mutex); assert(m_window != NULL); @@ -134,7 +142,8 @@ void CMSWindowsSecondaryScreen::enter( onEnter(x, y); } -void CMSWindowsSecondaryScreen::leave() +void +CMSWindowsSecondaryScreen::leave() { CLock lock(&m_mutex); assert(m_window != NULL); @@ -171,8 +180,10 @@ void CMSWindowsSecondaryScreen::leave() } } -void CMSWindowsSecondaryScreen::keyDown( - KeyID key, KeyModifierMask mask) +void +CMSWindowsSecondaryScreen::keyDown( + KeyID key, + KeyModifierMask mask) { Keystrokes keys; UINT virtualKey; @@ -184,8 +195,9 @@ void CMSWindowsSecondaryScreen::keyDown( // get the sequence of keys to simulate key press and the final // modifier state. m_mask = mapKey(keys, virtualKey, key, mask, kPress); - if (keys.empty()) + if (keys.empty()) { return; + } // generate key events doKeystrokes(keys, 1); @@ -210,8 +222,11 @@ void CMSWindowsSecondaryScreen::keyDown( } } -void CMSWindowsSecondaryScreen::keyRepeat( - KeyID key, KeyModifierMask mask, SInt32 count) +void +CMSWindowsSecondaryScreen::keyRepeat( + KeyID key, + KeyModifierMask mask, + SInt32 count) { Keystrokes keys; UINT virtualKey; @@ -223,15 +238,18 @@ void CMSWindowsSecondaryScreen::keyRepeat( // get the sequence of keys to simulate key repeat and the final // modifier state. m_mask = mapKey(keys, virtualKey, key, mask, kRepeat); - if (keys.empty()) + if (keys.empty()) { return; + } // generate key events doKeystrokes(keys, count); } -void CMSWindowsSecondaryScreen::keyUp( - KeyID key, KeyModifierMask mask) +void +CMSWindowsSecondaryScreen::keyUp( + KeyID key, + KeyModifierMask mask) { Keystrokes keys; UINT virtualKey; @@ -243,8 +261,9 @@ void CMSWindowsSecondaryScreen::keyUp( // get the sequence of keys to simulate key release and the final // modifier state. m_mask = mapKey(keys, virtualKey, key, mask, kRelease); - if (keys.empty()) + if (keys.empty()) { return; + } // generate key events doKeystrokes(keys, 1); @@ -290,7 +309,9 @@ void CMSWindowsSecondaryScreen::keyUp( } } -void CMSWindowsSecondaryScreen::mouseDown(ButtonID button) +void +CMSWindowsSecondaryScreen::mouseDown( + ButtonID button) { CLock lock(&m_mutex); assert(m_window != NULL); @@ -300,11 +321,14 @@ void CMSWindowsSecondaryScreen::mouseDown(ButtonID button) DWORD flags = mapButton(button, true); // send event - if (flags != 0) + if (flags != 0) { mouse_event(flags, 0, 0, 0, 0); + } } -void CMSWindowsSecondaryScreen::mouseUp(ButtonID button) +void +CMSWindowsSecondaryScreen::mouseUp( + ButtonID button) { CLock lock(&m_mutex); assert(m_window != NULL); @@ -314,12 +338,15 @@ void CMSWindowsSecondaryScreen::mouseUp(ButtonID button) DWORD flags = mapButton(button, false); // send event - if (flags != 0) + if (flags != 0) { mouse_event(flags, 0, 0, 0, 0); + } } -void CMSWindowsSecondaryScreen::mouseMove( - SInt32 x, SInt32 y) +void +CMSWindowsSecondaryScreen::mouseMove( + SInt32 x, + SInt32 y) { CLock lock(&m_mutex); assert(m_window != NULL); @@ -333,7 +360,9 @@ void CMSWindowsSecondaryScreen::mouseMove( 0, 0); } -void CMSWindowsSecondaryScreen::mouseWheel(SInt32 delta) +void +CMSWindowsSecondaryScreen::mouseWheel( + SInt32 delta) { CLock lock(&m_mutex); assert(m_window != NULL); @@ -342,8 +371,10 @@ void CMSWindowsSecondaryScreen::mouseWheel(SInt32 delta) mouse_event(MOUSEEVENTF_WHEEL, 0, 0, delta, 0); } -void CMSWindowsSecondaryScreen::setClipboard( - ClipboardID /*id*/, const IClipboard* src) +void +CMSWindowsSecondaryScreen::setClipboard( + ClipboardID /*id*/, + const IClipboard* src) { CLock lock(&m_mutex); assert(m_window != NULL); @@ -352,8 +383,9 @@ void CMSWindowsSecondaryScreen::setClipboard( CClipboard::copy(&dst, src); } -void CMSWindowsSecondaryScreen::grabClipboard( - ClipboardID /*id*/) +void +CMSWindowsSecondaryScreen::grabClipboard( + ClipboardID /*id*/) { CLock lock(&m_mutex); assert(m_window != NULL); @@ -364,8 +396,10 @@ void CMSWindowsSecondaryScreen::grabClipboard( } } -void CMSWindowsSecondaryScreen::getMousePos( - SInt32* x, SInt32* y) const +void +CMSWindowsSecondaryScreen::getMousePos( + SInt32* x, + SInt32* y) const { assert(x != NULL); assert(y != NULL); @@ -385,19 +419,24 @@ void CMSWindowsSecondaryScreen::getMousePos( } } -void CMSWindowsSecondaryScreen::getSize( - SInt32* width, SInt32* height) const +void +CMSWindowsSecondaryScreen::getSize( + SInt32* width, + SInt32* height) const { getScreenSize(width, height); } -SInt32 CMSWindowsSecondaryScreen::getJumpZoneSize() const +SInt32 +CMSWindowsSecondaryScreen::getJumpZoneSize() const { return 0; } -void CMSWindowsSecondaryScreen::getClipboard( - ClipboardID /*id*/, IClipboard* dst) const +void +CMSWindowsSecondaryScreen::getClipboard( + ClipboardID /*id*/, + IClipboard* dst) const { CLock lock(&m_mutex); assert(m_window != NULL); @@ -406,7 +445,8 @@ void CMSWindowsSecondaryScreen::getClipboard( CClipboard::copy(dst, &src); } -void CMSWindowsSecondaryScreen::onOpenDisplay() +void +CMSWindowsSecondaryScreen::onOpenDisplay() { assert(m_window == NULL); @@ -426,7 +466,8 @@ void CMSWindowsSecondaryScreen::onOpenDisplay() } } -void CMSWindowsSecondaryScreen::onCloseDisplay() +void +CMSWindowsSecondaryScreen::onCloseDisplay() { // disconnect from desktop if (m_is95Family) { @@ -443,7 +484,9 @@ void CMSWindowsSecondaryScreen::onCloseDisplay() assert(m_desk == NULL); } -bool CMSWindowsSecondaryScreen::onPreTranslate(MSG* msg) +bool +CMSWindowsSecondaryScreen::onPreTranslate( + MSG* msg) { // handle event switch (msg->message) { @@ -466,9 +509,12 @@ bool CMSWindowsSecondaryScreen::onPreTranslate(MSG* msg) return false; } -LRESULT CMSWindowsSecondaryScreen::onEvent( - HWND hwnd, UINT msg, - WPARAM wParam, LPARAM lParam) +LRESULT +CMSWindowsSecondaryScreen::onEvent( + HWND hwnd, + UINT msg, + WPARAM wParam, + LPARAM lParam) { switch (msg) { case WM_QUERYENDSESSION: @@ -516,10 +562,12 @@ LRESULT CMSWindowsSecondaryScreen::onEvent( return 0; case WM_CHANGECBCHAIN: - if (m_nextClipboardWindow == (HWND)wParam) + if (m_nextClipboardWindow == (HWND)wParam) { m_nextClipboardWindow = (HWND)lParam; - else + } + else { SendMessage(m_nextClipboardWindow, msg, wParam, lParam); + } return 0; case WM_DISPLAYCHANGE: @@ -532,7 +580,10 @@ LRESULT CMSWindowsSecondaryScreen::onEvent( return DefWindowProc(hwnd, msg, wParam, lParam); } -void CMSWindowsSecondaryScreen::onEnter(SInt32 x, SInt32 y) +void +CMSWindowsSecondaryScreen::onEnter( + SInt32 x, + SInt32 y) { // warp to requested location SInt32 w, h; @@ -546,7 +597,8 @@ void CMSWindowsSecondaryScreen::onEnter(SInt32 x, SInt32 y) ShowWindow(m_window, SW_HIDE); } -void CMSWindowsSecondaryScreen::onLeave() +void +CMSWindowsSecondaryScreen::onLeave() { // move hider window under the mouse (rather than moving the mouse // somewhere else on the screen) @@ -558,7 +610,8 @@ void CMSWindowsSecondaryScreen::onLeave() ShowWindow(m_window, SW_SHOWNORMAL); } -bool CMSWindowsSecondaryScreen::openDesktop() +bool +CMSWindowsSecondaryScreen::openDesktop() { CLock lock(&m_mutex); @@ -584,7 +637,8 @@ bool CMSWindowsSecondaryScreen::openDesktop() return true; } -void CMSWindowsSecondaryScreen::closeDesktop() +void +CMSWindowsSecondaryScreen::closeDesktop() { CLock lock(&m_mutex); @@ -599,7 +653,9 @@ void CMSWindowsSecondaryScreen::closeDesktop() } } -bool CMSWindowsSecondaryScreen::switchDesktop(HDESK desk) +bool +CMSWindowsSecondaryScreen::switchDesktop( + HDESK desk) { CLock lock(&m_mutex); @@ -680,7 +736,8 @@ bool CMSWindowsSecondaryScreen::switchDesktop(HDESK desk) return true; } -void CMSWindowsSecondaryScreen::syncDesktop() const +void +CMSWindowsSecondaryScreen::syncDesktop() const { // note -- mutex must be locked on entry @@ -697,7 +754,8 @@ void CMSWindowsSecondaryScreen::syncDesktop() const AttachThreadInput(threadID, m_threadID, TRUE); } -CString CMSWindowsSecondaryScreen::getCurrentDesktopName() const +CString +CMSWindowsSecondaryScreen::getCurrentDesktopName() const { return m_deskName; } @@ -1189,8 +1247,10 @@ static const UINT* g_mapTable[] = /* 0xfc */ NULL, g_terminal, g_function, g_miscellany }; -DWORD CMSWindowsSecondaryScreen::mapButton( - ButtonID button, bool press) const +DWORD +CMSWindowsSecondaryScreen::mapButton( + ButtonID button, + bool press) const { // map button id to button flag switch (button) { @@ -1208,11 +1268,13 @@ DWORD CMSWindowsSecondaryScreen::mapButton( } } -KeyModifierMask CMSWindowsSecondaryScreen::mapKey( - Keystrokes& keys, - UINT& virtualKey, - KeyID id, KeyModifierMask mask, - EKeyAction action) const +KeyModifierMask +CMSWindowsSecondaryScreen::mapKey( + Keystrokes& keys, + UINT& virtualKey, + KeyID id, + KeyModifierMask mask, + EKeyAction action) const { // lookup the key table const UInt32 mapID = ((id >> 8) & 0xff); @@ -1264,12 +1326,15 @@ KeyModifierMask CMSWindowsSecondaryScreen::mapKey( outMask &= ~KeyModifierShift; // convert system modifier mask to our mask - if (HIBYTE(vk) & 1) + if (HIBYTE(vk) & 1) { outMask |= KeyModifierShift; - if (HIBYTE(vk) & 2) + } + if (HIBYTE(vk) & 2) { outMask |= KeyModifierControl; - if (HIBYTE(vk) & 4) + } + if (HIBYTE(vk) & 4) { outMask |= KeyModifierAlt; + } log((CLOG_DEBUG2 "character %d to virtual key %d mask 0x%04x", code, LOBYTE(vk), outMask)); // handle combination of caps-lock and shift. if caps-lock is @@ -1457,8 +1522,9 @@ KeyModifierMask CMSWindowsSecondaryScreen::mapKey( // add the key event keystroke.m_virtualKey = virtualKey; - if (isExtended) + if (isExtended) { keystroke.m_virtualKey |= 0x100; + } switch (action) { case kPress: keystroke.m_press = true; @@ -1523,12 +1589,15 @@ KeyModifierMask CMSWindowsSecondaryScreen::mapKey( return mask; } -void CMSWindowsSecondaryScreen::doKeystrokes( - const Keystrokes& keys, SInt32 count) +void +CMSWindowsSecondaryScreen::doKeystrokes( + const Keystrokes& keys, + SInt32 count) { // do nothing if no keys or no repeats - if (count < 1 || keys.empty()) + if (count < 1 || keys.empty()) { return; + } // generate key events for (Keystrokes::const_iterator k = keys.begin(); k != keys.end(); ) { @@ -1556,7 +1625,8 @@ void CMSWindowsSecondaryScreen::doKeystrokes( } } -void CMSWindowsSecondaryScreen::updateKeys() +void +CMSWindowsSecondaryScreen::updateKeys() { // clear key state memset(m_keys, 0, sizeof(m_keys)); @@ -1579,29 +1649,40 @@ void CMSWindowsSecondaryScreen::updateKeys() m_keys[VK_SCROLL] = static_cast(GetKeyState(VK_SCROLL)); } -void CMSWindowsSecondaryScreen::updateModifiers() +void +CMSWindowsSecondaryScreen::updateModifiers() { // update active modifier mask m_mask = 0; - if ((m_keys[VK_LSHIFT] & 0x80) != 0 || (m_keys[VK_RSHIFT] & 0x80) != 0) + if ((m_keys[VK_LSHIFT] & 0x80) != 0 || (m_keys[VK_RSHIFT] & 0x80) != 0) { m_mask |= KeyModifierShift; - if ((m_keys[VK_LCONTROL] & 0x80) != 0 || (m_keys[VK_RCONTROL] & 0x80) != 0) + } + if ((m_keys[VK_LCONTROL] & 0x80) != 0 || + (m_keys[VK_RCONTROL] & 0x80) != 0) { m_mask |= KeyModifierControl; - if ((m_keys[VK_LMENU] & 0x80) != 0 || (m_keys[VK_RMENU] & 0x80) != 0) + } + if ((m_keys[VK_LMENU] & 0x80) != 0 || (m_keys[VK_RMENU] & 0x80) != 0) { m_mask |= KeyModifierAlt; - if ((m_keys[VK_LWIN] & 0x80) != 0 || (m_keys[VK_RWIN] & 0x80) != 0) + } + if ((m_keys[VK_LWIN] & 0x80) != 0 || (m_keys[VK_RWIN] & 0x80) != 0) { m_mask |= KeyModifierMeta; - if ((m_keys[VK_CAPITAL] & 0x01) != 0) + } + if ((m_keys[VK_CAPITAL] & 0x01) != 0) { m_mask |= KeyModifierCapsLock; - if ((m_keys[VK_NUMLOCK] & 0x01) != 0) + } + if ((m_keys[VK_NUMLOCK] & 0x01) != 0) { m_mask |= KeyModifierNumLock; - if ((m_keys[VK_SCROLL] & 0x01) != 0) + } + if ((m_keys[VK_SCROLL] & 0x01) != 0) { m_mask |= KeyModifierScrollLock; + } log((CLOG_DEBUG2 "modifiers on update: 0x%04x", m_mask)); } -void CMSWindowsSecondaryScreen::toggleKey( - UINT virtualKey, KeyModifierMask mask) +void +CMSWindowsSecondaryScreen::toggleKey( + UINT virtualKey, + KeyModifierMask mask) { // send key events to simulate a press and release sendKeyEvent(virtualKey, true); @@ -1612,13 +1693,15 @@ void CMSWindowsSecondaryScreen::toggleKey( m_keys[virtualKey & 0xff] ^= 0x01; } -UINT CMSWindowsSecondaryScreen::virtualKeyToScanCode( - UINT& virtualKey) +UINT +CMSWindowsSecondaryScreen::virtualKeyToScanCode( + UINT& virtualKey) { // try mapping given virtual key UINT code = MapVirtualKey(virtualKey & 0xff, 0); - if (code != 0) + if (code != 0) { return code; + } // no dice. if the virtual key distinguishes between left/right // then try the one that doesn't distinguish sides. windows (or @@ -1663,12 +1746,14 @@ UINT CMSWindowsSecondaryScreen::virtualKeyToScanCode( } } -bool CMSWindowsSecondaryScreen::isExtendedKey( - UINT virtualKey) +bool +CMSWindowsSecondaryScreen::isExtendedKey( + UINT virtualKey) { // see if we've already encoded the extended flag - if ((virtualKey & 0x100) != 0) + if ((virtualKey & 0x100) != 0) { return true; + } // check known virtual keys switch (virtualKey & 0xff) { @@ -1685,14 +1770,18 @@ bool CMSWindowsSecondaryScreen::isExtendedKey( } } -void CMSWindowsSecondaryScreen::sendKeyEvent( - UINT virtualKey, bool press) +void +CMSWindowsSecondaryScreen::sendKeyEvent( + UINT virtualKey, + bool press) { DWORD flags = 0; - if (isExtendedKey(virtualKey)) + if (isExtendedKey(virtualKey)) { flags |= KEYEVENTF_EXTENDEDKEY; - if (!press) + } + if (!press) { flags |= KEYEVENTF_KEYUP; + } const UINT code = virtualKeyToScanCode(virtualKey); keybd_event(static_cast(virtualKey & 0xff), static_cast(code), flags, 0); diff --git a/client/CMSWindowsSecondaryScreen.h b/client/CMSWindowsSecondaryScreen.h index d8cce84b..176203f2 100644 --- a/client/CMSWindowsSecondaryScreen.h +++ b/client/CMSWindowsSecondaryScreen.h @@ -7,7 +7,8 @@ #include "CString.h" #include "stdvector.h" -class CMSWindowsSecondaryScreen : public CMSWindowsScreen, public ISecondaryScreen { +class CMSWindowsSecondaryScreen : public CMSWindowsScreen, + public ISecondaryScreen { public: CMSWindowsSecondaryScreen(); virtual ~CMSWindowsSecondaryScreen(); @@ -18,7 +19,7 @@ public: virtual void open(CClient*); virtual void close(); virtual void enter(SInt32 xAbsolute, SInt32 yAbsolute, - KeyModifierMask mask); + KeyModifierMask mask); virtual void leave(); virtual void keyDown(KeyID, KeyModifierMask); virtual void keyRepeat(KeyID, KeyModifierMask, SInt32 count); @@ -68,7 +69,7 @@ private: // key and button queries and operations DWORD mapButton(ButtonID button, bool press) const; KeyModifierMask mapKey(Keystrokes&, UINT& virtualKey, KeyID, - KeyModifierMask, EKeyAction) const; + KeyModifierMask, EKeyAction) const; void doKeystrokes(const Keystrokes&, SInt32 count); void updateKeys(); diff --git a/client/CXWindowsSecondaryScreen.cpp b/client/CXWindowsSecondaryScreen.cpp index e3e3aa97..46a6b3f1 100644 --- a/client/CXWindowsSecondaryScreen.cpp +++ b/client/CXWindowsSecondaryScreen.cpp @@ -1,10 +1,9 @@ #include "CXWindowsSecondaryScreen.h" +#include "CClient.h" #include "CXWindowsClipboard.h" #include "CXWindowsUtil.h" -#include "CClient.h" #include "CThread.h" #include "CLog.h" -#include #include #include #define XK_MISCELLANY @@ -17,8 +16,8 @@ // CXWindowsSecondaryScreen::CXWindowsSecondaryScreen() : - m_client(NULL), - m_window(None) + m_client(NULL), + m_window(None) { // do nothing } @@ -28,7 +27,8 @@ CXWindowsSecondaryScreen::~CXWindowsSecondaryScreen() assert(m_window == None); } -void CXWindowsSecondaryScreen::run() +void +CXWindowsSecondaryScreen::run() { assert(m_window != None); @@ -41,34 +41,39 @@ void CXWindowsSecondaryScreen::run() // handle event switch (xevent.type) { - case MappingNotify: { - // keyboard mapping changed - CDisplayLock display(this); - XRefreshKeyboardMapping(&xevent.xmapping); - updateKeys(display); - updateKeycodeMap(display); - updateModifierMap(display); - updateModifiers(display); + case MappingNotify: + { + // keyboard mapping changed + CDisplayLock display(this); + XRefreshKeyboardMapping(&xevent.xmapping); + updateKeys(display); + updateKeycodeMap(display); + updateModifierMap(display); + updateModifiers(display); + } break; - } - case LeaveNotify: { - // mouse moved out of hider window somehow. hide the window. - assert(m_window != None); - CDisplayLock display(this); - XUnmapWindow(display, m_window); + case LeaveNotify: + { + // mouse moved out of hider window somehow. hide the window. + assert(m_window != None); + CDisplayLock display(this); + XUnmapWindow(display, m_window); + } break; } - } } } -void CXWindowsSecondaryScreen::stop() +void +CXWindowsSecondaryScreen::stop() { doStop(); } -void CXWindowsSecondaryScreen::open(CClient* client) +void +CXWindowsSecondaryScreen::open( + CClient* client) { assert(m_client == NULL); assert(client != NULL); @@ -84,8 +89,9 @@ void CXWindowsSecondaryScreen::open(CClient* client) CDisplayLock display(this); int majorOpcode, firstEvent, firstError; if (!XQueryExtension(display, XTestExtensionName, - &majorOpcode, &firstEvent, &firstError)) + &majorOpcode, &firstEvent, &firstError)) { throw int(6); // FIXME -- make exception for this + } // update key state updateKeys(display); @@ -102,11 +108,13 @@ void CXWindowsSecondaryScreen::open(CClient* client) m_capsLockHalfDuplex = true; // assume primary has all clipboards - for (ClipboardID id = 0; id < kClipboardEnd; ++id) + for (ClipboardID id = 0; id < kClipboardEnd; ++id) { grabClipboard(id); + } } -void CXWindowsSecondaryScreen::close() +void +CXWindowsSecondaryScreen::close() { assert(m_client != NULL); @@ -117,8 +125,11 @@ void CXWindowsSecondaryScreen::close() m_client = NULL; } -void CXWindowsSecondaryScreen::enter( - SInt32 x, SInt32 y, KeyModifierMask mask) +void +CXWindowsSecondaryScreen::enter( + SInt32 x, + SInt32 y, + KeyModifierMask mask) { assert(m_window != None); @@ -149,14 +160,17 @@ void CXWindowsSecondaryScreen::enter( XSync(display, False); } -void CXWindowsSecondaryScreen::leave() +void +CXWindowsSecondaryScreen::leave() { CDisplayLock display(this); leaveNoLock(display); } -void CXWindowsSecondaryScreen::keyDown( - KeyID key, KeyModifierMask mask) +void +CXWindowsSecondaryScreen::keyDown( + KeyID key, + KeyModifierMask mask) { Keystrokes keys; KeyCode keycode; @@ -164,8 +178,9 @@ void CXWindowsSecondaryScreen::keyDown( // get the sequence of keys to simulate key press and the final // modifier state. m_mask = mapKey(keys, keycode, key, mask, kPress); - if (keys.empty()) + if (keys.empty()) { return; + } // generate key events doKeystrokes(keys, 1); @@ -174,8 +189,11 @@ void CXWindowsSecondaryScreen::keyDown( m_keys[keycode] = true; } -void CXWindowsSecondaryScreen::keyRepeat( - KeyID key, KeyModifierMask mask, SInt32 count) +void +CXWindowsSecondaryScreen::keyRepeat( + KeyID key, + KeyModifierMask mask, + SInt32 count) { Keystrokes keys; KeyCode keycode; @@ -183,15 +201,18 @@ void CXWindowsSecondaryScreen::keyRepeat( // get the sequence of keys to simulate key repeat and the final // modifier state. m_mask = mapKey(keys, keycode, key, mask, kRepeat); - if (keys.empty()) + if (keys.empty()) { return; + } // generate key events doKeystrokes(keys, count); } -void CXWindowsSecondaryScreen::keyUp( - KeyID key, KeyModifierMask mask) +void +CXWindowsSecondaryScreen::keyUp( + KeyID key, + KeyModifierMask mask) { Keystrokes keys; KeyCode keycode; @@ -199,8 +220,9 @@ void CXWindowsSecondaryScreen::keyUp( // get the sequence of keys to simulate key release and the final // modifier state. m_mask = mapKey(keys, keycode, key, mask, kRelease); - if (keys.empty()) + if (keys.empty()) { return; + } // generate key events doKeystrokes(keys, 1); @@ -209,28 +231,37 @@ void CXWindowsSecondaryScreen::keyUp( m_keys[keycode] = false; } -void CXWindowsSecondaryScreen::mouseDown(ButtonID button) +void +CXWindowsSecondaryScreen::mouseDown( + ButtonID button) { CDisplayLock display(this); XTestFakeButtonEvent(display, mapButton(button), True, CurrentTime); XSync(display, False); } -void CXWindowsSecondaryScreen::mouseUp(ButtonID button) +void +CXWindowsSecondaryScreen::mouseUp( + ButtonID button) { CDisplayLock display(this); XTestFakeButtonEvent(display, mapButton(button), False, CurrentTime); XSync(display, False); } -void CXWindowsSecondaryScreen::mouseMove(SInt32 x, SInt32 y) +void +CXWindowsSecondaryScreen::mouseMove( + SInt32 x, + SInt32 y) { CDisplayLock display(this); XTestFakeMotionEvent(display, getScreen(), x, y, CurrentTime); XSync(display, False); } -void CXWindowsSecondaryScreen::mouseWheel(SInt32 delta) +void +CXWindowsSecondaryScreen::mouseWheel( + SInt32 delta) { // choose button depending on rotation direction const unsigned int button = (delta >= 0) ? 4 : 5; @@ -249,19 +280,25 @@ void CXWindowsSecondaryScreen::mouseWheel(SInt32 delta) XSync(display, False); } -void CXWindowsSecondaryScreen::setClipboard( - ClipboardID id, const IClipboard* clipboard) +void +CXWindowsSecondaryScreen::setClipboard( + ClipboardID id, + const IClipboard* clipboard) { setDisplayClipboard(id, clipboard); } -void CXWindowsSecondaryScreen::grabClipboard(ClipboardID id) +void +CXWindowsSecondaryScreen::grabClipboard( + ClipboardID id) { setDisplayClipboard(id, NULL); } -void CXWindowsSecondaryScreen::getMousePos( - SInt32* x, SInt32* y) const +void +CXWindowsSecondaryScreen::getMousePos( + SInt32* x, + SInt32* y) const { CDisplayLock display(this); int xTmp, yTmp, dummy; @@ -273,25 +310,31 @@ void CXWindowsSecondaryScreen::getMousePos( *y = yTmp; } -void CXWindowsSecondaryScreen::getSize( - SInt32* width, SInt32* height) const +void +CXWindowsSecondaryScreen::getSize( + SInt32* width, + SInt32* height) const { getScreenSize(width, height); } -SInt32 CXWindowsSecondaryScreen::getJumpZoneSize() const +SInt32 +CXWindowsSecondaryScreen::getJumpZoneSize() const { return 0; } -void CXWindowsSecondaryScreen::getClipboard( - ClipboardID id, IClipboard* clipboard) const +void +CXWindowsSecondaryScreen::getClipboard( + ClipboardID id, + IClipboard* clipboard) const { getDisplayClipboard(id, clipboard); } -void CXWindowsSecondaryScreen::onOpenDisplay( - Display* display) +void +CXWindowsSecondaryScreen::onOpenDisplay( + Display* display) { assert(m_window == None); @@ -318,15 +361,17 @@ void CXWindowsSecondaryScreen::onOpenDisplay( leaveNoLock(display); } -CXWindowsClipboard* CXWindowsSecondaryScreen::createClipboard( - ClipboardID id) +CXWindowsClipboard* +CXWindowsSecondaryScreen::createClipboard( + ClipboardID id) { CDisplayLock display(this); return new CXWindowsClipboard(display, m_window, id); } -void CXWindowsSecondaryScreen::onCloseDisplay( - Display* display) +void +CXWindowsSecondaryScreen::onCloseDisplay( + Display* display) { assert(m_window != None); @@ -340,14 +385,17 @@ void CXWindowsSecondaryScreen::onCloseDisplay( m_window = None; } -void CXWindowsSecondaryScreen::onLostClipboard( - ClipboardID id) +void +CXWindowsSecondaryScreen::onLostClipboard( + ClipboardID id) { // tell client that the clipboard was grabbed locally m_client->onClipboardChanged(id); } -void CXWindowsSecondaryScreen::leaveNoLock(Display* display) +void +CXWindowsSecondaryScreen::leaveNoLock( + Display* display) { assert(display != NULL); assert(m_window != None); @@ -368,18 +416,21 @@ void CXWindowsSecondaryScreen::leaveNoLock(Display* display) XWarpPointer(display, None, m_window, 0, 0, 0, 0, 0, 0); } -unsigned int CXWindowsSecondaryScreen::mapButton( - ButtonID id) const +unsigned int +CXWindowsSecondaryScreen::mapButton( + ButtonID id) const { // FIXME -- should use button mapping? return static_cast(id); } -KeyModifierMask CXWindowsSecondaryScreen::mapKey( - Keystrokes& keys, - KeyCode& keycode, - KeyID id, KeyModifierMask mask, - EKeyAction action) const +KeyModifierMask +CXWindowsSecondaryScreen::mapKey( + Keystrokes& keys, + KeyCode& keycode, + KeyID id, + KeyModifierMask mask, + EKeyAction action) const { // note -- must have display locked on entry @@ -602,11 +653,12 @@ KeyModifierMask CXWindowsSecondaryScreen::mapKey( return mask; } -bool CXWindowsSecondaryScreen::findKeyCode( - KeyCode& keycode, - unsigned int& maskOut, - KeyID id, - unsigned int maskIn) const +bool +CXWindowsSecondaryScreen::findKeyCode( + KeyCode& keycode, + unsigned int& maskOut, + KeyID id, + unsigned int maskIn) const { // if XK_Tab is requested with shift active then try XK_ISO_Left_Tab // instead. if that doesn't work, we'll fall back to XK_Tab with @@ -734,12 +786,15 @@ bool CXWindowsSecondaryScreen::findKeyCode( return true; } -void CXWindowsSecondaryScreen::doKeystrokes( - const Keystrokes& keys, SInt32 count) +void +CXWindowsSecondaryScreen::doKeystrokes( + const Keystrokes& keys, + SInt32 count) { // do nothing if no keys or no repeats - if (count < 1 || keys.empty()) + if (count < 1 || keys.empty()) { return; + } // lock display CDisplayLock display(this); @@ -774,29 +829,39 @@ void CXWindowsSecondaryScreen::doKeystrokes( XSync(display, False); } -unsigned int CXWindowsSecondaryScreen::maskToX( - KeyModifierMask inMask) const +unsigned int +CXWindowsSecondaryScreen::maskToX( + KeyModifierMask inMask) const { // FIXME -- should be configurable. also not using Mod3Mask. unsigned int outMask = 0; - if (inMask & KeyModifierShift) + if (inMask & KeyModifierShift) { outMask |= ShiftMask; - if (inMask & KeyModifierControl) + } + if (inMask & KeyModifierControl) { outMask |= ControlMask; - if (inMask & KeyModifierAlt) + } + if (inMask & KeyModifierAlt) { outMask |= Mod1Mask; - if (inMask & KeyModifierMeta) + } + if (inMask & KeyModifierMeta) { outMask |= Mod4Mask; - if (inMask & KeyModifierCapsLock) + } + if (inMask & KeyModifierCapsLock) { outMask |= m_capsLockMask; - if (inMask & KeyModifierNumLock) + } + if (inMask & KeyModifierNumLock) { outMask |= m_numLockMask; - if (inMask & KeyModifierScrollLock) + } + if (inMask & KeyModifierScrollLock) { outMask |= m_scrollLockMask; + } return outMask; } -void CXWindowsSecondaryScreen::updateKeys(Display* display) +void +CXWindowsSecondaryScreen::updateKeys( + Display* display) { // ask server which keys are pressed char keys[32]; @@ -815,8 +880,9 @@ void CXWindowsSecondaryScreen::updateKeys(Display* display) } } -void CXWindowsSecondaryScreen::updateModifiers( - Display* display) +void +CXWindowsSecondaryScreen::updateModifiers( + Display* display) { // query the pointer to get the keyboard state Window root, window; @@ -844,8 +910,9 @@ void CXWindowsSecondaryScreen::updateModifiers( } } -void CXWindowsSecondaryScreen::updateKeycodeMap( - Display* display) +void +CXWindowsSecondaryScreen::updateKeycodeMap( + Display* display) { // get the number of keycodes int minKeycode, maxKeycode; @@ -898,8 +965,9 @@ void CXWindowsSecondaryScreen::updateKeycodeMap( XFree(keysyms); } -void CXWindowsSecondaryScreen::updateModifierMap( - Display* display) +void +CXWindowsSecondaryScreen::updateModifierMap( + Display* display) { // get modifier map from server XModifierKeymap* keymap = XGetModifierMapping(display); @@ -927,8 +995,9 @@ void CXWindowsSecondaryScreen::updateModifierMap( m_keycodeToModifier.insert(std::make_pair(keycode, i)); // modifier is enabled if keycode isn't 0 - if (keycode != 0) + if (keycode != 0) { m_modifierMask |= bit; + } // modifier is a toggle if the keysym is a toggle modifier const KeySym keysym = XKeycodeToKeysym(display, keycode, 0); @@ -952,14 +1021,17 @@ void CXWindowsSecondaryScreen::updateModifierMap( XFreeModifiermap(keymap); } -void CXWindowsSecondaryScreen::toggleKey( - Display* display, - KeySym keysym, unsigned int mask) +void +CXWindowsSecondaryScreen::toggleKey( + Display* display, + KeySym keysym, + unsigned int mask) { // lookup the keycode KeyCodeMap::const_iterator index = m_keycodeMap.find(keysym); - if (index == m_keycodeMap.end()) + if (index == m_keycodeMap.end()) { return; + } KeyCode keycode = index->second.m_keycode; // toggle the key @@ -978,7 +1050,9 @@ void CXWindowsSecondaryScreen::toggleKey( m_mask ^= mask; } -bool CXWindowsSecondaryScreen::isToggleKeysym(KeySym key) +bool +CXWindowsSecondaryScreen::isToggleKeysym( + KeySym key) { switch (key) { case XK_Caps_Lock: diff --git a/client/CXWindowsSecondaryScreen.h b/client/CXWindowsSecondaryScreen.h index d4a00a48..77ebf158 100644 --- a/client/CXWindowsSecondaryScreen.h +++ b/client/CXWindowsSecondaryScreen.h @@ -6,7 +6,8 @@ #include "stdmap.h" #include "stdvector.h" -class CXWindowsSecondaryScreen : public CXWindowsScreen, public ISecondaryScreen { +class CXWindowsSecondaryScreen : public CXWindowsScreen, + public ISecondaryScreen { public: CXWindowsSecondaryScreen(); virtual ~CXWindowsSecondaryScreen(); @@ -17,7 +18,7 @@ public: virtual void open(CClient*); virtual void close(); virtual void enter(SInt32 xAbsolute, SInt32 yAbsolute, - KeyModifierMask mask); + KeyModifierMask mask); virtual void leave(); virtual void keyDown(KeyID, KeyModifierMask); virtual void keyRepeat(KeyID, KeyModifierMask, SInt32 count); @@ -64,9 +65,9 @@ private: unsigned int mapButton(ButtonID button) const; unsigned int mapKey(Keystrokes&, KeyCode&, KeyID, - KeyModifierMask, EKeyAction) const; + KeyModifierMask, EKeyAction) const; bool findKeyCode(KeyCode&, unsigned int&, - KeyID id, unsigned int) const; + KeyID id, unsigned int) const; void doKeystrokes(const Keystrokes&, SInt32 count); unsigned int maskToX(KeyModifierMask) const; diff --git a/client/client.cpp b/client/client.cpp index c2797ae1..b7c7214c 100644 --- a/client/client.cpp +++ b/client/client.cpp @@ -1,17 +1,18 @@ #include "CClient.h" -#include "CString.h" -#include "CLog.h" +#include "CPlatform.h" +#include "ProtocolTypes.h" +#include "Version.h" +#include "CNetwork.h" +#include "CNetworkAddress.h" +#include "XSocket.h" #include "CCondVar.h" #include "CLock.h" #include "CMutex.h" -#include "CNetwork.h" -#include "CNetworkAddress.h" -#include "CPlatform.h" #include "CThread.h" #include "XThread.h" -#include "ProtocolTypes.h" -#include "Version.h" -#include +#include "CLog.h" +#include "CString.h" +#include // platform dependent name of a daemon #if defined(CONFIG_PLATFORM_WIN32) @@ -43,7 +44,10 @@ static CNetworkAddress s_serverAddress; static CMutex* s_logMutex = NULL; -static void logLock(bool lock) +static +void +logLock( + bool lock) { assert(s_logMutex != NULL); @@ -62,7 +66,10 @@ static void logLock(bool lock) static CClient* s_client = NULL; -static int realMain(CMutex* mutex) +static +int +realMain( + CMutex* mutex) { try { // initialize threading library @@ -124,14 +131,18 @@ static int realMain(CMutex* mutex) return 0; } -static int restartMain() +static +int +restartMain() { return realMain(NULL); } // invoke realMain and wait for it. if s_restartable then keep // restarting realMain until it returns a terminate code. -static int restartableMain() +static +int +restartableMain() { if (s_restartable) { CPlatform platform; @@ -151,7 +162,9 @@ static int restartableMain() static void (*bye)(int) = &exit; -static void version() +static +void +version() { log((CLOG_PRINT "%s %d.%d.%d, protocol version %d.%d\n" @@ -165,7 +178,9 @@ static void version() kCopyright)); } -static void help() +static +void +help() { log((CLOG_PRINT "Usage: %s" @@ -213,11 +228,14 @@ static void help() } -static bool isArg(int argi, - int argc, const char** argv, - const char* name1, - const char* name2, - int minRequiredParameters = 0) +static +bool +isArg(int argi, + int argc, + const char** argv, + const char* name1, + const char* name2, + int minRequiredParameters = 0) { if ((name1 != NULL && strcmp(argv[argi], name1) == 0) || (name2 != NULL && strcmp(argv[argi], name2) == 0)) { @@ -234,7 +252,11 @@ static bool isArg(int argi, return false; } -static void parse(int argc, const char** argv) +static +void +parse( + int argc, + const char** argv) { assert(pname != NULL); assert(argv != NULL); @@ -413,7 +435,11 @@ static void parse(int argc, const char** argv) #include "CMSWindowsScreen.h" -static bool logMessageBox(int priority, const char* msg) +static +bool +logMessageBox( + int priority, + const char* msg) { if (priority <= CLog::kFATAL) { MessageBox(NULL, msg, pname, MB_OK | MB_ICONWARNING); @@ -424,18 +450,26 @@ static bool logMessageBox(int priority, const char* msg) } } -static void byeThrow(int x) +static +void +byeThrow(int x) { throw CWin32Platform::CDaemonFailed(x); } -static void daemonStop(void) +static +void +daemonStop(void) { s_client->quit(); } -static int daemonStartup(IPlatform* iplatform, - int argc, const char** argv) +static +int +daemonStartup( + IPlatform* iplatform, + int argc, + const char** argv) { // get platform pointer CWin32Platform* platform = static_cast(iplatform); @@ -456,19 +490,30 @@ static int daemonStartup(IPlatform* iplatform, return platform->runDaemon(realMain, daemonStop); } -static int daemonStartup95(IPlatform*, int, const char**) +static +int +daemonStartup95( + IPlatform*, + int, + const char**) { return realMain(NULL); } -static bool logDiscard(int, const char*) +static +bool +logDiscard( + int, + const char*) { return true; } static bool s_die = false; -static void checkParse(int e) +static +void +checkParse(int e) { // anything over 1 means invalid args. 1 means missing args. // 0 means graceful exit. we plan to exit for anything but @@ -478,7 +523,12 @@ static void checkParse(int e) throw s_die; } -int WINAPI WinMain(HINSTANCE instance, HINSTANCE, LPSTR, int) +int WINAPI +WinMain( + HINSTANCE instance, + HINSTANCE, + LPSTR, + int) { CPlatform platform; @@ -594,12 +644,20 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE, LPSTR, int) #elif defined(CONFIG_PLATFORM_UNIX) -static int daemonStartup(IPlatform*, int, const char**) +static +int +daemonStartup( + IPlatform*, + int, + const char**) { return restartableMain(); } -int main(int argc, char** argv) +int +main( + int argc, + char** argv) { CPlatform platform; diff --git a/http/CHTTPProtocol.cpp b/http/CHTTPProtocol.cpp index d1bf09e3..3a668f84 100644 --- a/http/CHTTPProtocol.cpp +++ b/http/CHTTPProtocol.cpp @@ -1,12 +1,11 @@ #include "CHTTPProtocol.h" -#include "CLog.h" #include "XHTTP.h" #include "IInputStream.h" #include "IOutputStream.h" +#include "CLog.h" #include "stdsstream.h" -#include -#include -#include +#include +#include #include // @@ -23,8 +22,10 @@ CHTTPRequest::~CHTTPRequest() // do nothing } -void CHTTPRequest::insertHeader( - const CString& name, const CString& value) +void +CHTTPRequest::insertHeader( + const CString& name, + const CString& value) { CHeaderMap::iterator index = m_headerByName.find(name); if (index != m_headerByName.end()) { @@ -37,8 +38,10 @@ void CHTTPRequest::insertHeader( } } -void CHTTPRequest::appendHeader( - const CString& name, const CString& value) +void +CHTTPRequest::appendHeader( + const CString& name, + const CString& value) { CHeaderMap::iterator index = m_headerByName.find(name); if (index != m_headerByName.end()) { @@ -52,7 +55,9 @@ void CHTTPRequest::appendHeader( } } -void CHTTPRequest::eraseHeader(const CString& name) +void +CHTTPRequest::eraseHeader( + const CString& name) { CHeaderMap::iterator index = m_headerByName.find(name); if (index != m_headerByName.end()) { @@ -60,12 +65,16 @@ void CHTTPRequest::eraseHeader(const CString& name) } } -bool CHTTPRequest::isHeader(const CString& name) const +bool +CHTTPRequest::isHeader( + const CString& name) const { return (m_headerByName.find(name) != m_headerByName.end()); } -CString CHTTPRequest::getHeader(const CString& name) const +CString +CHTTPRequest::getHeader( + const CString& name) const { CHeaderMap::const_iterator index = m_headerByName.find(name); if (index != m_headerByName.end()) { @@ -81,8 +90,10 @@ CString CHTTPRequest::getHeader(const CString& name) const // CHTTPProtocol // -CHTTPRequest* CHTTPProtocol::readRequest( - IInputStream* stream, UInt32 maxSize) +CHTTPRequest* +CHTTPProtocol::readRequest( + IInputStream* stream, + UInt32 maxSize) { CString scratch; @@ -229,9 +240,10 @@ CHTTPRequest* CHTTPProtocol::readRequest( return request; } -void CHTTPProtocol::reply( - IOutputStream* stream, - CHTTPReply& reply) +void +CHTTPProtocol::reply( + IOutputStream* stream, + CHTTPReply& reply) { // suppress body for certain replies bool hasBody = true; @@ -308,9 +320,10 @@ void CHTTPProtocol::reply( } } -bool CHTTPProtocol::parseFormData( - const CHTTPRequest& request, - CFormParts& parts) +bool +CHTTPProtocol::parseFormData( + const CHTTPRequest& request, + CFormParts& parts) { static const char formData[] = "multipart/form-data"; static const char boundary[] = "boundary="; @@ -444,9 +457,10 @@ bool CHTTPProtocol::parseFormData( return false; } -CString CHTTPProtocol::readLine( - IInputStream* stream, - CString& tmpBuffer) +CString +CHTTPProtocol::readLine( + IInputStream* stream, + CString& tmpBuffer) { // read up to and including a CRLF from stream, using whatever // is in tmpBuffer as if it were at the head of the stream. @@ -478,10 +492,11 @@ CString CHTTPProtocol::readLine( } } -CString CHTTPProtocol::readBlock( - IInputStream* stream, - UInt32 numBytes, - CString& tmpBuffer) +CString +CHTTPProtocol::readBlock( + IInputStream* stream, + UInt32 numBytes, + CString& tmpBuffer) { CString data; @@ -527,10 +542,11 @@ CString CHTTPProtocol::readBlock( return data; } -CString CHTTPProtocol::readChunk( - IInputStream* stream, - CString& tmpBuffer, - UInt32* maxSize) +CString +CHTTPProtocol::readChunk( + IInputStream* stream, + CString& tmpBuffer, + UInt32* maxSize) { CString line; @@ -577,12 +593,13 @@ CString CHTTPProtocol::readChunk( return data; } -void CHTTPProtocol::readHeaders( - IInputStream* stream, - CHTTPRequest* request, - bool isFooter, - CString& tmpBuffer, - UInt32* maxSize) +void +CHTTPProtocol::readHeaders( + IInputStream* stream, + CHTTPRequest* request, + bool isFooter, + CString& tmpBuffer, + UInt32* maxSize) { // parse headers. done with headers when we get a blank line. CString name; @@ -634,7 +651,9 @@ void CHTTPProtocol::readHeaders( } } -bool CHTTPProtocol::isValidToken(const CString& token) +bool +CHTTPProtocol::isValidToken( + const CString& token) { return (token.find("()<>@,;:\\\"/[]?={} " "\0\1\2\3\4\5\6\7" diff --git a/http/CHTTPProtocol.h b/http/CHTTPProtocol.h index 19818b95..19979ed1 100644 --- a/http/CHTTPProtocol.h +++ b/http/CHTTPProtocol.h @@ -1,8 +1,8 @@ #ifndef CHTTPPROTOCOL_H #define CHTTPPROTOCOL_H -#include "BasicTypes.h" #include "CString.h" +#include "BasicTypes.h" #include "stdlist.h" #include "stdmap.h" #include "stdvector.h" @@ -14,7 +14,7 @@ class CHTTPRequest { public: typedef std::list > CHeaderList; typedef std::map CHeaderMap; + CStringUtil::CaselessCmp> CHeaderMap; typedef CHeaderList::const_iterator const_iterator; CHTTPRequest(); @@ -93,18 +93,18 @@ public: // FIXME -- name/value pairs insufficient to save part headers typedef std::map CFormParts; static bool parseFormData(const CHTTPRequest&, - CFormParts& parts); + CFormParts& parts); private: static CString readLine(IInputStream*, CString& tmpBuffer); static CString readBlock(IInputStream*, - UInt32 numBytes, CString& tmpBuffer); + UInt32 numBytes, CString& tmpBuffer); static CString readChunk(IInputStream*, CString& tmpBuffer, - UInt32* maxSize); + UInt32* maxSize); static void readHeaders(IInputStream*, - CHTTPRequest*, bool isFooter, - CString& tmpBuffer, - UInt32* maxSize); + CHTTPRequest*, bool isFooter, + CString& tmpBuffer, + UInt32* maxSize); static bool isValidToken(const CString&); }; diff --git a/http/XHTTP.cpp b/http/XHTTP.cpp index f069f1da..6232bc03 100644 --- a/http/XHTTP.cpp +++ b/http/XHTTP.cpp @@ -6,18 +6,21 @@ // XHTTP // -XHTTP::XHTTP(SInt32 statusCode) : - XBase(), - m_status(statusCode), - m_reason(getReason(statusCode)) +XHTTP::XHTTP( + SInt32 statusCode) : + XBase(), + m_status(statusCode), + m_reason(getReason(statusCode)) { // do nothing } -XHTTP::XHTTP(SInt32 statusCode, const CString& reasonPhrase) : - XBase(), - m_status(statusCode), - m_reason(reasonPhrase) +XHTTP::XHTTP( + SInt32 statusCode, + const CString& reasonPhrase) : + XBase(), + m_status(statusCode), + m_reason(reasonPhrase) { // do nothing } @@ -27,22 +30,27 @@ XHTTP::~XHTTP() // do nothing } -SInt32 XHTTP::getStatus() const +SInt32 +XHTTP::getStatus() const { return m_status; } -CString XHTTP::getReason() const +CString +XHTTP::getReason() const { return m_reason; } -void XHTTP::addHeaders(CHTTPReply&) const +void +XHTTP::addHeaders( + CHTTPReply&) const { // do nothing } -CString XHTTP::getWhat() const throw() +CString +XHTTP::getWhat() const throw() { try { std::ostringstream s; @@ -60,7 +68,9 @@ CString XHTTP::getWhat() const throw() } } -const char* XHTTP::getReason(SInt32 status) +const char* +XHTTP::getReason( + SInt32 status) { switch (status) { case 300: return "Multiple Choices"; @@ -100,9 +110,10 @@ const char* XHTTP::getReason(SInt32 status) // XHTTPAllow // -XHTTPAllow::XHTTPAllow(const CString& allowed) : - XHTTP(405), - m_allowed(allowed) +XHTTPAllow::XHTTPAllow( + const CString& allowed) : + XHTTP(405), + m_allowed(allowed) { // do nothing } @@ -112,7 +123,9 @@ XHTTPAllow::~XHTTPAllow() // do nothing } -void XHTTPAllow::addHeaders(CHTTPReply& reply) const +void +XHTTPAllow::addHeaders( + CHTTPReply& reply) const { reply.m_headers.push_back(std::make_pair(CString("Allow"), m_allowed)); } diff --git a/http/XHTTP.h b/http/XHTTP.h index 754a345f..e098a713 100644 --- a/http/XHTTP.h +++ b/http/XHTTP.h @@ -2,7 +2,6 @@ #define XHTTP_H #include "BasicTypes.h" -#include "CString.h" #include "XBase.h" class CHTTPReply; diff --git a/io/CBufferedInputStream.cpp b/io/CBufferedInputStream.cpp index 740f7dc6..5078b39d 100644 --- a/io/CBufferedInputStream.cpp +++ b/io/CBufferedInputStream.cpp @@ -4,19 +4,20 @@ #include "CThread.h" #include "IJob.h" #include "XIO.h" -#include -#include +#include // // CBufferedInputStream // -CBufferedInputStream::CBufferedInputStream(CMutex* mutex, IJob* closeCB) : - m_mutex(mutex), - m_empty(mutex, true), - m_closeCB(closeCB), - m_closed(false), - m_hungup(false) +CBufferedInputStream::CBufferedInputStream( + CMutex* mutex, + IJob* closeCB) : + m_mutex(mutex), + m_empty(mutex, true), + m_closeCB(closeCB), + m_closed(false), + m_hungup(false) { assert(m_mutex != NULL); } @@ -26,8 +27,10 @@ CBufferedInputStream::~CBufferedInputStream() delete m_closeCB; } -void CBufferedInputStream::write( - const void* data, UInt32 n) +void +CBufferedInputStream::write( + const void* data, + UInt32 n) { if (!m_hungup && n > 0) { m_buffer.write(data, n); @@ -36,14 +39,17 @@ void CBufferedInputStream::write( } } -void CBufferedInputStream::hangup() +void +CBufferedInputStream::hangup() { m_hungup = true; m_empty.broadcast(); } -UInt32 CBufferedInputStream::readNoLock( - void* dst, UInt32 n) +UInt32 +CBufferedInputStream::readNoLock( + void* dst, + UInt32 n) { if (m_closed) { throw XIOClosed(); @@ -74,12 +80,14 @@ UInt32 CBufferedInputStream::readNoLock( return n; } -UInt32 CBufferedInputStream::getSizeNoLock() const +UInt32 +CBufferedInputStream::getSizeNoLock() const { return m_buffer.getSize(); } -void CBufferedInputStream::close() +void +CBufferedInputStream::close() { CLock lock(m_mutex); if (m_closed) { @@ -95,16 +103,18 @@ void CBufferedInputStream::close() } } -UInt32 CBufferedInputStream::read( - void* dst, UInt32 n) +UInt32 +CBufferedInputStream::read( + void* dst, + UInt32 n) { CLock lock(m_mutex); return readNoLock(dst, n); } -UInt32 CBufferedInputStream::getSize() const +UInt32 +CBufferedInputStream::getSize() const { CLock lock(m_mutex); return getSizeNoLock(); } - diff --git a/io/CBufferedInputStream.h b/io/CBufferedInputStream.h index d1abfea2..f47658f3 100644 --- a/io/CBufferedInputStream.h +++ b/io/CBufferedInputStream.h @@ -1,9 +1,9 @@ #ifndef CBUFFEREDINPUTSTREAM_H #define CBUFFEREDINPUTSTREAM_H +#include "IInputStream.h" #include "CStreamBuffer.h" #include "CCondVar.h" -#include "IInputStream.h" class CMutex; class IJob; diff --git a/io/CBufferedOutputStream.cpp b/io/CBufferedOutputStream.cpp index 3acd168b..386c2b60 100644 --- a/io/CBufferedOutputStream.cpp +++ b/io/CBufferedOutputStream.cpp @@ -1,20 +1,21 @@ #include "CBufferedOutputStream.h" +#include "XIO.h" #include "CLock.h" #include "CMutex.h" #include "CThread.h" #include "IJob.h" -#include "XIO.h" -#include // // CBufferedOutputStream // -CBufferedOutputStream::CBufferedOutputStream(CMutex* mutex, IJob* closeCB) : - m_mutex(mutex), - m_closeCB(closeCB), - m_empty(mutex, true), - m_closed(false) +CBufferedOutputStream::CBufferedOutputStream( + CMutex* mutex, + IJob* closeCB) : + m_mutex(mutex), + m_closeCB(closeCB), + m_empty(mutex, true), + m_closed(false) { assert(m_mutex != NULL); } @@ -24,12 +25,16 @@ CBufferedOutputStream::~CBufferedOutputStream() delete m_closeCB; } -const void* CBufferedOutputStream::peek(UInt32 n) +const void* +CBufferedOutputStream::peek( + UInt32 n) { return m_buffer.peek(n); } -void CBufferedOutputStream::pop(UInt32 n) +void +CBufferedOutputStream::pop( + UInt32 n) { m_buffer.pop(n); if (m_buffer.getSize() == 0) { @@ -37,12 +42,14 @@ void CBufferedOutputStream::pop(UInt32 n) } } -UInt32 CBufferedOutputStream::getSize() const +UInt32 +CBufferedOutputStream::getSize() const { return m_buffer.getSize(); } -void CBufferedOutputStream::close() +void +CBufferedOutputStream::close() { CLock lock(m_mutex); if (m_closed) { @@ -56,8 +63,10 @@ void CBufferedOutputStream::close() } } -UInt32 CBufferedOutputStream::write( - const void* data, UInt32 n) +UInt32 +CBufferedOutputStream::write( + const void* data, + UInt32 n) { CLock lock(m_mutex); if (m_closed) { @@ -68,7 +77,8 @@ UInt32 CBufferedOutputStream::write( return n; } -void CBufferedOutputStream::flush() +void +CBufferedOutputStream::flush() { // wait until all data is written CLock lock(m_mutex); diff --git a/io/CBufferedOutputStream.h b/io/CBufferedOutputStream.h index c609336e..6f0ba6a1 100644 --- a/io/CBufferedOutputStream.h +++ b/io/CBufferedOutputStream.h @@ -1,8 +1,8 @@ #ifndef CBUFFEREDOUTPUTSTREAM_H #define CBUFFEREDOUTPUTSTREAM_H -#include "CStreamBuffer.h" #include "IOutputStream.h" +#include "CStreamBuffer.h" #include "CCondVar.h" class CMutex; diff --git a/io/CInputStreamFilter.cpp b/io/CInputStreamFilter.cpp index 254c2313..276c1a34 100644 --- a/io/CInputStreamFilter.cpp +++ b/io/CInputStreamFilter.cpp @@ -1,13 +1,14 @@ #include "CInputStreamFilter.h" -#include // // CInputStreamFilter // -CInputStreamFilter::CInputStreamFilter(IInputStream* stream, bool adopted) : - m_stream(stream), - m_adopted(adopted) +CInputStreamFilter::CInputStreamFilter( + IInputStream* stream, + bool adopted) : + m_stream(stream), + m_adopted(adopted) { assert(m_stream != NULL); } @@ -19,7 +20,8 @@ CInputStreamFilter::~CInputStreamFilter() } } -IInputStream* CInputStreamFilter::getStream() const +IInputStream* +CInputStreamFilter::getStream() const { return m_stream; } diff --git a/io/COutputStreamFilter.cpp b/io/COutputStreamFilter.cpp index 8adc2862..197d626a 100644 --- a/io/COutputStreamFilter.cpp +++ b/io/COutputStreamFilter.cpp @@ -1,13 +1,14 @@ #include "COutputStreamFilter.h" -#include // // COutputStreamFilter // -COutputStreamFilter::COutputStreamFilter(IOutputStream* stream, bool adopted) : - m_stream(stream), - m_adopted(adopted) +COutputStreamFilter::COutputStreamFilter( + IOutputStream* stream, + bool adopted) : + m_stream(stream), + m_adopted(adopted) { assert(m_stream != NULL); } @@ -19,7 +20,8 @@ COutputStreamFilter::~COutputStreamFilter() } } -IOutputStream* COutputStreamFilter::getStream() const +IOutputStream* +COutputStreamFilter::getStream() const { return m_stream; } diff --git a/io/CStreamBuffer.cpp b/io/CStreamBuffer.cpp index d468847d..fee8546b 100644 --- a/io/CStreamBuffer.cpp +++ b/io/CStreamBuffer.cpp @@ -1,5 +1,4 @@ #include "CStreamBuffer.h" -#include // // CStreamBuffer @@ -7,7 +6,8 @@ const UInt32 CStreamBuffer::kChunkSize = 4096; -CStreamBuffer::CStreamBuffer() : m_size(0) +CStreamBuffer::CStreamBuffer() : + m_size(0) { // do nothing } @@ -17,7 +17,9 @@ CStreamBuffer::~CStreamBuffer() // do nothing } -const void* CStreamBuffer::peek(UInt32 n) +const void* +CStreamBuffer::peek( + UInt32 n) { assert(n <= m_size); @@ -36,7 +38,9 @@ const void* CStreamBuffer::peek(UInt32 n) return reinterpret_cast(head->begin()); } -void CStreamBuffer::pop(UInt32 n) +void +CStreamBuffer::pop( + UInt32 n) { // discard all chunks if n is greater than or equal to m_size if (n >= m_size) { @@ -63,8 +67,10 @@ void CStreamBuffer::pop(UInt32 n) } } -void CStreamBuffer::write( - const void* vdata, UInt32 n) +void +CStreamBuffer::write( + const void* vdata, + UInt32 n) { assert(vdata != NULL); @@ -81,8 +87,9 @@ void CStreamBuffer::write( ChunkList::iterator scan = m_chunks.end(); if (scan != m_chunks.begin()) { --scan; - if (scan->size() >= kChunkSize) + if (scan->size() >= kChunkSize) { ++scan; + } } if (scan == m_chunks.end()) { scan = m_chunks.insert(scan, Chunk()); @@ -109,7 +116,8 @@ void CStreamBuffer::write( } } -UInt32 CStreamBuffer::getSize() const +UInt32 +CStreamBuffer::getSize() const { return m_size; } diff --git a/io/IInputStream.h b/io/IInputStream.h index 700e11a0..f025ed40 100644 --- a/io/IInputStream.h +++ b/io/IInputStream.h @@ -3,7 +3,6 @@ #include "IInterface.h" #include "BasicTypes.h" -#include "XIO.h" class IInputStream : public IInterface { public: diff --git a/io/IOutputStream.h b/io/IOutputStream.h index 688f5af7..301ce482 100644 --- a/io/IOutputStream.h +++ b/io/IOutputStream.h @@ -3,7 +3,6 @@ #include "IInterface.h" #include "BasicTypes.h" -#include "XIO.h" class IOutputStream : public IInterface { public: diff --git a/io/XIO.cpp b/io/XIO.cpp index c51641d4..67508865 100644 --- a/io/XIO.cpp +++ b/io/XIO.cpp @@ -4,12 +4,14 @@ // XIOErrno // -XIOErrno::XIOErrno() : MXErrno() +XIOErrno::XIOErrno() : + MXErrno() { // do nothing } -XIOErrno::XIOErrno(int err) : MXErrno(err) +XIOErrno::XIOErrno(int err) : + MXErrno(err) { // do nothing } @@ -19,7 +21,8 @@ XIOErrno::XIOErrno(int err) : MXErrno(err) // XIOClose // -CString XIOClose::getWhat() const throw() +CString +XIOClose::getWhat() const throw() { return format("XIOClose", "close: %1", XIOErrno::getErrstr()); } @@ -29,7 +32,8 @@ CString XIOClose::getWhat() const throw() // XIOClosed // -CString XIOClosed::getWhat() const throw() +CString +XIOClosed::getWhat() const throw() { return format("XIOClosed", "already closed"); } @@ -39,8 +43,8 @@ CString XIOClosed::getWhat() const throw() // XIOEndOfStream // -CString XIOEndOfStream::getWhat() const throw() +CString +XIOEndOfStream::getWhat() const throw() { return format("XIOEndOfStream", "reached end of stream"); } - diff --git a/io/XIO.h b/io/XIO.h index 743c0aaa..4c4e4315 100644 --- a/io/XIO.h +++ b/io/XIO.h @@ -2,7 +2,6 @@ #define XIO_H #include "XBase.h" -#include "BasicTypes.h" class XIO : public XBase { }; diff --git a/mt/CCondVar.cpp b/mt/CCondVar.cpp index 104332c6..53d70fc8 100644 --- a/mt/CCondVar.cpp +++ b/mt/CCondVar.cpp @@ -1,15 +1,14 @@ #include "CCondVar.h" #include "CStopwatch.h" -#include // // CCondVarBase // CCondVarBase::CCondVarBase(CMutex* mutex) : - m_mutex(mutex) + m_mutex(mutex) #if defined(CONFIG_PLATFORM_WIN32) - , m_waitCountMutex() + , m_waitCountMutex() #endif { assert(m_mutex != NULL); @@ -21,23 +20,27 @@ CCondVarBase::~CCondVarBase() fini(); } -void CCondVarBase::lock() const +void +CCondVarBase::lock() const { m_mutex->lock(); } -void CCondVarBase::unlock() const +void +CCondVarBase::unlock() const { m_mutex->unlock(); } -bool CCondVarBase::wait(double timeout) const +bool +CCondVarBase::wait(double timeout) const { CStopwatch timer(true); return wait(timer, timeout); } -CMutex* CCondVarBase::getMutex() const +CMutex* +CCondVarBase::getMutex() const { return m_mutex; } @@ -47,9 +50,10 @@ CMutex* CCondVarBase::getMutex() const #include "CThread.h" #include #include -#include +#include -void CCondVarBase::init() +void +CCondVarBase::init() { pthread_cond_t* cond = new pthread_cond_t; int status = pthread_cond_init(cond, NULL); @@ -57,7 +61,8 @@ void CCondVarBase::init() m_cond = reinterpret_cast(cond); } -void CCondVarBase::fini() +void +CCondVarBase::fini() { pthread_cond_t* cond = reinterpret_cast(m_cond); int status = pthread_cond_destroy(cond); @@ -65,22 +70,26 @@ void CCondVarBase::fini() delete cond; } -void CCondVarBase::signal() +void +CCondVarBase::signal() { pthread_cond_t* cond = reinterpret_cast(m_cond); int status = pthread_cond_signal(cond); assert(status == 0); } -void CCondVarBase::broadcast() +void +CCondVarBase::broadcast() { pthread_cond_t* cond = reinterpret_cast(m_cond); int status = pthread_cond_broadcast(cond); assert(status == 0); } -bool CCondVarBase::wait( - CStopwatch& timer, double timeout) const +bool +CCondVarBase::wait( + CStopwatch& timer, + double timeout) const { // check timeout against timer if (timeout >= 0.0) { @@ -143,8 +152,9 @@ bool CCondVarBase::wait( CThread::testCancel(); // check wait status - if (status != ETIMEDOUT && status != EINTR) + if (status != ETIMEDOUT && status != EINTR) { break; + } } switch (status) { @@ -180,7 +190,8 @@ bool CCondVarBase::wait( // can cause busy waiting. // -void CCondVarBase::init() +void +CCondVarBase::init() { // prepare events HANDLE* events = new HANDLE[2]; @@ -192,7 +203,8 @@ void CCondVarBase::init() m_waitCount = 0; } -void CCondVarBase::fini() +void +CCondVarBase::fini() { HANDLE* events = reinterpret_cast(m_cond); CloseHandle(events[kSignal]); @@ -200,7 +212,8 @@ void CCondVarBase::fini() delete[] events; } -void CCondVarBase::signal() +void +CCondVarBase::signal() { // is anybody waiting? bool hasWaiter; @@ -210,11 +223,13 @@ void CCondVarBase::signal() } // wake one thread if anybody is waiting - if (hasWaiter) + if (hasWaiter) { SetEvent(reinterpret_cast(m_cond)[kSignal]); + } } -void CCondVarBase::broadcast() +void +CCondVarBase::broadcast() { // is anybody waiting? bool hasWaiter; @@ -224,18 +239,22 @@ void CCondVarBase::broadcast() } // wake all threads if anybody is waiting - if (hasWaiter) + if (hasWaiter) { SetEvent(reinterpret_cast(m_cond)[kBroadcast]); + } } -bool CCondVarBase::wait( - CStopwatch& timer, double timeout) const +bool +CCondVarBase::wait( + CStopwatch& timer, + double timeout) const { // check timeout against timer if (timeout >= 0.0) { timeout -= timer.getTime(); - if (timeout < 0.0) + if (timeout < 0.0) { return false; + } } // prepare to wait @@ -267,8 +286,9 @@ bool CCondVarBase::wait( // cancel takes priority if (n == 3 && result != WAIT_OBJECT_0 + 2 && - WaitForSingleObject(handles[2], 0) == WAIT_OBJECT_0) + WaitForSingleObject(handles[2], 0) == WAIT_OBJECT_0) { result = WAIT_OBJECT_0 + 2; + } // update the waiter count and check if we're the last waiter bool last; @@ -279,15 +299,17 @@ bool CCondVarBase::wait( } // reset the broadcast event if we're the last waiter - if (last) + if (last) { ResetEvent(events[kBroadcast]); + } // reacquire the mutex m_mutex->lock(); // cancel thread if necessary - if (result == WAIT_OBJECT_0 + 2) + if (result == WAIT_OBJECT_0 + 2) { currentRep->testCancel(); + } // return success or failure return (result == WAIT_OBJECT_0 + 0 || diff --git a/mt/CCondVar.h b/mt/CCondVar.h index 59b2d90c..cf0f824b 100644 --- a/mt/CCondVar.h +++ b/mt/CCondVar.h @@ -90,17 +90,21 @@ private: template inline -CCondVar::CCondVar(CMutex* mutex, const T& data) : - CCondVarBase(mutex), m_data(data) +CCondVar::CCondVar( + CMutex* mutex, + const T& data) : + CCondVarBase(mutex), + m_data(data) { // do nothing } template inline -CCondVar::CCondVar(const CCondVar& cv) : - CCondVarBase(cv.getMutex()), - m_data(cv.m_data) +CCondVar::CCondVar( + const CCondVar& cv) : + CCondVarBase(cv.getMutex()), + m_data(cv.m_data) { // do nothing } @@ -114,7 +118,9 @@ CCondVar::~CCondVar() template inline -CCondVar& CCondVar::operator=(const CCondVar& cv) +CCondVar& +CCondVar::operator=( + const CCondVar& cv) { m_data = cv.m_data; return *this; @@ -122,7 +128,9 @@ CCondVar& CCondVar::operator=(const CCondVar& cv) template inline -CCondVar& CCondVar::operator=(const T& data) +CCondVar& +CCondVar::operator=( + const T& data) { m_data = data; return *this; diff --git a/mt/CLock.cpp b/mt/CLock.cpp index 41ceae9c..d9f6f7d2 100644 --- a/mt/CLock.cpp +++ b/mt/CLock.cpp @@ -1,17 +1,19 @@ #include "CLock.h" -#include "CMutex.h" #include "CCondVar.h" +#include "CMutex.h" // // CLock // -CLock::CLock(const CMutex* mutex) : m_mutex(mutex) +CLock::CLock(const CMutex* mutex) : + m_mutex(mutex) { m_mutex->lock(); } -CLock::CLock(const CCondVarBase* cv) : m_mutex(cv->getMutex()) +CLock::CLock(const CCondVarBase* cv) : + m_mutex(cv->getMutex()) { m_mutex->lock(); } diff --git a/mt/CLock.h b/mt/CLock.h index d554733f..2044855c 100644 --- a/mt/CLock.h +++ b/mt/CLock.h @@ -1,8 +1,6 @@ #ifndef CLOCK_H #define CLOCK_H -#include "common.h" - class CMutex; class CCondVarBase; diff --git a/mt/CMutex.cpp b/mt/CMutex.cpp index 0318908a..547dfb18 100644 --- a/mt/CMutex.cpp +++ b/mt/CMutex.cpp @@ -1,6 +1,5 @@ #include "CMutex.h" #include "CLog.h" -#include // // CMutex @@ -21,7 +20,9 @@ CMutex::~CMutex() fini(); } -CMutex& CMutex::operator=(const CMutex&) +CMutex& +CMutex::operator=( + const CMutex&) { return *this; } @@ -29,9 +30,10 @@ CMutex& CMutex::operator=(const CMutex&) #if defined(CONFIG_PTHREADS) #include -#include +#include -void CMutex::init() +void +CMutex::init() { pthread_mutex_t* mutex = new pthread_mutex_t; int status = pthread_mutex_init(mutex, NULL); @@ -41,11 +43,8 @@ void CMutex::init() m_mutex = reinterpret_cast(mutex); } -#include -#include -#include -#include -void CMutex::fini() +void +CMutex::fini() { pthread_mutex_t* mutex = reinterpret_cast(m_mutex); int status = pthread_mutex_destroy(mutex); @@ -54,7 +53,8 @@ void CMutex::fini() delete mutex; } -void CMutex::lock() const +void +CMutex::lock() const { pthread_mutex_t* mutex = reinterpret_cast(m_mutex); int status = pthread_mutex_lock(mutex); @@ -78,7 +78,8 @@ void CMutex::lock() const } } -void CMutex::unlock() const +void +CMutex::unlock() const { pthread_mutex_t* mutex = reinterpret_cast(m_mutex); int status = pthread_mutex_unlock(mutex); @@ -105,26 +106,30 @@ void CMutex::unlock() const #define WIN32_LEAN_AND_MEAN #include -void CMutex::init() +void +CMutex::init() { CRITICAL_SECTION* mutex = new CRITICAL_SECTION; InitializeCriticalSection(mutex); m_mutex = reinterpret_cast(mutex); } -void CMutex::fini() +void +CMutex::fini() { CRITICAL_SECTION* mutex = reinterpret_cast(m_mutex); DeleteCriticalSection(mutex); delete mutex; } -void CMutex::lock() const +void +CMutex::lock() const { EnterCriticalSection(reinterpret_cast(m_mutex)); } -void CMutex::unlock() const +void +CMutex::unlock() const { LeaveCriticalSection(reinterpret_cast(m_mutex)); } diff --git a/mt/CMutex.h b/mt/CMutex.h index cf43ea70..2f6b9483 100644 --- a/mt/CMutex.h +++ b/mt/CMutex.h @@ -1,8 +1,6 @@ #ifndef CMUTEX_H #define CMUTEX_H -#include "common.h" - // recursive mutex class class CMutex { public: diff --git a/mt/CThread.cpp b/mt/CThread.cpp index f67573fb..924509f4 100644 --- a/mt/CThread.cpp +++ b/mt/CThread.cpp @@ -1,9 +1,9 @@ #include "CThread.h" +#include "CLock.h" #include "CThreadRep.h" #include "XThread.h" -#include "CLock.h" -#include "CStopwatch.h" #include "CLog.h" +#include "CStopwatch.h" // // CThread @@ -14,12 +14,14 @@ CThread::CThread(IJob* job, void* userData) m_rep = new CThreadRep(job, userData); } -CThread::CThread(const CThread& thread) : m_rep(thread.m_rep) +CThread::CThread(const CThread& thread) : + m_rep(thread.m_rep) { m_rep->ref(); } -CThread::CThread(CThreadRep* rep) : m_rep(rep) +CThread::CThread(CThreadRep* rep) : + m_rep(rep) { // do nothing. rep should have already been Ref()'d. } @@ -29,7 +31,9 @@ CThread::~CThread() m_rep->unref(); } -CThread& CThread::operator=(const CThread& thread) +CThread& +CThread::operator=( + const CThread& thread) { if (thread.m_rep != m_rep) { m_rep->unref(); @@ -39,12 +43,15 @@ CThread& CThread::operator=(const CThread& thread) return *this; } -void CThread::init() +void +CThread::init() { CThreadRep::initThreads(); } -void CThread::sleep(double timeout) +void +CThread::sleep( + double timeout) { CThreadPtr currentRep(CThreadRep::getCurrentThreadRep()); if (timeout >= 0.0) { @@ -54,47 +61,59 @@ void CThread::sleep(double timeout) currentRep->testCancel(); } -void CThread::exit(void* result) +void +CThread::exit( + void* result) { CThreadPtr currentRep(CThreadRep::getCurrentThreadRep()); log((CLOG_DEBUG1 "throw exit on thread %p", currentRep.operator->())); throw XThreadExit(result); } -bool CThread::enableCancel(bool enable) +bool +CThread::enableCancel( + bool enable) { CThreadPtr currentRep(CThreadRep::getCurrentThreadRep()); return currentRep->enableCancel(enable); } -void CThread::cancel() +void +CThread::cancel() { m_rep->cancel(); } -void CThread::setPriority(int n) +void +CThread::setPriority( + int n) { m_rep->setPriority(n); } -CThread CThread::getCurrentThread() +CThread +CThread::getCurrentThread() { return CThread(CThreadRep::getCurrentThreadRep()); } -bool CThread::wait(double timeout) const +bool +CThread::wait( + double timeout) const { CThreadPtr currentRep(CThreadRep::getCurrentThreadRep()); return currentRep->wait(m_rep, timeout); } -void CThread::testCancel() +void +CThread::testCancel() { CThreadPtr currentRep(CThreadRep::getCurrentThreadRep()); currentRep->testCancel(); } -void* CThread::getResult() const +void* +CThread::getResult() const { if (wait()) return m_rep->getResult(); @@ -102,18 +121,23 @@ void* CThread::getResult() const return NULL; } -void* CThread::getUserData() +void* +CThread::getUserData() { CThreadPtr currentRep(CThreadRep::getCurrentThreadRep()); return currentRep->getUserData(); } -bool CThread::operator==(const CThread& thread) const +bool +CThread::operator==( + const CThread& thread) const { return (m_rep == thread.m_rep); } -bool CThread::operator!=(const CThread& thread) const +bool +CThread::operator!=( + const CThread& thread) const { return (m_rep != thread.m_rep); } @@ -123,7 +147,8 @@ bool CThread::operator!=(const CThread& thread) const // CThreadMaskCancel // -CThreadMaskCancel::CThreadMaskCancel() : m_old(CThread::enableCancel(false)) +CThreadMaskCancel::CThreadMaskCancel() : + m_old(CThread::enableCancel(false)) { // do nothing } diff --git a/mt/CThread.h b/mt/CThread.h index ae49838c..03dc3fd3 100644 --- a/mt/CThread.h +++ b/mt/CThread.h @@ -1,8 +1,6 @@ #ifndef CTHREAD_H #define CTHREAD_H -#include "BasicTypes.h" - class IJob; class CThreadRep; diff --git a/mt/CThreadRep.cpp b/mt/CThreadRep.cpp index aa641b50..06af394a 100644 --- a/mt/CThreadRep.cpp +++ b/mt/CThreadRep.cpp @@ -1,11 +1,10 @@ #include "CThreadRep.h" -#include "CThread.h" -#include "CMutex.h" #include "CLock.h" +#include "CMutex.h" +#include "CThread.h" #include "XThread.h" #include "CLog.h" #include "IJob.h" -#include #if defined(CONFIG_PTHREADS) #include @@ -23,7 +22,7 @@ class XThreadUnavailable { }; #if defined(CONFIG_PLATFORM_UNIX) && !defined(NDEBUG) -#include +#include #include #include #include @@ -44,11 +43,12 @@ CThreadRep* CThreadRep::s_head = NULL; pthread_t CThreadRep::s_signalThread; #endif -CThreadRep::CThreadRep() : m_prev(NULL), - m_next(NULL), - m_refCount(1), - m_job(NULL), - m_userData(NULL) +CThreadRep::CThreadRep() : + m_prev(NULL), + m_next(NULL), + m_refCount(1), + m_job(NULL), + m_userData(NULL) { // note -- s_mutex must be locked on entry assert(s_mutex != NULL); @@ -73,11 +73,11 @@ CThreadRep::CThreadRep() : m_prev(NULL), } CThreadRep::CThreadRep(IJob* job, void* userData) : - m_prev(NULL), - m_next(NULL), - m_refCount(2), // 1 for us, 1 for thread - m_job(job), - m_userData(userData) + m_prev(NULL), + m_next(NULL), + m_refCount(2), // 1 for us, 1 for thread + m_job(job), + m_userData(userData) { assert(m_job != NULL); assert(s_mutex != NULL); @@ -103,15 +103,17 @@ CThreadRep::CThreadRep(IJob* job, void* userData) : pthread_sigmask(SIG_BLOCK, &sigset, &oldsigset); int status = pthread_create(&m_thread, NULL, threadFunc, (void*)this); pthread_sigmask(SIG_SETMASK, &oldsigset, NULL); - if (status != 0) + if (status != 0) { throw XThreadUnavailable(); + } #elif defined(CONFIG_PLATFORM_WIN32) unsigned int id; m_thread = reinterpret_cast(_beginthreadex(NULL, 0, threadFunc, (void*)this, 0, &id)); m_id = static_cast(id); - if (m_thread == 0) + if (m_thread == 0) { throw XThreadUnavailable(); + } #endif // insert ourself into linked list @@ -143,7 +145,8 @@ CThreadRep::~CThreadRep() fini(); } -void CThreadRep::initThreads() +void +CThreadRep::initThreads() { if (s_mutex == NULL) { s_mutex = new CMutex; @@ -197,13 +200,15 @@ void CThreadRep::initThreads() } } -void CThreadRep::ref() +void +CThreadRep::ref() { CLock lock(s_mutex); ++m_refCount; } -void CThreadRep::unref() +void +CThreadRep::unref() { CLock lock(s_mutex); if (--m_refCount == 0) { @@ -211,7 +216,8 @@ void CThreadRep::unref() } } -bool CThreadRep::enableCancel(bool enable) +bool +CThreadRep::enableCancel(bool enable) { CLock lock(s_mutex); const bool old = m_cancellable; @@ -219,25 +225,29 @@ bool CThreadRep::enableCancel(bool enable) return old; } -bool CThreadRep::isCancellable() const +bool +CThreadRep::isCancellable() const { CLock lock(s_mutex); return (m_cancellable && !m_cancelling); } -void* CThreadRep::getResult() const +void* +CThreadRep::getResult() const { // no lock necessary since thread isn't running return m_result; } -void* CThreadRep::getUserData() const +void* +CThreadRep::getUserData() const { // no lock necessary because the value never changes return m_userData; } -CThreadRep* CThreadRep::getCurrentThreadRep() +CThreadRep* +CThreadRep::getCurrentThreadRep() { assert(s_mutex != NULL); @@ -276,7 +286,8 @@ CThreadRep* CThreadRep::getCurrentThreadRep() return scan; } -void CThreadRep::doThreadFunc() +void +CThreadRep::doThreadFunc() { // default priority is slightly below normal setPriority(1); @@ -318,9 +329,10 @@ void CThreadRep::doThreadFunc() #if defined(CONFIG_PTHREADS) #include "CStopwatch.h" -#include +#include -void CThreadRep::init() +void +CThreadRep::init() { m_result = NULL; m_cancellable = true; @@ -329,7 +341,8 @@ void CThreadRep::init() m_exit = false; } -void CThreadRep::fini() +void +CThreadRep::fini() { // main thread has NULL job if (m_job != NULL) { @@ -337,10 +350,13 @@ void CThreadRep::fini() } } -void CThreadRep::sleep(double timeout) +void +CThreadRep::sleep( + double timeout) { - if (timeout < 0.0) + if (timeout < 0.0) { return; + } struct timespec t; t.tv_sec = (long)timeout; t.tv_nsec = (long)(1000000000.0 * (timeout - (double)t.tv_sec)); @@ -348,7 +364,8 @@ void CThreadRep::sleep(double timeout) testCancel(); } -void CThreadRep::cancel() +void +CThreadRep::cancel() { CLock lock(s_mutex); if (m_cancellable && !m_cancelling) { @@ -363,14 +380,16 @@ void CThreadRep::cancel() pthread_kill(m_thread, SIGWAKEUP); } -void CThreadRep::testCancel() +void +CThreadRep::testCancel() { { CLock lock(s_mutex); // done if not cancelled, not cancellable, or already cancelling - if (!m_cancel || !m_cancellable || m_cancelling) + if (!m_cancel || !m_cancellable || m_cancelling) { return; + } // update state for cancel m_cancel = false; @@ -382,40 +401,50 @@ void CThreadRep::testCancel() throw XThreadCancel(); } -bool CThreadRep::wait(CThreadRep* target, double timeout) +bool +CThreadRep::wait( + CThreadRep* target, + double timeout) { - if (target == this) + if (target == this) { return false; + } testCancel(); - if (target->isExited()) + if (target->isExited()) { return true; + } if (timeout != 0.0) { CStopwatch timer; do { sleep(0.05); testCancel(); - if (target->isExited()) + if (target->isExited()) { return true; + } } while (timeout < 0.0 || timer.getTime() <= timeout); } return false; } -void CThreadRep::setPriority(int) +void +CThreadRep::setPriority( + int) { // FIXME } -bool CThreadRep::isExited() const +bool +CThreadRep::isExited() const { CLock lock(s_mutex); return m_exit; } -void* CThreadRep::threadFunc(void* arg) +void* +CThreadRep::threadFunc(void* arg) { CThreadRep* rep = (CThreadRep*)arg; @@ -438,12 +467,16 @@ void* CThreadRep::threadFunc(void* arg) return NULL; } -void CThreadRep::threadCancel(int) +void +CThreadRep::threadCancel( + int) { // do nothing } -void* CThreadRep::threadSignalHandler(void* vrep) +void* +CThreadRep::threadSignalHandler( + void* vrep) { CThreadRep* mainThreadRep = reinterpret_cast(vrep); @@ -466,7 +499,8 @@ void* CThreadRep::threadSignalHandler(void* vrep) #elif defined(CONFIG_PLATFORM_WIN32) -void CThreadRep::init() +void +CThreadRep::init() { m_result = NULL; m_cancellable = true; @@ -475,7 +509,8 @@ void CThreadRep::init() m_cancel = CreateEvent(NULL, TRUE, FALSE, NULL); } -void CThreadRep::fini() +void +CThreadRep::fini() { // destroy the events CloseHandle(m_cancel); @@ -487,26 +522,33 @@ void CThreadRep::fini() } } -void CThreadRep::sleep(double timeout) +void +CThreadRep::sleep( + double timeout) { - if (isCancellable()) + if (isCancellable()) { WaitForSingleObject(m_cancel, (DWORD)(1000.0 * timeout)); - else + } + else { Sleep((DWORD)(1000.0 * timeout)); + } } -void CThreadRep::cancel() +void +CThreadRep::cancel() { log((CLOG_DEBUG1 "cancel thread %p", this)); SetEvent(m_cancel); } -void CThreadRep::testCancel() +void +CThreadRep::testCancel() { // poll cancel event. return if not set. const DWORD result = WaitForSingleObject(getCancelEvent(), 0); - if (result != WAIT_OBJECT_0) + if (result != WAIT_OBJECT_0) { return; + } { // ignore if disabled or already cancelling @@ -524,23 +566,29 @@ void CThreadRep::testCancel() throw XThreadCancel(); } -bool CThreadRep::wait(CThreadRep* target, double timeout) +bool +CThreadRep::wait( + CThreadRep* target, + double timeout) { // get the current thread. if it's the same as the target thread // then the thread is waiting on itself. CThreadPtr currentRep(CThreadRep::getCurrentThreadRep()); - if (target == this) + if (target == this) { return false; + } // is cancellation enabled? const DWORD n = (isCancellable() ? 2 : 1); // convert timeout DWORD t; - if (timeout < 0.0) + if (timeout < 0.0) { t = INFINITE; - else + } + else { t = (DWORD)(1000.0 * timeout); + } // wait for this thread to be cancelled or for the target thread to // terminate. @@ -551,8 +599,9 @@ bool CThreadRep::wait(CThreadRep* target, double timeout) // cancel takes priority if (n == 2 && result != WAIT_OBJECT_0 + 1 && - WaitForSingleObject(handles[1], 0) == WAIT_OBJECT_0) + WaitForSingleObject(handles[1], 0) == WAIT_OBJECT_0) { result = WAIT_OBJECT_0 + 1; + } // handle result switch (result) { @@ -570,7 +619,9 @@ bool CThreadRep::wait(CThreadRep* target, double timeout) } } -void CThreadRep::setPriority(int n) +void +CThreadRep::setPriority( + int n) { DWORD pClass = NORMAL_PRIORITY_CLASS; if (n < 0) { @@ -601,19 +652,23 @@ void CThreadRep::setPriority(int n) SetThreadPriority(m_thread, n); } -HANDLE CThreadRep::getExitEvent() const +HANDLE +CThreadRep::getExitEvent() const { // no lock necessary because the value never changes return m_exit; } -HANDLE CThreadRep::getCancelEvent() const +HANDLE +CThreadRep::getCancelEvent() const { // no lock necessary because the value never changes return m_cancel; } -unsigned int __stdcall CThreadRep::threadFunc(void* arg) +unsigned int __stdcall +CThreadRep::threadFunc( + void* arg) { CThreadRep* rep = (CThreadRep*)arg; diff --git a/mt/CTimerThread.cpp b/mt/CTimerThread.cpp index 786ed8df..b47cc429 100644 --- a/mt/CTimerThread.cpp +++ b/mt/CTimerThread.cpp @@ -2,7 +2,6 @@ #include "CThread.h" #include "TMethodJob.h" #include "CLog.h" -#include // // CTimerThread @@ -33,7 +32,9 @@ CTimerThread::~CTimerThread() } } -void CTimerThread::timer(void*) +void +CTimerThread::timer( + void*) { log((CLOG_DEBUG1 "timeout in %f seconds", m_timeout)); CThread::sleep(m_timeout); diff --git a/mt/CTimerThread.h b/mt/CTimerThread.h index 118fde1d..5605fadc 100644 --- a/mt/CTimerThread.h +++ b/mt/CTimerThread.h @@ -1,8 +1,6 @@ #ifndef CTIMERTHREAD_H #define CTIMERTHREAD_H -#include "common.h" - class CThread; class CTimerThread { diff --git a/mt/XThread.h b/mt/XThread.h index bc56a44c..18c22f09 100644 --- a/mt/XThread.h +++ b/mt/XThread.h @@ -1,8 +1,6 @@ #ifndef XTHREAD_H #define XTHREAD_H -#include "common.h" - // generic thread exception class XThread { }; diff --git a/net/CNetwork.cpp b/net/CNetwork.cpp index 4037d9d9..23cc9701 100644 --- a/net/CNetwork.cpp +++ b/net/CNetwork.cpp @@ -1,7 +1,6 @@ #include "CNetwork.h" #include "XNetwork.h" #include "CLog.h" -#include // // CNetwork @@ -51,15 +50,21 @@ const CNetwork::Socket CNetwork::Null = INVALID_SOCKET; static HMODULE s_networkModule = NULL; -static FARPROC netGetProcAddress(HMODULE module, LPCSTR name) +static +FARPROC +netGetProcAddress( + HMODULE module, + LPCSTR name) { FARPROC func = ::GetProcAddress(module, name); - if (!func) + if (!func) { throw XNetworkFunctionUnavailable(name); + } return func; } -void CNetwork::init() +void +CNetwork::init() { assert(WSACleanup == NULL); assert(s_networkModule == NULL); @@ -98,7 +103,8 @@ void CNetwork::init() throw XNetworkUnavailable(); } -void CNetwork::cleanup() +void +CNetwork::cleanup() { if (s_networkModule != NULL) { WSACleanup(); @@ -109,41 +115,55 @@ void CNetwork::cleanup() } } -UInt32 CNetwork::swaphtonl(UInt32 v) +UInt32 +CNetwork::swaphtonl( + UInt32 v) { static const union { UInt16 s; UInt8 b[2]; } s_endian = { 0x1234 }; - if (s_endian.b[0] == 0x34) + if (s_endian.b[0] == 0x34) { return ((v & 0xff000000lu) >> 24) | ((v & 0x00ff0000lu) >> 8) | ((v & 0x0000ff00lu) << 8) | ((v & 0x000000fflu) << 24); - else + } + else { return v; + } } -UInt16 CNetwork::swaphtons(UInt16 v) +UInt16 +CNetwork::swaphtons( + UInt16 v) { static const union { UInt16 s; UInt8 b[2]; } s_endian = { 0x1234 }; - if (s_endian.b[0] == 0x34) + if (s_endian.b[0] == 0x34) { return static_cast( ((v & 0xff00u) >> 8) | ((v & 0x00ffu) << 8)); - else + } + else { return v; + } } -UInt32 CNetwork::swapntohl(UInt32 v) +UInt32 +CNetwork::swapntohl( + UInt32 v) { return swaphtonl(v); } -UInt16 CNetwork::swapntohs(UInt16 v) +UInt16 +CNetwork::swapntohs( + UInt16 v) { return swaphtons(v); } #define setfunc(var, name, type) var = (type)netGetProcAddress(module, #name) -void CNetwork::init2(HMODULE module) +void +CNetwork::init2( + HMODULE module) { assert(module != NULL); @@ -155,10 +175,12 @@ void CNetwork::init2(HMODULE module) WORD version = MAKEWORD(1 /*major*/, 1 /*minor*/); WSADATA data; int err = startup(version, &data); - if (data.wVersion != version) + if (data.wVersion != version) { throw XNetworkVersion(LOBYTE(data.wVersion), HIBYTE(data.wVersion)); - if (err != 0) + } + if (err != 0) { throw XNetworkFailed(); + } // get function addresses setfunc(accept, accept, Socket (PASCAL FAR *)(Socket s, Address FAR *addr, AddressLength FAR *addrlen)); @@ -198,7 +220,11 @@ void CNetwork::init2(HMODULE module) s_networkModule = module; } -int PASCAL FAR CNetwork::poll2(PollEntry fd[], int nfds, int timeout) +int PASCAL FAR +CNetwork::poll2( + PollEntry fd[], + int nfds, + int timeout) { int i; @@ -241,32 +267,45 @@ int PASCAL FAR CNetwork::poll2(PollEntry fd[], int nfds, int timeout) int n = select(0, readSetP, writeSetP, errSetP, timeout2P); // handle results - if (n == Error) + if (n == Error) { return Error; - if (n == 0) + } + if (n == 0) { return 0; + } n = 0; for (i = 0; i < nfds; ++i) { fd[i].revents = 0; - if (FD_ISSET(fd[i].fd, &readSet)) + if (FD_ISSET(fd[i].fd, &readSet)) { fd[i].revents |= kPOLLIN; - if (FD_ISSET(fd[i].fd, &writeSet)) + } + if (FD_ISSET(fd[i].fd, &writeSet)) { fd[i].revents |= kPOLLOUT; - if (FD_ISSET(fd[i].fd, &errSet)) + } + if (FD_ISSET(fd[i].fd, &errSet)) { fd[i].revents |= kPOLLERR; - if (fd[i].revents != 0) + } + if (fd[i].revents != 0) { ++n; + } } return n; } -ssize_t PASCAL FAR CNetwork::read2(Socket s, void FAR * buf, size_t len) +ssize_t PASCAL FAR +CNetwork::read2( + Socket s, + void FAR* buf, + size_t len) { return recv(s, buf, len, 0); } -ssize_t PASCAL FAR CNetwork::write2(Socket s, - const void FAR * buf, size_t len) +ssize_t PASCAL FAR +CNetwork::write2( + Socket s, + const void FAR* buf, + size_t len) { return send(s, buf, len, 0); } @@ -283,37 +322,53 @@ ssize_t PASCAL FAR CNetwork::write2(Socket s, #define setfunc(var, name, type) var = (type)::name -UInt32 CNetwork::swaphtonl(UInt32 v) +UInt32 +CNetwork::swaphtonl( + UInt32 v) { return htonl(v); } -UInt16 CNetwork::swaphtons(UInt16 v) +UInt16 +CNetwork::swaphtons( + UInt16 v) { return htons(v); } -UInt32 CNetwork::swapntohl(UInt32 v) +UInt32 +CNetwork::swapntohl( + UInt32 v) { return ntohl(v); } -UInt16 CNetwork::swapntohs(UInt16 v) +UInt16 +CNetwork::swapntohs( + UInt16 v) { return ntohs(v); } -static int myerrno() +static +int +myerrno() { return errno; } -static int myherrno() +static +int +myherrno() { return h_errno; } -static int mygethostname(char* name, int namelen) +static +int +mygethostname( + char* name, + int namelen) { return gethostname(name, namelen); } @@ -321,7 +376,8 @@ static int mygethostname(char* name, int namelen) const int CNetwork::Error = -1; const CNetwork::Socket CNetwork::Null = -1; -void CNetwork::init() +void +CNetwork::init() { setfunc(accept, accept, Socket (PASCAL FAR *)(Socket s, Address FAR *addr, AddressLength FAR *addrlen)); setfunc(bind, bind, int (PASCAL FAR *)(Socket s, const Address FAR *addr, AddressLength namelen)); @@ -355,7 +411,8 @@ void CNetwork::init() setfunc(gethosterror, myherrno, int (PASCAL FAR *)(void)); } -void CNetwork::cleanup() +void +CNetwork::cleanup() { // do nothing } diff --git a/net/CNetworkAddress.cpp b/net/CNetworkAddress.cpp index 0e07605e..28f20537 100644 --- a/net/CNetworkAddress.cpp +++ b/net/CNetworkAddress.cpp @@ -1,12 +1,14 @@ #include "CNetworkAddress.h" -#include "CString.h" -#include +#include "XSocket.h" +#include +#include // // CNetworkAddress // -CNetworkAddress::CNetworkAddress() : m_port(0) +CNetworkAddress::CNetworkAddress() : + m_port(0) { // note -- make no calls to CNetwork socket interface here; // we're often called prior to CNetwork::init(). @@ -19,7 +21,9 @@ CNetworkAddress::CNetworkAddress() : m_port(0) memset(inetAddress->sin_zero, 0, sizeof(inetAddress->sin_zero)); } -CNetworkAddress::CNetworkAddress(UInt16 port) : m_port(port) +CNetworkAddress::CNetworkAddress( + UInt16 port) : + m_port(port) { if (port == 0) { throw XSocketAddress(XSocketAddress::kBadPort, m_hostname, m_port); @@ -33,9 +37,11 @@ CNetworkAddress::CNetworkAddress(UInt16 port) : m_port(port) memset(inetAddress->sin_zero, 0, sizeof(inetAddress->sin_zero)); } -CNetworkAddress::CNetworkAddress(const CString& hostname_, UInt16 port) : - m_hostname(hostname_), - m_port(port) +CNetworkAddress::CNetworkAddress( + const CString& hostname_, + UInt16 port) : + m_hostname(hostname_), + m_port(port) { CString hostname(m_hostname); @@ -126,27 +132,32 @@ CNetworkAddress::~CNetworkAddress() // do nothing } -bool CNetworkAddress::isValid() const +bool +CNetworkAddress::isValid() const { return (m_port != 0); } -const CNetwork::Address* CNetworkAddress::getAddress() const +const CNetwork::Address* +CNetworkAddress::getAddress() const { return &m_address; } -CNetwork::AddressLength CNetworkAddress::getAddressLength() const +CNetwork::AddressLength +CNetworkAddress::getAddressLength() const { return sizeof(m_address); } -CString CNetworkAddress::getHostname() const +CString +CNetworkAddress::getHostname() const { return m_hostname; } -UInt16 CNetworkAddress::getPort() const +UInt16 +CNetworkAddress::getPort() const { return m_port; } diff --git a/net/CNetworkAddress.h b/net/CNetworkAddress.h index 08750e29..1fd60fd4 100644 --- a/net/CNetworkAddress.h +++ b/net/CNetworkAddress.h @@ -2,7 +2,6 @@ #define CNETWORKADDRESS_H #include "CNetwork.h" -#include "XSocket.h" #include "CString.h" #include "BasicTypes.h" diff --git a/net/CTCPListenSocket.cpp b/net/CTCPListenSocket.cpp index 28e254c9..f7f2266e 100644 --- a/net/CTCPListenSocket.cpp +++ b/net/CTCPListenSocket.cpp @@ -1,6 +1,8 @@ #include "CTCPListenSocket.h" #include "CTCPSocket.h" #include "CNetworkAddress.h" +#include "XIO.h" +#include "XSocket.h" #include "CThread.h" // @@ -25,8 +27,9 @@ CTCPListenSocket::~CTCPListenSocket() } } -void CTCPListenSocket::bind( - const CNetworkAddress& addr) +void +CTCPListenSocket::bind( + const CNetworkAddress& addr) { if (CNetwork::bind(m_fd, addr.getAddress(), addr.getAddressLength()) == CNetwork::Error) { @@ -40,7 +43,8 @@ void CTCPListenSocket::bind( } } -ISocket* CTCPListenSocket::accept() +ISocket* +CTCPListenSocket::accept() { CNetwork::PollEntry pfds[1]; pfds[0].fd = m_fd; @@ -59,7 +63,8 @@ ISocket* CTCPListenSocket::accept() } } -void CTCPListenSocket::close() +void +CTCPListenSocket::close() { if (m_fd == CNetwork::Null) { throw XIOClosed(); diff --git a/net/CTCPSocket.cpp b/net/CTCPSocket.cpp index 3429c9f8..fdc640f3 100644 --- a/net/CTCPSocket.cpp +++ b/net/CTCPSocket.cpp @@ -2,13 +2,14 @@ #include "CBufferedInputStream.h" #include "CBufferedOutputStream.h" #include "CNetworkAddress.h" +#include "XIO.h" +#include "XSocket.h" +#include "CCondVar.h" #include "CLock.h" #include "CMutex.h" -#include "CCondVar.h" #include "CThread.h" -#include "TMethodJob.h" #include "CStopwatch.h" -#include +#include "TMethodJob.h" // // CTCPSocket @@ -23,7 +24,8 @@ CTCPSocket::CTCPSocket() init(); } -CTCPSocket::CTCPSocket(CNetwork::Socket fd) : m_fd(fd) +CTCPSocket::CTCPSocket(CNetwork::Socket fd) : + m_fd(fd) { assert(m_fd != CNetwork::Null); @@ -52,7 +54,9 @@ CTCPSocket::~CTCPSocket() delete m_mutex; } -void CTCPSocket::bind(const CNetworkAddress& addr) +void +CTCPSocket::bind( + const CNetworkAddress& addr) { if (CNetwork::bind(m_fd, addr.getAddress(), addr.getAddressLength()) == CNetwork::Error) { @@ -63,7 +67,9 @@ void CTCPSocket::bind(const CNetworkAddress& addr) } } -void CTCPSocket::connect(const CNetworkAddress& addr) +void +CTCPSocket::connect( + const CNetworkAddress& addr) { CThread::testCancel(); if (CNetwork::connect(m_fd, addr.getAddress(), @@ -78,7 +84,8 @@ void CTCPSocket::connect(const CNetworkAddress& addr) this, &CTCPSocket::ioThread)); } -void CTCPSocket::close() +void +CTCPSocket::close() { // see if buffers should be flushed bool doFlush = false; @@ -117,17 +124,20 @@ void CTCPSocket::close() } } -IInputStream* CTCPSocket::getInputStream() +IInputStream* +CTCPSocket::getInputStream() { return m_input; } -IOutputStream* CTCPSocket::getOutputStream() +IOutputStream* +CTCPSocket::getOutputStream() { return m_output; } -void CTCPSocket::init() +void +CTCPSocket::init() { m_mutex = new CMutex; m_thread = NULL; @@ -146,7 +156,8 @@ void CTCPSocket::init() CNetwork::setsockopt(m_fd, SOL_TCP, TCP_NODELAY, &flag, sizeof(flag)); } -void CTCPSocket::ioThread(void*) +void +CTCPSocket::ioThread(void*) { try { ioService(); @@ -158,7 +169,8 @@ void CTCPSocket::ioThread(void*) } } -void CTCPSocket::ioCleanup() +void +CTCPSocket::ioCleanup() { try { m_input->close(); @@ -174,7 +186,8 @@ void CTCPSocket::ioCleanup() } } -void CTCPSocket::ioService() +void +CTCPSocket::ioService() { assert(m_fd != CNetwork::Null); @@ -249,14 +262,16 @@ void CTCPSocket::ioService() } } -void CTCPSocket::closeInput(void*) +void +CTCPSocket::closeInput(void*) { // note -- m_mutex should already be locked CNetwork::shutdown(m_fd, 0); m_connected &= ~kRead; } -void CTCPSocket::closeOutput(void*) +void +CTCPSocket::closeOutput(void*) { // note -- m_mutex should already be locked CNetwork::shutdown(m_fd, 1); diff --git a/net/CTCPSocket.h b/net/CTCPSocket.h index 3e7913b2..980e0dec 100644 --- a/net/CTCPSocket.h +++ b/net/CTCPSocket.h @@ -3,7 +3,6 @@ #include "ISocket.h" #include "CNetwork.h" -#include "XThread.h" class CMutex; template diff --git a/net/IListenSocket.h b/net/IListenSocket.h index f62f2239..dd454976 100644 --- a/net/IListenSocket.h +++ b/net/IListenSocket.h @@ -2,8 +2,6 @@ #define ILISTENSOCKET_H #include "IInterface.h" -#include "XIO.h" -#include "XSocket.h" class CNetworkAddress; class ISocket; diff --git a/net/ISocket.h b/net/ISocket.h index 0a28ccc7..6c853b59 100644 --- a/net/ISocket.h +++ b/net/ISocket.h @@ -2,9 +2,6 @@ #define ISOCKET_H #include "IInterface.h" -#include "BasicTypes.h" -#include "XSocket.h" -#include "XIO.h" class CNetworkAddress; class IInputStream; diff --git a/net/Makefile b/net/Makefile index 38110334..741ba8bf 100644 --- a/net/Makefile +++ b/net/Makefile @@ -19,6 +19,7 @@ CXXFILES = \ CNetworkAddress.cpp \ CTCPSocket.cpp \ CTCPListenSocket.cpp \ + XNetwork.cpp \ XSocket.cpp \ $(NULL) diff --git a/net/XNetwork.cpp b/net/XNetwork.cpp index a745fc6a..26108535 100644 --- a/net/XNetwork.cpp +++ b/net/XNetwork.cpp @@ -4,7 +4,8 @@ // XNetworkUnavailable // -CString XNetworkUnavailable::getWhat() const throw() +CString +XNetworkUnavailable::getWhat() const throw() { return format("XNetworkUnavailable", "network library is not available"); } @@ -14,7 +15,8 @@ CString XNetworkUnavailable::getWhat() const throw() // XNetworkFailed // -CString XNetworkFailed::getWhat() const throw() +CString +XNetworkFailed::getWhat() const throw() { return format("XNetworkFailed", "cannot initialize network library"); } @@ -24,24 +26,29 @@ CString XNetworkFailed::getWhat() const throw() // XNetworkVersion // -XNetworkVersion::XNetworkVersion(int major, int minor) throw() : - m_major(major), - m_minor(minor) +XNetworkVersion::XNetworkVersion( + int major, + int minor) throw() : + m_major(major), + m_minor(minor) { // do nothing } -int XNetworkVersion::getMajor() const throw() +int +XNetworkVersion::getMajor() const throw() { return m_major; } -int XNetworkVersion::getMinor() const throw() +int +XNetworkVersion::getMinor() const throw() { return m_minor; } -CString XNetworkVersion::getWhat() const throw() +CString +XNetworkVersion::getWhat() const throw() { return format("XNetworkVersion", "unsupported network version %d.%d", @@ -54,7 +61,7 @@ CString XNetworkVersion::getWhat() const throw() // XNetworkFunctionUnavailable::XNetworkFunctionUnavailable( - const char* name) throw() + const char* name) throw() { try { m_name = name; @@ -64,7 +71,8 @@ XNetworkFunctionUnavailable::XNetworkFunctionUnavailable( } } -CString XNetworkFunctionUnavailable::getWhat() const throw() +CString +XNetworkFunctionUnavailable::getWhat() const throw() { return format("XNetworkFunctionUnavailable", "missing network function %s", diff --git a/net/XNetwork.h b/net/XNetwork.h index a971d423..ac0e5a24 100644 --- a/net/XNetwork.h +++ b/net/XNetwork.h @@ -1,9 +1,8 @@ #ifndef XNETWORK_H #define XNETWORK_H -#include "CString.h" #include "XBase.h" -#include "BasicTypes.h" +#include "CString.h" class XNetwork : public XBase { }; diff --git a/net/XSocket.cpp b/net/XSocket.cpp index 983e9eae..73731115 100644 --- a/net/XSocket.cpp +++ b/net/XSocket.cpp @@ -4,31 +4,37 @@ // XSocketAddress // -XSocketAddress::XSocketAddress(Error error, - const CString& hostname, UInt16 port) throw() : - m_error(error), - m_hostname(hostname), - m_port(port) +XSocketAddress::XSocketAddress( + Error error, + const CString& hostname, + UInt16 port) throw() : + m_error(error), + m_hostname(hostname), + m_port(port) { // do nothing } -XSocketAddress::Error XSocketAddress::getError() const throw() +XSocketAddress::Error +XSocketAddress::getError() const throw() { return m_error; } -CString XSocketAddress::getHostname() const throw() +CString +XSocketAddress::getHostname() const throw() { return m_hostname; } -UInt16 XSocketAddress::getPort() const throw() +UInt16 +XSocketAddress::getPort() const throw() { return m_port; } -CString XSocketAddress::getWhat() const throw() +CString +XSocketAddress::getWhat() const throw() { return "no address"; /* @@ -43,12 +49,15 @@ CString XSocketAddress::getWhat() const throw() // XSocketErrno // -XSocketErrno::XSocketErrno() : MXErrno() +XSocketErrno::XSocketErrno() : + MXErrno() { // do nothing } -XSocketErrno::XSocketErrno(int err) : MXErrno(err) +XSocketErrno::XSocketErrno( + int err) : + MXErrno(err) { // do nothing } @@ -58,7 +67,8 @@ XSocketErrno::XSocketErrno(int err) : MXErrno(err) // XSocketBind // -CString XSocketBind::getWhat() const throw() +CString +XSocketBind::getWhat() const throw() { return format("XSocketBind", "cannot bind address"); } @@ -68,7 +78,8 @@ CString XSocketBind::getWhat() const throw() // XSocketConnect // -CString XSocketConnect::getWhat() const throw() +CString +XSocketConnect::getWhat() const throw() { return format("XSocketConnect", "cannot connect socket"); } @@ -78,7 +89,8 @@ CString XSocketConnect::getWhat() const throw() // XSocketCreate // -CString XSocketCreate::getWhat() const throw() +CString +XSocketCreate::getWhat() const throw() { return format("XSocketCreate", "cannot create socket"); } diff --git a/net/XSocket.h b/net/XSocket.h index 1a83c99d..4b0fbf7c 100644 --- a/net/XSocket.h +++ b/net/XSocket.h @@ -1,8 +1,8 @@ #ifndef XSOCKET_H #define XSOCKET_H -#include "CString.h" #include "XBase.h" +#include "CString.h" #include "BasicTypes.h" class XSocket : public XBase { }; diff --git a/platform/CMSWindowsClipboard.cpp b/platform/CMSWindowsClipboard.cpp index 8503574c..87b2b298 100644 --- a/platform/CMSWindowsClipboard.cpp +++ b/platform/CMSWindowsClipboard.cpp @@ -1,14 +1,14 @@ #include "CMSWindowsClipboard.h" -#include "CString.h" #include "CLog.h" // // CMSWindowsClipboard // -CMSWindowsClipboard::CMSWindowsClipboard(HWND window) : - m_window(window), - m_time(0) +CMSWindowsClipboard::CMSWindowsClipboard( + HWND window) : + m_window(window), + m_time(0) { // do nothing } @@ -18,7 +18,8 @@ CMSWindowsClipboard::~CMSWindowsClipboard() // do nothing } -bool CMSWindowsClipboard::empty() +bool +CMSWindowsClipboard::empty() { log((CLOG_DEBUG "empty clipboard")); @@ -30,8 +31,10 @@ bool CMSWindowsClipboard::empty() return true; } -void CMSWindowsClipboard::add( - EFormat format, const CString& data) +void +CMSWindowsClipboard::add( + EFormat format, + const CString& data) { log((CLOG_DEBUG "add %d bytes to clipboard format: %d", data.size(), format)); @@ -54,7 +57,9 @@ void CMSWindowsClipboard::add( } } -bool CMSWindowsClipboard::open(Time time) const +bool +CMSWindowsClipboard::open( + Time time) const { log((CLOG_DEBUG "open clipboard")); @@ -68,29 +73,36 @@ bool CMSWindowsClipboard::open(Time time) const return true; } -void CMSWindowsClipboard::close() const +void +CMSWindowsClipboard::close() const { log((CLOG_DEBUG "close clipboard")); CloseClipboard(); } -IClipboard::Time CMSWindowsClipboard::getTime() const +IClipboard::Time +CMSWindowsClipboard::getTime() const { return m_time; } -bool CMSWindowsClipboard::has(EFormat format) const +bool +CMSWindowsClipboard::has( + EFormat format) const { const UINT win32Format = convertFormatToWin32(format); return (win32Format != 0 && IsClipboardFormatAvailable(win32Format) != 0); } -CString CMSWindowsClipboard::get(EFormat format) const +CString +CMSWindowsClipboard::get( + EFormat format) const { // get the win32 format. return empty data if unknown format. const UINT win32Format = convertFormatToWin32(format); - if (win32Format == 0) + if (win32Format == 0) { return CString(); + } // get a handle to the clipboard data and convert it HANDLE win32Data = GetClipboardData(win32Format); @@ -106,8 +118,9 @@ CString CMSWindowsClipboard::get(EFormat format) const return data; } -UINT CMSWindowsClipboard::convertFormatToWin32( - EFormat format) const +UINT +CMSWindowsClipboard::convertFormatToWin32( + EFormat format) const { switch (format) { case kText: @@ -118,8 +131,9 @@ UINT CMSWindowsClipboard::convertFormatToWin32( } } -HANDLE CMSWindowsClipboard::convertTextToWin32( - const CString& data) const +HANDLE +CMSWindowsClipboard::convertTextToWin32( + const CString& data) const { // compute size of converted text UInt32 dstSize = 1; @@ -157,14 +171,16 @@ HANDLE CMSWindowsClipboard::convertTextToWin32( return gData; } -CString CMSWindowsClipboard::convertTextFromWin32( - HANDLE handle) const +CString +CMSWindowsClipboard::convertTextFromWin32( + HANDLE handle) const { // get source data and it's size const char* src = (const char*)GlobalLock(handle); UInt32 srcSize = (SInt32)GlobalSize(handle); - if (src == NULL || srcSize <= 1) + if (src == NULL || srcSize <= 1) { return CString(); + } // ignore trailing NUL --srcSize; @@ -175,8 +191,9 @@ CString CMSWindowsClipboard::convertTextFromWin32( for (index = 0; index < srcSize; ++index) { if (src[index] == '\r') { // skip \r - if (index + 1 < srcSize && src[index + 1] == '\n') + if (index + 1 < srcSize && src[index + 1] == '\n') { ++index; + } } ++dstSize; } @@ -189,8 +206,9 @@ CString CMSWindowsClipboard::convertTextFromWin32( for (index = 0; index < srcSize; ++index) { if (src[index] == '\r') { // skip \r - if (index + 1 < srcSize && src[index + 1] == '\n') + if (index + 1 < srcSize && src[index + 1] == '\n') { ++index; + } } data += src[index]; } diff --git a/platform/CMSWindowsScreen.cpp b/platform/CMSWindowsScreen.cpp index 83e11704..f093c770 100644 --- a/platform/CMSWindowsScreen.cpp +++ b/platform/CMSWindowsScreen.cpp @@ -4,8 +4,7 @@ #include "TMethodJob.h" #include "CLog.h" #include "CString.h" -#include -#include +#include // // CMSWindowsScreen @@ -15,10 +14,10 @@ HINSTANCE CMSWindowsScreen::s_instance = NULL; CMSWindowsScreen* CMSWindowsScreen::s_screen = NULL; CMSWindowsScreen::CMSWindowsScreen() : - m_class(0), - m_cursor(NULL), - m_w(0), m_h(0), - m_thread(0) + m_class(0), + m_cursor(NULL), + m_w(0), m_h(0), + m_thread(0) { assert(s_screen == NULL); s_screen = this; @@ -30,12 +29,15 @@ CMSWindowsScreen::~CMSWindowsScreen() s_screen = NULL; } -void CMSWindowsScreen::init(HINSTANCE instance) +void +CMSWindowsScreen::init( + HINSTANCE instance) { s_instance = instance; } -void CMSWindowsScreen::doRun() +void +CMSWindowsScreen::doRun() { // save thread id for posting quit message m_thread = GetCurrentThreadId(); @@ -59,12 +61,14 @@ void CMSWindowsScreen::doRun() } } -void CMSWindowsScreen::doStop() +void +CMSWindowsScreen::doStop() { PostThreadMessage(m_thread, WM_QUIT, 0, 0); } -void CMSWindowsScreen::openDisplay() +void +CMSWindowsScreen::openDisplay() { assert(s_instance != NULL); assert(m_class == 0); @@ -106,7 +110,8 @@ void CMSWindowsScreen::openDisplay() onOpenDisplay(); } -void CMSWindowsScreen::closeDisplay() +void +CMSWindowsScreen::closeDisplay() { assert(s_instance != NULL); assert(m_class != 0); @@ -125,25 +130,30 @@ void CMSWindowsScreen::closeDisplay() log((CLOG_DEBUG "closed display")); } -HINSTANCE CMSWindowsScreen::getInstance() +HINSTANCE +CMSWindowsScreen::getInstance() { return s_instance; } -ATOM CMSWindowsScreen::getClass() const +ATOM +CMSWindowsScreen::getClass() const { return m_class; } -void CMSWindowsScreen::updateScreenSize() +void +CMSWindowsScreen::updateScreenSize() { m_w = GetSystemMetrics(SM_CXSCREEN); m_h = GetSystemMetrics(SM_CYSCREEN); log((CLOG_INFO "display resize: %dx%d", m_w, m_h)); } -void CMSWindowsScreen::getScreenSize( - SInt32* w, SInt32* h) const +void +CMSWindowsScreen::getScreenSize( + SInt32* w, + SInt32* h) const { assert(m_class != 0); assert(w != NULL && h != NULL); @@ -152,7 +162,8 @@ void CMSWindowsScreen::getScreenSize( *h = m_h; } -HDESK CMSWindowsScreen::openInputDesktop() const +HDESK +CMSWindowsScreen::openInputDesktop() const { return OpenInputDesktop(DF_ALLOWOTHERACCOUNTHOOK, TRUE, DESKTOP_CREATEWINDOW | @@ -160,8 +171,9 @@ HDESK CMSWindowsScreen::openInputDesktop() const GENERIC_WRITE); } -CString CMSWindowsScreen::getDesktopName( - HDESK desk) const +CString +CMSWindowsScreen::getDesktopName( + HDESK desk) const { if (desk == NULL) { return CString(); @@ -177,14 +189,17 @@ CString CMSWindowsScreen::getDesktopName( } } -bool CMSWindowsScreen::isCurrentDesktop( - HDESK desk) const +bool +CMSWindowsScreen::isCurrentDesktop( + HDESK desk) const { return CStringUtil::CaselessCmp::equal(getDesktopName(desk), getCurrentDesktopName()); } -void CMSWindowsScreen::getEvent(MSG* msg) const +void +CMSWindowsScreen::getEvent( + MSG* msg) const { // wait for an event in a cancellable way while (HIWORD(GetQueueStatus(QS_ALLINPUT)) == 0) { @@ -193,9 +208,12 @@ void CMSWindowsScreen::getEvent(MSG* msg) const GetMessage(msg, NULL, 0, 0); } -LRESULT CALLBACK CMSWindowsScreen::wndProc( - HWND hwnd, UINT msg, - WPARAM wParam, LPARAM lParam) +LRESULT CALLBACK +CMSWindowsScreen::wndProc( + HWND hwnd, + UINT msg, + WPARAM wParam, + LPARAM lParam) { assert(s_screen != NULL); return s_screen->onEvent(hwnd, msg, wParam, lParam); diff --git a/platform/CMSWindowsScreen.h b/platform/CMSWindowsScreen.h index 0e54205b..f3db8a43 100644 --- a/platform/CMSWindowsScreen.h +++ b/platform/CMSWindowsScreen.h @@ -1,9 +1,8 @@ #ifndef CMSWINDOWSSCREEN_H #define CMSWINDOWSSCREEN_H -#include "CMutex.h" #include "IClipboard.h" -#include "BasicTypes.h" +#include "CMutex.h" #define WIN32_LEAN_AND_MEAN #include diff --git a/platform/CUnixPlatform.cpp b/platform/CUnixPlatform.cpp index 99349ea7..ea14d40f 100644 --- a/platform/CUnixPlatform.cpp +++ b/platform/CUnixPlatform.cpp @@ -1,6 +1,6 @@ #include "CUnixPlatform.h" #include "CLog.h" -#include +#include #include #include #include @@ -9,7 +9,6 @@ #include #include - // // CUnixPlatform // @@ -24,24 +23,29 @@ CUnixPlatform::~CUnixPlatform() // do nothing } -bool CUnixPlatform::installDaemon( - const char*, - const char*, - const char*, - const char*) +bool +CUnixPlatform::installDaemon( + const char*, + const char*, + const char*, + const char*) { // daemons don't require special installation return true; } -bool CUnixPlatform::uninstallDaemon(const char*) +bool +CUnixPlatform::uninstallDaemon( + const char*) { // daemons don't require special installation return true; } -int CUnixPlatform::daemonize( - const char* name, DaemonFunc func) +int +CUnixPlatform::daemonize( + const char* name, + DaemonFunc func) { // fork so shell thinks we're done and so we're not a process // group leader @@ -86,43 +90,46 @@ int CUnixPlatform::daemonize( return func(this, 1, &name); } -int CUnixPlatform::restart( - RestartFunc func, int minErrorCode) +int +CUnixPlatform::restart( + RestartFunc func, + int minErrorCode) { for (;;) { switch (fork()) { - default: { - // parent process. wait for child to exit. - int status; - if (wait(&status) == -1) { - // wait failed. this is unexpected so bail. - log((CLOG_CRIT "wait() failed")); - return minErrorCode; - } + default: + { + // parent process. wait for child to exit. + int status; + if (wait(&status) == -1) { + // wait failed. this is unexpected so bail. + log((CLOG_CRIT "wait() failed")); + return minErrorCode; + } - // what happened? if the child exited normally with a - // status less than 16 then the child was deliberately - // terminated so we also terminate. - if (WIFEXITED(status) && WEXITSTATUS(status) < minErrorCode) { - return WEXITSTATUS(status); - } + // what happened? if the child exited normally with a + // status less than 16 then the child was deliberately + // terminated so we also terminate. + if (WIFEXITED(status) && WEXITSTATUS(status) < minErrorCode) { + return WEXITSTATUS(status); + } - // did child die horribly? - if (WIFSIGNALED(status)) { - switch (WTERMSIG(status)) { - case SIGHUP: - case SIGINT: - case SIGQUIT: - case SIGTERM: - break; + // did child die horribly? + if (WIFSIGNALED(status)) { + switch (WTERMSIG(status)) { + case SIGHUP: + case SIGINT: + case SIGQUIT: + case SIGTERM: + break; - default: - // uh oh. bail out. - return 16; + default: + // uh oh. bail out. + return 16; + } } } break; - } case -1: // fork() failed. log the error and proceed as a child @@ -136,7 +143,9 @@ int CUnixPlatform::restart( } } -const char* CUnixPlatform::getBasename(const char* pathname) const +const char* +CUnixPlatform::getBasename( + const char* pathname) const { if (pathname == NULL) { return NULL; @@ -151,7 +160,8 @@ const char* CUnixPlatform::getBasename(const char* pathname) const } } -CString CUnixPlatform::getUserDirectory() const +CString +CUnixPlatform::getUserDirectory() const { // FIXME -- use geteuid? shouldn't run this setuid anyway. struct passwd* pwent = getpwuid(getuid()); @@ -163,14 +173,16 @@ CString CUnixPlatform::getUserDirectory() const } } -CString CUnixPlatform::getSystemDirectory() const +CString +CUnixPlatform::getSystemDirectory() const { return "/etc"; } -CString CUnixPlatform::addPathComponent( - const CString& prefix, - const CString& suffix) const +CString +CUnixPlatform::addPathComponent( + const CString& prefix, + const CString& suffix) const { CString path; path.reserve(prefix.size() + 1 + suffix.size()); @@ -182,14 +194,18 @@ CString CUnixPlatform::addPathComponent( return path; } -void CUnixPlatform::setDaemonLogger(const char* name) +void +CUnixPlatform::setDaemonLogger( + const char* name) { openlog(name, 0, LOG_DAEMON); CLog::setOutputter(&CUnixPlatform::deamonLogger); } -bool CUnixPlatform::deamonLogger( - int priority, const char* msg) +bool +CUnixPlatform::deamonLogger( + int priority, + const char* msg) { // convert priority switch (priority) { diff --git a/platform/CUnixPlatform.h b/platform/CUnixPlatform.h index 94bc4a05..d5a92ec3 100644 --- a/platform/CUnixPlatform.h +++ b/platform/CUnixPlatform.h @@ -10,9 +10,9 @@ public: // IPlatform overrides virtual bool installDaemon(const char* name, - const char* description, - const char* pathname, - const char* commandLine); + const char* description, + const char* pathname, + const char* commandLine); virtual bool uninstallDaemon(const char* name); virtual int daemonize(const char* name, DaemonFunc); virtual int restart(RestartFunc, int minErrorCode); @@ -20,8 +20,8 @@ public: virtual CString getUserDirectory() const; virtual CString getSystemDirectory() const; virtual CString addPathComponent( - const CString& prefix, - const CString& suffix) const; + const CString& prefix, + const CString& suffix) const; protected: virtual void setDaemonLogger(const char* name); diff --git a/platform/CWin32Platform.cpp b/platform/CWin32Platform.cpp index 9e71a141..75dc0c37 100644 --- a/platform/CWin32Platform.cpp +++ b/platform/CWin32Platform.cpp @@ -3,10 +3,9 @@ #include "CThread.h" #include "CLog.h" #include "stdvector.h" -#include +#include #include #include -#include // // CWin32Platform @@ -25,7 +24,8 @@ CWin32Platform::~CWin32Platform() // do nothing } -bool CWin32Platform::isWindows95Family() +bool +CWin32Platform::isWindows95Family() { OSVERSIONINFO version; version.dwOSVersionInfoSize = sizeof(version); @@ -36,16 +36,20 @@ bool CWin32Platform::isWindows95Family() return (version.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS); } -void CWin32Platform::setStatus( - SERVICE_STATUS_HANDLE handle, - DWORD state) +void +CWin32Platform::setStatus( + SERVICE_STATUS_HANDLE handle, + DWORD state) { setStatus(handle, state, 0, 0); } -void CWin32Platform::setStatus( - SERVICE_STATUS_HANDLE handle, - DWORD state, DWORD step, DWORD waitHint) +void +CWin32Platform::setStatus( + SERVICE_STATUS_HANDLE handle, + DWORD state, + DWORD step, + DWORD waitHint) { SERVICE_STATUS status; status.dwServiceType = SERVICE_WIN32_OWN_PROCESS | @@ -61,9 +65,10 @@ void CWin32Platform::setStatus( SetServiceStatus(handle, &status); } -void CWin32Platform::setStatusError( - SERVICE_STATUS_HANDLE handle, - DWORD error) +void +CWin32Platform::setStatusError( + SERVICE_STATUS_HANDLE handle, + DWORD error) { SERVICE_STATUS status; status.dwServiceType = SERVICE_WIN32_OWN_PROCESS | @@ -79,11 +84,12 @@ void CWin32Platform::setStatusError( SetServiceStatus(handle, &status); } -bool CWin32Platform::installDaemon( - const char* name, - const char* description, - const char* pathname, - const char* commandLine) +bool +CWin32Platform::installDaemon( + const char* name, + const char* description, + const char* pathname, + const char* commandLine) { // windows 95 family services if (isWindows95Family()) { @@ -174,7 +180,9 @@ bool CWin32Platform::installDaemon( } } -bool CWin32Platform::uninstallDaemon(const char* name) +bool +CWin32Platform::uninstallDaemon( + const char* name) { // windows 95 family services if (isWindows95Family()) { @@ -231,9 +239,10 @@ bool CWin32Platform::uninstallDaemon(const char* name) } } -int CWin32Platform::daemonize( - const char* name, - DaemonFunc func) +int +CWin32Platform::daemonize( + const char* name, + DaemonFunc func) { assert(name != NULL); assert(func != NULL); @@ -294,8 +303,10 @@ int CWin32Platform::daemonize( } } -int CWin32Platform::restart( - RestartFunc func, int /*minErrorCode*/) +int +CWin32Platform::restart( + RestartFunc func, + int /*minErrorCode*/) { // FIXME -- start in separate process or thread. note that this // isn't too critical as win32 doesn't force us to terminate for @@ -303,7 +314,9 @@ int CWin32Platform::restart( return func(); } -const char* CWin32Platform::getBasename(const char* pathname) const +const char* +CWin32Platform::getBasename( + const char* pathname) const { if (pathname == NULL) { return NULL; @@ -327,7 +340,8 @@ const char* CWin32Platform::getBasename(const char* pathname) const return basename; } -CString CWin32Platform::getUserDirectory() const +CString +CWin32Platform::getUserDirectory() const { // try %HOMEPATH% TCHAR dir[MAX_PATH]; @@ -370,7 +384,8 @@ CString CWin32Platform::getUserDirectory() const return "C:"; } -CString CWin32Platform::getSystemDirectory() const +CString +CWin32Platform::getSystemDirectory() const { // get windows directory char dir[MAX_PATH]; @@ -383,9 +398,10 @@ CString CWin32Platform::getSystemDirectory() const } } -CString CWin32Platform::addPathComponent( - const CString& prefix, - const CString& suffix) const +CString +CWin32Platform::addPathComponent( + const CString& prefix, + const CString& suffix) const { CString path; path.reserve(prefix.size() + 1 + suffix.size()); @@ -399,8 +415,10 @@ CString CWin32Platform::addPathComponent( return path; } -HKEY CWin32Platform::openKey( - HKEY key, const char* keyName) +HKEY +CWin32Platform::openKey( + HKEY key, + const char* keyName) { // open next key HKEY newKey; @@ -422,8 +440,10 @@ HKEY CWin32Platform::openKey( return newKey; } -HKEY CWin32Platform::openKey( - HKEY key, const char** keyNames) +HKEY +CWin32Platform::openKey( + HKEY key, + const char** keyNames) { for (UInt32 i = 0; key != NULL && keyNames[i] != NULL; ++i) { // open next key @@ -432,28 +452,39 @@ HKEY CWin32Platform::openKey( return key; } -void CWin32Platform::closeKey(HKEY key) +void +CWin32Platform::closeKey( + HKEY key) { assert(key != NULL); RegCloseKey(key); } -void CWin32Platform::deleteKey(HKEY key, const char* name) +void +CWin32Platform::deleteKey( + HKEY key, + const char* name) { assert(key != NULL); assert(name != NULL); RegDeleteKey(key, name); } -void CWin32Platform::deleteValue(HKEY key, const char* name) +void +CWin32Platform::deleteValue( + HKEY key, + const char* name) { assert(key != NULL); assert(name != NULL); RegDeleteValue(key, name); } -void CWin32Platform::setValue(HKEY key, - const char* name, const CString& value) +void +CWin32Platform::setValue( + HKEY key, + const char* name, + const CString& value) { assert(key != NULL); assert(name != NULL); @@ -462,8 +493,10 @@ void CWin32Platform::setValue(HKEY key, value.size() + 1); } -CString CWin32Platform::readValueString(HKEY key, - const char* name) +CString +CWin32Platform::readValueString( + HKEY key, + const char* name) { // get the size of the string DWORD type; @@ -490,7 +523,8 @@ CString CWin32Platform::readValueString(HKEY key, return value; } -HKEY CWin32Platform::openNTServicesKey() +HKEY +CWin32Platform::openNTServicesKey() { static const char* s_keyNames[] = { _T("SYSTEM"), @@ -502,7 +536,8 @@ HKEY CWin32Platform::openNTServicesKey() return openKey(HKEY_LOCAL_MACHINE, s_keyNames); } -HKEY CWin32Platform::open95ServicesKey() +HKEY +CWin32Platform::open95ServicesKey() { static const char* s_keyNames[] = { _T("Software"), @@ -516,7 +551,10 @@ HKEY CWin32Platform::open95ServicesKey() return openKey(HKEY_LOCAL_MACHINE, s_keyNames); } -int CWin32Platform::runDaemon(RunFunc run, StopFunc stop) +int +CWin32Platform::runDaemon( + RunFunc run, + StopFunc stop) { // should only be called from DaemonFunc assert(m_serviceMutex != NULL); @@ -595,8 +633,10 @@ int CWin32Platform::runDaemon(RunFunc run, StopFunc stop) } } -void CWin32Platform::serviceMain( - DWORD argc, LPTSTR* argvIn) +void +CWin32Platform::serviceMain( + DWORD argc, + LPTSTR* argvIn) { typedef std::vector ArgList; typedef std::vector Arguments; @@ -718,13 +758,17 @@ void CWin32Platform::serviceMain( // FIXME -- close event log? } -void WINAPI CWin32Platform::serviceMainEntry( - DWORD argc, LPTSTR* argv) +void WINAPI +CWin32Platform::serviceMainEntry( + DWORD argc, + LPTSTR* argv) { s_daemonPlatform->serviceMain(argc, argv); } -void CWin32Platform::serviceHandler(DWORD ctrl) +void +CWin32Platform::serviceHandler( + DWORD ctrl) { assert(m_serviceMutex != NULL); assert(m_serviceState != NULL); @@ -796,13 +840,17 @@ void CWin32Platform::serviceHandler(DWORD ctrl) setStatus(m_statusHandle, *m_serviceState); } -void WINAPI CWin32Platform::serviceHandlerEntry(DWORD ctrl) +void WINAPI +CWin32Platform::serviceHandlerEntry( + DWORD ctrl) { s_daemonPlatform->serviceHandler(ctrl); } -bool CWin32Platform::serviceLogger( - int priority, const char* msg) +bool +CWin32Platform::serviceLogger( + int priority, + const char* msg) { if (s_eventLog == NULL) { return false; diff --git a/platform/CWin32Platform.h b/platform/CWin32Platform.h index 4300c050..40dfbe29 100644 --- a/platform/CWin32Platform.h +++ b/platform/CWin32Platform.h @@ -21,7 +21,7 @@ public: // utility for calling SetServiceStatus() static void setStatus(SERVICE_STATUS_HANDLE, DWORD state); static void setStatus(SERVICE_STATUS_HANDLE, - DWORD state, DWORD step, DWORD waitHint); + DWORD state, DWORD step, DWORD waitHint); static void setStatusError(SERVICE_STATUS_HANDLE, DWORD error); // run a service. the RunFunc should unlock the passed in mutex @@ -43,9 +43,9 @@ public: // IPlatform overrides virtual bool installDaemon(const char* name, - const char* description, - const char* pathname, - const char* commandLine); + const char* description, + const char* pathname, + const char* commandLine); virtual bool uninstallDaemon(const char* name); virtual int daemonize(const char* name, DaemonFunc); virtual int restart(RestartFunc, int minErrorCode); @@ -53,8 +53,8 @@ public: virtual CString getUserDirectory() const; virtual CString getSystemDirectory() const; virtual CString addPathComponent( - const CString& prefix, - const CString& suffix) const; + const CString& prefix, + const CString& suffix) const; private: static HKEY openKey(HKEY parent, const char*); @@ -63,7 +63,7 @@ private: static void deleteKey(HKEY, const char* name); static void deleteValue(HKEY, const char* name); static void setValue(HKEY, const char* name, - const CString& value); + const CString& value); static CString readValueString(HKEY, const char* name); static HKEY openNTServicesKey(); static HKEY open95ServicesKey(); diff --git a/platform/CXWindowsClipboard.cpp b/platform/CXWindowsClipboard.cpp index 9a225e39..a025d372 100644 --- a/platform/CXWindowsClipboard.cpp +++ b/platform/CXWindowsClipboard.cpp @@ -1,25 +1,27 @@ #include "CXWindowsClipboard.h" #include "CXWindowsUtil.h" -#include "CLog.h" #include "CThread.h" +#include "CLog.h" #include "TMethodJob.h" -#include +#include #include // // CXWindowsClipboard // -CXWindowsClipboard::CXWindowsClipboard(Display* display, - Window window, ClipboardID id) : - m_display(display), - m_window(window), - m_id(id), - m_open(false), - m_time(0), - m_owner(false), - m_timeOwned(0), - m_timeLost(0) +CXWindowsClipboard::CXWindowsClipboard( + Display* display, + Window window, + ClipboardID id) : + m_display(display), + m_window(window), + m_id(id), + m_open(false), + m_time(0), + m_owner(false), + m_timeOwned(0), + m_timeLost(0) { // get some atoms m_atomTargets = XInternAtom(m_display, "TARGETS", False); @@ -60,7 +62,9 @@ CXWindowsClipboard::~CXWindowsClipboard() clearReplies(); } -void CXWindowsClipboard::lost(Time time) +void +CXWindowsClipboard::lost( + Time time) { log((CLOG_DEBUG "lost clipboard %d ownership at %d", m_id, time)); if (m_owner) { @@ -70,10 +74,13 @@ void CXWindowsClipboard::lost(Time time) } } -void CXWindowsClipboard::addRequest( - Window owner, - Window requestor, Atom target, - ::Time time, Atom property) +void +CXWindowsClipboard::addRequest( + Window owner, + Window requestor, + Atom target, + ::Time time, + Atom property) { // must be for our window and we must have owned the selection // at the given time. @@ -110,9 +117,12 @@ void CXWindowsClipboard::addRequest( pushReplies(); } -bool CXWindowsClipboard::addSimpleRequest( - Window requestor, Atom target, - ::Time time, Atom property) +bool +CXWindowsClipboard::addSimpleRequest( + Window requestor, + Atom target, + ::Time time, + Atom property) { // obsolete requestors may supply a None property. in // that case we use the target as the property to store @@ -151,9 +161,11 @@ bool CXWindowsClipboard::addSimpleRequest( } } -bool CXWindowsClipboard::processRequest( - Window requestor, - ::Time /*time*/, Atom property) +bool +CXWindowsClipboard::processRequest( + Window requestor, + ::Time /*time*/, + Atom property) { CReplyMap::iterator index = m_replies.find(requestor); if (index == m_replies.end()) { @@ -179,8 +191,9 @@ bool CXWindowsClipboard::processRequest( return false; } -bool CXWindowsClipboard::destroyRequest( - Window requestor) +bool +CXWindowsClipboard::destroyRequest( + Window requestor) { CReplyMap::iterator index = m_replies.find(requestor); if (index == m_replies.end()) { @@ -198,17 +211,20 @@ bool CXWindowsClipboard::destroyRequest( return true; } -Window CXWindowsClipboard::getWindow() const +Window +CXWindowsClipboard::getWindow() const { return m_window; } -Atom CXWindowsClipboard::getSelection() const +Atom +CXWindowsClipboard::getSelection() const { return m_selection; } -bool CXWindowsClipboard::empty() +bool +CXWindowsClipboard::empty() { assert(m_open); @@ -240,8 +256,10 @@ bool CXWindowsClipboard::empty() return true; } -void CXWindowsClipboard::add( - EFormat format, const CString& data) +void +CXWindowsClipboard::add( + EFormat format, + const CString& data) { assert(m_open); assert(m_owner); @@ -254,7 +272,9 @@ void CXWindowsClipboard::add( // FIXME -- set motif clipboard item? } -bool CXWindowsClipboard::open(Time time) const +bool +CXWindowsClipboard::open( + Time time) const { assert(!m_open); @@ -304,7 +324,8 @@ bool CXWindowsClipboard::open(Time time) const return true; } -void CXWindowsClipboard::close() const +void +CXWindowsClipboard::close() const { assert(m_open); @@ -319,12 +340,15 @@ void CXWindowsClipboard::close() const m_open = false; } -IClipboard::Time CXWindowsClipboard::getTime() const +IClipboard::Time +CXWindowsClipboard::getTime() const { return m_timeOwned; } -bool CXWindowsClipboard::has(EFormat format) const +bool +CXWindowsClipboard::has( + EFormat format) const { assert(m_open); @@ -332,7 +356,9 @@ bool CXWindowsClipboard::has(EFormat format) const return m_added[format]; } -CString CXWindowsClipboard::get(EFormat format) const +CString +CXWindowsClipboard::get( + EFormat format) const { assert(m_open); @@ -340,23 +366,28 @@ CString CXWindowsClipboard::get(EFormat format) const return m_data[format]; } -IClipboard::EFormat CXWindowsClipboard::getFormat(Atom src) const +IClipboard::EFormat +CXWindowsClipboard::getFormat( + Atom src) const { // FIXME -- handle more formats (especially mime-type-like formats // and various character encodings like unicode). if (src == m_atomString || src == m_atomText /*|| - src == m_atomCompoundText*/) + src == m_atomCompoundText*/) { return IClipboard::kText; + } return IClipboard::kNumFormats; } -void CXWindowsClipboard::clearCache() const +void +CXWindowsClipboard::clearCache() const { const_cast(this)->doClearCache(); } -void CXWindowsClipboard::doClearCache() +void +CXWindowsClipboard::doClearCache() { m_cached = false; for (SInt32 index = 0; index < kNumFormats; ++index) { @@ -365,7 +396,8 @@ void CXWindowsClipboard::doClearCache() } } -void CXWindowsClipboard::fillCache() const +void +CXWindowsClipboard::fillCache() const { // get the selection data if not already cached if (!m_cached) { @@ -373,7 +405,8 @@ void CXWindowsClipboard::fillCache() const } } -void CXWindowsClipboard::doFillCache() +void +CXWindowsClipboard::doFillCache() { if (m_motif) { motifFillCache(); @@ -385,7 +418,8 @@ void CXWindowsClipboard::doFillCache() m_cacheTime = m_timeOwned; } -void CXWindowsClipboard::icccmFillCache() +void +CXWindowsClipboard::icccmFillCache() { log((CLOG_DEBUG "ICCCM fill clipboard %d", m_id)); @@ -447,10 +481,11 @@ void CXWindowsClipboard::icccmFillCache() } } -bool CXWindowsClipboard::icccmGetSelection( - Atom target, - Atom* actualTarget, - CString* data) const +bool +CXWindowsClipboard::icccmGetSelection( + Atom target, + Atom* actualTarget, + CString* data) const { assert(actualTarget != NULL); assert(data != NULL); @@ -470,7 +505,8 @@ bool CXWindowsClipboard::icccmGetSelection( return true; } -IClipboard::Time CXWindowsClipboard::icccmGetTime() const +IClipboard::Time +CXWindowsClipboard::icccmGetTime() const { Atom actualTarget; CString data; @@ -487,7 +523,8 @@ IClipboard::Time CXWindowsClipboard::icccmGetTime() const } } -bool CXWindowsClipboard::motifLockClipboard() const +bool +CXWindowsClipboard::motifLockClipboard() const { // fail if anybody owns the lock (even us, so this is non-recursive) Window lockOwner = XGetSelectionOwner(m_display, m_atomMotifClipLock); @@ -510,7 +547,8 @@ bool CXWindowsClipboard::motifLockClipboard() const return true; } -void CXWindowsClipboard::motifUnlockClipboard() const +void +CXWindowsClipboard::motifUnlockClipboard() const { log((CLOG_DEBUG1 "unlocked motif clipboard")); @@ -525,7 +563,8 @@ void CXWindowsClipboard::motifUnlockClipboard() const XSetSelectionOwner(m_display, m_atomMotifClipLock, None, time); } -bool CXWindowsClipboard::motifOwnsClipboard() const +bool +CXWindowsClipboard::motifOwnsClipboard() const { // get the current selection owner // FIXME -- this can't be right. even if the window is destroyed @@ -563,7 +602,8 @@ bool CXWindowsClipboard::motifOwnsClipboard() const return false; } -void CXWindowsClipboard::motifFillCache() +void +CXWindowsClipboard::motifFillCache() { log((CLOG_DEBUG "Motif fill clipboard %d", m_id)); @@ -677,14 +717,18 @@ void CXWindowsClipboard::motifFillCache() } } -IClipboard::Time CXWindowsClipboard::motifGetTime() const +IClipboard::Time +CXWindowsClipboard::motifGetTime() const { // FIXME -- does Motif report this? return 0; } -bool CXWindowsClipboard::insertMultipleReply( - Window requestor, ::Time time, Atom property) +bool +CXWindowsClipboard::insertMultipleReply( + Window requestor, + ::Time time, + Atom property) { // get the requested targets Atom target; @@ -735,7 +779,9 @@ bool CXWindowsClipboard::insertMultipleReply( return true; } -void CXWindowsClipboard::insertReply(CReply* reply) +void +CXWindowsClipboard::insertReply( + CReply* reply) { assert(reply != NULL); @@ -780,7 +826,8 @@ void CXWindowsClipboard::insertReply(CReply* reply) } } -void CXWindowsClipboard::pushReplies() +void +CXWindowsClipboard::pushReplies() { // send the first reply for each window if that reply hasn't // been sent yet. @@ -793,10 +840,11 @@ void CXWindowsClipboard::pushReplies() } } -void CXWindowsClipboard::pushReplies( - CReplyMap::iterator mapIndex, - CReplyList& replies, - CReplyList::iterator index) +void +CXWindowsClipboard::pushReplies( + CReplyMap::iterator mapIndex, + CReplyList& replies, + CReplyList::iterator index) { CReply* reply = *index; while (sendReply(reply)) { @@ -821,7 +869,9 @@ void CXWindowsClipboard::pushReplies( } } -bool CXWindowsClipboard::sendReply(CReply* reply) +bool +CXWindowsClipboard::sendReply( + CReply* reply) { assert(reply != NULL); @@ -943,7 +993,8 @@ bool CXWindowsClipboard::sendReply(CReply* reply) return false; } -void CXWindowsClipboard::clearReplies() +void +CXWindowsClipboard::clearReplies() { for (CReplyMap::iterator index = m_replies.begin(); index != m_replies.end(); ++index) { @@ -953,7 +1004,9 @@ void CXWindowsClipboard::clearReplies() m_eventMasks.clear(); } -void CXWindowsClipboard::clearReplies(CReplyList& replies) +void +CXWindowsClipboard::clearReplies( + CReplyList& replies) { for (CReplyList::iterator index = replies.begin(); index != replies.end(); ++index) { @@ -962,9 +1015,13 @@ void CXWindowsClipboard::clearReplies(CReplyList& replies) replies.clear(); } -void CXWindowsClipboard::sendNotify( - Window requestor, Atom selection, - Atom target, Atom property, Time time) +void +CXWindowsClipboard::sendNotify( + Window requestor, + Atom selection, + Atom target, + Atom property, + Time time) { XEvent event; event.xselection.type = SelectionNotify; @@ -978,26 +1035,33 @@ void CXWindowsClipboard::sendNotify( XSendEvent(m_display, requestor, False, 0, &event); } -bool CXWindowsClipboard::wasOwnedAtTime( - ::Time time) const +bool +CXWindowsClipboard::wasOwnedAtTime( + ::Time time) const { // not owned if we've never owned the selection - if (m_timeOwned == 0) + if (m_timeOwned == 0) { return false; + } // if time is CurrentTime then return true if we still own the // selection and false if we do not. else if we still own the // selection then get the current time, otherwise use // m_timeLost as the end time. Time lost = m_timeLost; - if (m_timeLost == 0) - if (time == CurrentTime) + if (m_timeLost == 0) { + if (time == CurrentTime) { return true; - else + } + else { lost = CXWindowsUtil::getCurrentTime(m_display, m_window); - else - if (time == CurrentTime) + } + } + else { + if (time == CurrentTime) { return false; + } + } // compare time to range Time duration = lost - m_timeOwned; @@ -1005,8 +1069,10 @@ bool CXWindowsClipboard::wasOwnedAtTime( return (/*when >= 0 &&*/ when < duration); } -Atom CXWindowsClipboard::getTargetsData( - CString& data, int* format) const +Atom +CXWindowsClipboard::getTargetsData( + CString& data, + int* format) const { assert(format != NULL); @@ -1029,8 +1095,10 @@ Atom CXWindowsClipboard::getTargetsData( return m_atomTargets; } -Atom CXWindowsClipboard::getTimestampData( - CString& data, int* format) const +Atom +CXWindowsClipboard::getTimestampData( + CString& data, + int* format) const { assert(format != NULL); @@ -1040,8 +1108,10 @@ Atom CXWindowsClipboard::getTimestampData( return m_atomTimestamp; } -Atom CXWindowsClipboard::getStringData( - CString& data, int* format) const +Atom +CXWindowsClipboard::getStringData( + CString& data, + int* format) const { assert(format != NULL); @@ -1061,17 +1131,19 @@ Atom CXWindowsClipboard::getStringData( // CXWindowsClipboard::CICCCMGetClipboard::CICCCMGetClipboard( - Window requestor, Time time, Atom property) : - m_requestor(requestor), - m_time(time), - m_property(property), - m_incr(false), - m_failed(false), - m_done(false), - m_reading(false), - m_data(NULL), - m_actualTarget(NULL), - m_error(false) + Window requestor, + Time time, + Atom property) : + m_requestor(requestor), + m_time(time), + m_property(property), + m_incr(false), + m_failed(false), + m_done(false), + m_reading(false), + m_data(NULL), + m_actualTarget(NULL), + m_error(false) { // do nothing } @@ -1081,10 +1153,13 @@ CXWindowsClipboard::CICCCMGetClipboard::~CICCCMGetClipboard() // do nothing } -bool CXWindowsClipboard::CICCCMGetClipboard::readClipboard( - Display* display, - Atom selection, Atom target, - Atom* actualTarget, CString* data) +bool +CXWindowsClipboard::CICCCMGetClipboard::readClipboard( + Display* display, + Atom selection, + Atom target, + Atom* actualTarget, + CString* data) { assert(actualTarget != NULL); assert(data != NULL); @@ -1139,9 +1214,10 @@ bool CXWindowsClipboard::CICCCMGetClipboard::readClipboard( return !m_failed; } -bool CXWindowsClipboard::CICCCMGetClipboard::doEventPredicate( - Display* display, - XEvent* xevent) +bool +CXWindowsClipboard::CICCCMGetClipboard::doEventPredicate( + Display* display, + XEvent* xevent) { // process event switch (xevent->type) { @@ -1276,17 +1352,19 @@ log((CLOG_INFO " INCR secondary chunk")); // FIXME return !m_incr; } -Bool CXWindowsClipboard::CICCCMGetClipboard::eventPredicate( - Display* display, - XEvent* xevent, - XPointer arg) +Bool +CXWindowsClipboard::CICCCMGetClipboard::eventPredicate( + Display* display, + XEvent* xevent, + XPointer arg) { CICCCMGetClipboard* self = reinterpret_cast(arg); return self->doEventPredicate(display, xevent) ? True : False; } -void CXWindowsClipboard::CICCCMGetClipboard::timeout( - void* vdisplay) +void +CXWindowsClipboard::CICCCMGetClipboard::timeout( + void* vdisplay) { // wait CThread::sleep(0.2); // FIXME -- is this too short? @@ -1308,35 +1386,42 @@ void CXWindowsClipboard::CICCCMGetClipboard::timeout( // CXWindowsClipboard::CReply // -CXWindowsClipboard::CReply::CReply(Window requestor, - Atom target, ::Time time) : - m_requestor(requestor), - m_target(target), - m_time(time), - m_property(None), - m_replied(false), - m_done(false), - m_data(), - m_type(None), - m_format(32), - m_ptr(0) +CXWindowsClipboard::CReply::CReply( + Window requestor, + Atom target, + ::Time time) : + m_requestor(requestor), + m_target(target), + m_time(time), + m_property(None), + m_replied(false), + m_done(false), + m_data(), + m_type(None), + m_format(32), + m_ptr(0) { // do nothing } -CXWindowsClipboard::CReply::CReply(Window requestor, - Atom target, ::Time time, Atom property, - const CString& data, Atom type, int format) : - m_requestor(requestor), - m_target(target), - m_time(time), - m_property(property), - m_replied(false), - m_done(false), - m_data(data), - m_type(type), - m_format(format), - m_ptr(0) +CXWindowsClipboard::CReply::CReply( + Window requestor, + Atom target, + ::Time time, + Atom property, + const CString& data, + Atom type, + int format) : + m_requestor(requestor), + m_target(target), + m_time(time), + m_property(property), + m_replied(false), + m_done(false), + m_data(data), + m_type(type), + m_format(format), + m_ptr(0) { // do nothing } diff --git a/platform/CXWindowsClipboard.h b/platform/CXWindowsClipboard.h index 9c04c9bc..f1d04580 100644 --- a/platform/CXWindowsClipboard.h +++ b/platform/CXWindowsClipboard.h @@ -3,7 +3,6 @@ #include "IClipboard.h" #include "ClipboardTypes.h" -#include "CString.h" #include "stdmap.h" #include "stdlist.h" #include @@ -20,13 +19,13 @@ public: // owner window isn't this clipboard's window then this simply // sends a failure event to the requestor. void addRequest(Window owner, - Window requestor, Atom target, - ::Time time, Atom property); + Window requestor, Atom target, + ::Time time, Atom property); // continue processing a selection request. returns true if the // request was handled, false if the request was unknown. bool processRequest(Window requestor, - ::Time time, Atom property); + ::Time time, Atom property); // terminate a selection request. returns true iff the request // was known and handled. @@ -56,8 +55,8 @@ private: // could be performed, false otherwise. in either case, the // reply is inserted. bool addSimpleRequest( - Window requestor, Atom target, - ::Time time, Atom property); + Window requestor, Atom target, + ::Time time, Atom property); // clear the cache, resetting the cached flag and the added flag for // each format. @@ -71,8 +70,8 @@ private: // ICCCM interoperability methods void icccmFillCache(); bool icccmGetSelection(Atom target, - Atom* actualTarget, - CString* data) const; + Atom* actualTarget, + CString* data) const; Time icccmGetTime() const; // motif interoperability methods @@ -97,15 +96,15 @@ private: // true iff the conversion was successful or the conversion // cannot be performed (in which case *actualTarget == None). bool readClipboard(Display* display, - Atom selection, Atom target, - Atom* actualTarget, CString* data); + Atom selection, Atom target, + Atom* actualTarget, CString* data); private: bool doEventPredicate(Display* display, - XEvent* event); + XEvent* event); static Bool eventPredicate(Display* display, - XEvent* event, - XPointer arg); + XEvent* event, + XPointer arg); void timeout(void*); private: @@ -177,7 +176,7 @@ private: public: CReply(Window, Atom target, ::Time); CReply(Window, Atom target, ::Time, Atom property, - const CString& data, Atom type, int format); + const CString& data, Atom type, int format); public: // information about the request @@ -209,12 +208,12 @@ private: void insertReply(CReply*); void pushReplies(); void pushReplies(CReplyMap::iterator, - CReplyList&, CReplyList::iterator); + CReplyList&, CReplyList::iterator); bool sendReply(CReply*); void clearReplies(); void clearReplies(CReplyList&); void sendNotify(Window requestor, Atom selection, - Atom target, Atom property, Time time); + Atom target, Atom property, Time time); bool wasOwnedAtTime(::Time) const; // data conversion methods diff --git a/platform/CXWindowsScreen.cpp b/platform/CXWindowsScreen.cpp index adbc5193..9f283283 100644 --- a/platform/CXWindowsScreen.cpp +++ b/platform/CXWindowsScreen.cpp @@ -2,14 +2,13 @@ #include "CXWindowsClipboard.h" #include "CXWindowsUtil.h" #include "CClipboard.h" +#include "XScreen.h" #include "CLock.h" +#include "CThread.h" #include "CLog.h" #include "CString.h" -#include "CThread.h" -#include "XScreen.h" -#include -#include -#include +#include +#include // // CXWindowsScreen @@ -18,10 +17,10 @@ CXWindowsScreen* CXWindowsScreen::s_screen = NULL; CXWindowsScreen::CXWindowsScreen() : - m_display(NULL), - m_root(None), - m_w(0), m_h(0), - m_stop(false) + m_display(NULL), + m_root(None), + m_w(0), m_h(0), + m_stop(false) { assert(s_screen == NULL); s_screen = this; @@ -35,7 +34,8 @@ CXWindowsScreen::~CXWindowsScreen() s_screen = NULL; } -void CXWindowsScreen::openDisplay() +void +CXWindowsScreen::openDisplay() { assert(m_display == NULL); @@ -51,11 +51,12 @@ void CXWindowsScreen::openDisplay() // open the display log((CLOG_DEBUG "XOpenDisplay(\"%s\")", display)); m_display = XOpenDisplay(display); - if (m_display == NULL) + if (m_display == NULL) { throw XScreenOpenFailure(); + } // get default screen - m_screen = DefaultScreen(m_display); + m_screen = DefaultScreen(m_display); Screen* screen = ScreenOfDisplay(m_display, m_screen); // get screen size @@ -75,7 +76,8 @@ void CXWindowsScreen::openDisplay() } } -void CXWindowsScreen::closeDisplay() +void +CXWindowsScreen::closeDisplay() { CLock lock(&m_mutex); @@ -96,20 +98,24 @@ void CXWindowsScreen::closeDisplay() XSetIOErrorHandler(NULL); } -int CXWindowsScreen::getScreen() const +int +CXWindowsScreen::getScreen() const { assert(m_display != NULL); return m_screen; } -Window CXWindowsScreen::getRoot() const +Window +CXWindowsScreen::getRoot() const { assert(m_display != NULL); return m_root; } -void CXWindowsScreen::getScreenSize( - SInt32* w, SInt32* h) const +void +CXWindowsScreen::getScreenSize( + SInt32* w, + SInt32* h) const { assert(m_display != NULL); assert(w != NULL && h != NULL); @@ -118,7 +124,8 @@ void CXWindowsScreen::getScreenSize( *h = m_h; } -Cursor CXWindowsScreen::createBlankCursor() const +Cursor +CXWindowsScreen::createBlankCursor() const { // this seems just a bit more complicated than really necessary @@ -153,7 +160,9 @@ Cursor CXWindowsScreen::createBlankCursor() const return cursor; } -bool CXWindowsScreen::getEvent(XEvent* xevent) const +bool +CXWindowsScreen::getEvent( + XEvent* xevent) const { // wait for an event in a cancellable way and don't lock the // display while we're waiting. @@ -182,13 +191,15 @@ bool CXWindowsScreen::getEvent(XEvent* xevent) const } } -void CXWindowsScreen::doStop() +void +CXWindowsScreen::doStop() { // caller must have locked display m_stop = true; } -ClipboardID CXWindowsScreen::getClipboardID(Atom selection) const +ClipboardID +CXWindowsScreen::getClipboardID(Atom selection) const { for (ClipboardID id = 0; id < kClipboardEnd; ++id) { if (m_clipboard[id] != NULL && @@ -199,27 +210,31 @@ ClipboardID CXWindowsScreen::getClipboardID(Atom selection) const return kClipboardEnd; } -void CXWindowsScreen::onUnexpectedClose() +void +CXWindowsScreen::onUnexpectedClose() { // do nothing } -bool CXWindowsScreen::processEvent(XEvent* xevent) +bool +CXWindowsScreen::processEvent( + XEvent* xevent) { switch (xevent->type) { - case SelectionClear: { - // we just lost the selection. that means someone else - // grabbed the selection so this screen is now the - // selection owner. report that to the subclass. - ClipboardID id = getClipboardID(xevent->xselectionclear.selection); - if (id != kClipboardEnd) { - log((CLOG_DEBUG "lost clipboard %d ownership at time %d", id, xevent->xselectionclear.time)); - m_clipboard[id]->lost(xevent->xselectionclear.time); - onLostClipboard(id); - return true; + case SelectionClear: + { + // we just lost the selection. that means someone else + // grabbed the selection so this screen is now the + // selection owner. report that to the subclass. + ClipboardID id = getClipboardID(xevent->xselectionclear.selection); + if (id != kClipboardEnd) { + log((CLOG_DEBUG "lost clipboard %d ownership at time %d", id, xevent->xselectionclear.time)); + m_clipboard[id]->lost(xevent->xselectionclear.time); + onLostClipboard(id); + return true; + } } break; - } case SelectionNotify: // notification of selection transferred. we shouldn't @@ -234,28 +249,30 @@ bool CXWindowsScreen::processEvent(XEvent* xevent) } return true; - case SelectionRequest: { - // somebody is asking for clipboard data - ClipboardID id = getClipboardID(xevent->xselectionrequest.selection); - if (id != kClipboardEnd) { - CLock lock(&m_mutex); - m_clipboard[id]->addRequest( + case SelectionRequest: + { + // somebody is asking for clipboard data + ClipboardID id = getClipboardID( + xevent->xselectionrequest.selection); + if (id != kClipboardEnd) { + CLock lock(&m_mutex); + m_clipboard[id]->addRequest( xevent->xselectionrequest.owner, xevent->xselectionrequest.requestor, xevent->xselectionrequest.target, xevent->xselectionrequest.time, xevent->xselectionrequest.property); - return true; + return true; + } } break; - } case PropertyNotify: // property delete may be part of a selection conversion if (xevent->xproperty.state == PropertyDelete) { processClipboardRequest(xevent->xproperty.window, - xevent->xproperty.time, - xevent->xproperty.atom); + xevent->xproperty.time, + xevent->xproperty.atom); return true; } break; @@ -270,9 +287,10 @@ bool CXWindowsScreen::processEvent(XEvent* xevent) return false; } -bool CXWindowsScreen::setDisplayClipboard( - ClipboardID id, - const IClipboard* clipboard) +bool +CXWindowsScreen::setDisplayClipboard( + ClipboardID id, + const IClipboard* clipboard) { CLock lock(&m_mutex); @@ -300,9 +318,10 @@ bool CXWindowsScreen::setDisplayClipboard( } } -bool CXWindowsScreen::getDisplayClipboard( - ClipboardID id, - IClipboard* clipboard) const +bool +CXWindowsScreen::getDisplayClipboard( + ClipboardID id, + IClipboard* clipboard) const { assert(clipboard != NULL); @@ -322,9 +341,11 @@ bool CXWindowsScreen::getDisplayClipboard( return CClipboard::copy(clipboard, m_clipboard[id], timestamp); } -void CXWindowsScreen::processClipboardRequest( - Window requestor, - Time time, Atom property) +void +CXWindowsScreen::processClipboardRequest( + Window requestor, + Time time, + Atom property) { CLock lock(&m_mutex); @@ -337,8 +358,9 @@ void CXWindowsScreen::processClipboardRequest( } } -void CXWindowsScreen::destroyClipboardRequest( - Window requestor) +void +CXWindowsScreen::destroyClipboardRequest( + Window requestor) { CLock lock(&m_mutex); @@ -351,7 +373,9 @@ void CXWindowsScreen::destroyClipboardRequest( } } -int CXWindowsScreen::ioErrorHandler(Display*) +int +CXWindowsScreen::ioErrorHandler( + Display*) { // the display has disconnected, probably because X is shutting // down. X forces us to exit at this point. that's arguably @@ -371,9 +395,10 @@ int CXWindowsScreen::ioErrorHandler(Display*) // CXWindowsScreen::CDisplayLock // -CXWindowsScreen::CDisplayLock::CDisplayLock(const CXWindowsScreen* screen) : - m_mutex(&screen->m_mutex), - m_display(screen->m_display) +CXWindowsScreen::CDisplayLock::CDisplayLock( + const CXWindowsScreen* screen) : + m_mutex(&screen->m_mutex), + m_display(screen->m_display) { assert(m_display != NULL); diff --git a/platform/CXWindowsScreen.h b/platform/CXWindowsScreen.h index a100d22a..404d77b8 100644 --- a/platform/CXWindowsScreen.h +++ b/platform/CXWindowsScreen.h @@ -1,7 +1,6 @@ #ifndef CXWINDOWSSCREEN_H #define CXWINDOWSSCREEN_H -#include "BasicTypes.h" #include "ClipboardTypes.h" #include "CMutex.h" #include @@ -58,11 +57,11 @@ protected: // set the contents of the clipboard (i.e. primary selection) bool setDisplayClipboard(ClipboardID, - const IClipboard* clipboard); + const IClipboard* clipboard); // copy the clipboard contents to clipboard bool getDisplayClipboard(ClipboardID, - IClipboard* clipboard) const; + IClipboard* clipboard) const; // called by openDisplay() to allow subclasses to prepare the display. // the display is locked and passed to the subclass. @@ -93,7 +92,7 @@ private: // continue processing a selection request void processClipboardRequest(Window window, - Time time, Atom property); + Time time, Atom property); // terminate a selection request void destroyClipboardRequest(Window window); diff --git a/platform/CXWindowsUtil.cpp b/platform/CXWindowsUtil.cpp index 64b46a44..6dbb5f7e 100644 --- a/platform/CXWindowsUtil.cpp +++ b/platform/CXWindowsUtil.cpp @@ -1,18 +1,21 @@ #include "CXWindowsUtil.h" -#include "CLog.h" #include "CThread.h" -#include +#include "CLog.h" #include // // CXWindowsUtil // -bool CXWindowsUtil::getWindowProperty( - Display* display, - Window window, Atom property, - CString* data, Atom* type, - int* format, bool deleteProperty) +bool +CXWindowsUtil::getWindowProperty( + Display* display, + Window window, + Atom property, + CString* data, + Atom* type, + int* format, + bool deleteProperty) { assert(display != NULL); assert(data != NULL); @@ -84,11 +87,15 @@ bool CXWindowsUtil::getWindowProperty( return true; } -bool CXWindowsUtil::setWindowProperty( - Display* display, - Window window, Atom property, - const void* vdata, UInt32 size, - Atom type, SInt32 format) +bool +CXWindowsUtil::setWindowProperty( + Display* display, + Window window, + Atom property, + const void* vdata, + UInt32 size, + Atom type, + SInt32 format) { const UInt32 length = 4 * XMaxRequestSize(display); const unsigned char* data = reinterpret_cast(vdata); @@ -100,8 +107,9 @@ bool CXWindowsUtil::setWindowProperty( // how much data to send in first chunk? UInt32 chunkSize = size; - if (chunkSize > length) + if (chunkSize > length) { chunkSize = length; + } // send first chunk XChangeProperty(display, window, property, @@ -113,8 +121,9 @@ bool CXWindowsUtil::setWindowProperty( size -= chunkSize; while (!error && size > 0) { chunkSize = size; - if (chunkSize > length) + if (chunkSize > length) { chunkSize = length; + } XChangeProperty(display, window, property, type, format, PropModeAppend, data, chunkSize / datumSize); @@ -125,8 +134,10 @@ bool CXWindowsUtil::setWindowProperty( return !error; } -Time CXWindowsUtil::getCurrentTime( - Display* display, Window window) +Time +CXWindowsUtil::getCurrentTime( + Display* display, + Window window) { // select property events on window XWindowAttributes attr; @@ -162,8 +173,11 @@ Time CXWindowsUtil::getCurrentTime( return xevent.xproperty.time; } -Bool CXWindowsUtil::propertyNotifyPredicate( - Display*, XEvent* xevent, XPointer arg) +Bool +CXWindowsUtil::propertyNotifyPredicate( + Display*, + XEvent* xevent, + XPointer arg) { CPropertyNotifyPredicateInfo* filter = reinterpret_cast(arg); @@ -185,12 +199,15 @@ CXWindowsUtil::CErrorLock::CErrorLock() install(&CXWindowsUtil::CErrorLock::ignoreHandler, NULL); } -CXWindowsUtil::CErrorLock::CErrorLock(bool* flag) +CXWindowsUtil::CErrorLock::CErrorLock( + bool* flag) { install(&CXWindowsUtil::CErrorLock::saveHandler, flag); } -CXWindowsUtil::CErrorLock::CErrorLock(ErrorHandler handler, void* data) +CXWindowsUtil::CErrorLock::CErrorLock( + ErrorHandler handler, + void* data) { install(handler, data); } @@ -201,8 +218,10 @@ CXWindowsUtil::CErrorLock::~CErrorLock() s_top = m_next; } -void CXWindowsUtil::CErrorLock::install( - ErrorHandler handler, void* data) +void +CXWindowsUtil::CErrorLock::install( + ErrorHandler handler, + void* data) { m_handler = handler; m_userData = data; @@ -212,8 +231,10 @@ void CXWindowsUtil::CErrorLock::install( s_top = this; } -int CXWindowsUtil::CErrorLock::internalHandler( - Display* display, XErrorEvent* event) +int +CXWindowsUtil::CErrorLock::internalHandler( + Display* display, + XErrorEvent* event) { if (s_top != NULL && s_top->m_handler != NULL) { s_top->m_handler(display, event, s_top->m_userData); @@ -221,14 +242,20 @@ int CXWindowsUtil::CErrorLock::internalHandler( return 0; } -void CXWindowsUtil::CErrorLock::ignoreHandler( - Display*, XErrorEvent*, void*) +void +CXWindowsUtil::CErrorLock::ignoreHandler( + Display*, + XErrorEvent*, + void*) { // do nothing } -void CXWindowsUtil::CErrorLock::saveHandler( - Display*, XErrorEvent*, void* flag) +void +CXWindowsUtil::CErrorLock::saveHandler( + Display*, + XErrorEvent*, + void* flag) { *reinterpret_cast(flag) = true; } diff --git a/platform/CXWindowsUtil.h b/platform/CXWindowsUtil.h index 82414dd5..3f01b667 100644 --- a/platform/CXWindowsUtil.h +++ b/platform/CXWindowsUtil.h @@ -1,20 +1,20 @@ #ifndef CXWINDOWSUTIL_H #define CXWINDOWSUTIL_H -#include "BasicTypes.h" #include "CString.h" +#include "BasicTypes.h" #include class CXWindowsUtil { public: static bool getWindowProperty(Display*, - Window window, Atom property, - CString* data, Atom* type, - SInt32* format, bool deleteProperty); + Window window, Atom property, + CString* data, Atom* type, + SInt32* format, bool deleteProperty); static bool setWindowProperty(Display*, - Window window, Atom property, - const void* data, UInt32 size, - Atom type, SInt32 format); + Window window, Atom property, + const void* data, UInt32 size, + Atom type, SInt32 format); static Time getCurrentTime(Display*, Window); // class to set an X error handler in the c'tor and restore the @@ -55,7 +55,7 @@ private: }; static Bool propertyNotifyPredicate(Display*, - XEvent* xevent, XPointer arg); + XEvent* xevent, XPointer arg); }; #endif diff --git a/platform/IPlatform.h b/platform/IPlatform.h index 7012304e..a5d0bde9 100644 --- a/platform/IPlatform.h +++ b/platform/IPlatform.h @@ -1,9 +1,8 @@ #ifndef IPLATFORM_H #define IPLATFORM_H -#include "BasicTypes.h" -#include "CString.h" #include "IInterface.h" +#include "CString.h" class IPlatform : public IInterface { public: @@ -16,9 +15,9 @@ public: // include the name of program as the first argument. // FIXME -- throw on error? will get better error messages that way. virtual bool installDaemon(const char* name, - const char* description, - const char* pathname, - const char* commandLine) = 0; + const char* description, + const char* pathname, + const char* commandLine) = 0; virtual bool uninstallDaemon(const char* name) = 0; // daemonize. this should have the side effect of sending log @@ -67,8 +66,8 @@ public: // is longer than allowed by the system. we'll rely on the // system calls to tell us that. virtual CString addPathComponent( - const CString& prefix, - const CString& suffix) const = 0; + const CString& prefix, + const CString& suffix) const = 0; }; #endif diff --git a/server/CConfig.cpp b/server/CConfig.cpp index 167db361..cc3cfe46 100644 --- a/server/CConfig.cpp +++ b/server/CConfig.cpp @@ -1,8 +1,8 @@ #include "CConfig.h" #include "ProtocolTypes.h" +#include "XSocket.h" #include "stdistream.h" #include "stdostream.h" -#include // // CConfig @@ -18,7 +18,9 @@ CConfig::~CConfig() // do nothing } -bool CConfig::addScreen(const CString& name) +bool +CConfig::addScreen( + const CString& name) { // alias name must not exist if (m_nameToCanonicalName.find(name) != m_nameToCanonicalName.end()) { @@ -34,7 +36,9 @@ bool CConfig::addScreen(const CString& name) return true; } -void CConfig::removeScreen(const CString& name) +void +CConfig::removeScreen( + const CString& name) { // get canonical name and find cell CString canonical = getCanonicalName(name); @@ -67,14 +71,17 @@ void CConfig::removeScreen(const CString& name) } } -void CConfig::removeAllScreens() +void +CConfig::removeAllScreens() { m_map.clear(); m_nameToCanonicalName.clear(); } -bool CConfig::addAlias(const CString& canonical, - const CString& alias) +bool +CConfig::addAlias( + const CString& canonical, + const CString& alias) { // alias name must not exist if (m_nameToCanonicalName.find(alias) != m_nameToCanonicalName.end()) { @@ -92,7 +99,9 @@ bool CConfig::addAlias(const CString& canonical, return true; } -bool CConfig::removeAlias(const CString& alias) +bool +CConfig::removeAlias( + const CString& alias) { // must not be a canonical name if (m_map.find(alias) != m_map.end()) { @@ -111,7 +120,8 @@ bool CConfig::removeAlias(const CString& alias) return true; } -void CConfig::removeAllAliases() +void +CConfig::removeAllAliases() { // remove all names m_nameToCanonicalName.clear(); @@ -124,9 +134,11 @@ void CConfig::removeAllAliases() } } -bool CConfig::connect(const CString& srcName, - EDirection srcSide, - const CString& dstName) +bool +CConfig::connect( + const CString& srcName, + EDirection srcSide, + const CString& dstName) { // find source cell CCellMap::iterator index = m_map.find(getCanonicalName(srcName)); @@ -142,8 +154,10 @@ bool CConfig::connect(const CString& srcName, return true; } -bool CConfig::disconnect(const CString& srcName, - EDirection srcSide) +bool +CConfig::disconnect( + const CString& srcName, + EDirection srcSide) { // find source cell CCellMap::iterator index = m_map.find(srcName); @@ -157,17 +171,23 @@ bool CConfig::disconnect(const CString& srcName, return true; } -void CConfig::setSynergyAddress(const CNetworkAddress& addr) +void +CConfig::setSynergyAddress( + const CNetworkAddress& addr) { m_synergyAddress = addr; } -void CConfig::setHTTPAddress(const CNetworkAddress& addr) +void +CConfig::setHTTPAddress( + const CNetworkAddress& addr) { m_httpAddress = addr; } -bool CConfig::isValidScreenName(const CString& name) const +bool +CConfig::isValidScreenName( + const CString& name) const { // name is valid if matches validname // name ::= [A-Za-z0-9] | [A-Za-z0-9][-A-Za-z0-9]*[A-Za-z0-9] @@ -211,27 +231,35 @@ bool CConfig::isValidScreenName(const CString& name) const return true; } -CConfig::const_iterator CConfig::begin() const +CConfig::const_iterator +CConfig::begin() const { return const_iterator(m_map.begin()); } -CConfig::const_iterator CConfig::end() const +CConfig::const_iterator +CConfig::end() const { return const_iterator(m_map.end()); } -bool CConfig::isScreen(const CString& name) const +bool +CConfig::isScreen( + const CString& name) const { return (m_nameToCanonicalName.count(name) > 0); } -bool CConfig::isCanonicalName(const CString& name) const +bool +CConfig::isCanonicalName( + const CString& name) const { return CStringUtil::CaselessCmp::equal(getCanonicalName(name), name); } -CString CConfig::getCanonicalName(const CString& name) const +CString +CConfig::getCanonicalName( + const CString& name) const { CNameMap::const_iterator index = m_nameToCanonicalName.find(name); if (index == m_nameToCanonicalName.end()) { @@ -242,8 +270,10 @@ CString CConfig::getCanonicalName(const CString& name) const } } -CString CConfig::getNeighbor(const CString& srcName, - EDirection srcSide) const +CString +CConfig::getNeighbor( + const CString& srcName, + EDirection srcSide) const { // find source cell CCellMap::const_iterator index = m_map.find(getCanonicalName(srcName)); @@ -256,23 +286,30 @@ CString CConfig::getNeighbor(const CString& srcName, srcSide - kFirstDirection]); } -const CNetworkAddress& CConfig::getSynergyAddress() const +const CNetworkAddress& +CConfig::getSynergyAddress() const { return m_synergyAddress; } -const CNetworkAddress& CConfig::getHTTPAddress() const +const CNetworkAddress& +CConfig::getHTTPAddress() const { return m_httpAddress; } -const char* CConfig::dirName(EDirection dir) +const char* +CConfig::dirName( + EDirection dir) { static const char* s_name[] = { "left", "right", "top", "bottom" }; return s_name[dir - kFirstDirection]; } -bool CConfig::readLine(std::istream& s, CString& line) +bool +CConfig::readLine( + std::istream& s, + CString& line) { s >> std::ws; while (std::getline(s, line)) { @@ -295,7 +332,9 @@ bool CConfig::readLine(std::istream& s, CString& line) return false; } -void CConfig::readSection(std::istream& s) +void +CConfig::readSection( + std::istream& s) { static const char s_section[] = "section:"; static const char s_network[] = "network"; @@ -343,7 +382,9 @@ void CConfig::readSection(std::istream& s) } } -void CConfig::readSectionNetwork(std::istream& s) +void +CConfig::readSectionNetwork( + std::istream& s) { CString line; CString name; @@ -398,7 +439,9 @@ void CConfig::readSectionNetwork(std::istream& s) throw XConfigRead("unexpected end of screens section"); } -void CConfig::readSectionScreens(std::istream& s) +void +CConfig::readSectionScreens( + std::istream& s) { CString line; CString name; @@ -433,7 +476,9 @@ void CConfig::readSectionScreens(std::istream& s) throw XConfigRead("unexpected end of screens section"); } -void CConfig::readSectionLinks(std::istream& s) +void +CConfig::readSectionLinks( + std::istream& s) { CString line; CString screen; @@ -513,7 +558,9 @@ void CConfig::readSectionLinks(std::istream& s) throw XConfigRead("unexpected end of links section"); } -void CConfig::readSectionAliases(std::istream& s) +void +CConfig::readSectionAliases( + std::istream& s) { CString line; CString screen; @@ -559,7 +606,10 @@ void CConfig::readSectionAliases(std::istream& s) // CConfig I/O // -std::istream& operator>>(std::istream& s, CConfig& config) +std::istream& +operator>>( + std::istream& s, + CConfig& config) { // FIXME -- should track line and column to improve error reporting @@ -571,7 +621,10 @@ std::istream& operator>>(std::istream& s, CConfig& config) return s; } -std::ostream& operator<<(std::ostream& s, const CConfig& config) +std::ostream& +operator<<( + std::ostream& s, + const CConfig& config) { // network section s << "section: network" << std::endl; @@ -657,7 +710,9 @@ std::ostream& operator<<(std::ostream& s, const CConfig& config) // CConfig I/O exceptions // -XConfigRead::XConfigRead(const CString& error) : m_error(error) +XConfigRead::XConfigRead( + const CString& error) : + m_error(error) { // do nothing } @@ -667,7 +722,8 @@ XConfigRead::~XConfigRead() // do nothing } -CString XConfigRead::getWhat() const throw() +CString +XConfigRead::getWhat() const throw() { return m_error; } diff --git a/server/CConfig.h b/server/CConfig.h index 73f4a911..a12d1a03 100644 --- a/server/CConfig.h +++ b/server/CConfig.h @@ -1,13 +1,11 @@ #ifndef CCONFIG_H #define CCONFIG_H -#include "BasicTypes.h" -#include "CString.h" #include "CNetworkAddress.h" #include "XBase.h" -#include #include "stdmap.h" #include "stdset.h" +#include class CConfig; @@ -85,17 +83,17 @@ public: // or the canonical name is unknown. removeAlias() fails if // the alias is unknown or a canonical name. bool addAlias(const CString& canonical, - const CString& alias); + const CString& alias); bool removeAlias(const CString& alias); void removeAllAliases(); // connect/disconnect edges. both return false if srcName is // unknown. bool connect(const CString& srcName, - EDirection srcSide, - const CString& dstName); + EDirection srcSide, + const CString& dstName); bool disconnect(const CString& srcName, - EDirection srcSide); + EDirection srcSide); // set the synergy and http listen addresses. there are no // default addresses. diff --git a/server/CHTTPServer.cpp b/server/CHTTPServer.cpp index 95cb6d43..36f46967 100644 --- a/server/CHTTPServer.cpp +++ b/server/CHTTPServer.cpp @@ -1,14 +1,13 @@ #include "CHTTPServer.h" -#include "CHTTPProtocol.h" -#include "XHTTP.h" -#include "CServer.h" #include "CConfig.h" -#include "CLog.h" -#include "XThread.h" +#include "CHTTPProtocol.h" +#include "CServer.h" +#include "XHTTP.h" #include "ISocket.h" +#include "XThread.h" +#include "CLog.h" #include "stdset.h" #include "stdsstream.h" -#include // // CHTTPServer @@ -19,7 +18,9 @@ // malicious client from causing us to use too much memory. const UInt32 CHTTPServer::s_maxRequestSize = 32768; -CHTTPServer::CHTTPServer(CServer* server) : m_server(server) +CHTTPServer::CHTTPServer( + CServer* server) : + m_server(server) { // do nothing } @@ -29,7 +30,9 @@ CHTTPServer::~CHTTPServer() // do nothing } -void CHTTPServer::processRequest(ISocket* socket) +void +CHTTPServer::processRequest( + ISocket* socket) { assert(socket != NULL); @@ -88,9 +91,10 @@ void CHTTPServer::processRequest(ISocket* socket) } } -void CHTTPServer::doProcessRequest( - CHTTPRequest& request, - CHTTPReply& reply) +void +CHTTPServer::doProcessRequest( + CHTTPRequest& request, + CHTTPReply& reply) { reply.m_majorVersion = request.m_majorVersion; reply.m_minorVersion = request.m_minorVersion; @@ -118,9 +122,10 @@ void CHTTPServer::doProcessRequest( } } -void CHTTPServer::doProcessGetEditMap( - CHTTPRequest& /*request*/, - CHTTPReply& reply) +void +CHTTPServer::doProcessGetEditMap( + CHTTPRequest& /*request*/, + CHTTPReply& reply) { static const char* s_editMapProlog1 = "\r\n" @@ -228,9 +233,10 @@ void CHTTPServer::doProcessGetEditMap( reply.m_body += s_editMapEpilog; } -void CHTTPServer::doProcessPostEditMap( - CHTTPRequest& request, - CHTTPReply& reply) +void +CHTTPServer::doProcessPostEditMap( + CHTTPRequest& request, + CHTTPReply& reply) { typedef std::vector ScreenArray; typedef std::set ScreenSet; @@ -323,8 +329,11 @@ void CHTTPServer::doProcessPostEditMap( } } -bool CHTTPServer::parseXY( - const CString& xy, SInt32& x, SInt32& y) +bool +CHTTPServer::parseXY( + const CString& xy, + SInt32& x, + SInt32& y) { std::istringstream s(xy); char delimiter; @@ -339,7 +348,9 @@ bool CHTTPServer::parseXY( // CHTTPServer::CScreenArray // -CHTTPServer::CScreenArray::CScreenArray() : m_w(0), m_h(0) +CHTTPServer::CScreenArray::CScreenArray() : + m_w(0), + m_h(0) { // do nothing } @@ -349,7 +360,10 @@ CHTTPServer::CScreenArray::~CScreenArray() // do nothing } -void CHTTPServer::CScreenArray::resize(SInt32 w, SInt32 h) +void +CHTTPServer::CScreenArray::resize( + SInt32 w, + SInt32 h) { m_screens.clear(); m_screens.resize(w * h); @@ -357,7 +371,9 @@ void CHTTPServer::CScreenArray::resize(SInt32 w, SInt32 h) m_h = h; } -void CHTTPServer::CScreenArray::insertRow(SInt32 i) +void +CHTTPServer::CScreenArray::insertRow( + SInt32 i) { assert(i >= 0 && i <= m_h); @@ -379,7 +395,9 @@ void CHTTPServer::CScreenArray::insertRow(SInt32 i) ++m_h; } -void CHTTPServer::CScreenArray::insertColumn(SInt32 i) +void +CHTTPServer::CScreenArray::insertColumn( + SInt32 i) { assert(i >= 0 && i <= m_w); @@ -399,7 +417,9 @@ void CHTTPServer::CScreenArray::insertColumn(SInt32 i) ++m_w; } -void CHTTPServer::CScreenArray::eraseRow(SInt32 i) +void +CHTTPServer::CScreenArray::eraseRow( + SInt32 i) { assert(i >= 0 && i < m_h); @@ -421,7 +441,9 @@ void CHTTPServer::CScreenArray::eraseRow(SInt32 i) --m_h; } -void CHTTPServer::CScreenArray::eraseColumn(SInt32 i) +void +CHTTPServer::CScreenArray::eraseColumn( + SInt32 i) { assert(i >= 0 && i < m_w); @@ -441,7 +463,9 @@ void CHTTPServer::CScreenArray::eraseColumn(SInt32 i) --m_w; } -void CHTTPServer::CScreenArray::rotateRows(SInt32 i) +void +CHTTPServer::CScreenArray::rotateRows( + SInt32 i) { // nothing to do if no rows if (m_h == 0) { @@ -471,7 +495,9 @@ void CHTTPServer::CScreenArray::rotateRows(SInt32 i) } } -void CHTTPServer::CScreenArray::rotateColumns(SInt32 i) +void +CHTTPServer::CScreenArray::rotateColumns( + SInt32 i) { // nothing to do if no columns if (m_h == 0) { @@ -501,13 +527,19 @@ void CHTTPServer::CScreenArray::rotateColumns(SInt32 i) } } -void CHTTPServer::CScreenArray::remove(SInt32 x, SInt32 y) +void +CHTTPServer::CScreenArray::remove( + SInt32 x, + SInt32 y) { set(x, y, CString()); } -void CHTTPServer::CScreenArray::set( - SInt32 x, SInt32 y, const CString& name) +void +CHTTPServer::CScreenArray::set( + SInt32 x, + SInt32 y, + const CString& name) { assert(x >= 0 && x < m_w); assert(y >= 0 && y < m_h); @@ -515,8 +547,10 @@ void CHTTPServer::CScreenArray::set( m_screens[x + y * m_w] = name; } -bool CHTTPServer::CScreenArray::isAllowed( - SInt32 x, SInt32 y) const +bool +CHTTPServer::CScreenArray::isAllowed( + SInt32 x, + SInt32 y) const { assert(x >= 0 && x < m_w); assert(y >= 0 && y < m_h); @@ -536,8 +570,10 @@ bool CHTTPServer::CScreenArray::isAllowed( return false; } -bool CHTTPServer::CScreenArray::isSet( - SInt32 x, SInt32 y) const +bool +CHTTPServer::CScreenArray::isSet( + SInt32 x, + SInt32 y) const { assert(x >= 0 && x < m_w); assert(y >= 0 && y < m_h); @@ -545,8 +581,10 @@ bool CHTTPServer::CScreenArray::isSet( return !m_screens[x + y * m_w].empty(); } -CString CHTTPServer::CScreenArray::get( - SInt32 x, SInt32 y) const +CString +CHTTPServer::CScreenArray::get( + SInt32 x, + SInt32 y) const { assert(x >= 0 && x < m_w); assert(y >= 0 && y < m_h); @@ -554,9 +592,11 @@ CString CHTTPServer::CScreenArray::get( return m_screens[x + y * m_w]; } -bool CHTTPServer::CScreenArray::find( - const CString& name, - SInt32& xOut, SInt32& yOut) const +bool +CHTTPServer::CScreenArray::find( + const CString& name, + SInt32& xOut, + SInt32& yOut) const { for (SInt32 y = 0; y < m_h; ++y) { for (SInt32 x = 0; x < m_w; ++x) { @@ -570,7 +610,8 @@ bool CHTTPServer::CScreenArray::find( return false; } -bool CHTTPServer::CScreenArray::isValid() const +bool +CHTTPServer::CScreenArray::isValid() const { SInt32 count = 0, isolated = 0; for (SInt32 y = 0; y < m_h; ++y) { @@ -586,8 +627,9 @@ bool CHTTPServer::CScreenArray::isValid() const return (count <= 1 || isolated == 0); } -bool CHTTPServer::CScreenArray::convertFrom( - const CConfig& config) +bool +CHTTPServer::CScreenArray::convertFrom( + const CConfig& config) { typedef std::set ScreenSet; @@ -717,8 +759,9 @@ bool CHTTPServer::CScreenArray::convertFrom( return true; } -void CHTTPServer::CScreenArray::convertTo( - CConfig& config) const +void +CHTTPServer::CScreenArray::convertTo( + CConfig& config) const { config.removeAllScreens(); diff --git a/server/CHTTPServer.h b/server/CHTTPServer.h index 7c0cf311..9d9ac35e 100644 --- a/server/CHTTPServer.h +++ b/server/CHTTPServer.h @@ -1,8 +1,8 @@ #ifndef CHTTPSERVER_H #define CHTTPSERVER_H -#include "BasicTypes.h" #include "CString.h" +#include "BasicTypes.h" #include "stdvector.h" class CServer; diff --git a/server/CMSWindowsPrimaryScreen.cpp b/server/CMSWindowsPrimaryScreen.cpp index b85c6909..0f81690b 100644 --- a/server/CMSWindowsPrimaryScreen.cpp +++ b/server/CMSWindowsPrimaryScreen.cpp @@ -1,29 +1,28 @@ #include "CMSWindowsPrimaryScreen.h" -#include "CMSWindowsClipboard.h" #include "CServer.h" +#include "CMSWindowsClipboard.h" #include "CPlatform.h" #include "XScreen.h" #include "XSynergy.h" -#include "CLog.h" #include "CThread.h" -#include -#include +#include "CLog.h" +#include // // CMSWindowsPrimaryScreen // CMSWindowsPrimaryScreen::CMSWindowsPrimaryScreen() : - m_server(NULL), - m_threadID(0), - m_desk(NULL), - m_deskName(), - m_window(NULL), - m_active(false), - m_mark(0), - m_markReceived(0), - m_nextClipboardWindow(NULL), - m_clipboardOwner(NULL) + m_server(NULL), + m_threadID(0), + m_desk(NULL), + m_deskName(), + m_window(NULL), + m_active(false), + m_mark(0), + m_markReceived(0), + m_nextClipboardWindow(NULL), + m_clipboardOwner(NULL) { // load the hook library m_hookLibrary = LoadLibrary("synrgyhk"); @@ -61,7 +60,8 @@ CMSWindowsPrimaryScreen::~CMSWindowsPrimaryScreen() FreeLibrary(m_hookLibrary); } -void CMSWindowsPrimaryScreen::run() +void +CMSWindowsPrimaryScreen::run() { // must call run() from same thread as open() assert(m_threadID == GetCurrentThreadId()); @@ -87,12 +87,15 @@ void CMSWindowsPrimaryScreen::run() } } -void CMSWindowsPrimaryScreen::stop() +void +CMSWindowsPrimaryScreen::stop() { doStop(); } -void CMSWindowsPrimaryScreen::open(CServer* server) +void +CMSWindowsPrimaryScreen::open( + CServer* server) { assert(m_server == NULL); assert(server != NULL); @@ -126,7 +129,8 @@ void CMSWindowsPrimaryScreen::open(CServer* server) enterNoWarp(); } -void CMSWindowsPrimaryScreen::close() +void +CMSWindowsPrimaryScreen::close() { assert(m_server != NULL); @@ -137,7 +141,10 @@ void CMSWindowsPrimaryScreen::close() m_server = NULL; } -void CMSWindowsPrimaryScreen::enter(SInt32 x, SInt32 y) +void +CMSWindowsPrimaryScreen::enter( + SInt32 x, + SInt32 y) { log((CLOG_INFO "entering primary at %d,%d", x, y)); assert(m_active == true); @@ -149,7 +156,8 @@ void CMSWindowsPrimaryScreen::enter(SInt32 x, SInt32 y) warpCursor(x, y); } -bool CMSWindowsPrimaryScreen::leave() +bool +CMSWindowsPrimaryScreen::leave() { log((CLOG_INFO "leaving primary")); assert(m_active == false); @@ -219,7 +227,8 @@ bool CMSWindowsPrimaryScreen::leave() return true; } -void CMSWindowsPrimaryScreen::onConfigure() +void +CMSWindowsPrimaryScreen::onConfigure() { if ((m_is95Family || m_desk != NULL) && !m_active) { SInt32 w, h; @@ -229,14 +238,19 @@ void CMSWindowsPrimaryScreen::onConfigure() } } -void CMSWindowsPrimaryScreen::warpCursor(SInt32 x, SInt32 y) +void +CMSWindowsPrimaryScreen::warpCursor( + SInt32 x, + SInt32 y) { // set the cursor position without generating an event SetCursorPos(x, y); } -void CMSWindowsPrimaryScreen::setClipboard( - ClipboardID /*id*/, const IClipboard* src) +void +CMSWindowsPrimaryScreen::setClipboard( + ClipboardID /*id*/, + const IClipboard* src) { assert(m_window != NULL); @@ -244,8 +258,9 @@ void CMSWindowsPrimaryScreen::setClipboard( CClipboard::copy(&dst, src); } -void CMSWindowsPrimaryScreen::grabClipboard( - ClipboardID /*id*/) +void +CMSWindowsPrimaryScreen::grabClipboard( + ClipboardID /*id*/) { assert(m_window != NULL); @@ -255,19 +270,24 @@ void CMSWindowsPrimaryScreen::grabClipboard( } } -void CMSWindowsPrimaryScreen::getSize( - SInt32* width, SInt32* height) const +void +CMSWindowsPrimaryScreen::getSize( + SInt32* width, + SInt32* height) const { getScreenSize(width, height); } -SInt32 CMSWindowsPrimaryScreen::getJumpZoneSize() const +SInt32 +CMSWindowsPrimaryScreen::getJumpZoneSize() const { return 1; } -void CMSWindowsPrimaryScreen::getClipboard( - ClipboardID /*id*/, IClipboard* dst) const +void +CMSWindowsPrimaryScreen::getClipboard( + ClipboardID /*id*/, + IClipboard* dst) const { assert(m_window != NULL); @@ -275,7 +295,8 @@ void CMSWindowsPrimaryScreen::getClipboard( CClipboard::copy(dst, &src); } -KeyModifierMask CMSWindowsPrimaryScreen::getToggleMask() const +KeyModifierMask +CMSWindowsPrimaryScreen::getToggleMask() const { KeyModifierMask mask = 0; if ((GetKeyState(VK_CAPITAL) & 0x01) != 0) @@ -287,7 +308,8 @@ KeyModifierMask CMSWindowsPrimaryScreen::getToggleMask() const return mask; } -bool CMSWindowsPrimaryScreen::isLockedToScreen() const +bool +CMSWindowsPrimaryScreen::isLockedToScreen() const { // check buttons if (GetAsyncKeyState(VK_LBUTTON) < 0 || @@ -310,7 +332,8 @@ bool CMSWindowsPrimaryScreen::isLockedToScreen() const return false; } -void CMSWindowsPrimaryScreen::onOpenDisplay() +void +CMSWindowsPrimaryScreen::onOpenDisplay() { assert(m_window == NULL); assert(m_server != NULL); @@ -331,7 +354,8 @@ void CMSWindowsPrimaryScreen::onOpenDisplay() } } -void CMSWindowsPrimaryScreen::onCloseDisplay() +void +CMSWindowsPrimaryScreen::onCloseDisplay() { // disconnect from desktop if (m_is95Family) { @@ -348,7 +372,9 @@ void CMSWindowsPrimaryScreen::onCloseDisplay() assert(m_desk == NULL); } -bool CMSWindowsPrimaryScreen::onPreTranslate(MSG* msg) +bool +CMSWindowsPrimaryScreen::onPreTranslate( + MSG* msg) { // handle event switch (msg->message) { @@ -477,9 +503,12 @@ bool CMSWindowsPrimaryScreen::onPreTranslate(MSG* msg) return false; } -LRESULT CMSWindowsPrimaryScreen::onEvent( - HWND hwnd, UINT msg, - WPARAM wParam, LPARAM lParam) +LRESULT +CMSWindowsPrimaryScreen::onEvent( + HWND hwnd, + UINT msg, + WPARAM wParam, + LPARAM lParam) { switch (msg) { case WM_QUERYENDSESSION: @@ -571,7 +600,8 @@ LRESULT CMSWindowsPrimaryScreen::onEvent( return DefWindowProc(hwnd, msg, wParam, lParam); } -void CMSWindowsPrimaryScreen::enterNoWarp() +void +CMSWindowsPrimaryScreen::enterNoWarp() { // not active anymore m_active = false; @@ -595,7 +625,8 @@ void CMSWindowsPrimaryScreen::enterNoWarp() nextMark(); } -void CMSWindowsPrimaryScreen::onEnter() +void +CMSWindowsPrimaryScreen::onEnter() { // restore the active window and hide our window. we can only set // the active window for another thread if we first attach our input @@ -613,7 +644,8 @@ void CMSWindowsPrimaryScreen::onEnter() ShowWindow(m_window, SW_HIDE); } -bool CMSWindowsPrimaryScreen::onLeave() +bool +CMSWindowsPrimaryScreen::onLeave() { // remember the active window before we leave. GetActiveWindow() // will only return the active window for the thread's queue (i.e. @@ -643,7 +675,8 @@ bool CMSWindowsPrimaryScreen::onLeave() return true; } -void CMSWindowsPrimaryScreen::nextMark() +void +CMSWindowsPrimaryScreen::nextMark() { // next mark ++m_mark; @@ -652,7 +685,8 @@ void CMSWindowsPrimaryScreen::nextMark() PostThreadMessage(m_threadID, SYNERGY_MSG_MARK, m_mark, 0); } -bool CMSWindowsPrimaryScreen::openDesktop() +bool +CMSWindowsPrimaryScreen::openDesktop() { // install hooks m_install(m_threadID); @@ -687,7 +721,8 @@ bool CMSWindowsPrimaryScreen::openDesktop() return true; } -void CMSWindowsPrimaryScreen::closeDesktop() +void +CMSWindowsPrimaryScreen::closeDesktop() { // destroy old window if (m_window != NULL) { @@ -714,7 +749,9 @@ void CMSWindowsPrimaryScreen::closeDesktop() m_uninstall(); } -bool CMSWindowsPrimaryScreen::switchDesktop(HDESK desk) +bool +CMSWindowsPrimaryScreen::switchDesktop( + HDESK desk) { // did we own the clipboard? bool ownClipboard = (m_clipboardOwner == m_window); @@ -818,7 +855,8 @@ bool CMSWindowsPrimaryScreen::switchDesktop(HDESK desk) return true; } -CString CMSWindowsPrimaryScreen::getCurrentDesktopName() const +CString +CMSWindowsPrimaryScreen::getCurrentDesktopName() const { return m_deskName; } @@ -1083,9 +1121,11 @@ static const KeyID g_virtualKey[] = /* 0xff */ kKeyNone // reserved }; -KeyID CMSWindowsPrimaryScreen::mapKey( - WPARAM vkCode, LPARAM info, - KeyModifierMask* maskOut) +KeyID +CMSWindowsPrimaryScreen::mapKey( + WPARAM vkCode, + LPARAM info, + KeyModifierMask* maskOut) { // note: known microsoft bugs // Q72583 -- MapVirtualKey() maps keypad keys incorrectly @@ -1101,25 +1141,32 @@ KeyID CMSWindowsPrimaryScreen::mapKey( KeyModifierMask mask = 0; if (((m_keys[VK_LSHIFT] | m_keys[VK_RSHIFT] | - m_keys[VK_SHIFT]) & 0x80) != 0) + m_keys[VK_SHIFT]) & 0x80) != 0) { mask |= KeyModifierShift; + } if (((m_keys[VK_LCONTROL] | m_keys[VK_RCONTROL] | - m_keys[VK_CONTROL]) & 0x80) != 0) + m_keys[VK_CONTROL]) & 0x80) != 0) { mask |= KeyModifierControl; + } if (((m_keys[VK_LMENU] | m_keys[VK_RMENU] | - m_keys[VK_MENU]) & 0x80) != 0) + m_keys[VK_MENU]) & 0x80) != 0) { mask |= KeyModifierAlt; + } if (((m_keys[VK_LWIN] | - m_keys[VK_RWIN]) & 0x80) != 0) + m_keys[VK_RWIN]) & 0x80) != 0) { mask |= KeyModifierMeta; - if ((m_keys[VK_CAPITAL] & 0x01) != 0) + } + if ((m_keys[VK_CAPITAL] & 0x01) != 0) { mask |= KeyModifierCapsLock; - if ((m_keys[VK_NUMLOCK] & 0x01) != 0) + } + if ((m_keys[VK_NUMLOCK] & 0x01) != 0) { mask |= KeyModifierNumLock; - if ((m_keys[VK_SCROLL] & 0x01) != 0) + } + if ((m_keys[VK_SCROLL] & 0x01) != 0) { mask |= KeyModifierScrollLock; + } *maskOut = mask; log((CLOG_DEBUG2 "key in vk=%d info=0x%08x mask=0x%04x", vkCode, info, mask)); @@ -1133,17 +1180,20 @@ KeyID CMSWindowsPrimaryScreen::mapKey( UINT vkCode2 = MapVirtualKey(scanCode, 3); // work around bug Q72583 (bad num pad conversion in MapVirtualKey()) - if (vkCode >= VK_NUMPAD0 && vkCode <= VK_DIVIDE) + if (vkCode >= VK_NUMPAD0 && vkCode <= VK_DIVIDE) { vkCode2 = vkCode; + } // MapVirtualKey() appears to map VK_LWIN, VK_RWIN, VK_APPS to // some other meaningless virtual key. work around that bug. - else if (vkCode >= VK_LWIN && vkCode <= VK_APPS) + else if (vkCode >= VK_LWIN && vkCode <= VK_APPS) { vkCode2 = vkCode; + } // if MapVirtualKey failed then use original virtual key - else if (vkCode2 == 0) + else if (vkCode2 == 0) { vkCode2 = vkCode; + } // sadly, win32 will not distinguish between the left and right // control and alt keys using the above function. however, we @@ -1223,12 +1273,16 @@ KeyID CMSWindowsPrimaryScreen::mapKey( // set shift state required to generate key BYTE keys[256]; memset(keys, 0, sizeof(keys)); - if (vkCode & 0x0100) +// FIXME -- surely these masks should be different in each if expression + if (vkCode & 0x0100) { keys[VK_SHIFT] = 0x80; - if (vkCode & 0x0100) + } + if (vkCode & 0x0100) { keys[VK_CONTROL] = 0x80; - if (vkCode & 0x0100) + } + if (vkCode & 0x0100) { keys[VK_MENU] = 0x80; + } // strip shift state off of virtual key code vkCode &= 0x00ff; @@ -1245,8 +1299,9 @@ KeyID CMSWindowsPrimaryScreen::mapKey( return kKeyNone; } -ButtonID CMSWindowsPrimaryScreen::mapButton( - WPARAM button) const +ButtonID +CMSWindowsPrimaryScreen::mapButton( + WPARAM button) const { switch (button) { case WM_LBUTTONDOWN: @@ -1266,7 +1321,8 @@ ButtonID CMSWindowsPrimaryScreen::mapButton( } } -void CMSWindowsPrimaryScreen::updateKeys() +void +CMSWindowsPrimaryScreen::updateKeys() { // not using GetKeyboardState() because that doesn't seem to give // up-to-date results. i don't know why that is or why GetKeyState() @@ -1293,8 +1349,10 @@ void CMSWindowsPrimaryScreen::updateKeys() m_keys[VK_SCROLL] = static_cast(GetKeyState(VK_SCROLL)); } -void CMSWindowsPrimaryScreen::updateKey( - UINT vkCode, bool press) +void +CMSWindowsPrimaryScreen::updateKey( + UINT vkCode, + bool press) { if (press) { switch (vkCode) { diff --git a/server/CMSWindowsPrimaryScreen.h b/server/CMSWindowsPrimaryScreen.h index a568171a..c026e466 100644 --- a/server/CMSWindowsPrimaryScreen.h +++ b/server/CMSWindowsPrimaryScreen.h @@ -2,10 +2,10 @@ #define CMSWINDOWSPRIMARYSCREEN_H #include "CMSWindowsScreen.h" -#include "IPrimaryScreen.h" -#include "MouseTypes.h" -#include "CString.h" #include "CSynergyHook.h" +#include "MouseTypes.h" +#include "IPrimaryScreen.h" +#include "CString.h" class CMSWindowsPrimaryScreen : public CMSWindowsScreen, public IPrimaryScreen { public: @@ -56,7 +56,7 @@ private: // key and button queries KeyID mapKey(WPARAM keycode, LPARAM info, - KeyModifierMask* maskOut); + KeyModifierMask* maskOut); ButtonID mapButton(WPARAM button) const; void updateKeys(); void updateKey(UINT vkCode, bool press); diff --git a/server/CServer.cpp b/server/CServer.cpp index dfaa86da..3bbeef49 100644 --- a/server/CServer.cpp +++ b/server/CServer.cpp @@ -2,26 +2,25 @@ #include "CHTTPServer.h" #include "CInputPacketStream.h" #include "COutputPacketStream.h" -#include "CServerProtocol.h" #include "CProtocolUtil.h" +#include "CServerProtocol.h" #include "IPrimaryScreen.h" -#include "ISocketFactory.h" #include "ProtocolTypes.h" +#include "XScreen.h" +#include "XSynergy.h" #include "CNetworkAddress.h" -#include "ISocket.h" #include "IListenSocket.h" +#include "ISocket.h" +#include "ISocketFactory.h" +#include "XSocket.h" #include "CLock.h" -#include "CLog.h" #include "CThread.h" #include "CTimerThread.h" -#include "CStopwatch.h" -#include "CFunctionJob.h" -#include "TMethodJob.h" -#include "XScreen.h" -#include "XSocket.h" -#include "XSynergy.h" #include "XThread.h" -#include +#include "CFunctionJob.h" +#include "CLog.h" +#include "CStopwatch.h" +#include "TMethodJob.h" #include // hack to work around operator=() bug in STL in g++ prior to v3 @@ -31,32 +30,22 @@ #define assign(_dst, _src, _type) _dst = std::auto_ptr<_type >(_src) #endif - -/* XXX -#include -#include -#include -#include -if (fork() == 0) abort(); -else { wait(0); exit(1); } -*/ - // // CServer // const SInt32 CServer::s_httpMaxSimultaneousRequests = 3; -CServer::CServer(const CString& serverName) : - m_name(serverName), - m_cleanupSize(&m_mutex, 0), - m_primary(NULL), - m_active(NULL), - m_primaryInfo(NULL), - m_seqNum(0), - m_httpServer(NULL), - m_httpAvailable(&m_mutex, - s_httpMaxSimultaneousRequests) +CServer::CServer( + const CString& serverName) : + m_name(serverName), + m_cleanupSize(&m_mutex, 0), + m_primary(NULL), + m_active(NULL), + m_primaryInfo(NULL), + m_seqNum(0), + m_httpServer(NULL), + m_httpAvailable(&m_mutex, s_httpMaxSimultaneousRequests) { m_socketFactory = NULL; m_securityFactory = NULL; @@ -68,7 +57,8 @@ CServer::~CServer() // do nothing } -void CServer::run() +void +CServer::run() { try { log((CLOG_NOTE "starting server")); @@ -149,12 +139,14 @@ void CServer::run() } } -void CServer::quit() +void +CServer::quit() { m_primary->stop(); } -void CServer::shutdown() +void +CServer::shutdown() { // stop all running threads but don't wait too long since some // threads may be unable to proceed until this thread returns. @@ -167,7 +159,9 @@ void CServer::shutdown() // note -- we do not attempt to close down the primary screen } -bool CServer::setConfig(const CConfig& config) +bool +CServer::setConfig( + const CConfig& config) { typedef std::vector CThreads; CThreads threads; @@ -228,12 +222,15 @@ bool CServer::setConfig(const CConfig& config) return true; } -CString CServer::getPrimaryScreenName() const +CString +CServer::getPrimaryScreenName() const { return m_name; } -void CServer::getConfig(CConfig* config) const +void +CServer::getConfig( + CConfig* config) const { assert(config != NULL); @@ -241,7 +238,8 @@ void CServer::getConfig(CConfig* config) const *config = m_config; } -UInt32 CServer::getActivePrimarySides() const +UInt32 +CServer::getActivePrimarySides() const { UInt32 sides = 0; CLock lock(&m_mutex); @@ -264,26 +262,40 @@ UInt32 CServer::getActivePrimarySides() const return sides; } -void CServer::setInfo( - SInt32 w, SInt32 h, SInt32 zoneSize, - SInt32 x, SInt32 y) +void +CServer::setInfo( + SInt32 w, + SInt32 h, + SInt32 zoneSize, + SInt32 x, + SInt32 y) { CLock lock(&m_mutex); assert(m_primaryInfo != NULL); setInfoNoLock(m_primaryInfo->m_name, w, h, zoneSize, x, y); } -void CServer::setInfo(const CString& client, - SInt32 w, SInt32 h, SInt32 zoneSize, - SInt32 x, SInt32 y) +void +CServer::setInfo( + const CString& client, + SInt32 w, + SInt32 h, + SInt32 zoneSize, + SInt32 x, + SInt32 y) { CLock lock(&m_mutex); setInfoNoLock(client, w, h, zoneSize, x, y); } -void CServer::setInfoNoLock(const CString& screen, - SInt32 w, SInt32 h, SInt32 zoneSize, - SInt32 x, SInt32 y) +void +CServer::setInfoNoLock( + const CString& screen, + SInt32 w, + SInt32 h, + SInt32 zoneSize, + SInt32 x, + SInt32 y) { assert(!screen.empty()); assert(w > 0); @@ -327,24 +339,30 @@ void CServer::setInfoNoLock(const CString& screen, } } -void CServer::grabClipboard(ClipboardID id) +void +CServer::grabClipboard( + ClipboardID id) { CLock lock(&m_mutex); assert(m_primaryInfo != NULL); grabClipboardNoLock(id, 0, m_primaryInfo->m_name); } -void CServer::grabClipboard( - ClipboardID id, UInt32 seqNum, - const CString& client) +void +CServer::grabClipboard( + ClipboardID id, + UInt32 seqNum, + const CString& client) { CLock lock(&m_mutex); grabClipboardNoLock(id, seqNum, client); } -void CServer::grabClipboardNoLock( - ClipboardID id, UInt32 seqNum, - const CString& screen) +void +CServer::grabClipboardNoLock( + ClipboardID id, + UInt32 seqNum, + const CString& screen) { // note -- must be locked on entry CClipboardInfo& clipboard = m_clipboards[id]; @@ -402,8 +420,11 @@ void CServer::grabClipboardNoLock( } } -void CServer::setClipboard(ClipboardID id, - UInt32 seqNum, const CString& data) +void +CServer::setClipboard( + ClipboardID id, + UInt32 seqNum, + const CString& data) { CLock lock(&m_mutex); CClipboardInfo& clipboard = m_clipboards[id]; @@ -433,13 +454,19 @@ void CServer::setClipboard(ClipboardID id, sendClipboard(id); } -bool CServer::onCommandKey(KeyID /*id*/, - KeyModifierMask /*mask*/, bool /*down*/) +bool +CServer::onCommandKey( + KeyID /*id*/, + KeyModifierMask /*mask*/, + bool /*down*/) { return false; } -void CServer::onKeyDown(KeyID id, KeyModifierMask mask) +void +CServer::onKeyDown( + KeyID id, + KeyModifierMask mask) { log((CLOG_DEBUG1 "onKeyDown id=%d mask=0x%04x", id, mask)); CLock lock(&m_mutex); @@ -456,7 +483,10 @@ void CServer::onKeyDown(KeyID id, KeyModifierMask mask) } } -void CServer::onKeyUp(KeyID id, KeyModifierMask mask) +void +CServer::onKeyUp( + KeyID id, + KeyModifierMask mask) { log((CLOG_DEBUG1 "onKeyUp id=%d mask=0x%04x", id, mask)); CLock lock(&m_mutex); @@ -473,8 +503,11 @@ void CServer::onKeyUp(KeyID id, KeyModifierMask mask) } } -void CServer::onKeyRepeat( - KeyID id, KeyModifierMask mask, SInt32 count) +void +CServer::onKeyRepeat( + KeyID id, + KeyModifierMask mask, + SInt32 count) { log((CLOG_DEBUG1 "onKeyRepeat id=%d mask=0x%04x count=%d", id, mask, count)); CLock lock(&m_mutex); @@ -492,7 +525,9 @@ void CServer::onKeyRepeat( } } -void CServer::onMouseDown(ButtonID id) +void +CServer::onMouseDown( + ButtonID id) { log((CLOG_DEBUG1 "onMouseDown id=%d", id)); CLock lock(&m_mutex); @@ -504,7 +539,9 @@ void CServer::onMouseDown(ButtonID id) } } -void CServer::onMouseUp(ButtonID id) +void +CServer::onMouseUp( + ButtonID id) { log((CLOG_DEBUG1 "onMouseUp id=%d", id)); CLock lock(&m_mutex); @@ -516,14 +553,20 @@ void CServer::onMouseUp(ButtonID id) } } -bool CServer::onMouseMovePrimary(SInt32 x, SInt32 y) +bool +CServer::onMouseMovePrimary( + SInt32 x, + SInt32 y) { log((CLOG_DEBUG2 "onMouseMovePrimary %d,%d", x, y)); CLock lock(&m_mutex); return onMouseMovePrimaryNoLock(x, y); } -bool CServer::onMouseMovePrimaryNoLock(SInt32 x, SInt32 y) +bool +CServer::onMouseMovePrimaryNoLock( + SInt32 x, + SInt32 y) { // mouse move on primary (server's) screen assert(m_active != NULL); @@ -577,15 +620,20 @@ bool CServer::onMouseMovePrimaryNoLock(SInt32 x, SInt32 y) return true; } -void CServer::onMouseMoveSecondary(SInt32 dx, SInt32 dy) +void +CServer::onMouseMoveSecondary( + SInt32 dx, + SInt32 dy) { log((CLOG_DEBUG2 "onMouseMoveSecondary %+d,%+d", dx, dy)); CLock lock(&m_mutex); onMouseMoveSecondaryNoLock(dx, dy); } -void CServer::onMouseMoveSecondaryNoLock( - SInt32 dx, SInt32 dy) +void +CServer::onMouseMoveSecondaryNoLock( + SInt32 dx, + SInt32 dy) { // mouse move on secondary (client's) screen assert(m_active != NULL); @@ -687,7 +735,9 @@ void CServer::onMouseMoveSecondaryNoLock( } } -void CServer::onMouseWheel(SInt32 delta) +void +CServer::onMouseWheel( + SInt32 delta) { log((CLOG_DEBUG1 "onMouseWheel %+d", delta)); CLock lock(&m_mutex); @@ -699,13 +749,15 @@ void CServer::onMouseWheel(SInt32 delta) } } -bool CServer::isLockedToScreen() const +bool +CServer::isLockedToScreen() const { CLock lock(&m_mutex); return isLockedToScreenNoLock(); } -bool CServer::isLockedToScreenNoLock() const +bool +CServer::isLockedToScreenNoLock() const { // locked if primary says we're locked if (m_primary->isLockedToScreen()) { @@ -721,8 +773,11 @@ bool CServer::isLockedToScreenNoLock() const return false; } -void CServer::switchScreen(CScreenInfo* dst, - SInt32 x, SInt32 y) +void +CServer::switchScreen( + CScreenInfo* dst, + SInt32 x, + SInt32 y) { assert(dst != NULL); assert(x >= 0 && y >= 0 && x < dst->m_width && y < dst->m_height); @@ -789,8 +844,10 @@ void CServer::switchScreen(CScreenInfo* dst, } } -CServer::CScreenInfo* CServer::getNeighbor(CScreenInfo* src, - CConfig::EDirection dir) const +CServer::CScreenInfo* +CServer::getNeighbor( + CScreenInfo* src, + CConfig::EDirection dir) const { assert(src != NULL); @@ -821,9 +878,12 @@ CServer::CScreenInfo* CServer::getNeighbor(CScreenInfo* src, } } -CServer::CScreenInfo* CServer::getNeighbor(CScreenInfo* src, - CConfig::EDirection srcSide, - SInt32& x, SInt32& y) const +CServer::CScreenInfo* +CServer::getNeighbor( + CScreenInfo* src, + CConfig::EDirection srcSide, + SInt32& x, + SInt32& y) const { assert(src != NULL); @@ -936,10 +996,13 @@ CServer::CScreenInfo* CServer::getNeighbor(CScreenInfo* src, return lastGoodScreen; } -void CServer::mapPosition(CScreenInfo* src, - CConfig::EDirection srcSide, - CScreenInfo* dst, - SInt32& x, SInt32& y) const +void +CServer::mapPosition( + CScreenInfo* src, + CConfig::EDirection srcSide, + CScreenInfo* dst, + SInt32& x, + SInt32& y) const { assert(src != NULL); assert(dst != NULL); @@ -949,32 +1012,39 @@ void CServer::mapPosition(CScreenInfo* src, switch (srcSide) { case CConfig::kLeft: case CConfig::kRight: - if (y < 0) + if (y < 0) { y = 0; - else if (y >= src->m_height) + } + else if (y >= src->m_height) { y = dst->m_height - 1; - else + } + else { y = static_cast(0.5 + y * static_cast(dst->m_height - 1) / (src->m_height - 1)); + } break; case CConfig::kTop: case CConfig::kBottom: - if (x < 0) + if (x < 0) { x = 0; - else if (x >= src->m_width) + } + else if (x >= src->m_width) { x = dst->m_width - 1; - else + } + else { x = static_cast(0.5 + x * static_cast(dst->m_width - 1) / (src->m_width - 1)); + } break; } } #include "CTCPListenSocket.h" -void CServer::acceptClients(void*) +void +CServer::acceptClients(void*) { log((CLOG_DEBUG1 "starting to wait for clients")); @@ -1030,7 +1100,9 @@ void CServer::acceptClients(void*) } } -void CServer::handshakeClient(void* vsocket) +void +CServer::handshakeClient( + void* vsocket) { log((CLOG_DEBUG1 "negotiating with new client")); @@ -1162,7 +1234,8 @@ void CServer::handshakeClient(void* vsocket) } } -void CServer::acceptHTTPClients(void*) +void +CServer::acceptHTTPClients(void*) { log((CLOG_DEBUG1 "starting to wait for HTTP clients")); @@ -1229,7 +1302,9 @@ void CServer::acceptHTTPClients(void*) } } -void CServer::processHTTPRequest(void* vsocket) +void +CServer::processHTTPRequest( + void* vsocket) { // add this thread to the list of threads to cancel. remove from // list in d'tor. @@ -1266,7 +1341,9 @@ void CServer::processHTTPRequest(void* vsocket) } } -void CServer::clearGotClipboard(ClipboardID id) +void +CServer::clearGotClipboard( + ClipboardID id) { for (CScreenList::const_iterator index = m_screens.begin(); index != m_screens.end(); ++index) { @@ -1274,7 +1351,9 @@ void CServer::clearGotClipboard(ClipboardID id) } } -void CServer::sendClipboard(ClipboardID id) +void +CServer::sendClipboard( + ClipboardID id) { // do nothing if clipboard was already sent if (!m_active->m_gotClipboard[id]) { @@ -1295,7 +1374,9 @@ void CServer::sendClipboard(ClipboardID id) } } -void CServer::updatePrimaryClipboard(ClipboardID id) +void +CServer::updatePrimaryClipboard( + ClipboardID id) { CClipboardInfo& clipboard = m_clipboards[id]; @@ -1339,7 +1420,8 @@ void CServer::updatePrimaryClipboard(ClipboardID id) #elif defined(CONFIG_PLATFORM_UNIX) #include "CXWindowsPrimaryScreen.h" #endif -void CServer::openPrimaryScreen() +void +CServer::openPrimaryScreen() { assert(m_primary == NULL); @@ -1387,7 +1469,8 @@ void CServer::openPrimaryScreen() } } -void CServer::closePrimaryScreen() +void +CServer::closePrimaryScreen() { assert(m_primary != NULL); @@ -1410,14 +1493,18 @@ void CServer::closePrimaryScreen() m_primary = NULL; } -void CServer::addCleanupThread(const CThread& thread) +void +CServer::addCleanupThread( + const CThread& thread) { CLock lock(&m_mutex); m_cleanupList.insert(m_cleanupList.begin(), new CThread(thread)); m_cleanupSize = m_cleanupSize + 1; } -void CServer::removeCleanupThread(const CThread& thread) +void +CServer::removeCleanupThread( + const CThread& thread) { CLock lock(&m_mutex); for (CThreadList::iterator index = m_cleanupList.begin(); @@ -1435,7 +1522,9 @@ void CServer::removeCleanupThread(const CThread& thread) } } -void CServer::cleanupThreads(double timeout) +void +CServer::cleanupThreads( + double timeout) { log((CLOG_DEBUG1 "cleaning up threads")); @@ -1474,8 +1563,10 @@ void CServer::cleanupThreads(double timeout) log((CLOG_DEBUG1 "cleaned up threads")); } -CServer::CScreenInfo* CServer::addConnection( - const CString& name, IServerProtocol* protocol) +CServer::CScreenInfo* +CServer::addConnection( + const CString& name, + IServerProtocol* protocol) { log((CLOG_DEBUG "adding connection \"%s\"", name.c_str())); @@ -1499,7 +1590,9 @@ CServer::CScreenInfo* CServer::addConnection( return newScreen; } -void CServer::removeConnection(const CString& name) +void +CServer::removeConnection( + const CString& name) { log((CLOG_DEBUG "removing connection \"%s\"", name.c_str())); CLock lock(&m_mutex); @@ -1534,7 +1627,9 @@ void CServer::removeConnection(const CString& name) // CServer::CCleanupNote // -CServer::CCleanupNote::CCleanupNote(CServer* server) : m_server(server) +CServer::CCleanupNote::CCleanupNote( + CServer* server) : + m_server(server) { assert(m_server != NULL); m_server->addCleanupThread(CThread::getCurrentThread()); @@ -1550,11 +1645,12 @@ CServer::CCleanupNote::~CCleanupNote() // CServer::CConnectionNote // -CServer::CConnectionNote::CConnectionNote(CServer* server, - const CString& name, - IServerProtocol* protocol) : - m_server(server), - m_name(name) +CServer::CConnectionNote::CConnectionNote( + CServer* server, + const CString& name, + IServerProtocol* protocol) : + m_server(server), + m_name(name) { assert(m_server != NULL); m_server->addConnection(m_name, protocol); @@ -1570,14 +1666,16 @@ CServer::CConnectionNote::~CConnectionNote() // CServer::CScreenInfo // -CServer::CScreenInfo::CScreenInfo(const CString& name, - IServerProtocol* protocol) : - m_thread(CThread::getCurrentThread()), - m_name(name), - m_protocol(protocol), - m_ready(false), - m_width(0), m_height(0), - m_zoneSize(0) +CServer::CScreenInfo::CScreenInfo( + const CString& name, + IServerProtocol* protocol) : + m_thread(CThread::getCurrentThread()), + m_name(name), + m_protocol(protocol), + m_ready(false), + m_width(0), + m_height(0), + m_zoneSize(0) { for (ClipboardID id = 0; id < kClipboardEnd; ++id) m_gotClipboard[id] = false; @@ -1594,11 +1692,11 @@ CServer::CScreenInfo::~CScreenInfo() // CServer::CClipboardInfo::CClipboardInfo() : - m_clipboard(), - m_clipboardData(), - m_clipboardOwner(), - m_clipboardSeqNum(0), - m_clipboardReady(false) + m_clipboard(), + m_clipboardData(), + m_clipboardOwner(), + m_clipboardSeqNum(0), + m_clipboardReady(false) { // do nothing } diff --git a/server/CServer.h b/server/CServer.h index 568d2c1d..c68a71a5 100644 --- a/server/CServer.h +++ b/server/CServer.h @@ -1,17 +1,15 @@ #ifndef CSERVER_H #define CSERVER_H +#include "CConfig.h" +#include "CClipboard.h" #include "ClipboardTypes.h" #include "KeyTypes.h" #include "MouseTypes.h" -#include "CConfig.h" -#include "CClipboard.h" #include "CNetworkAddress.h" #include "CCondVar.h" #include "CMutex.h" -#include "CString.h" #include "CThread.h" -#include "XBase.h" #include "stdlist.h" #include "stdmap.h" @@ -58,18 +56,18 @@ public: // handle updates from primary void setInfo(SInt32 wScreen, SInt32 hScreen, - SInt32 zoneSize, - SInt32 xMouse, SInt32 yMouse); + SInt32 zoneSize, + SInt32 xMouse, SInt32 yMouse); // handle messages from clients void setInfo(const CString& clientName, - SInt32 wScreen, SInt32 hScreen, - SInt32 zoneSize, - SInt32 xMouse, SInt32 yMouse); + SInt32 wScreen, SInt32 hScreen, + SInt32 zoneSize, + SInt32 xMouse, SInt32 yMouse); void grabClipboard(ClipboardID, - UInt32 seqNum, const CString& clientName); + UInt32 seqNum, const CString& clientName); void setClipboard(ClipboardID, - UInt32 seqNum, const CString& data); + UInt32 seqNum, const CString& data); // accessors @@ -132,13 +130,13 @@ private: // update screen info void setInfoNoLock(const CString& screenName, - SInt32 wScreen, SInt32 hScreen, - SInt32 zoneSize, - SInt32 xMouse, SInt32 yMouse); + SInt32 wScreen, SInt32 hScreen, + SInt32 zoneSize, + SInt32 xMouse, SInt32 yMouse); // grab the clipboard void grabClipboardNoLock(ClipboardID, - UInt32 seqNum, const CString& clientName); + UInt32 seqNum, const CString& clientName); // returns true iff mouse should be locked to the current screen bool isLockedToScreenNoLock() const; @@ -154,16 +152,16 @@ private: // if the position is sufficiently far from the source then we // cross multiple screens. CScreenInfo* getNeighbor(CScreenInfo*, - CConfig::EDirection, - SInt32& x, SInt32& y) const; + CConfig::EDirection, + SInt32& x, SInt32& y) const; // adjust coordinates to account for resolution differences. the // position is converted to a resolution independent form then // converted back to screen coordinates on the destination screen. void mapPosition(CScreenInfo* src, - CConfig::EDirection srcSide, - CScreenInfo* dst, - SInt32& x, SInt32& y) const; + CConfig::EDirection srcSide, + CScreenInfo* dst, + SInt32& x, SInt32& y) const; // open/close the primary screen void openPrimaryScreen(); diff --git a/server/CServerProtocol.cpp b/server/CServerProtocol.cpp index 73b7ecc5..dd65ba1c 100644 --- a/server/CServerProtocol.cpp +++ b/server/CServerProtocol.cpp @@ -1,20 +1,23 @@ #include "CServerProtocol.h" #include "CServerProtocol1_0.h" #include "ProtocolTypes.h" +#include "XSynergy.h" #include "IOutputStream.h" -#include -#include +#include // // CServerProtocol // -CServerProtocol::CServerProtocol(CServer* server, const CString& client, - IInputStream* input, IOutputStream* output) : - m_server(server), - m_client(client), - m_input(input), - m_output(output) +CServerProtocol::CServerProtocol( + CServer* server, + const CString& client, + IInputStream* input, + IOutputStream* output) : + m_server(server), + m_client(client), + m_input(input), + m_output(output) { assert(m_server != NULL); assert(m_input != NULL); @@ -26,29 +29,38 @@ CServerProtocol::~CServerProtocol() // do nothing } -CServer* CServerProtocol::getServer() const +CServer* +CServerProtocol::getServer() const { return m_server; } -CString CServerProtocol::getClient() const +CString +CServerProtocol::getClient() const { return m_client; } -IInputStream* CServerProtocol::getInputStream() const +IInputStream* +CServerProtocol::getInputStream() const { return m_input; } -IOutputStream* CServerProtocol::getOutputStream() const +IOutputStream* +CServerProtocol::getOutputStream() const { return m_output; } -IServerProtocol* CServerProtocol::create(SInt32 major, SInt32 minor, - CServer* server, const CString& client, - IInputStream* input, IOutputStream* output) +IServerProtocol* +CServerProtocol::create( + SInt32 major, + SInt32 minor, + CServer* server, + const CString& client, + IInputStream* input, + IOutputStream* output) { // disallow invalid version numbers if (major < 0 || minor < 0) { @@ -70,4 +82,3 @@ IServerProtocol* CServerProtocol::create(SInt32 major, SInt32 minor, // given version. return new CServerProtocol1_0(server, client, input, output); } - diff --git a/server/CServerProtocol.h b/server/CServerProtocol.h index 47ae856d..311e5d0f 100644 --- a/server/CServerProtocol.h +++ b/server/CServerProtocol.h @@ -1,7 +1,6 @@ #ifndef CSERVERPROTOCOL_H #define CSERVERPROTOCOL_H -#include "CString.h" #include "IServerProtocol.h" class CServer; @@ -11,7 +10,7 @@ class IOutputStream; class CServerProtocol : public IServerProtocol { public: CServerProtocol(CServer*, const CString& clientName, - IInputStream*, IOutputStream*); + IInputStream*, IOutputStream*); ~CServerProtocol(); // manipulators @@ -24,15 +23,15 @@ public: virtual IOutputStream* getOutputStream() const; static IServerProtocol* create(SInt32 major, SInt32 minor, - CServer*, const CString& clientName, - IInputStream*, IOutputStream*); + CServer*, const CString& clientName, + IInputStream*, IOutputStream*); // IServerProtocol overrides virtual void run() = 0; virtual void queryInfo() = 0; virtual void sendClose() = 0; virtual void sendEnter(SInt32 xAbs, SInt32 yAbs, - UInt32 seqNum, KeyModifierMask mask) = 0; + UInt32 seqNum, KeyModifierMask mask) = 0; virtual void sendLeave() = 0; virtual void sendClipboard(ClipboardID, const CString&) = 0; virtual void sendGrabClipboard(ClipboardID) = 0; diff --git a/server/CServerProtocol1_0.cpp b/server/CServerProtocol1_0.cpp index 5fe9ffd4..4de3347f 100644 --- a/server/CServerProtocol1_0.cpp +++ b/server/CServerProtocol1_0.cpp @@ -3,19 +3,23 @@ #include "CClipboard.h" #include "CProtocolUtil.h" #include "ProtocolTypes.h" +#include "XSynergy.h" #include "IInputStream.h" #include "IOutputStream.h" -#include "CLog.h" #include "CThread.h" -#include +#include "CLog.h" +#include // // CServerProtocol1_0 // -CServerProtocol1_0::CServerProtocol1_0(CServer* server, const CString& client, - IInputStream* input, IOutputStream* output) : - CServerProtocol(server, client, input, output) +CServerProtocol1_0::CServerProtocol1_0( + CServer* server, + const CString& client, + IInputStream* input, + IOutputStream* output) : + CServerProtocol(server, client, input, output) { // do nothing } @@ -25,7 +29,8 @@ CServerProtocol1_0::~CServerProtocol1_0() // do nothing } -void CServerProtocol1_0::run() +void +CServerProtocol1_0::run() { // handle messages until the client hangs up for (;;) { @@ -71,7 +76,8 @@ void CServerProtocol1_0::run() } } -void CServerProtocol1_0::queryInfo() +void +CServerProtocol1_0::queryInfo() { log((CLOG_DEBUG1 "querying client \"%s\" info", getClient().c_str())); @@ -89,7 +95,8 @@ void CServerProtocol1_0::queryInfo() recvInfo(); } -void CServerProtocol1_0::sendClose() +void +CServerProtocol1_0::sendClose() { log((CLOG_DEBUG1 "send close to \"%s\"", getClient().c_str())); CProtocolUtil::writef(getOutputStream(), kMsgCClose); @@ -98,96 +105,120 @@ void CServerProtocol1_0::sendClose() getOutputStream()->flush(); } -void CServerProtocol1_0::sendEnter( - SInt32 xAbs, SInt32 yAbs, - UInt32 seqNum, KeyModifierMask mask) +void +CServerProtocol1_0::sendEnter( + SInt32 xAbs, + SInt32 yAbs, + UInt32 seqNum, + KeyModifierMask mask) { log((CLOG_DEBUG1 "send enter to \"%s\", %d,%d %d %04x", getClient().c_str(), xAbs, yAbs, seqNum, mask)); CProtocolUtil::writef(getOutputStream(), kMsgCEnter, xAbs, yAbs, seqNum, mask); } -void CServerProtocol1_0::sendLeave() +void +CServerProtocol1_0::sendLeave() { log((CLOG_DEBUG1 "send leave to \"%s\"", getClient().c_str())); CProtocolUtil::writef(getOutputStream(), kMsgCLeave); } -void CServerProtocol1_0::sendClipboard( - ClipboardID id, const CString& data) +void +CServerProtocol1_0::sendClipboard( + ClipboardID id, + const CString& data) { log((CLOG_DEBUG "send clipboard %d to \"%s\" size=%d", id, getClient().c_str(), data.size())); CProtocolUtil::writef(getOutputStream(), kMsgDClipboard, id, 0, &data); } -void CServerProtocol1_0::sendGrabClipboard(ClipboardID id) +void +CServerProtocol1_0::sendGrabClipboard( + ClipboardID id) { log((CLOG_DEBUG "send grab clipboard %d to \"%s\"", id, getClient().c_str())); CProtocolUtil::writef(getOutputStream(), kMsgCClipboard, id, 0); } -void CServerProtocol1_0::sendScreenSaver(bool on) +void +CServerProtocol1_0::sendScreenSaver( + bool on) { log((CLOG_DEBUG1 "send screen saver to \"%s\" on=%d", getClient().c_str(), on ? 1 : 0)); CProtocolUtil::writef(getOutputStream(), kMsgCScreenSaver, on ? 1 : 0); } -void CServerProtocol1_0::sendInfoAcknowledgment() +void +CServerProtocol1_0::sendInfoAcknowledgment() { log((CLOG_DEBUG1 "send info ack to \"%s\"", getClient().c_str())); CProtocolUtil::writef(getOutputStream(), kMsgCInfoAck); } -void CServerProtocol1_0::sendKeyDown( - KeyID key, KeyModifierMask mask) +void +CServerProtocol1_0::sendKeyDown( + KeyID key, + KeyModifierMask mask) { log((CLOG_DEBUG1 "send key down to \"%s\" id=%d, mask=0x%04x", getClient().c_str(), key, mask)); CProtocolUtil::writef(getOutputStream(), kMsgDKeyDown, key, mask); } -void CServerProtocol1_0::sendKeyRepeat( - KeyID key, KeyModifierMask mask, SInt32 count) +void +CServerProtocol1_0::sendKeyRepeat( + KeyID key, + KeyModifierMask mask, + SInt32 count) { log((CLOG_DEBUG1 "send key repeat to \"%s\" id=%d, mask=0x%04x, count=%d", getClient().c_str(), key, mask, count)); CProtocolUtil::writef(getOutputStream(), kMsgDKeyRepeat, key, mask, count); } -void CServerProtocol1_0::sendKeyUp( - KeyID key, KeyModifierMask mask) +void +CServerProtocol1_0::sendKeyUp( + KeyID key, + KeyModifierMask mask) { log((CLOG_DEBUG1 "send key up to \"%s\" id=%d, mask=0x%04x", getClient().c_str(), key, mask)); CProtocolUtil::writef(getOutputStream(), kMsgDKeyUp, key, mask); } -void CServerProtocol1_0::sendMouseDown( - ButtonID button) +void +CServerProtocol1_0::sendMouseDown( + ButtonID button) { log((CLOG_DEBUG1 "send mouse down to \"%s\" id=%d", getClient().c_str(), button)); CProtocolUtil::writef(getOutputStream(), kMsgDMouseDown, button); } -void CServerProtocol1_0::sendMouseUp( - ButtonID button) +void +CServerProtocol1_0::sendMouseUp( + ButtonID button) { log((CLOG_DEBUG1 "send mouse up to \"%s\" id=%d", getClient().c_str(), button)); CProtocolUtil::writef(getOutputStream(), kMsgDMouseUp, button); } -void CServerProtocol1_0::sendMouseMove( - SInt32 xAbs, SInt32 yAbs) +void +CServerProtocol1_0::sendMouseMove( + SInt32 xAbs, + SInt32 yAbs) { log((CLOG_DEBUG2 "send mouse move to \"%s\" %d,%d", getClient().c_str(), xAbs, yAbs)); CProtocolUtil::writef(getOutputStream(), kMsgDMouseMove, xAbs, yAbs); } -void CServerProtocol1_0::sendMouseWheel( - SInt32 delta) +void +CServerProtocol1_0::sendMouseWheel( + SInt32 delta) { log((CLOG_DEBUG2 "send mouse wheel to \"%s\" %+d", getClient().c_str(), delta)); CProtocolUtil::writef(getOutputStream(), kMsgDMouseWheel, delta); } -void CServerProtocol1_0::recvInfo() +void +CServerProtocol1_0::recvInfo() { // parse the message SInt16 x, y, w, h, zoneInfo; @@ -207,7 +238,8 @@ void CServerProtocol1_0::recvInfo() getServer()->setInfo(getClient(), w, h, zoneInfo, x, y); } -void CServerProtocol1_0::recvClipboard() +void +CServerProtocol1_0::recvClipboard() { // parse message ClipboardID id; @@ -225,7 +257,8 @@ void CServerProtocol1_0::recvClipboard() getServer()->setClipboard(id, seqNum, data); } -void CServerProtocol1_0::recvGrabClipboard() +void +CServerProtocol1_0::recvGrabClipboard() { // parse message ClipboardID id; diff --git a/server/CServerProtocol1_0.h b/server/CServerProtocol1_0.h index 4114643e..4e14dac7 100644 --- a/server/CServerProtocol1_0.h +++ b/server/CServerProtocol1_0.h @@ -17,7 +17,7 @@ public: virtual void queryInfo(); virtual void sendClose(); virtual void sendEnter(SInt32 xAbs, SInt32 yAbs, - UInt32 seqNum, KeyModifierMask mask); + UInt32 seqNum, KeyModifierMask mask); virtual void sendLeave(); virtual void sendClipboard(ClipboardID, const CString&); virtual void sendGrabClipboard(ClipboardID); diff --git a/server/CSynergyHook.cpp b/server/CSynergyHook.cpp index de47ab5f..281ab443 100644 --- a/server/CSynergyHook.cpp +++ b/server/CSynergyHook.cpp @@ -1,6 +1,5 @@ #include "CSynergyHook.h" #include "CConfig.h" -#include #include // @@ -60,7 +59,9 @@ static DWORD g_cursorThread = 0; // internal functions // -static void hideCursor(DWORD thread) +static +void +hideCursor(DWORD thread) { // we should be running the context of the window who's cursor // we want to hide so we shouldn't have to attach thread input. @@ -69,7 +70,9 @@ static void hideCursor(DWORD thread) SetCursor(NULL); } -static void restoreCursor() +static +void +restoreCursor() { // restore the show cursor in the window we hid it last if (g_cursor != NULL && g_cursorThread != 0) { @@ -84,7 +87,12 @@ static void restoreCursor() g_cursorThread = 0; } -static LRESULT CALLBACK keyboardHook(int code, WPARAM wParam, LPARAM lParam) +static +LRESULT CALLBACK +keyboardHook( + int code, + WPARAM wParam, + LPARAM lParam) { if (code >= 0) { if (g_relay) { @@ -111,7 +119,12 @@ static LRESULT CALLBACK keyboardHook(int code, WPARAM wParam, LPARAM lParam) return CallNextHookEx(g_keyboard, code, wParam, lParam); } -static LRESULT CALLBACK mouseHook(int code, WPARAM wParam, LPARAM lParam) +static +LRESULT CALLBACK +mouseHook( + int code, + WPARAM wParam, + LPARAM lParam) { if (code >= 0) { if (g_relay) { @@ -213,7 +226,12 @@ static LRESULT CALLBACK mouseHook(int code, WPARAM wParam, LPARAM lParam) return CallNextHookEx(g_mouse, code, wParam, lParam); } -static LRESULT CALLBACK cbtHook(int code, WPARAM wParam, LPARAM lParam) +static +LRESULT CALLBACK +cbtHook( + int code, + WPARAM wParam, + LPARAM lParam) { if (code >= 0) { if (g_relay) { @@ -224,7 +242,12 @@ static LRESULT CALLBACK cbtHook(int code, WPARAM wParam, LPARAM lParam) return CallNextHookEx(g_cbt, code, wParam, lParam); } -static LRESULT CALLBACK getMessageHook(int code, WPARAM wParam, LPARAM lParam) +static +LRESULT CALLBACK +getMessageHook( + int code, + WPARAM wParam, + LPARAM lParam) { if (code >= 0) { if (g_relay) { @@ -252,7 +275,12 @@ static LRESULT CALLBACK getMessageHook(int code, WPARAM wParam, LPARAM lParam) // side, key repeats are not compressed for us. // -static LRESULT CALLBACK keyboardLLHook(int code, WPARAM wParam, LPARAM lParam) +static +LRESULT CALLBACK +keyboardLLHook( + int code, + WPARAM wParam, + LPARAM lParam) { if (code >= 0) { if (g_relay) { @@ -296,7 +324,10 @@ static LRESULT CALLBACK keyboardLLHook(int code, WPARAM wParam, LPARAM lParam) return CallNextHookEx(g_keyboardLL, code, wParam, lParam); } -static DWORD WINAPI getKeyboardLLProc(void*) +static +DWORD WINAPI +getKeyboardLLProc( + void*) { // thread proc for low-level keyboard hook. this does nothing but // install the hook, process events, and uninstall the hook. @@ -349,7 +380,10 @@ static DWORD WINAPI getKeyboardLLProc(void*) #error foo -static DWORD WINAPI getKeyboardLLProc(void*) +static +DWORD WINAPI +getKeyboardLLProc( + void*) { g_keyHookThreadID = 0; SetEvent(g_keyHookEvent); @@ -358,7 +392,9 @@ static DWORD WINAPI getKeyboardLLProc(void*) #endif -static EWheelSupport GetWheelSupport() +static +EWheelSupport +getWheelSupport() { // get operating system OSVERSIONINFO info; @@ -404,7 +440,11 @@ static EWheelSupport GetWheelSupport() // external functions // -BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID) +BOOL WINAPI +DllMain( + HINSTANCE instance, + DWORD reason, + LPVOID) { if (reason == DLL_PROCESS_ATTACH) { if (g_hinstance == NULL) { @@ -425,7 +465,9 @@ BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID) extern "C" { -int install(DWORD threadID) +int +install( + DWORD threadID) { assert(g_threadID == 0); assert(g_hinstance != NULL); @@ -448,7 +490,7 @@ int install(DWORD threadID) g_cursorThread = 0; // check for mouse wheel support - g_wheelSupport = GetWheelSupport(); + g_wheelSupport = getWheelSupport(); // install keyboard hook g_keyboard = SetWindowsHookEx(WH_KEYBOARD, @@ -528,7 +570,9 @@ int install(DWORD threadID) return 1; } -int uninstall(void) +int +uninstall( + void) { assert(g_keyboard != NULL); assert(g_mouse != NULL); @@ -562,8 +606,12 @@ int uninstall(void) return 1; } -void setZone(UInt32 sides, - SInt32 w, SInt32 h, SInt32 jumpZoneSize) +void +setZone( + UInt32 sides, + SInt32 w, + SInt32 h, + SInt32 jumpZoneSize) { g_zoneSize = jumpZoneSize; g_zoneSides = sides; @@ -573,7 +621,9 @@ void setZone(UInt32 sides, restoreCursor(); } -void setRelay(void) +void +setRelay( + void) { g_relay = true; g_zoneSize = 0; diff --git a/server/CSynergyHook.h b/server/CSynergyHook.h index 4aefcafc..2d38d708 100644 --- a/server/CSynergyHook.h +++ b/server/CSynergyHook.h @@ -31,7 +31,7 @@ typedef void (*SetRelayFunc)(void); CSYNERGYHOOK_API int install(DWORD); CSYNERGYHOOK_API int uninstall(void); CSYNERGYHOOK_API void setZone(UInt32 sides, - SInt32 w, SInt32 h, SInt32 jumpZoneSize); + SInt32 w, SInt32 h, SInt32 jumpZoneSize); CSYNERGYHOOK_API void setRelay(void); } diff --git a/server/CXWindowsPrimaryScreen.cpp b/server/CXWindowsPrimaryScreen.cpp index 52297109..b175517c 100644 --- a/server/CXWindowsPrimaryScreen.cpp +++ b/server/CXWindowsPrimaryScreen.cpp @@ -1,11 +1,10 @@ #include "CXWindowsPrimaryScreen.h" +#include "CServer.h" #include "CXWindowsClipboard.h" #include "CXWindowsUtil.h" -#include "CServer.h" -#include "CStopwatch.h" #include "CThread.h" #include "CLog.h" -#include +#include "CStopwatch.h" #include #include #define XK_MISCELLANY @@ -16,9 +15,9 @@ // CXWindowsPrimaryScreen::CXWindowsPrimaryScreen() : - m_server(NULL), - m_active(false), - m_window(None) + m_server(NULL), + m_active(false), + m_window(None) { // do nothing } @@ -28,7 +27,8 @@ CXWindowsPrimaryScreen::~CXWindowsPrimaryScreen() assert(m_window == None); } -void CXWindowsPrimaryScreen::run() +void +CXWindowsPrimaryScreen::run() { for (;;) { // wait for and get the next event @@ -39,152 +39,163 @@ void CXWindowsPrimaryScreen::run() // handle event switch (xevent.type) { - case CreateNotify: { - // select events on new window - CDisplayLock display(this); - selectEvents(display, xevent.xcreatewindow.window); - break; - } - - case MappingNotify: { - // keyboard mapping changed - CDisplayLock display(this); - XRefreshKeyboardMapping(&xevent.xmapping); - updateModifierMap(display); - break; - } - - case KeyPress: { - log((CLOG_DEBUG1 "event: KeyPress code=%d, state=0x%04x", xevent.xkey.keycode, xevent.xkey.state)); - const KeyModifierMask mask = mapModifier(xevent.xkey.state); - const KeyID key = mapKey(&xevent.xkey); - if (key != kKeyNone) { - m_server->onKeyDown(key, mask); - if (key == XK_Caps_Lock && m_capsLockHalfDuplex) { - m_server->onKeyUp(key, mask | KeyModifierCapsLock); - } - else if (key == XK_Num_Lock && m_numLockHalfDuplex) { - m_server->onKeyUp(key, mask | KeyModifierNumLock); - } + case CreateNotify: + { + // select events on new window + CDisplayLock display(this); + selectEvents(display, xevent.xcreatewindow.window); } break; - } - case KeyRelease: { - const KeyModifierMask mask = mapModifier(xevent.xkey.state); - const KeyID key = mapKey(&xevent.xkey); - if (key != kKeyNone) { - // check if this is a key repeat by getting the next - // KeyPress event that has the same key and time as - // this release event, if any. first prepare the - // filter info. - CKeyEventInfo filter; - filter.m_event = KeyPress; - filter.m_window = xevent.xkey.window; - filter.m_time = xevent.xkey.time; - filter.m_keycode = xevent.xkey.keycode; - - // now check for event - XEvent xevent2; + case MappingNotify: + { + // keyboard mapping changed CDisplayLock display(this); - if (XCheckIfEvent(display, &xevent2, - &CXWindowsPrimaryScreen::findKeyEvent, - (XPointer)&filter) != True) { - // no press event follows so it's a plain release - log((CLOG_DEBUG1 "event: KeyRelease code=%d, state=0x%04x", xevent.xkey.keycode, xevent.xkey.state)); + XRefreshKeyboardMapping(&xevent.xmapping); + updateModifierMap(display); + } + break; + + case KeyPress: + { + log((CLOG_DEBUG1 "event: KeyPress code=%d, state=0x%04x", xevent.xkey.keycode, xevent.xkey.state)); + const KeyModifierMask mask = mapModifier(xevent.xkey.state); + const KeyID key = mapKey(&xevent.xkey); + if (key != kKeyNone) { + m_server->onKeyDown(key, mask); if (key == XK_Caps_Lock && m_capsLockHalfDuplex) { - m_server->onKeyDown(key, mask); + m_server->onKeyUp(key, mask | KeyModifierCapsLock); } else if (key == XK_Num_Lock && m_numLockHalfDuplex) { - m_server->onKeyDown(key, mask); + m_server->onKeyUp(key, mask | KeyModifierNumLock); } - m_server->onKeyUp(key, mask); + } + } + break; + + case KeyRelease: + { + const KeyModifierMask mask = mapModifier(xevent.xkey.state); + const KeyID key = mapKey(&xevent.xkey); + if (key != kKeyNone) { + // check if this is a key repeat by getting the next + // KeyPress event that has the same key and time as + // this release event, if any. first prepare the + // filter info. + CKeyEventInfo filter; + filter.m_event = KeyPress; + filter.m_window = xevent.xkey.window; + filter.m_time = xevent.xkey.time; + filter.m_keycode = xevent.xkey.keycode; + + // now check for event + XEvent xevent2; + CDisplayLock display(this); + if (XCheckIfEvent(display, &xevent2, + &CXWindowsPrimaryScreen::findKeyEvent, + (XPointer)&filter) != True) { + // no press event follows so it's a plain release + log((CLOG_DEBUG1 "event: KeyRelease code=%d, state=0x%04x", xevent.xkey.keycode, xevent.xkey.state)); + if (key == XK_Caps_Lock && m_capsLockHalfDuplex) { + m_server->onKeyDown(key, mask); + } + else if (key == XK_Num_Lock && m_numLockHalfDuplex) { + m_server->onKeyDown(key, mask); + } + m_server->onKeyUp(key, mask); + } + else { + // found a press event following so it's a repeat. + // we could attempt to count the already queued + // repeats but we'll just send a repeat of 1. + // note that we discard the press event. + log((CLOG_DEBUG1 "event: repeat code=%d, state=0x%04x", xevent.xkey.keycode, xevent.xkey.state)); + m_server->onKeyRepeat(key, mask, 1); + } + } + } + break; + + case ButtonPress: + { + log((CLOG_DEBUG1 "event: ButtonPress button=%d", xevent.xbutton.button)); + const ButtonID button = mapButton(xevent.xbutton.button); + if (button != kButtonNone) { + m_server->onMouseDown(button); + } + } + break; + + case ButtonRelease: + { + log((CLOG_DEBUG1 "event: ButtonRelease button=%d", xevent.xbutton.button)); + const ButtonID button = mapButton(xevent.xbutton.button); + if (button != kButtonNone) { + m_server->onMouseUp(button); + } + else if (xevent.xbutton.button == 4) { + // wheel forward (away from user) + m_server->onMouseWheel(120); + } + else if (xevent.xbutton.button == 5) { + // wheel backward (toward user) + m_server->onMouseWheel(-120); + } + } + break; + + case MotionNotify: + { + log((CLOG_DEBUG2 "event: MotionNotify %d,%d", xevent.xmotion.x_root, xevent.xmotion.y_root)); + SInt32 x, y; + if (!m_active) { + x = xevent.xmotion.x_root; + y = xevent.xmotion.y_root; + m_server->onMouseMovePrimary(x, y); } else { - // found a press event following so it's a repeat. - // we could attempt to count the already queued - // repeats but we'll just send a repeat of 1. - // note that we discard the press event. - log((CLOG_DEBUG1 "event: repeat code=%d, state=0x%04x", xevent.xkey.keycode, xevent.xkey.state)); - m_server->onKeyRepeat(key, mask, 1); + // FIXME -- slurp up all remaining motion events? + // probably not since keystrokes may go to wrong place. + + // get mouse deltas + { + CDisplayLock display(this); + Window root, window; + int xRoot, yRoot, xWindow, yWindow; + unsigned int mask; + if (!XQueryPointer(display, m_window, &root, &window, + &xRoot, &yRoot, &xWindow, &yWindow, &mask)) { + break; + } + + // compute position of center of window + SInt32 w, h; + getScreenSize(&w, &h); + x = xRoot - (w >> 1); + y = yRoot - (h >> 1); + + // warp mouse back to center + warpCursorNoLock(display, w >> 1, h >> 1); + } + + m_server->onMouseMoveSecondary(x, y); } } break; } - - case ButtonPress: { - log((CLOG_DEBUG1 "event: ButtonPress button=%d", xevent.xbutton.button)); - const ButtonID button = mapButton(xevent.xbutton.button); - if (button != kButtonNone) { - m_server->onMouseDown(button); - } - break; - } - - case ButtonRelease: { - log((CLOG_DEBUG1 "event: ButtonRelease button=%d", xevent.xbutton.button)); - const ButtonID button = mapButton(xevent.xbutton.button); - if (button != kButtonNone) { - m_server->onMouseUp(button); - } - else if (xevent.xbutton.button == 4) { - // wheel forward (away from user) - m_server->onMouseWheel(120); - } - else if (xevent.xbutton.button == 5) { - // wheel backward (toward user) - m_server->onMouseWheel(-120); - } - break; - } - - case MotionNotify: { - log((CLOG_DEBUG2 "event: MotionNotify %d,%d", xevent.xmotion.x_root, xevent.xmotion.y_root)); - SInt32 x, y; - if (!m_active) { - x = xevent.xmotion.x_root; - y = xevent.xmotion.y_root; - m_server->onMouseMovePrimary(x, y); - } - else { - // FIXME -- slurp up all remaining motion events? - // probably not since key strokes may go to wrong place. - - // get mouse deltas - { - CDisplayLock display(this); - Window root, window; - int xRoot, yRoot, xWindow, yWindow; - unsigned int mask; - if (!XQueryPointer(display, m_window, &root, &window, - &xRoot, &yRoot, &xWindow, &yWindow, &mask)) - break; - - // compute position of center of window - SInt32 w, h; - getScreenSize(&w, &h); - x = xRoot - (w >> 1); - y = yRoot - (h >> 1); - - // warp mouse back to center - warpCursorNoLock(display, w >> 1, h >> 1); - } - - m_server->onMouseMoveSecondary(x, y); - } - break; - } - } } } -void CXWindowsPrimaryScreen::stop() +void +CXWindowsPrimaryScreen::stop() { CDisplayLock display(this); doStop(); } -void CXWindowsPrimaryScreen::open(CServer* server) +void +CXWindowsPrimaryScreen::open( + CServer* server) { assert(m_server == NULL); assert(server != NULL); @@ -228,7 +239,8 @@ void CXWindowsPrimaryScreen::open(CServer* server) m_server->setInfo(w, h, getJumpZoneSize(), x, y); } -void CXWindowsPrimaryScreen::close() +void +CXWindowsPrimaryScreen::close() { assert(m_server != NULL); @@ -239,7 +251,10 @@ void CXWindowsPrimaryScreen::close() m_server = NULL; } -void CXWindowsPrimaryScreen::enter(SInt32 x, SInt32 y) +void +CXWindowsPrimaryScreen::enter( + SInt32 x, + SInt32 y) { log((CLOG_INFO "entering primary at %d,%d", x, y)); assert(m_active == true); @@ -268,7 +283,8 @@ void CXWindowsPrimaryScreen::enter(SInt32 x, SInt32 y) m_active = false; } -bool CXWindowsPrimaryScreen::leave() +bool +CXWindowsPrimaryScreen::leave() { log((CLOG_INFO "leaving primary")); assert(m_active == false); @@ -333,19 +349,26 @@ bool CXWindowsPrimaryScreen::leave() return true; } -void CXWindowsPrimaryScreen::onConfigure() +void +CXWindowsPrimaryScreen::onConfigure() { // do nothing } -void CXWindowsPrimaryScreen::warpCursor(SInt32 x, SInt32 y) +void +CXWindowsPrimaryScreen::warpCursor( + SInt32 x, + SInt32 y) { CDisplayLock display(this); warpCursorNoLock(display, x, y); } -void CXWindowsPrimaryScreen::warpCursorNoLock( - Display* display, SInt32 x, SInt32 y) +void +CXWindowsPrimaryScreen::warpCursorNoLock( + Display* display, + SInt32 x, + SInt32 y) { assert(display != NULL); assert(m_window != None); @@ -363,35 +386,45 @@ void CXWindowsPrimaryScreen::warpCursorNoLock( } } -void CXWindowsPrimaryScreen::setClipboard( - ClipboardID id, const IClipboard* clipboard) +void +CXWindowsPrimaryScreen::setClipboard( + ClipboardID id, + const IClipboard* clipboard) { setDisplayClipboard(id, clipboard); } -void CXWindowsPrimaryScreen::grabClipboard(ClipboardID id) +void +CXWindowsPrimaryScreen::grabClipboard( + ClipboardID id) { setDisplayClipboard(id, NULL); } -void CXWindowsPrimaryScreen::getSize( - SInt32* width, SInt32* height) const +void +CXWindowsPrimaryScreen::getSize( + SInt32* width, + SInt32* height) const { getScreenSize(width, height); } -SInt32 CXWindowsPrimaryScreen::getJumpZoneSize() const +SInt32 +CXWindowsPrimaryScreen::getJumpZoneSize() const { return 1; } -void CXWindowsPrimaryScreen::getClipboard( - ClipboardID id, IClipboard* clipboard) const +void +CXWindowsPrimaryScreen::getClipboard( + ClipboardID id, + IClipboard* clipboard) const { getDisplayClipboard(id, clipboard); } -KeyModifierMask CXWindowsPrimaryScreen::getToggleMask() const +KeyModifierMask +CXWindowsPrimaryScreen::getToggleMask() const { CDisplayLock display(this); @@ -417,7 +450,8 @@ KeyModifierMask CXWindowsPrimaryScreen::getToggleMask() const return mask; } -bool CXWindowsPrimaryScreen::isLockedToScreen() const +bool +CXWindowsPrimaryScreen::isLockedToScreen() const { CDisplayLock display(this); @@ -449,7 +483,9 @@ bool CXWindowsPrimaryScreen::isLockedToScreen() const return false; } -void CXWindowsPrimaryScreen::onOpenDisplay(Display* display) +void +CXWindowsPrimaryScreen::onOpenDisplay( + Display* display) { assert(m_window == None); @@ -479,14 +515,17 @@ void CXWindowsPrimaryScreen::onOpenDisplay(Display* display) selectEvents(display, getRoot()); } -CXWindowsClipboard* CXWindowsPrimaryScreen::createClipboard( - ClipboardID id) +CXWindowsClipboard* +CXWindowsPrimaryScreen::createClipboard( + ClipboardID id) { CDisplayLock display(this); return new CXWindowsClipboard(display, m_window, id); } -void CXWindowsPrimaryScreen::onCloseDisplay(Display* display) +void +CXWindowsPrimaryScreen::onCloseDisplay( + Display* display) { assert(m_window != None); @@ -497,7 +536,8 @@ void CXWindowsPrimaryScreen::onCloseDisplay(Display* display) m_window = None; } -void CXWindowsPrimaryScreen::onUnexpectedClose() +void +CXWindowsPrimaryScreen::onUnexpectedClose() { // tell server to shutdown if (m_server != NULL) { @@ -505,15 +545,18 @@ void CXWindowsPrimaryScreen::onUnexpectedClose() } } -void CXWindowsPrimaryScreen::onLostClipboard( - ClipboardID id) +void +CXWindowsPrimaryScreen::onLostClipboard( + ClipboardID id) { // tell server that the clipboard was grabbed locally m_server->grabClipboard(id); } -void CXWindowsPrimaryScreen::selectEvents( - Display* display, Window w) const +void +CXWindowsPrimaryScreen::selectEvents( + Display* display, + Window w) const { // ignore errors while we adjust event masks CXWindowsUtil::CErrorLock lock; @@ -522,8 +565,10 @@ void CXWindowsPrimaryScreen::selectEvents( doSelectEvents(display, w); } -void CXWindowsPrimaryScreen::doSelectEvents( - Display* display, Window w) const +void +CXWindowsPrimaryScreen::doSelectEvents( + Display* display, + Window w) const { // we want to track the mouse everywhere on the display. to achieve // that we select PointerMotionMask on every window. we also select @@ -531,8 +576,9 @@ void CXWindowsPrimaryScreen::doSelectEvents( // select events on new windows too. // we don't want to adjust our grab window - if (w == m_window) + if (w == m_window) { return; + } // select events of interest XSelectInput(display, w, PointerMotionMask | SubstructureNotifyMask); @@ -541,14 +587,16 @@ void CXWindowsPrimaryScreen::doSelectEvents( Window rw, pw, *cw; unsigned int nc; if (XQueryTree(display, w, &rw, &pw, &cw, &nc)) { - for (unsigned int i = 0; i < nc; ++i) + for (unsigned int i = 0; i < nc; ++i) { doSelectEvents(display, cw[i]); + } XFree(cw); } } -KeyModifierMask CXWindowsPrimaryScreen::mapModifier( - unsigned int state) const +KeyModifierMask +CXWindowsPrimaryScreen::mapModifier( + unsigned int state) const { // FIXME -- should be configurable KeyModifierMask mask = 0; @@ -569,7 +617,9 @@ KeyModifierMask CXWindowsPrimaryScreen::mapModifier( return mask; } -KeyID CXWindowsPrimaryScreen::mapKey(XKeyEvent* event) const +KeyID +CXWindowsPrimaryScreen::mapKey( + XKeyEvent* event) const { KeySym keysym; char dummy[1]; @@ -579,18 +629,22 @@ KeyID CXWindowsPrimaryScreen::mapKey(XKeyEvent* event) const return static_cast(keysym); } -ButtonID CXWindowsPrimaryScreen::mapButton( - unsigned int button) const +ButtonID +CXWindowsPrimaryScreen::mapButton( + unsigned int button) const { // FIXME -- should use button mapping? - if (button >= 1 && button <= 3) + if (button >= 1 && button <= 3) { return static_cast(button); - else + } + else { return kButtonNone; + } } -void CXWindowsPrimaryScreen::updateModifierMap( - Display* display) +void +CXWindowsPrimaryScreen::updateModifierMap( + Display* display) { // get modifier map from server XModifierKeymap* keymap = XGetModifierMapping(display); @@ -624,8 +678,11 @@ void CXWindowsPrimaryScreen::updateModifierMap( XFreeModifiermap(keymap); } -Bool CXWindowsPrimaryScreen::findKeyEvent( - Display*, XEvent* xevent, XPointer arg) +Bool +CXWindowsPrimaryScreen::findKeyEvent( + Display*, + XEvent* xevent, + XPointer arg) { CKeyEventInfo* filter = reinterpret_cast(arg); return (xevent->type == filter->m_event && diff --git a/server/CXWindowsPrimaryScreen.h b/server/CXWindowsPrimaryScreen.h index aa30c327..fe4bbc87 100644 --- a/server/CXWindowsPrimaryScreen.h +++ b/server/CXWindowsPrimaryScreen.h @@ -1,10 +1,9 @@ #ifndef CXWINDOWSPRIMARYSCREEN_H #define CXWINDOWSPRIMARYSCREEN_H -#include "KeyTypes.h" -#include "MouseTypes.h" #include "CXWindowsScreen.h" #include "IPrimaryScreen.h" +#include "MouseTypes.h" class CXWindowsPrimaryScreen : public CXWindowsScreen, public IPrimaryScreen { public: @@ -41,7 +40,7 @@ private: void selectEvents(Display*, Window) const; void doSelectEvents(Display*, Window) const; void warpCursorNoLock(Display*, - SInt32 xAbsolute, SInt32 yAbsolute); + SInt32 xAbsolute, SInt32 yAbsolute); KeyModifierMask mapModifier(unsigned int state) const; KeyID mapKey(XKeyEvent*) const; diff --git a/server/server.cpp b/server/server.cpp index 0b671e0a..aca20d12 100644 --- a/server/server.cpp +++ b/server/server.cpp @@ -1,16 +1,17 @@ #include "CServer.h" #include "CConfig.h" -#include "CLog.h" -#include "CLock.h" -#include "CMutex.h" -#include "CNetwork.h" #include "CPlatform.h" -#include "CThread.h" -#include "XThread.h" #include "ProtocolTypes.h" #include "Version.h" +#include "CNetwork.h" +#include "XSocket.h" +#include "CLock.h" +#include "CMutex.h" +#include "CThread.h" +#include "XThread.h" +#include "CLog.h" #include "stdfstream.h" -#include +#include // platform dependent name of a daemon #if defined(CONFIG_PLATFORM_WIN32) @@ -51,7 +52,10 @@ static CConfig s_config; static CMutex* s_logMutex = NULL; -static void logLock(bool lock) +static +void +logLock( + bool lock) { assert(s_logMutex != NULL); @@ -70,7 +74,10 @@ static void logLock(bool lock) static CServer* s_server = NULL; -static int realMain(CMutex* mutex) +static +int +realMain( + CMutex* mutex) { // s_serverLock should have mutex locked on entry @@ -153,14 +160,18 @@ static int realMain(CMutex* mutex) return 0; } -static int restartMain() +static +int +restartMain() { return realMain(NULL); } // invoke realMain and wait for it. if s_restartable then keep // restarting realMain until it returns a terminate code. -static int restartableMain() +static +int +restartableMain() { if (s_restartable) { CPlatform platform; @@ -180,7 +191,9 @@ static int restartableMain() static void (*bye)(int) = &exit; -static void version() +static +void +version() { log((CLOG_PRINT "%s %d.%d.%d, protocol version %d.%d\n" @@ -194,7 +207,9 @@ static void version() kCopyright)); } -static void help() +static +void +help() { CPlatform platform; @@ -256,11 +271,14 @@ static void help() CONFIG_NAME).c_str())); } -static bool isArg(int argi, - int argc, const char** argv, - const char* name1, - const char* name2, - int minRequiredParameters = 0) +static +bool +isArg(int argi, + int argc, + const char** argv, + const char* name1, + const char* name2, + int minRequiredParameters = 0) { if ((name1 != NULL && strcmp(argv[argi], name1) == 0) || (name2 != NULL && strcmp(argv[argi], name2) == 0)) { @@ -277,7 +295,11 @@ static bool isArg(int argi, return false; } -static void parse(int argc, const char** argv) +static +void +parse( + int argc, + const char** argv) { assert(pname != NULL); assert(argv != NULL); @@ -442,7 +464,11 @@ static void parse(int argc, const char** argv) } } -static bool loadConfig(const char* pathname, bool require) +static +bool +loadConfig( + const char* pathname, + bool require) { assert(pathname != NULL); @@ -471,7 +497,9 @@ static bool loadConfig(const char* pathname, bool require) return false; } -static void loadConfig() +static +void +loadConfig() { // load the config file, if specified if (s_configFile != NULL) { @@ -512,7 +540,11 @@ static void loadConfig() #include "CMSWindowsScreen.h" -static bool logMessageBox(int priority, const char* msg) +static +bool +logMessageBox( + int priority, + const char* msg) { if (priority <= CLog::kFATAL) { MessageBox(NULL, msg, pname, MB_OK | MB_ICONWARNING); @@ -523,18 +555,26 @@ static bool logMessageBox(int priority, const char* msg) } } -static void byeThrow(int x) +static +void +byeThrow(int x) { throw CWin32Platform::CDaemonFailed(x); } -static void daemonStop(void) +static +void +daemonStop(void) { s_server->quit(); } -static int daemonStartup(IPlatform* iplatform, - int argc, const char** argv) +static +int +daemonStartup( + IPlatform* iplatform, + int argc, + const char** argv) { // get platform pointer CWin32Platform* platform = static_cast(iplatform); @@ -558,19 +598,30 @@ static int daemonStartup(IPlatform* iplatform, return platform->runDaemon(realMain, daemonStop); } -static int daemonStartup95(IPlatform*, int, const char**) +static +int +daemonStartup95( + IPlatform*, + int, + const char**) { return realMain(NULL); } -static bool logDiscard(int, const char*) +static +bool +logDiscard( + int, + const char*) { return true; } static bool s_die = false; -static void checkParse(int e) +static +void +checkParse(int e) { // anything over 1 means invalid args. 1 means missing args. // 0 means graceful exit. we plan to exit for anything but @@ -580,7 +631,12 @@ static void checkParse(int e) throw s_die; } -int WINAPI WinMain(HINSTANCE instance, HINSTANCE, LPSTR, int) +int WINAPI +WinMain( + HINSTANCE instance, + HINSTANCE, + LPSTR, + int) { CPlatform platform; @@ -703,12 +759,20 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE, LPSTR, int) #elif defined(CONFIG_PLATFORM_UNIX) -static int daemonStartup(IPlatform*, int, const char**) +static +int +daemonStartup( + IPlatform*, + int, + const char**) { return restartableMain(); } -int main(int argc, char** argv) +int +main( + int argc, + char** argv) { CPlatform platform; diff --git a/synergy/CClipboard.cpp b/synergy/CClipboard.cpp index f60c5a76..d5ec7018 100644 --- a/synergy/CClipboard.cpp +++ b/synergy/CClipboard.cpp @@ -1,11 +1,12 @@ #include "CClipboard.h" -#include // // CClipboard // -CClipboard::CClipboard() : m_open(false), m_owner(false) +CClipboard::CClipboard() : + m_open(false), + m_owner(false) { open(0); empty(); @@ -17,7 +18,8 @@ CClipboard::~CClipboard() // do nothing } -bool CClipboard::empty() +bool +CClipboard::empty() { assert(m_open); @@ -36,7 +38,10 @@ bool CClipboard::empty() return true; } -void CClipboard::add(EFormat format, const CString& data) +void +CClipboard::add( + EFormat format, + const CString& data) { assert(m_open); assert(m_owner); @@ -45,7 +50,9 @@ void CClipboard::add(EFormat format, const CString& data) m_added[format] = true; } -bool CClipboard::open(Time time) const +bool +CClipboard::open( + Time time) const { assert(!m_open); @@ -55,31 +62,40 @@ bool CClipboard::open(Time time) const return true; } -void CClipboard::close() const +void +CClipboard::close() const { assert(m_open); m_open = false; } -CClipboard::Time CClipboard::getTime() const +CClipboard::Time +CClipboard::getTime() const { return m_timeOwned; } -bool CClipboard::has(EFormat format) const +bool +CClipboard::has( + EFormat format) const { assert(m_open); return m_added[format]; } -CString CClipboard::get(EFormat format) const +CString +CClipboard::get( + EFormat format) const { assert(m_open); return m_data[format]; } -bool CClipboard::copy(IClipboard* dst, const IClipboard* src) +bool +CClipboard::copy( + IClipboard* dst, + const IClipboard* src) { assert(dst != NULL); assert(src != NULL); @@ -87,8 +103,11 @@ bool CClipboard::copy(IClipboard* dst, const IClipboard* src) return copy(dst, src, src->getTime()); } -bool CClipboard::copy(IClipboard* dst, - const IClipboard* src, Time time) +bool +CClipboard::copy( + IClipboard* dst, + const IClipboard* src, + Time time) { assert(dst != NULL); assert(src != NULL); @@ -114,7 +133,10 @@ bool CClipboard::copy(IClipboard* dst, return success; } -void CClipboard::unmarshall(const CString& data, Time time) +void +CClipboard::unmarshall( + const CString& data, + Time time) { const char* index = data.data(); @@ -146,7 +168,8 @@ void CClipboard::unmarshall(const CString& data, Time time) close(); } -CString CClipboard::marshall() const +CString +CClipboard::marshall() const { CString data; @@ -177,7 +200,9 @@ CString CClipboard::marshall() const return data; } -UInt32 CClipboard::readUInt32(const char* buf) const +UInt32 +CClipboard::readUInt32( + const char* buf) const { const unsigned char* ubuf = reinterpret_cast(buf); return (static_cast(ubuf[0]) << 24) | @@ -186,7 +211,10 @@ UInt32 CClipboard::readUInt32(const char* buf) const static_cast(ubuf[3]); } -void CClipboard::writeUInt32(CString* buf, UInt32 v) const +void +CClipboard::writeUInt32( + CString* buf, + UInt32 v) const { *buf += static_cast((v >> 24) & 0xff); *buf += static_cast((v >> 16) & 0xff); diff --git a/synergy/CClipboard.h b/synergy/CClipboard.h index 80fdec04..fea2b1d2 100644 --- a/synergy/CClipboard.h +++ b/synergy/CClipboard.h @@ -6,7 +6,6 @@ // #include "IClipboard.h" -#include "CString.h" class CClipboard : public IClipboard { public: @@ -23,6 +22,14 @@ public: // marshall clipboard data CString marshall() const; + // transfer all the data in one clipboard to another. the + // clipboards can be of any concrete clipboard type (and + // they don't have to be the same type). this also sets + // the timestamp to time, if provided, or the time in src. + // returns true iff the copy succeeded. + static bool copy(IClipboard* dst, const IClipboard* src); + static bool copy(IClipboard* dst, const IClipboard* src, Time); + // IClipboard overrides virtual bool empty(); virtual void add(EFormat, const CString& data); @@ -32,16 +39,6 @@ public: virtual bool has(EFormat) const; virtual CString get(EFormat) const; - // accessors - - // transfer all the data in one clipboard to another. the - // clipboards can be of any concrete clipboard type (and - // they don't have to be the same type). this also sets - // the timestamp to time, if provided, or the time in src. - // returns true iff the copy succeeded. - static bool copy(IClipboard* dst, const IClipboard* src); - static bool copy(IClipboard* dst, const IClipboard* src, Time); - private: UInt32 readUInt32(const char*) const; void writeUInt32(CString*, UInt32) const; diff --git a/synergy/CInputPacketStream.cpp b/synergy/CInputPacketStream.cpp index 607ac4f5..ce5b74cf 100644 --- a/synergy/CInputPacketStream.cpp +++ b/synergy/CInputPacketStream.cpp @@ -1,16 +1,17 @@ #include "CInputPacketStream.h" #include "CLock.h" -#include // // CInputPacketStream // -CInputPacketStream::CInputPacketStream(IInputStream* stream, bool adopt) : - CInputStreamFilter(stream, adopt), - m_mutex(), - m_size(0), - m_buffer(&m_mutex, NULL) +CInputPacketStream::CInputPacketStream( + IInputStream* stream, + bool adopt) : + CInputStreamFilter(stream, adopt), + m_mutex(), + m_size(0), + m_buffer(&m_mutex, NULL) { // do nothing } @@ -20,13 +21,16 @@ CInputPacketStream::~CInputPacketStream() // do nothing } -void CInputPacketStream::close() +void +CInputPacketStream::close() { getStream()->close(); } -UInt32 CInputPacketStream::read( - void* buffer, UInt32 n) +UInt32 +CInputPacketStream::read( + void* buffer, + UInt32 n) { CLock lock(&m_mutex); @@ -50,13 +54,15 @@ UInt32 CInputPacketStream::read( return n; } -UInt32 CInputPacketStream::getSize() const +UInt32 +CInputPacketStream::getSize() const { CLock lock(&m_mutex); return getSizeNoLock(); } -UInt32 CInputPacketStream::getSizeNoLock() const +UInt32 +CInputPacketStream::getSizeNoLock() const { while (!hasFullMessage()) { // read more data @@ -76,7 +82,8 @@ UInt32 CInputPacketStream::getSizeNoLock() const return m_size; } -bool CInputPacketStream::hasFullMessage() const +bool +CInputPacketStream::hasFullMessage() const { // get payload length if we don't have it yet if (m_size == 0) { @@ -106,4 +113,3 @@ bool CInputPacketStream::hasFullMessage() const // the buffer return (m_buffer.getSizeNoLock() >= m_size); } - diff --git a/synergy/COutputPacketStream.cpp b/synergy/COutputPacketStream.cpp index e9ffc68f..5e90f116 100644 --- a/synergy/COutputPacketStream.cpp +++ b/synergy/COutputPacketStream.cpp @@ -4,8 +4,10 @@ // COuputPacketStream // -COutputPacketStream::COutputPacketStream(IOutputStream* stream, bool adopt) : - COutputStreamFilter(stream, adopt) +COutputPacketStream::COutputPacketStream( + IOutputStream* stream, + bool adopt) : + COutputStreamFilter(stream, adopt) { // do nothing } @@ -15,13 +17,16 @@ COutputPacketStream::~COutputPacketStream() // do nothing } -void COutputPacketStream::close() +void +COutputPacketStream::close() { getStream()->close(); } -UInt32 COutputPacketStream::write( - const void* buffer, UInt32 count) +UInt32 +COutputPacketStream::write( + const void* buffer, + UInt32 count) { // write the length of the payload UInt8 length[4]; @@ -49,7 +54,8 @@ UInt32 COutputPacketStream::write( return count; } -void COutputPacketStream::flush() +void +COutputPacketStream::flush() { getStream()->flush(); } diff --git a/synergy/CProtocolUtil.cpp b/synergy/CProtocolUtil.cpp index fb0543a7..246f484d 100644 --- a/synergy/CProtocolUtil.cpp +++ b/synergy/CProtocolUtil.cpp @@ -2,16 +2,18 @@ #include "IInputStream.h" #include "IOutputStream.h" #include "CLog.h" -#include -#include -#include +#include +#include // // CProtocolUtil // -void CProtocolUtil::writef(IOutputStream* stream, - const char* fmt, ...) +void +CProtocolUtil::writef( + IOutputStream* stream, + const char* fmt, + ...) { assert(stream != NULL); assert(fmt != NULL); @@ -47,8 +49,11 @@ void CProtocolUtil::writef(IOutputStream* stream, delete[] buffer; } -void CProtocolUtil::readf(IInputStream* stream, - const char* fmt, ...) +void +CProtocolUtil::readf( + IInputStream* stream, + const char* fmt, + ...) { assert(stream != NULL); assert(fmt != NULL); @@ -179,8 +184,10 @@ void CProtocolUtil::readf(IInputStream* stream, va_end(args); } -UInt32 CProtocolUtil::getLength( - const char* fmt, va_list args) +UInt32 +CProtocolUtil::getLength( + const char* fmt, + va_list args) { UInt32 n = 0; while (*fmt) { @@ -228,8 +235,11 @@ UInt32 CProtocolUtil::getLength( return n; } -void CProtocolUtil::writef(void* buffer, - const char* fmt, va_list args) +void +CProtocolUtil::writef( + void* buffer, + const char* fmt, + va_list args) { UInt8* dst = reinterpret_cast(buffer); @@ -315,7 +325,9 @@ void CProtocolUtil::writef(void* buffer, } } -UInt32 CProtocolUtil::eatLength(const char** pfmt) +UInt32 +CProtocolUtil::eatLength( + const char** pfmt) { const char* fmt = *pfmt; UInt32 n = 0; @@ -339,8 +351,11 @@ UInt32 CProtocolUtil::eatLength(const char** pfmt) } } -void CProtocolUtil::read(IInputStream* stream, - void* vbuffer, UInt32 count) +void +CProtocolUtil::read( + IInputStream* stream, + void* vbuffer, + UInt32 count) { assert(stream != NULL); assert(vbuffer != NULL); @@ -367,7 +382,8 @@ void CProtocolUtil::read(IInputStream* stream, // XIOReadMismatch // -CString XIOReadMismatch::getWhat() const throw() +CString +XIOReadMismatch::getWhat() const throw() { return "CProtocolUtil::readf() mismatch"; } diff --git a/synergy/CProtocolUtil.h b/synergy/CProtocolUtil.h index 63a4376b..d6d1bce7 100644 --- a/synergy/CProtocolUtil.h +++ b/synergy/CProtocolUtil.h @@ -3,7 +3,7 @@ #include "BasicTypes.h" #include "XIO.h" -#include +#include class IInputStream; class IOutputStream; @@ -23,7 +23,7 @@ public: // %s -- converts CString* to stream of bytes // %S -- converts integer N and const UInt8* to stream of N bytes static void writef(IOutputStream*, - const char* fmt, ...); + const char* fmt, ...); // read formatted binary data from a buffer. this performs the // reverse operation of writef(). @@ -35,7 +35,7 @@ public: // %4i -- reads an NBO 4 byte integer; arg is SInt32* or UInt32* // %s -- reads bytes; argument must be a CString*, *not* a char* static void readf(IInputStream*, - const char* fmt, ...); + const char* fmt, ...); private: static UInt32 getLength(const char* fmt, va_list); diff --git a/synergy/CTCPSocketFactory.cpp b/synergy/CTCPSocketFactory.cpp index 7b10ff8d..5c5da342 100644 --- a/synergy/CTCPSocketFactory.cpp +++ b/synergy/CTCPSocketFactory.cpp @@ -16,12 +16,14 @@ CTCPSocketFactory::~CTCPSocketFactory() // do nothing } -ISocket* CTCPSocketFactory::create() const +ISocket* +CTCPSocketFactory::create() const { return new CTCPSocket; } -IListenSocket* CTCPSocketFactory::createListen() const +IListenSocket* +CTCPSocketFactory::createListen() const { return new CTCPListenSocket; } diff --git a/synergy/IClipboard.h b/synergy/IClipboard.h index 43632f02..66e35d2a 100644 --- a/synergy/IClipboard.h +++ b/synergy/IClipboard.h @@ -2,10 +2,9 @@ #define ICLIPBOARD_H #include "IInterface.h" +#include "CString.h" #include "BasicTypes.h" -class CString; - class IClipboard : public IInterface { public: // timestamp type. timestamps are in milliseconds from some diff --git a/synergy/IPrimaryScreen.h b/synergy/IPrimaryScreen.h index fbe00b46..c88207d5 100644 --- a/synergy/IPrimaryScreen.h +++ b/synergy/IPrimaryScreen.h @@ -2,7 +2,6 @@ #define IPRIMARYSCREEN_H #include "IInterface.h" -#include "BasicTypes.h" #include "KeyTypes.h" #include "ClipboardTypes.h" diff --git a/synergy/ISecondaryScreen.h b/synergy/ISecondaryScreen.h index c5bd736e..be709890 100644 --- a/synergy/ISecondaryScreen.h +++ b/synergy/ISecondaryScreen.h @@ -2,7 +2,6 @@ #define ISECONDARYSCREEN_H #include "IInterface.h" -#include "BasicTypes.h" #include "ClipboardTypes.h" #include "KeyTypes.h" #include "MouseTypes.h" @@ -35,7 +34,7 @@ public: // the cursor to the given coordinates and unhide it. prepare to // simulate input events. virtual void enter(SInt32 xAbsolute, SInt32 yAbsolute, - KeyModifierMask mask) = 0; + KeyModifierMask mask) = 0; // called when the user navigates off the secondary screen. clean // up input event simulation and hide the cursor. diff --git a/synergy/IServerProtocol.h b/synergy/IServerProtocol.h index ecddeeda..e329d0a4 100644 --- a/synergy/IServerProtocol.h +++ b/synergy/IServerProtocol.h @@ -1,12 +1,11 @@ #ifndef ISERVERPROTOCOL_H #define ISERVERPROTOCOL_H +#include "IInterface.h" #include "ClipboardTypes.h" #include "KeyTypes.h" #include "MouseTypes.h" -#include "IInterface.h" -#include "XSynergy.h" -#include "XIO.h" +#include "CString.h" class IClipboard; @@ -25,7 +24,7 @@ public: // send various messages to client virtual void sendClose() = 0; virtual void sendEnter(SInt32 xAbs, SInt32 yAbs, - UInt32 seqNum, KeyModifierMask mask) = 0; + UInt32 seqNum, KeyModifierMask mask) = 0; virtual void sendLeave() = 0; virtual void sendClipboard(ClipboardID, const CString&) = 0; virtual void sendGrabClipboard(ClipboardID) = 0; diff --git a/synergy/ISocketFactory.h b/synergy/ISocketFactory.h index 287e4302..9d0f1104 100644 --- a/synergy/ISocketFactory.h +++ b/synergy/ISocketFactory.h @@ -2,7 +2,6 @@ #define ISOCKETFACTORY_H #include "IInterface.h" -#include "XSocket.h" class ISocket; class IListenSocket; diff --git a/synergy/XScreen.cpp b/synergy/XScreen.cpp index 4466525f..2354b04c 100644 --- a/synergy/XScreen.cpp +++ b/synergy/XScreen.cpp @@ -4,7 +4,8 @@ // XScreenOpenFailure // -CString XScreenOpenFailure::getWhat() const throw() +CString +XScreenOpenFailure::getWhat() const throw() { return "XScreenOpenFailure"; } diff --git a/synergy/XSynergy.cpp b/synergy/XSynergy.cpp index 94159f9a..b40e7fb3 100644 --- a/synergy/XSynergy.cpp +++ b/synergy/XSynergy.cpp @@ -4,7 +4,8 @@ // XBadClient // -CString XBadClient::getWhat() const throw() +CString +XBadClient::getWhat() const throw() { return "XBadClient"; } @@ -14,24 +15,29 @@ CString XBadClient::getWhat() const throw() // XIncompatibleClient // -XIncompatibleClient::XIncompatibleClient(int major, int minor) : - m_major(major), - m_minor(minor) +XIncompatibleClient::XIncompatibleClient( + int major, + int minor) : + m_major(major), + m_minor(minor) { // do nothing } -int XIncompatibleClient::getMajor() const throw() +int +XIncompatibleClient::getMajor() const throw() { return m_major; } -int XIncompatibleClient::getMinor() const throw() +int +XIncompatibleClient::getMinor() const throw() { return m_minor; } -CString XIncompatibleClient::getWhat() const throw() +CString +XIncompatibleClient::getWhat() const throw() { return "XIncompatibleClient"; } @@ -41,17 +47,21 @@ CString XIncompatibleClient::getWhat() const throw() // XDuplicateClient // -XDuplicateClient::XDuplicateClient(const CString& name) : m_name(name) +XDuplicateClient::XDuplicateClient( + const CString& name) : + m_name(name) { // do nothing } -const CString& XDuplicateClient::getName() const throw() +const CString& +XDuplicateClient::getName() const throw() { return m_name; } -CString XDuplicateClient::getWhat() const throw() +CString +XDuplicateClient::getWhat() const throw() { return "XDuplicateClient"; } @@ -61,17 +71,21 @@ CString XDuplicateClient::getWhat() const throw() // XUnknownClient // -XUnknownClient::XUnknownClient(const CString& name) : m_name(name) +XUnknownClient::XUnknownClient( + const CString& name) : + m_name(name) { // do nothing } -const CString& XUnknownClient::getName() const throw() +const CString& +XUnknownClient::getName() const throw() { return m_name; } -CString XUnknownClient::getWhat() const throw() +CString +XUnknownClient::getWhat() const throw() { return "XUnknownClient"; }