Changeset 2752

Timestamp:

Jul 29, 2006, 6:43:07 AM (19 years ago)

Author:

bird

Message:

Two classes (CPMScreen and CPMKeyState) + the hook dll left (and debugging of course).

Location:

trunk/synergy

Files:

• Makefile.kmk (added)
• cmd/Makefile.kmk (added)
• cmd/synergyc/CPMClientTaskBarReceiver.cpp (copied) (copied from trunk/synergy/cmd/synergyc/COSXClientTaskBarReceiver.cpp ) (7 diffs)
• cmd/synergyc/CPMClientTaskBarReceiver.h (copied) (copied from trunk/synergy/cmd/synergyc/COSXClientTaskBarReceiver.h ) (4 diffs)
• cmd/synergyc/Makefile.kmk (added)
• cmd/synergyc/synergyc.cpp (modified) (3 diffs)
• cmd/synergys/CPMServerTaskBarReceiver.cpp (copied) (copied from trunk/synergy/cmd/synergys/COSXServerTaskBarReceiver.cpp ) (7 diffs)
• cmd/synergys/CPMServerTaskBarReceiver.h (copied) (copied from trunk/synergy/cmd/synergys/COSXServerTaskBarReceiver.h ) (3 diffs)
• cmd/synergys/Makefile.kmk (added)
• cmd/synergys/synergys.cpp (modified) (3 diffs)
• lib/Makefile.kmk (added)
• lib/arch/CArch.cpp (modified) (2 diffs)
• lib/arch/CArchMultithreadOS2.cpp (added)
• lib/arch/CArchMultithreadOS2.h (added)
• lib/arch/CArchMultithreadPosix.h (modified) (2 diffs)
• lib/arch/CArchTaskBarOS2.cpp (added)
• lib/arch/CArchTaskBarOS2.h (added)
• lib/arch/Makefile.kmk (added)
• lib/base/Makefile.kmk (added)
• lib/client/Makefile.kmk (added)
• lib/common/common.h (modified) (1 diff)
• lib/io/Makefile.kmk (added)
• lib/mt/Makefile.kmk (added)
• lib/net/Makefile.kmk (added)
• lib/platform/CPMClipboard.cpp (copied) (copied from trunk/synergy/lib/platform/CMSWindowsClipboard.cpp ) (12 diffs)
• lib/platform/CPMClipboard.h (copied) (copied from trunk/synergy/lib/platform/CMSWindowsClipboard.h ) (5 diffs)
• lib/platform/CPMClipboardAnyTextConverter.cpp (copied) (copied from trunk/synergy/lib/platform/CMSWindowsClipboardAnyTextConverter.cpp ) (5 diffs)
• lib/platform/CPMClipboardAnyTextConverter.h (copied) (copied from trunk/synergy/lib/platform/CMSWindowsClipboardAnyTextConverter.h ) (3 diffs)
• lib/platform/CPMClipboardBitmapConverter.cpp (copied) (copied from trunk/synergy/lib/platform/CMSWindowsClipboardBitmapConverter.cpp ) (5 diffs)
• lib/platform/CPMClipboardBitmapConverter.h (copied) (copied from trunk/synergy/lib/platform/CMSWindowsClipboardBitmapConverter.h ) (2 diffs)
• lib/platform/CPMClipboardHTMLConverter.cpp (copied) (copied from trunk/synergy/lib/platform/CMSWindowsClipboardHTMLConverter.cpp ) (6 diffs)
• lib/platform/CPMClipboardHTMLConverter.h (copied) (copied from trunk/synergy/lib/platform/CMSWindowsClipboardHTMLConverter.h ) (3 diffs)
• lib/platform/CPMClipboardTextConverter.cpp (copied) (copied from trunk/synergy/lib/platform/CMSWindowsClipboardTextConverter.cpp ) (4 diffs)
• lib/platform/CPMClipboardTextConverter.h (copied) (copied from trunk/synergy/lib/platform/CMSWindowsClipboardTextConverter.h ) (2 diffs)
• lib/platform/CPMEventQueueBuffer.cpp (copied) (copied from trunk/synergy/lib/platform/CMSWindowsEventQueueBuffer.cpp ) (4 diffs)
• lib/platform/CPMEventQueueBuffer.h (copied) (copied from trunk/synergy/lib/platform/CMSWindowsEventQueueBuffer.h ) (3 diffs)
• lib/platform/CPMKeyState.cpp (copied) (copied from trunk/synergy/lib/platform/CMSWindowsKeyState.cpp ) (31 diffs)
• lib/platform/CPMKeyState.h (copied) (copied from trunk/synergy/lib/platform/CMSWindowsKeyState.h ) (12 diffs)
• lib/platform/CPMScreen.cpp (copied) (copied from trunk/synergy/lib/platform/CMSWindowsScreen.cpp ) (75 diffs)
• lib/platform/CPMScreen.h (copied) (copied from trunk/synergy/lib/platform/CMSWindowsScreen.h ) (12 diffs)
• lib/platform/CPMScreenSaver.cpp (copied) (copied from trunk/synergy/lib/platform/CMSWindowsScreenSaver.cpp ) (2 diffs)
• lib/platform/CPMScreenSaver.h (copied) (copied from trunk/synergy/lib/platform/CMSWindowsScreenSaver.h ) (3 diffs)
• lib/platform/CPMSynergyHook.cpp (copied) (copied from trunk/synergy/lib/platform/CSynergyHook.cpp )
• lib/platform/CPMSynergyHook.h (copied) (copied from trunk/synergy/lib/platform/CSynergyHook.h ) (4 diffs)
• lib/platform/CPMUtil.cpp (copied) (copied from trunk/synergy/lib/platform/CMSWindowsUtil.cpp ) (3 diffs)
• lib/platform/CPMUtil.h (copied) (copied from trunk/synergy/lib/platform/CMSWindowsUtil.h ) (4 diffs)
• lib/platform/Makefile.kmk (added)
• lib/server/Makefile.kmk (added)
• lib/synergy/Makefile.kmk (added)

trunk/synergy/cmd/synergyc/CPMClientTaskBarReceiver.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "COSXClientTaskBarReceiver.h"
+#include "CPMClientTaskBarReceiver.h"
 #include "CArch.h"
 
 //
-// COSXClientTaskBarReceiver
+// CPMClientTaskBarReceiver
 //
 
-COSXClientTaskBarReceiver::COSXClientTaskBarReceiver(
+CPMClientTaskBarReceiver::CPMClientTaskBarReceiver(
                                 const CBufferedLogOutputter*)
 {
@@ -27 +28 @@
 }
 
-COSXClientTaskBarReceiver::~COSXClientTaskBarReceiver()
+CPMClientTaskBarReceiver::~CPMClientTaskBarReceiver()
 {
         ARCH->removeReceiver(this);
@@ -33 +34 @@
 
 void
-COSXClientTaskBarReceiver::showStatus()
+CPMClientTaskBarReceiver::showStatus()
 {
         // do nothing
@@ -39 +40 @@
 
 void
-COSXClientTaskBarReceiver::runMenu(int, int)
+CPMClientTaskBarReceiver::runMenu(int, int)
 {
         // do nothing
@@ -45 +46 @@
 
 void
-COSXClientTaskBarReceiver::primaryAction()
+CPMClientTaskBarReceiver::primaryAction()
 {
         // do nothing
@@ -51 +52 @@
 
 const IArchTaskBarReceiver::Icon
-COSXClientTaskBarReceiver::getIcon() const
+CPMClientTaskBarReceiver::getIcon() const
 {
         return NULL;
 }
+

trunk/synergy/cmd/synergyc/CPMClientTaskBarReceiver.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef COSXCLIENTTASKBARRECEIVER_H
-#define COSXCLIENTTASKBARRECEIVER_H
+#ifndef CPMCLIENTTASKBARRECEIVER_H
+#define CPMCLIENTTASKBARRECEIVER_H
 
 #include "CClientTaskBarReceiver.h"
@@ -20 +21 @@
 class CBufferedLogOutputter;
 
-//! Implementation of CClientTaskBarReceiver for OS X
-class COSXClientTaskBarReceiver : public CClientTaskBarReceiver {
+//! Implementation of CClientTaskBarReceiver for PM
+class CPMClientTaskBarReceiver : public CClientTaskBarReceiver {
 public:
-        COSXClientTaskBarReceiver(const CBufferedLogOutputter*);
-        virtual ~COSXClientTaskBarReceiver();
+        CPMClientTaskBarReceiver(const CBufferedLogOutputter*);
+        virtual ~CPMClientTaskBarReceiver();
 
         // IArchTaskBarReceiver overrides
@@ -34 +35 @@
 
 #endif
+

trunk/synergy/cmd/synergyc/synergyc.cpp

@@ -49 +49 @@
 #include "COSXScreen.h"
 #include "COSXClientTaskBarReceiver.h"
+#elif WINAPI_PM
+#include "CPMScreen.h"
+#include "CPMClientTaskBarReceiver.h"
 #endif
 
@@ -110 +113 @@
 #elif WINAPI_CARBON
         return new CScreen(new COSXScreen(false));
+#elif WINAPI_PM
+        return new CScreen(new CPMScreen(false));
 #endif
 }
@@ -124 +129 @@
 #elif WINAPI_CARBON
         return new COSXClientTaskBarReceiver(logBuffer);
+#elif WINAPI_PM
+        return new CPMClientTaskBarReceiver(logBuffer);
 #endif
 }

trunk/synergy/cmd/synergys/CPMServerTaskBarReceiver.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "COSXServerTaskBarReceiver.h"
+#include "CPMServerTaskBarReceiver.h"
 #include "CArch.h"
 
 //
-// COSXServerTaskBarReceiver
+// CPMServerTaskBarReceiver
 //
 
-COSXServerTaskBarReceiver::COSXServerTaskBarReceiver(
+CPMServerTaskBarReceiver::CPMServerTaskBarReceiver(
                                 const CBufferedLogOutputter*)
 {
@@ -27 +28 @@
 }
 
-COSXServerTaskBarReceiver::~COSXServerTaskBarReceiver()
+CPMServerTaskBarReceiver::~CPMServerTaskBarReceiver()
 {
         ARCH->removeReceiver(this);
@@ -33 +34 @@
 
 void
-COSXServerTaskBarReceiver::showStatus()
+CPMServerTaskBarReceiver::showStatus()
 {
         // do nothing
@@ -39 +40 @@
 
 void
-COSXServerTaskBarReceiver::runMenu(int, int)
+CPMServerTaskBarReceiver::runMenu(int, int)
 {
         // do nothing
@@ -45 +46 @@
 
 void
-COSXServerTaskBarReceiver::primaryAction()
+CPMServerTaskBarReceiver::primaryAction()
 {
         // do nothing
@@ -51 +52 @@
 
 const IArchTaskBarReceiver::Icon
-COSXServerTaskBarReceiver::getIcon() const
+CPMServerTaskBarReceiver::getIcon() const
 {
         return NULL;

trunk/synergy/cmd/synergys/CPMServerTaskBarReceiver.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef COSXSERVERTASKBARRECEIVER_H
-#define COSXSERVERTASKBARRECEIVER_H
+#ifndef CPMSERVERTASKBARRECEIVER_H
+#define CPMSERVERTASKBARRECEIVER_H
 
 #include "CServerTaskBarReceiver.h"
@@ -20 +21 @@
 class CBufferedLogOutputter;
 
-//! Implementation of CServerTaskBarReceiver for OS X
-class COSXServerTaskBarReceiver : public CServerTaskBarReceiver {
+//! Implementation of CServerTaskBarReceiver for PM
+class CPMServerTaskBarReceiver : public CServerTaskBarReceiver {
 public:
-        COSXServerTaskBarReceiver(const CBufferedLogOutputter*);
-        virtual ~COSXServerTaskBarReceiver();
+        CPMServerTaskBarReceiver(const CBufferedLogOutputter*);
+        virtual ~CPMServerTaskBarReceiver();
 
         // IArchTaskBarReceiver overrides

trunk/synergy/cmd/synergys/synergys.cpp

@@ -52 +52 @@
 #include "COSXScreen.h"
 #include "COSXServerTaskBarReceiver.h"
+#elif WINAPI_PM
+#include "CPMScreen.h"
+#include "CPMServerTaskBarReceiver.h"
 #endif
 
@@ -127 +130 @@
 #elif WINAPI_CARBON
         return new CScreen(new COSXScreen(true));
+#elif WINAPI_PM
+        return new CScreen(new CPMScreen(true));
 #endif
 }
@@ -141 +146 @@
 #elif WINAPI_CARBON
         return new COSXServerTaskBarReceiver(logBuffer);
+#elif WINAPI_PM
+        return new CPMServerTaskBarReceiver(logBuffer);
 #endif
 }

trunk/synergy/lib/arch/CArch.cpp

@@ -44 +44 @@
 #elif SYSAPI_UNIX
 #       include "CArchConsoleUnix.h"
-#       include "CArchDaemonUnix.h"
+#   ifdef __OS2__
+#               include "CArchDaemonNone.h"
+#       else
+#               include "CArchDaemonUnix.h"
+#       endif
 #       include "CArchFileUnix.h"
 #       include "CArchLogUnix.h"
@@ -54 +58 @@
 #       include "CArchStringUnix.h"
 #       include "CArchSystemUnix.h"
-#       include "CArchTaskBarXWindows.h"
+#   ifdef __OS2__ /// @todo isn't this really WINAPI?
+#               include "CArchTaskBarOS2.h"
+#       else
+#               include "CArchTaskBarXWindows.h"
+#       endif 
 #       include "CArchTimeUnix.h"
 #endif

trunk/synergy/lib/arch/CArchMultithreadPosix.h

@@ -15 +15 @@
 #ifndef CARCHMULTITHREADPOSIX_H
 #define CARCHMULTITHREADPOSIX_H
+
+#ifdef __OS2__
+
+#include "CArchMultithreadOS2.h"
+
+#else /* !__OS2__ */
 
 #include "IArchMultithread.h"
@@ -111 +117 @@
 };
 
+#endif /* !__OS2__ */
 #endif

trunk/synergy/lib/common/common.h

@@ -85 +85 @@
 #               define X_DISPLAY_MISSING 1
 #       endif
+
+#       if defined(__OS2__)
+#               define SYSAPI_UNIX 1
+#               define WINAPI_PM 1
+
+#               define HAVE_CXX_BOOL 1
+#               define HAVE_CXX_CASTS 1
+#               define HAVE_CXX_EXCEPTIONS 1
+#               define HAVE_CXX_MUTABLE 1
+#               define HAVE_CXX_STDLIB 1
+//#             define HAVE_GETPWUID_R 1
+#               define HAVE_GMTIME_R 1
+#               define HAVE_INET_ATON 1
+#               define HAVE_INTTYPES_H 1
+#               define HAVE_ISTREAM 1
+#               define HAVE_MEMORY_H 1
+#               define HAVE_NANOSLEEP 1
+#               define HAVE_OSTREAM 1
+#               define HAVE_POSIX_SIGWAIT 1
+// we don't have pthreads, but we use the same header to reduce changes.
+#               define HAVE_PTHREAD 1 
+//#             define HAVE_PTHREAD_SIGNAL 1
+#               include <sys/types.h>
+#               include <sys/socket.h>
+//#             if defined(_SOCKLEN_T)
+//#                     define HAVE_SOCKLEN_T 1
+//#             endif
+#               define HAVE_SSTREAM 1
+#               define HAVE_STDINT_H 1
+#               define HAVE_STDLIB_H 1
+#               define HAVE_STRINGS_H 1
+#               define HAVE_STRING_H 1
+#               define HAVE_SYS_SELECT_H 1
+#               define HAVE_SYS_SOCKET_H 1
+#               define HAVE_SYS_STAT_H 1
+#               define HAVE_SYS_TIME_H 1
+#               define HAVE_SYS_TYPES_H 1
+#               define HAVE_SYS_UTSNAME_H 1
+#               define HAVE_UNISTD_H 1
+#               define HAVE_VSNPRINTF 1
+#               define HAVE_WCHAR_H 1
+#               define HAVE_LOCALE_H 1
+
+#               define SELECT_TYPE_ARG1 int
+#               define SELECT_TYPE_ARG234 (fd_set *)
+#               define SELECT_TYPE_ARG5 (struct timeval *)
+#               define SIZEOF_CHAR 1
+#               define SIZEOF_INT 4
+#               define SIZEOF_LONG 4
+#               define SIZEOF_SHORT 2
+#               define STDC_HEADERS 1
+#               define TIME_WITH_SYS_TIME 1
+#               define X_DISPLAY_MISSING 1
+#       endif /* __OS2__ */
 #endif
 

trunk/synergy/lib/platform/CPMClipboard.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2002 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "CMSWindowsClipboard.h"
-#include "CMSWindowsClipboardTextConverter.h"
-#include "CMSWindowsClipboardUTF16Converter.h"
-#include "CMSWindowsClipboardBitmapConverter.h"
-#include "CMSWindowsClipboardHTMLConverter.h"
+#include "CPMClipboard.h"
+#include "CPMClipboardTextConverter.h"
+#include "CPMClipboardBitmapConverter.h"
+#include "CPMClipboardHTMLConverter.h"
+#include "CPMUtil.h"
 #include "CLog.h"
-#include "CArchMiscWindows.h"
 
 //
-// CMSWindowsClipboard
+// CPMClipboard
 //
 
-UINT                                    CMSWindowsClipboard::s_ownershipFormat = 0;
-
-CMSWindowsClipboard::CMSWindowsClipboard(HWND window) :
+ATOM                                    CPMClipboard::s_ownershipFormat = 0;
+
+CPMClipboard::CPMClipboard(HWND window) :
         m_window(window),
         m_time(0)
 {
         // add converters, most desired first
-        m_converters.push_back(new CMSWindowsClipboardUTF16Converter);
-        if (CArchMiscWindows::isWindows95Family()) {
-                // windows nt family converts to/from unicode automatically.
-                // let it do so to avoid text encoding issues.
-                m_converters.push_back(new CMSWindowsClipboardTextConverter);
-        }
-        m_converters.push_back(new CMSWindowsClipboardBitmapConverter);
-        m_converters.push_back(new CMSWindowsClipboardHTMLConverter);
-}
-
-CMSWindowsClipboard::~CMSWindowsClipboard()
+        m_converters.push_back(new CPMClipboardTextConverter);
+        m_converters.push_back(new CPMClipboardBitmapConverter);
+        m_converters.push_back(new CPMClipboardHTMLConverter);
+}
+
+CPMClipboard::~CPMClipboard()
 {
         clearConverters();
@@ -48 +43 @@
 
 bool
-CMSWindowsClipboard::emptyUnowned()
+CPMClipboard::emptyUnowned()
 {
         LOG((CLOG_DEBUG "empty clipboard"));
 
         // empty the clipboard (and take ownership)
-        if (!EmptyClipboard()) {
+        if (!WinEmptyClipbrd(CPMUtil::getHAB())) {
                 LOG((CLOG_DEBUG "failed to grab clipboard"));
                 return false;
@@ -62 +57 @@
 
 bool
-CMSWindowsClipboard::empty()
+CPMClipboard::empty()
 {
         if (!emptyUnowned()) {
@@ -69 +64 @@
 
         // mark clipboard as being owned by synergy
-        HGLOBAL data = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, 1);
-        SetClipboardData(getOwnershipFormat(), data);
-
-        return true;
+    PVOID pv = NULL;
+    APIRET rc = DosAllocSharedMem(&pv, NULL, 1, PAG_READ | PAG_WRITE | PAG_COMMIT | OBJ_GETTABLE | OBJ_GIVEABLE);
+    if (rc) {
+        assert(rc);
+        return false;
+    }
+        return !!WinSetClipbrdData(CPMUtil::getHAB(), (ULONG)pv, getOwnershipFormat(), CFI_POINTER);
 }
 
 void
-CMSWindowsClipboard::add(EFormat format, const CString& data)
+CPMClipboard::add(EFormat format, const CString& data)
 {
         LOG((CLOG_DEBUG "add %d bytes to clipboard format: %d", data.size(), format));
@@ -82 +80 @@
         // convert data to win32 form
         for (ConverterList::const_iterator index = m_converters.begin();
-                                                                index != m_converters.end(); ++index) {
-                IMSWindowsClipboardConverter* converter = *index;
+                 index != m_converters.end();
+                 ++index) {
+                IPMClipboardConverter* converter = *index;
 
                 // skip converters for other formats
                 if (converter->getFormat() == format) {
-                        HANDLE win32Data = converter->fromIClipboard(data);
-                        if (win32Data != NULL) {
-                                UINT win32Format = converter->getWin32Format();
-                                if (SetClipboardData(win32Format, win32Data) == NULL) {
-                                        // free converted data if we couldn't put it on
-                                        // the clipboard
-                                        GlobalFree(win32Data);
+                        ULONG ulPMData = converter->fromIClipboard(data);
+                        if (ulPMData != NULL) {
+                                ULONG ulPMFormat = converter->getPMFormat();
+                ULONG ulPMFormatInfo = converter->getPMFormatInfo();
+                                if (!WinSetClipbrdData(CPMUtil::getHAB(), ulPMData, ulPMFormat, ulPMFormatInfo)) {
+                                        // free converted data if we couldn't put it on the clipboard
+                    converter->freePMData(ulPMData);
                                 }
                         }
@@ -101 +100 @@
 
 bool
-CMSWindowsClipboard::open(Time time) const
+CPMClipboard::open(Time time) const
 {
         LOG((CLOG_DEBUG "open clipboard"));
 
-        if (!OpenClipboard(m_window)) {
+        if (!WinOpenClipbrd(m_window)) {
                 LOG((CLOG_WARN "failed to open clipboard"));
                 return false;
@@ -116 +115 @@
 
 void
-CMSWindowsClipboard::close() const
+CPMClipboard::close() const
 {
         LOG((CLOG_DEBUG "close clipboard"));
-        CloseClipboard();
+        WinCloseClipbrd(CPMUtil::getHAB());
 }
 
 IClipboard::Time
-CMSWindowsClipboard::getTime() const
+CPMClipboard::getTime() const
 {
         return m_time;
@@ -129 +128 @@
 
 bool
-CMSWindowsClipboard::has(EFormat format) const
+CPMClipboard::has(EFormat format) const
 {
         for (ConverterList::const_iterator index = m_converters.begin();
-                                                                index != m_converters.end(); ++index) {
-                IMSWindowsClipboardConverter* converter = *index;
+                 index != m_converters.end();
+                 ++index) {
+                IPMClipboardConverter* converter = *index;
                 if (converter->getFormat() == format) {
-                        if (IsClipboardFormatAvailable(converter->getWin32Format())) {
+            ULONG fFmtInfo;
+                        if (WinQueryClipbrdFmtInfo(CPMUtil::getHAB(), getOwnershipFormat(), &fFmtInfo)) {
                                 return true;
                         }
@@ -144 +145 @@
 
 CString
-CMSWindowsClipboard::get(EFormat format) const
+CPMClipboard::get(EFormat format) const
 {
         // find the converter for the first clipboard format we can handle
-        IMSWindowsClipboardConverter* converter = NULL;
-        UINT win32Format = EnumClipboardFormats(0);
-        while (converter == NULL && win32Format != 0) {
+        IPMClipboardConverter* converter = NULL;
+        ULONG pmFormat = WinEnumClipbrdFmts(CPMUtil::getHAB(), 0);
+        while (converter == NULL && pmFormat != 0) {
                 for (ConverterList::const_iterator index = m_converters.begin();
-                                                                index != m_converters.end(); ++index) {
+                         index != m_converters.end(); 
+             ++index) {
                         converter = *index;
-                        if (converter->getWin32Format() == win32Format &&
-                                converter->getFormat()      == format) {
+                        if (converter->getPMFormat() == pmFormat &&
+                                converter->getFormat()   == format) {
                                 break;
                         }
                         converter = NULL;
                 }
-                win32Format = EnumClipboardFormats(win32Format);
+                pmFormat = WinEnumClipbrdFmts(CPMUtil::getHAB(), pmFormat);
         }
 
@@ -168 +170 @@
 
         // get a handle to the clipboard data
-        HANDLE win32Data = GetClipboardData(converter->getWin32Format());
-        if (win32Data == NULL) {
+        ULONG ulData = WinQueryClipbrdData(CPMUtil::getHAB(), converter->getPMFormat());
+        if (ulData == 0) {
                 return CString();
         }
 
         // convert
-        return converter->toIClipboard(win32Data);
+        return converter->toIClipboard(ulData);
 }
 
 void
-CMSWindowsClipboard::clearConverters()
+CPMClipboard::clearConverters()
 {
         for (ConverterList::iterator index = m_converters.begin();
-                                                                index != m_converters.end(); ++index) {
+                 index != m_converters.end();
+                 ++index) {
                 delete *index;
         }
@@ -188 +191 @@
 
 bool
-CMSWindowsClipboard::isOwnedBySynergy()
+CPMClipboard::isOwnedBySynergy()
+{
+    ULONG fFmtInfo;
+        return (!!WinQueryClipbrdFmtInfo(CPMUtil::getHAB(), getOwnershipFormat(), &fFmtInfo));
+}
+
+ATOM
+CPMClipboard::getOwnershipFormat()
 {
         // create ownership format if we haven't yet
         if (s_ownershipFormat == 0) {
-                s_ownershipFormat = RegisterClipboardFormat(TEXT("SynergyOwnership"));
-        }
-        return (IsClipboardFormatAvailable(getOwnershipFormat()) != 0);
-}
-
-UINT
-CMSWindowsClipboard::getOwnershipFormat()
-{
-        // create ownership format if we haven't yet
-        if (s_ownershipFormat == 0) {
-                s_ownershipFormat = RegisterClipboardFormat(TEXT("SynergyOwnership"));
+        ATOM hAtom = WinAddAtom(WinQuerySystemAtomTable(), (PCSZ)"SynergyOwnership");
+        if (hAtom == 0)
+            hAtom = WinFindAtom(WinQuerySystemAtomTable(), (PCSZ)"SynergyOwnership");
+        assert(hAtom != 0);
+        s_ownershipFormat = hAtom;
         }
 

trunk/synergy/lib/platform/CPMClipboard.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2002 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef CMSWINDOWSCLIPBOARD_H
-#define CMSWINDOWSCLIPBOARD_H
+#ifndef CPMCLIPBOARD_H
+#define CPMCLIPBOARD_H
 
 #include "IClipboard.h"
 #include "stdvector.h"
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
+#define INCL_ERRORS
+#define INCL_BASE
+#define INCL_PM
+#include <os2.h>
 
-class IMSWindowsClipboardConverter;
+class IPMClipboardConverter;
 
 //! Microsoft windows clipboard implementation
-class CMSWindowsClipboard : public IClipboard {
+class CPMClipboard : public IClipboard {
 public:
-        CMSWindowsClipboard(HWND window);
-        virtual ~CMSWindowsClipboard();
+        CPMClipboard(HWND window);
+        virtual ~CPMClipboard();
 
         //! Empty clipboard without ownership
@@ -59 +62 @@
         void                            clearConverters();
 
-        UINT                            convertFormatToWin32(EFormat) const;
-        HANDLE                          convertTextToWin32(const CString& data) const;
-        CString                         convertTextFromWin32(HANDLE) const;
+        ULONG                           convertFormatToPM(EFormat) const;
+        ULONG                           convertTextToPM(const CString& data) const;
+        CString                         convertTextFromPM(ULONG) const;
 
-        static UINT                     getOwnershipFormat();
+        static ATOM                     getOwnershipFormat();
 
 private:
-        typedef std::vector<IMSWindowsClipboardConverter*> ConverterList;
+        typedef std::vector<IPMClipboardConverter*> ConverterList;
 
         HWND                            m_window;
         mutable Time            m_time;
         ConverterList           m_converters;
-        static UINT                     s_ownershipFormat;
+        static ATOM                     s_ownershipFormat;
 };
 
@@ -79 +82 @@
 converters.
 */
-class IMSWindowsClipboardConverter : public IInterface {
+class IPMClipboardConverter : public IInterface {
 public:
         // accessors
@@ -87 +90 @@
                                                 getFormat() const = 0;
 
-        // return the atom representing the win32 clipboard format that
+        // return the atom representing the PM clipboard format that
         // this object converts from/to
-        virtual UINT            getWin32Format() const = 0;
+        virtual ULONG           getPMFormat() const = 0;
 
-        // convert from the IClipboard format to the win32 clipboard format.
+        // return the format info flags for the PM clipboard format 
+        // this object converts from/to
+        virtual ULONG           getPMFormatInfo() const = 0;
+
+        // convert from the IClipboard format to the PM clipboard format.
         // the input data must be in the IClipboard format returned by
-        // getFormat().  the return data will be in the win32 clipboard
-        // format returned by getWin32Format(), allocated by GlobalAlloc().
-        virtual HANDLE          fromIClipboard(const CString&) const = 0;
+        // getFormat().  the return data will be in the PM clipboard
+        // format returned by getPMFormat().
+        virtual ULONG           fromIClipboard(const CString&) const = 0;
+
+        // free PM clipboard data (failure case).
+        virtual void            freePMData(ULONG) const = 0;
 
         // convert from the win32 clipboard format to the IClipboard format
         // (i.e., the reverse of fromIClipboard()).
-        virtual CString         toIClipboard(HANDLE data) const = 0;
+        virtual CString         toIClipboard(ULONG data) const = 0;
 };
 

trunk/synergy/lib/platform/CPMClipboardAnyTextConverter.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2002 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "CMSWindowsClipboardAnyTextConverter.h"
+#include "CPMClipboardAnyTextConverter.h"
 
 //
-// CMSWindowsClipboardAnyTextConverter
+// CPMClipboardAnyTextConverter
 //
 
-CMSWindowsClipboardAnyTextConverter::CMSWindowsClipboardAnyTextConverter()
+CPMClipboardAnyTextConverter::CPMClipboardAnyTextConverter()
 {
         // do nothing
 }
 
-CMSWindowsClipboardAnyTextConverter::~CMSWindowsClipboardAnyTextConverter()
+CPMClipboardAnyTextConverter::~CPMClipboardAnyTextConverter()
 {
         // do nothing
@@ -30 +31 @@
 
 IClipboard::EFormat
-CMSWindowsClipboardAnyTextConverter::getFormat() const
+CPMClipboardAnyTextConverter::getFormat() const
 {
         return IClipboard::kText;
 }
+ULONG
+CPMClipboardAnyTextConverter::getPMFormatInfo() const
+{
+    return CFI_POINTER;
+}
 
-HANDLE
-CMSWindowsClipboardAnyTextConverter::fromIClipboard(const CString& data) const
+ULONG
+CPMClipboardAnyTextConverter::fromIClipboard(const CString& data) const
 {
         // convert linefeeds and then convert to desired encoding
-        CString text = doFromIClipboard(convertLinefeedToWin32(data));
-        UInt32 size  = text.size();
+        CString text = doFromIClipboard(convertLinefeedToPM(data));
+        UInt32 cb = text.size();
 
         // copy to memory handle
-        HGLOBAL gData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, size);
-        if (gData != NULL) {
-                // get a pointer to the allocated memory
-                char* dst = (char*)GlobalLock(gData);
-                if (dst != NULL) {
-                        memcpy(dst, text.data(), size);
-                        GlobalUnlock(gData);
-                }
-                else {
-                        GlobalFree(gData);
-                        gData = NULL;
-                }
-        }
+    PVOID pv = NULL;
+    APIRET rc = DosAllocSharedMem(&pv, NULL, cb, PAG_READ | PAG_WRITE | PAG_COMMIT | OBJ_GETTABLE | OBJ_GIVEABLE);
+    if (rc == NO_ERROR) {
+        return (ULONG)memcpy(pv, text.data(), cb);
+    }
+    return 0;
+}
 
-        return gData;
+void 
+CPMClipboardAnyTextConverter::freePMData(ULONG ulPMData) const
+{
+    DosFreeMem((PVOID)ulPMData);
 }
 
 CString
-CMSWindowsClipboardAnyTextConverter::toIClipboard(HANDLE data) const
+CPMClipboardAnyTextConverter::toIClipboard(ULONG data) const
 {
-        // get datator
-        const char* src = (const char*)GlobalLock(data);
-        UInt32 srcSize = (UInt32)GlobalSize(data);
-        if (src == NULL || srcSize <= 1) {
-                return CString();
-        }
-
         // convert text
-        CString text = doToIClipboard(CString(src, srcSize));
-
-        // release handle
-        GlobalUnlock(data);
+    const char *psz = (const char *)data;
+        CString text = doToIClipboard(CString(psz));
 
         // convert newlines
@@ -81 +75 @@
 
 CString
-CMSWindowsClipboardAnyTextConverter::convertLinefeedToWin32(
-                                const CString& src) const
+CPMClipboardAnyTextConverter::convertLinefeedToPM(const CString& src) const
 {
         // note -- we assume src is a valid UTF-8 string
@@ -115 +108 @@
 
 CString
-CMSWindowsClipboardAnyTextConverter::convertLinefeedToUnix(
-                                const CString& src) const
+CPMClipboardAnyTextConverter::convertLinefeedToUnix(const CString& src) const
 {
         // count newlines in string

trunk/synergy/lib/platform/CPMClipboardAnyTextConverter.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2002 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef CMSWINDOWSCLIPBOARDANYTEXTCONVERTER_H
-#define CMSWINDOWSCLIPBOARDANYTEXTCONVERTER_H
+#ifndef CPMCLIPBOARDANYTEXTCONVERTER_H
+#define CPMCLIPBOARDANYTEXTCONVERTER_H
 
-#include "CMSWindowsClipboard.h"
+#include "CPMClipboard.h"
 
 //! Convert to/from some text encoding
-class CMSWindowsClipboardAnyTextConverter :
-                                public IMSWindowsClipboardConverter {
+class CPMClipboardAnyTextConverter :
+                                public IPMClipboardConverter {
 public:
-        CMSWindowsClipboardAnyTextConverter();
-        virtual ~CMSWindowsClipboardAnyTextConverter();
+        CPMClipboardAnyTextConverter();
+        virtual ~CPMClipboardAnyTextConverter();
 
-        // IMSWindowsClipboardConverter overrides
+        // IPMClipboardConverter overrides
         virtual IClipboard::EFormat
                                                 getFormat() const;
-        virtual UINT            getWin32Format() const = 0;
-        virtual HANDLE          fromIClipboard(const CString&) const;
-        virtual CString         toIClipboard(HANDLE) const;
+        virtual ULONG           getPMFormat() const = 0;
+        virtual ULONG           getPMFormatInfo() const;
+        virtual ULONG           fromIClipboard(const CString&) const;
+        virtual void            freePMData(ULONG) const;
+        virtual CString         toIClipboard(ULONG) const;
 
 protected:
@@ -50 +53 @@
 
 private:
-        CString                         convertLinefeedToWin32(const CString&) const;
+        CString                         convertLinefeedToPM(const CString&) const;
         CString                         convertLinefeedToUnix(const CString&) const;
 };

trunk/synergy/lib/platform/CPMClipboardBitmapConverter.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "CMSWindowsClipboardBitmapConverter.h"
+#include "CPMClipboardBitmapConverter.h"
 #include "CLog.h"
 
 //
-// CMSWindowsClipboardBitmapConverter
+// CPMClipboardBitmapConverter
 //
 
-CMSWindowsClipboardBitmapConverter::CMSWindowsClipboardBitmapConverter()
+CPMClipboardBitmapConverter::CPMClipboardBitmapConverter()
 {
         // do nothing
 }
 
-CMSWindowsClipboardBitmapConverter::~CMSWindowsClipboardBitmapConverter()
+CPMClipboardBitmapConverter::~CPMClipboardBitmapConverter()
 {
         // do nothing
@@ -31 +32 @@
 
 IClipboard::EFormat
-CMSWindowsClipboardBitmapConverter::getFormat() const
+CPMClipboardBitmapConverter::getFormat() const
 {
         return IClipboard::kBitmap;
 }
 
-UINT
-CMSWindowsClipboardBitmapConverter::getWin32Format() const
+ULONG
+CPMClipboardBitmapConverter::getPMFormat() const
 {
-        return CF_DIB;
+        return CF_BITMAP;
 }
 
-HANDLE
-CMSWindowsClipboardBitmapConverter::fromIClipboard(const CString& data) const
+ULONG
+CPMClipboardBitmapConverter::getPMFormatInfo() const
 {
-        // copy to memory handle
-        HGLOBAL gData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, data.size());
-        if (gData != NULL) {
-                // get a pointer to the allocated memory
-                char* dst = (char*)GlobalLock(gData);
-                if (dst != NULL) {
-                        memcpy(dst, data.data(), data.size());
-                        GlobalUnlock(gData);
-                }
-                else {
-                        GlobalFree(gData);
-                        gData = NULL;
-                }
-        }
+        return CFI_HANDLE;
+}
 
-        return gData;
+ULONG
+CPMClipboardBitmapConverter::fromIClipboard(const CString& data) const
+{
+    /*
+     * We're getting a windows DIB, create a PM bitmap from that.
+     */
+    /** @todo implement me */
+    return 0;
 }
 
 CString
-CMSWindowsClipboardBitmapConverter::toIClipboard(HANDLE data) const
+CPMClipboardBitmapConverter::toIClipboard(ULONG data) const
 {
+#if 1
+    /** @todo implement me */
+    return CString();
+#else
+    HBITMAP hbmp = (HBITMAP)data;
+
+    BITMAPINFOHEADER2 BmpHdr;
+
+    ULONG        cbFix;
+    ULONG        cx;
+    ULONG        cy;
+    USHORT cPlanes;
+    USHORT cBitCount;
+    ULONG        ulCompression;
+    ULONG        cbImage;
+    ULONG        cxResolution;
+    ULONG        cyResolution;
+    ULONG        cclrUsed;
+    ULONG        cclrImportant;
+    USHORT usUnits;
+    USHORT usReserved;
+    USHORT usRecording;
+    USHORT usRendering;
+    ULONG        cSize1;
+    ULONG        cSize2;
+    ULONG        ulColorEncoding;
+    ULONG        ulIdentifier;
+
+    if (GpiQueryBitmapInfoHeader(hbmp, &BmpHdr)) {
+        LOG((CLOG_INFO "bitmap: %dx%d %d", bmpData.biWidth, bitmap->bmiHeader.biHeight, (int)bitmap->bmiHeader.biBitCount));
+        if (    BmpHdr.cPlanes == 1
+            &&  (BmpHdr.cBitsCount == 32 || BmpHdr.cBitsCount == 24 /*???*/)
+            &&   BmpHdr.ulCompression == ) {
+            // already in canonical form
+            char *abImage = new char[BmpHdr.cbImage];
+            /* fun stuff starts here. */
+            //if (GipQueryBitmapBits() {
+            }
+            CString image(abImage, srcSize);
+            delete abImage;
+            return image;
+        }
+        
+    }
+    return CString();
+
         // get datator
         const char* src = (const char*)GlobalLock(data);
@@ -113 +155 @@
                         (bitmap->bmiHeader.biBitCount == 16 ||
                         bitmap->bmiHeader.biBitCount == 32)) {
-                        srcBits += 3 * sizeof(DWORD);
+                        srcBits += 3 * sizeof(ULONG);
                 }
         }
@@ -144 +186 @@
 
         return image;
+#endif
 }
+

trunk/synergy/lib/platform/CPMClipboardBitmapConverter.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef CMSWINDOWSCLIPBOARDBITMAPCONVERTER_H
-#define CMSWINDOWSCLIPBOARDBITMAPCONVERTER_H
+#ifndef CPMCLIPBOARDBITMAPCONVERTER_H
+#define CPMCLIPBOARDBITMAPCONVERTER_H
 
-#include "CMSWindowsClipboard.h"
+#include "CPMClipboard.h"
 
 //! Convert to/from some text encoding
-class CMSWindowsClipboardBitmapConverter :
-                                public IMSWindowsClipboardConverter {
+class CPMClipboardBitmapConverter :
+                                public IPMClipboardConverter {
 public:
-        CMSWindowsClipboardBitmapConverter();
-        virtual ~CMSWindowsClipboardBitmapConverter();
+        CPMClipboardBitmapConverter();
+        virtual ~CPMClipboardBitmapConverter();
 
-        // IMSWindowsClipboardConverter overrides
+        // IPMClipboardConverter overrides
         virtual IClipboard::EFormat
                                                 getFormat() const;
-        virtual UINT            getWin32Format() const;
-        virtual HANDLE          fromIClipboard(const CString&) const;
-        virtual CString         toIClipboard(HANDLE) const;
+        virtual ULONG           getPMFormat() const;
+        virtual ULONG           getPMFormatInfo() const;
+        virtual ULONG           fromIClipboard(const CString&) const;
+        virtual void            freePMData(ULONG) const;
+        virtual CString         toIClipboard(ULONG) const;
 };
 

trunk/synergy/lib/platform/CPMClipboardHTMLConverter.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "CMSWindowsClipboardHTMLConverter.h"
+#include "CPMClipboardHTMLConverter.h"
 #include "CStringUtil.h"
 
 //
-// CMSWindowsClipboardHTMLConverter
+// CPMClipboardHTMLConverter
 //
 
-CMSWindowsClipboardHTMLConverter::CMSWindowsClipboardHTMLConverter()
+CPMClipboardHTMLConverter::CPMClipboardHTMLConverter()
 {
-        m_format = RegisterClipboardFormat("HTML Format");
+        m_format = WinAddAtom(WinQuerySystemAtomTable(), (PCSZ)"HTML Format");
+    if (!m_format) {
+        m_format = WinFindAtom(WinQuerySystemAtomTable(), (PCSZ)"HTML Format");
+        assert(m_format);
+    }
 }
 
-CMSWindowsClipboardHTMLConverter::~CMSWindowsClipboardHTMLConverter()
+CPMClipboardHTMLConverter::~CPMClipboardHTMLConverter()
 {
         // do nothing
@@ -31 +36 @@
 
 IClipboard::EFormat
-CMSWindowsClipboardHTMLConverter::getFormat() const
+CPMClipboardHTMLConverter::getFormat() const
 {
         return IClipboard::kHTML;
 }
 
-UINT
-CMSWindowsClipboardHTMLConverter::getWin32Format() const
+ULONG
+CPMClipboardHTMLConverter::getPMFormat() const
 {
         return m_format;
@@ -43 +48 @@
 
 CString
-CMSWindowsClipboardHTMLConverter::doFromIClipboard(const CString& data) const
+CPMClipboardHTMLConverter::doFromIClipboard(const CString& data) const
 {
         // prepare to CF_HTML format prefix and suffix
@@ -64 +69 @@
 
 CString
-CMSWindowsClipboardHTMLConverter::doToIClipboard(const CString& data) const
+CPMClipboardHTMLConverter::doToIClipboard(const CString& data) const
 {
         // get fragment start/end args
@@ -85 +90 @@
 
 CString
-CMSWindowsClipboardHTMLConverter::findArg(
+CPMClipboardHTMLConverter::findArg(
                                 const CString& data, const CString& name) const
 {

trunk/synergy/lib/platform/CPMClipboardHTMLConverter.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef CMSWINDOWSCLIPBOARDHTMLCONVERTER_H
-#define CMSWINDOWSCLIPBOARDHTMLCONVERTER_H
+#ifndef CPMCLIPBOARDHTMLCONVERTER_H
+#define CPMCLIPBOARDHTMLCONVERTER_H
 
-#include "CMSWindowsClipboardAnyTextConverter.h"
+#include "CPMClipboardAnyTextConverter.h"
 
 //! Convert to/from HTML encoding
-class CMSWindowsClipboardHTMLConverter :
-                                public CMSWindowsClipboardAnyTextConverter {
+class CPMClipboardHTMLConverter :
+                                public CPMClipboardAnyTextConverter {
 public:
-        CMSWindowsClipboardHTMLConverter();
-        virtual ~CMSWindowsClipboardHTMLConverter();
+        CPMClipboardHTMLConverter();
+        virtual ~CPMClipboardHTMLConverter();
 
-        // IMSWindowsClipboardConverter overrides
-        virtual IClipboard::EFormat
-                                                getFormat() const;
-        virtual UINT            getWin32Format() const;
+        // IPMClipboardConverter overrides
+        virtual IClipboard::EFormat getFormat() const;
+        virtual ULONG           getPMFormat() const;
 
 protected:
-        // CMSWindowsClipboardAnyTextConverter overrides
+        // CPMClipboardAnyTextConverter overrides
         virtual CString         doFromIClipboard(const CString&) const;
         virtual CString         doToIClipboard(const CString&) const;
@@ -39 +39 @@
 
 private:
-        UINT                            m_format;
+        ATOM                            m_format;
 };
 

trunk/synergy/lib/platform/CPMClipboardTextConverter.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2002 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "CMSWindowsClipboardTextConverter.h"
+#include "CPMClipboardTextConverter.h"
 #include "CUnicode.h"
 
 //
-// CMSWindowsClipboardTextConverter
+// CPMClipboardTextConverter
 //
 
-CMSWindowsClipboardTextConverter::CMSWindowsClipboardTextConverter()
+CPMClipboardTextConverter::CPMClipboardTextConverter()
 {
         // do nothing
 }
 
-CMSWindowsClipboardTextConverter::~CMSWindowsClipboardTextConverter()
+CPMClipboardTextConverter::~CPMClipboardTextConverter()
 {
         // do nothing
 }
 
-UINT
-CMSWindowsClipboardTextConverter::getWin32Format() const
+ULONG
+CPMClipboardTextConverter::getPMFormat() const
 {
         return CF_TEXT;
@@ -37 +38 @@
 
 CString
-CMSWindowsClipboardTextConverter::doFromIClipboard(const CString& data) const
+CPMClipboardTextConverter::doFromIClipboard(const CString& data) const
 {
         // convert and add nul terminator
@@ -44 +45 @@
 
 CString
-CMSWindowsClipboardTextConverter::doToIClipboard(const CString& data) const
+CPMClipboardTextConverter::doToIClipboard(const CString& data) const
 {
         // convert and truncate at first nul terminator

trunk/synergy/lib/platform/CPMClipboardTextConverter.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2002 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef CMSWINDOWSCLIPBOARDTEXTCONVERTER_H
-#define CMSWINDOWSCLIPBOARDTEXTCONVERTER_H
+#ifndef CPMCLIPBOARDTEXTCONVERTER_H
+#define CPMCLIPBOARDTEXTCONVERTER_H
 
-#include "CMSWindowsClipboardAnyTextConverter.h"
+#include "CPMClipboardAnyTextConverter.h"
 
 //! Convert to/from locale text encoding
-class CMSWindowsClipboardTextConverter :
-                                public CMSWindowsClipboardAnyTextConverter {
+class CPMClipboardTextConverter :
+                                public CPMClipboardAnyTextConverter {
 public:
-        CMSWindowsClipboardTextConverter();
-        virtual ~CMSWindowsClipboardTextConverter();
+        CPMClipboardTextConverter();
+        virtual ~CPMClipboardTextConverter();
 
-        // IMSWindowsClipboardConverter overrides
-        virtual UINT            getWin32Format() const;
+        // IPMClipboardConverter overrides
+        virtual ULONG           getPMFormat() const;
 
 protected:
-        // CMSWindowsClipboardAnyTextConverter overrides
+        // CPMClipboardAnyTextConverter overrides
         virtual CString         doFromIClipboard(const CString&) const;
         virtual CString         doToIClipboard(const CString&) const;

trunk/synergy/lib/platform/CPMEventQueueBuffer.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "CMSWindowsEventQueueBuffer.h"
+#include "CPMEventQueueBuffer.h"
 #include "CThread.h"
 #include "IEventQueue.h"
-#include "CArchMiscWindows.h"
 
 //
@@ -26 +26 @@
 
 //
-// CMSWindowsEventQueueBuffer
+// CPMEventQueueBuffer
 //
 
-CMSWindowsEventQueueBuffer::CMSWindowsEventQueueBuffer()
+CPMEventQueueBuffer::CPMEventQueueBuffer()
 {
-        // remember thread.  we'll be posting messages to it.
-        m_thread     = GetCurrentThreadId();
+        // remember the queue (/ thread / hab).  we'll be posting messages to it.
+    m_hab = WinInitialize(0);
+    m_hmq = WinCreateMsgQueue(m_hab, 0);
+    assert(m_hmq != NULLHANDLE);
 
         // create a message type for custom events
-        m_userEvent  = RegisterWindowMessage("SYNERGY_USER_EVENT");
+        m_userEvent  = WM_USER + 42 + 42 + 42;
 
         // get message type for daemon quit
-        m_daemonQuit = CArchMiscWindows::getDaemonQuitMessage();
+        m_daemonQuit = WM_USER + 666;
 
-        // make sure this thread has a message queue
-        MSG dummy;
-        PeekMessage(&dummy, NULL, WM_USER, WM_USER, PM_NOREMOVE);
+    // create the event semaphore we'll be waiting on when waiting for messages.
+    m_hev = NULLHANDLE;
+    APIRET rc = DosCreateEventSem(NULL, &m_hev, 0, FALSE);
+    assert(rc == NO_ERROR);
 }
 
-CMSWindowsEventQueueBuffer::~CMSWindowsEventQueueBuffer()
+CPMEventQueueBuffer::~CPMEventQueueBuffer()
 {
         // do nothing
+    DosCloseEventSem(m_hev);
+    WinDestroyMsgQueue(m_hmq);
+    WinTerminate(m_hab);
 }
 
 void
-CMSWindowsEventQueueBuffer::waitForEvent(double timeout)
+CPMEventQueueBuffer::waitForEvent(double timeout)
 {
-        // check if messages are available first.  if we don't do this then
-        // MsgWaitForMultipleObjects() will block even if the queue isn't
-        // empty if the messages in the queue were there before the last
-        // call to GetMessage()/PeekMessage().
-        if (HIWORD(GetQueueStatus(QS_ALLINPUT)) != 0) {
-                return;
-        }
-
-        // convert timeout
-        DWORD t;
-        if (timeout < 0.0) {
-                t = INFINITE;
-        }
-        else {
-                t = (DWORD)(1000.0 * timeout);
-        }
-
-        // wait for a message.  we cannot be interrupted by thread
-        // cancellation but that's okay because we're run in the main
-        // thread and we never cancel that thread.
-        HANDLE dummy[1];
-        MsgWaitForMultipleObjects(0, dummy, FALSE, t, QS_ALLINPUT);
+        // check if messages are available first. 
+    ULONG fStatus = WinQueryQueueStatus(HWND_DESKTOP);
+    if (!fStatus) {
+        // convert timeout and wait.
+        ULONG ulPMTimeout = timeout < 0.0 
+                          ? SEM_INDEFINITE_WAIT
+                          : (ULONG)(1000.0 * timeout);
+        WinWaitEventSem(m_hev, ulPMTimeout);
+    }
 }
 
 IEventQueueBuffer::Type
-CMSWindowsEventQueueBuffer::getEvent(CEvent& event, UInt32& dataID)
+CPMEventQueueBuffer::getEvent(CEvent& event, UInt32& dataID)
 {
-        // peek at messages first.  waiting for QS_ALLINPUT will return
-        // if a message has been sent to our window but GetMessage will
-        // dispatch that message behind our backs and block.  PeekMessage
-        // will also dispatch behind our backs but won't block.
-        if (!PeekMessage(&m_event, NULL, 0, 0, PM_NOREMOVE) &&
-                !PeekMessage(&m_event, (HWND)-1, 0, 0, PM_NOREMOVE)) {
+        // peek at messages first.
+    QMSG qmsg;
+    if (!WinPeekMsg(m_hab, &qmsg, NULLHANDLE, 0, 0, PM_NOREMOVE)) {
                 return kNone;
-        }
+    }
 
-        // BOOL.  yeah, right.
-        BOOL result = GetMessage(&m_event, NULL, 0, 0);
-        if (result == -1) {
-                return kNone;
-        }
-        else if (result == 0) {
+    // get the message
+    if (    !WinGetMsg(m_hab, &m_event, NULLHANDLE, 0, 0)
+        ||  (m_event.msg == m_daemonQuit && m_daemonQuit != 0)) {
                 event = CEvent(CEvent::kQuit);
                 return kSystem;
         }
-        else if (m_daemonQuit != 0 && m_event.message == m_daemonQuit) {
-                event = CEvent(CEvent::kQuit);
-                return kSystem;
-        }
-        else if (m_event.message == m_userEvent) {
-                dataID = static_cast<UInt32>(m_event.wParam);
+        
+    if (m_event.msg == m_userEvent) {
+                dataID = (UInt32)(uintptr_t)m_event.mp1;
                 return kUser;
         }
-        else {
-                event = CEvent(CEvent::kSystem,
-                                                        IEventQueue::getSystemTarget(), &m_event);
-                return kSystem;
-        }
+    
+    event = CEvent(CEvent::kSystem, IEventQueue::getSystemTarget(), &m_event);
+    return kSystem;
 }
 
 bool
-CMSWindowsEventQueueBuffer::addEvent(UInt32 dataID)
+CPMEventQueueBuffer::addEvent(UInt32 dataID)
 {
-        return (PostThreadMessage(m_thread, m_userEvent,
-                                                        static_cast<WPARAM>(dataID), 0) != 0);
+    return WinPostQueueMsg(m_hmq, m_userEvent, (MPARAM)dataID, 0) != FALSE;
 }
 
 bool
-CMSWindowsEventQueueBuffer::isEmpty() const
+CPMEventQueueBuffer::isEmpty() const
 {
-        return (HIWORD(GetQueueStatus(QS_ALLINPUT)) == 0);
+    ULONG fStatus = WinQueryQueueStatus(HWND_DESKTOP);
+        return fStatus != 0; 
 }
 
 CEventQueueTimer*
-CMSWindowsEventQueueBuffer::newTimer(double, bool) const
+CPMEventQueueBuffer::newTimer(double, bool) const
 {
         return new CEventQueueTimer;
@@ -133 +115 @@
 
 void
-CMSWindowsEventQueueBuffer::deleteTimer(CEventQueueTimer* timer) const
+CPMEventQueueBuffer::deleteTimer(CEventQueueTimer* timer) const
 {
         delete timer;
 }
+

trunk/synergy/lib/platform/CPMEventQueueBuffer.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef CMSWINDOWSEVENTQUEUEBUFFER_H
-#define CMSWINDOWSEVENTQUEUEBUFFER_H
+#ifndef CPMEVENTQUEUEBUFFER_H
+#define CPMEVENTQUEUEBUFFER_H
 
 #include "IEventQueueBuffer.h"
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
+#define INCL_ERRORS
+#define INCL_BASE
+#define INCL_PM
+#include <os2.h>
 
-//! Event queue buffer for Win32
-class CMSWindowsEventQueueBuffer : public IEventQueueBuffer {
+//! Event queue buffer for PM
+class CPMEventQueueBuffer : public IEventQueueBuffer {
 public:
-        CMSWindowsEventQueueBuffer();
-        virtual ~CMSWindowsEventQueueBuffer();
+        CPMEventQueueBuffer();
+        virtual ~CPMEventQueueBuffer();
 
         // IEventQueueBuffer overrides
@@ -36 +39 @@
 
 private:
-        DWORD                           m_thread;
-        UINT                            m_userEvent;
-        MSG                                     m_event;
-        UINT                            m_daemonQuit;
+        HAB                                 m_hab;
+        HMQ                                 m_hmq;
+    HEV                 m_hev;
+        ULONG                           m_userEvent;
+        QMSG                            m_event;
+        ULONG                           m_daemonQuit;
 };
 

trunk/synergy/lib/platform/CPMKeyState.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2003 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "CMSWindowsKeyState.h"
-#include "CMSWindowsDesks.h"
+#include "CPMKeyState.h"
 #include "CThread.h"
 #include "CFunctionJob.h"
@@ -21 +21 @@
 #include "IEventQueue.h"
 #include "TMethodEventJob.h"
-#include "CArchMiscWindows.h"
-
-// extended mouse buttons
-#if !defined(VK_XBUTTON1)
-#define VK_XBUTTON1                             0x05
-#define VK_XBUTTON2                             0x06
-#endif
 
 //
-// CMSWindowsKeyState
+// CPMKeyState
 //
 
 // map virtual keys to synergy key enumeration
-const KeyID                             CMSWindowsKeyState::s_virtualKey[] =
-{
-        /* 0x000 */ { kKeyNone },               // reserved
-        /* 0x001 */ { kKeyNone },               // VK_LBUTTON
-        /* 0x002 */ { kKeyNone },               // VK_RBUTTON
-        /* 0x003 */ { kKeyNone },               // VK_CANCEL
-        /* 0x004 */ { kKeyNone },               // VK_MBUTTON
-        /* 0x005 */ { kKeyNone },               // VK_XBUTTON1
-        /* 0x006 */ { kKeyNone },               // VK_XBUTTON2
-        /* 0x007 */ { kKeyNone },               // undefined
-        /* 0x008 */ { kKeyBackSpace },  // VK_BACK
-        /* 0x009 */ { kKeyTab },                // VK_TAB
-        /* 0x00a */ { kKeyNone },               // undefined
-        /* 0x00b */ { kKeyNone },               // undefined
-        /* 0x00c */ { kKeyClear },              // VK_CLEAR
-        /* 0x00d */ { kKeyReturn },             // VK_RETURN
-        /* 0x00e */ { kKeyNone },               // undefined
-        /* 0x00f */ { kKeyNone },               // undefined
-        /* 0x010 */ { kKeyShift_L },    // VK_SHIFT
-        /* 0x011 */ { kKeyControl_L },  // VK_CONTROL
-        /* 0x012 */ { kKeyAlt_L },              // VK_MENU
-        /* 0x013 */ { kKeyPause },              // VK_PAUSE
-        /* 0x014 */ { kKeyCapsLock },   // VK_CAPITAL
-        /* 0x015 */ { kKeyNone },               // VK_KANA                      
-        /* 0x016 */ { kKeyNone },               // VK_HANGUL            
-        /* 0x017 */ { kKeyNone },               // VK_JUNJA                     
-        /* 0x018 */ { kKeyNone },               // VK_FINAL                     
-        /* 0x019 */ { kKeyZenkaku },    // VK_KANJI                     
-        /* 0x01a */ { kKeyNone },               // undefined
-        /* 0x01b */ { kKeyEscape },             // VK_ESCAPE
-        /* 0x01c */ { kKeyHenkan },             // VK_CONVERT           
-        /* 0x01d */ { kKeyNone },               // VK_NONCONVERT        
-        /* 0x01e */ { kKeyNone },               // VK_ACCEPT            
-        /* 0x01f */ { kKeyNone },               // VK_MODECHANGE        
-        /* 0x020 */ { kKeyNone },               // VK_SPACE
-        /* 0x021 */ { kKeyKP_PageUp },  // VK_PRIOR
-        /* 0x022 */ { kKeyKP_PageDown },// VK_NEXT
-        /* 0x023 */ { kKeyKP_End },             // VK_END
-        /* 0x024 */ { kKeyKP_Home },    // VK_HOME
-        /* 0x025 */ { kKeyKP_Left },    // VK_LEFT
-        /* 0x026 */ { kKeyKP_Up },              // VK_UP
-        /* 0x027 */ { kKeyKP_Right },   // VK_RIGHT
-        /* 0x028 */ { kKeyKP_Down },    // VK_DOWN
-        /* 0x029 */ { kKeySelect },             // VK_SELECT
-        /* 0x02a */ { kKeyNone },               // VK_PRINT
-        /* 0x02b */ { kKeyExecute },    // VK_EXECUTE
-        /* 0x02c */ { kKeyPrint },              // VK_SNAPSHOT
-        /* 0x02d */ { kKeyKP_Insert },  // VK_INSERT
-        /* 0x02e */ { kKeyKP_Delete },  // VK_DELETE
-        /* 0x02f */ { kKeyHelp },               // VK_HELP
-        /* 0x030 */ { kKeyNone },               // VK_0
-        /* 0x031 */ { kKeyNone },               // VK_1
-        /* 0x032 */ { kKeyNone },               // VK_2
-        /* 0x033 */ { kKeyNone },               // VK_3
-        /* 0x034 */ { kKeyNone },               // VK_4
-        /* 0x035 */ { kKeyNone },               // VK_5
-        /* 0x036 */ { kKeyNone },               // VK_6
-        /* 0x037 */ { kKeyNone },               // VK_7
-        /* 0x038 */ { kKeyNone },               // VK_8
-        /* 0x039 */ { kKeyNone },               // VK_9
-        /* 0x03a */ { kKeyNone },               // undefined
-        /* 0x03b */ { kKeyNone },               // undefined
-        /* 0x03c */ { kKeyNone },               // undefined
-        /* 0x03d */ { kKeyNone },               // undefined
-        /* 0x03e */ { kKeyNone },               // undefined
-        /* 0x03f */ { kKeyNone },               // undefined
-        /* 0x040 */ { kKeyNone },               // undefined
-        /* 0x041 */ { kKeyNone },               // VK_A
-        /* 0x042 */ { kKeyNone },               // VK_B
-        /* 0x043 */ { kKeyNone },               // VK_C
-        /* 0x044 */ { kKeyNone },               // VK_D
-        /* 0x045 */ { kKeyNone },               // VK_E
-        /* 0x046 */ { kKeyNone },               // VK_F
-        /* 0x047 */ { kKeyNone },               // VK_G
-        /* 0x048 */ { kKeyNone },               // VK_H
-        /* 0x049 */ { kKeyNone },               // VK_I
-        /* 0x04a */ { kKeyNone },               // VK_J
-        /* 0x04b */ { kKeyNone },               // VK_K
-        /* 0x04c */ { kKeyNone },               // VK_L
-        /* 0x04d */ { kKeyNone },               // VK_M
-        /* 0x04e */ { kKeyNone },               // VK_N
-        /* 0x04f */ { kKeyNone },               // VK_O
-        /* 0x050 */ { kKeyNone },               // VK_P
-        /* 0x051 */ { kKeyNone },               // VK_Q
-        /* 0x052 */ { kKeyNone },               // VK_R
-        /* 0x053 */ { kKeyNone },               // VK_S
-        /* 0x054 */ { kKeyNone },               // VK_T
-        /* 0x055 */ { kKeyNone },               // VK_U
-        /* 0x056 */ { kKeyNone },               // VK_V
-        /* 0x057 */ { kKeyNone },               // VK_W
-        /* 0x058 */ { kKeyNone },               // VK_X
-        /* 0x059 */ { kKeyNone },               // VK_Y
-        /* 0x05a */ { kKeyNone },               // VK_Z
-        /* 0x05b */ { kKeySuper_L },    // VK_LWIN
-        /* 0x05c */ { kKeySuper_R },    // VK_RWIN
-        /* 0x05d */ { kKeyMenu },               // VK_APPS
-        /* 0x05e */ { kKeyNone },               // undefined
-        /* 0x05f */ { kKeySleep },              // VK_SLEEP
-        /* 0x060 */ { kKeyKP_0 },               // VK_NUMPAD0
-        /* 0x061 */ { kKeyKP_1 },               // VK_NUMPAD1
-        /* 0x062 */ { kKeyKP_2 },               // VK_NUMPAD2
-        /* 0x063 */ { kKeyKP_3 },               // VK_NUMPAD3
-        /* 0x064 */ { kKeyKP_4 },               // VK_NUMPAD4
-        /* 0x065 */ { kKeyKP_5 },               // VK_NUMPAD5
-        /* 0x066 */ { kKeyKP_6 },               // VK_NUMPAD6
-        /* 0x067 */ { kKeyKP_7 },               // VK_NUMPAD7
-        /* 0x068 */ { kKeyKP_8 },               // VK_NUMPAD8
-        /* 0x069 */ { kKeyKP_9 },               // VK_NUMPAD9
-        /* 0x06a */ { kKeyKP_Multiply },// VK_MULTIPLY
-        /* 0x06b */ { kKeyKP_Add },             // VK_ADD
-        /* 0x06c */ { kKeyKP_Separator },// VK_SEPARATOR
-        /* 0x06d */ { kKeyKP_Subtract },// VK_SUBTRACT
-        /* 0x06e */ { kKeyKP_Decimal }, // VK_DECIMAL
-        /* 0x06f */ { kKeyNone },               // VK_DIVIDE
-        /* 0x070 */ { kKeyF1 },                 // VK_F1
-        /* 0x071 */ { kKeyF2 },                 // VK_F2
-        /* 0x072 */ { kKeyF3 },                 // VK_F3
-        /* 0x073 */ { kKeyF4 },                 // VK_F4
-        /* 0x074 */ { kKeyF5 },                 // VK_F5
-        /* 0x075 */ { kKeyF6 },                 // VK_F6
-        /* 0x076 */ { kKeyF7 },                 // VK_F7
-        /* 0x077 */ { kKeyF8 },                 // VK_F8
-        /* 0x078 */ { kKeyF9 },                 // VK_F9
-        /* 0x079 */ { kKeyF10 },                // VK_F10
-        /* 0x07a */ { kKeyF11 },                // VK_F11
-        /* 0x07b */ { kKeyF12 },                // VK_F12
-        /* 0x07c */ { kKeyF13 },                // VK_F13
-        /* 0x07d */ { kKeyF14 },                // VK_F14
-        /* 0x07e */ { kKeyF15 },                // VK_F15
-        /* 0x07f */ { kKeyF16 },                // VK_F16
-        /* 0x080 */ { kKeyF17 },                // VK_F17
-        /* 0x081 */ { kKeyF18 },                // VK_F18
-        /* 0x082 */ { kKeyF19 },                // VK_F19
-        /* 0x083 */ { kKeyF20 },                // VK_F20
-        /* 0x084 */ { kKeyF21 },                // VK_F21
-        /* 0x085 */ { kKeyF22 },                // VK_F22
-        /* 0x086 */ { kKeyF23 },                // VK_F23
-        /* 0x087 */ { kKeyF24 },                // VK_F24
-        /* 0x088 */ { kKeyNone },               // unassigned
-        /* 0x089 */ { kKeyNone },               // unassigned
-        /* 0x08a */ { kKeyNone },               // unassigned
-        /* 0x08b */ { kKeyNone },               // unassigned
-        /* 0x08c */ { kKeyNone },               // unassigned
-        /* 0x08d */ { kKeyNone },               // unassigned
-        /* 0x08e */ { kKeyNone },               // unassigned
-        /* 0x08f */ { kKeyNone },               // unassigned
-        /* 0x090 */ { kKeyNumLock },    // VK_NUMLOCK
-        /* 0x091 */ { kKeyScrollLock }, // VK_SCROLL
-        /* 0x092 */ { kKeyNone },               // unassigned
-        /* 0x093 */ { kKeyNone },               // unassigned
-        /* 0x094 */ { kKeyNone },               // unassigned
-        /* 0x095 */ { kKeyNone },               // unassigned
-        /* 0x096 */ { kKeyNone },               // unassigned
-        /* 0x097 */ { kKeyNone },               // unassigned
-        /* 0x098 */ { kKeyNone },               // unassigned
-        /* 0x099 */ { kKeyNone },               // unassigned
-        /* 0x09a */ { kKeyNone },               // unassigned
-        /* 0x09b */ { kKeyNone },               // unassigned
-        /* 0x09c */ { kKeyNone },               // unassigned
-        /* 0x09d */ { kKeyNone },               // unassigned
-        /* 0x09e */ { kKeyNone },               // unassigned
-        /* 0x09f */ { kKeyNone },               // unassigned
-        /* 0x0a0 */ { kKeyShift_L },    // VK_LSHIFT
-        /* 0x0a1 */ { kKeyShift_R },    // VK_RSHIFT
-        /* 0x0a2 */ { kKeyControl_L },  // VK_LCONTROL
-        /* 0x0a3 */ { kKeyControl_R },  // VK_RCONTROL
-        /* 0x0a4 */ { kKeyAlt_L },              // VK_LMENU
-        /* 0x0a5 */ { kKeyAlt_R },              // VK_RMENU
-        /* 0x0a6 */ { kKeyNone },               // VK_BROWSER_BACK
-        /* 0x0a7 */ { kKeyNone },               // VK_BROWSER_FORWARD
-        /* 0x0a8 */ { kKeyNone },               // VK_BROWSER_REFRESH
-        /* 0x0a9 */ { kKeyNone },               // VK_BROWSER_STOP
-        /* 0x0aa */ { kKeyNone },               // VK_BROWSER_SEARCH
-        /* 0x0ab */ { kKeyNone },               // VK_BROWSER_FAVORITES
-        /* 0x0ac */ { kKeyNone },               // VK_BROWSER_HOME
-        /* 0x0ad */ { kKeyNone },               // VK_VOLUME_MUTE
-        /* 0x0ae */ { kKeyNone },               // VK_VOLUME_DOWN
-        /* 0x0af */ { kKeyNone },               // VK_VOLUME_UP
-        /* 0x0b0 */ { kKeyNone },               // VK_MEDIA_NEXT_TRACK
-        /* 0x0b1 */ { kKeyNone },               // VK_MEDIA_PREV_TRACK
-        /* 0x0b2 */ { kKeyNone },               // VK_MEDIA_STOP
-        /* 0x0b3 */ { kKeyNone },               // VK_MEDIA_PLAY_PAUSE
-        /* 0x0b4 */ { kKeyNone },               // VK_LAUNCH_MAIL
-        /* 0x0b5 */ { kKeyNone },               // VK_LAUNCH_MEDIA_SELECT
-        /* 0x0b6 */ { kKeyNone },               // VK_LAUNCH_APP1
-        /* 0x0b7 */ { kKeyNone },               // VK_LAUNCH_APP2
-        /* 0x0b8 */ { kKeyNone },               // unassigned
-        /* 0x0b9 */ { kKeyNone },               // unassigned
-        /* 0x0ba */ { kKeyNone },               // OEM specific
-        /* 0x0bb */ { kKeyNone },               // OEM specific
-        /* 0x0bc */ { kKeyNone },               // OEM specific
-        /* 0x0bd */ { kKeyNone },               // OEM specific
-        /* 0x0be */ { kKeyNone },               // OEM specific
-        /* 0x0bf */ { kKeyNone },               // OEM specific
-        /* 0x0c0 */ { kKeyNone },               // OEM specific
-        /* 0x0c1 */ { kKeyNone },               // unassigned
-        /* 0x0c2 */ { kKeyNone },               // unassigned
-        /* 0x0c3 */ { kKeyNone },               // unassigned
-        /* 0x0c4 */ { kKeyNone },               // unassigned
-        /* 0x0c5 */ { kKeyNone },               // unassigned
-        /* 0x0c6 */ { kKeyNone },               // unassigned
-        /* 0x0c7 */ { kKeyNone },               // unassigned
-        /* 0x0c8 */ { kKeyNone },               // unassigned
-        /* 0x0c9 */ { kKeyNone },               // unassigned
-        /* 0x0ca */ { kKeyNone },               // unassigned
-        /* 0x0cb */ { kKeyNone },               // unassigned
-        /* 0x0cc */ { kKeyNone },               // unassigned
-        /* 0x0cd */ { kKeyNone },               // unassigned
-        /* 0x0ce */ { kKeyNone },               // unassigned
-        /* 0x0cf */ { kKeyNone },               // unassigned
-        /* 0x0d0 */ { kKeyNone },               // unassigned
-        /* 0x0d1 */ { kKeyNone },               // unassigned
-        /* 0x0d2 */ { kKeyNone },               // unassigned
-        /* 0x0d3 */ { kKeyNone },               // unassigned
-        /* 0x0d4 */ { kKeyNone },               // unassigned
-        /* 0x0d5 */ { kKeyNone },               // unassigned
-        /* 0x0d6 */ { kKeyNone },               // unassigned
-        /* 0x0d7 */ { kKeyNone },               // unassigned
-        /* 0x0d8 */ { kKeyNone },               // unassigned
-        /* 0x0d9 */ { kKeyNone },               // unassigned
-        /* 0x0da */ { kKeyNone },               // unassigned
-        /* 0x0db */ { kKeyNone },               // OEM specific
-        /* 0x0dc */ { kKeyNone },               // OEM specific
-        /* 0x0dd */ { kKeyNone },               // OEM specific
-        /* 0x0de */ { kKeyNone },               // OEM specific
-        /* 0x0df */ { kKeyNone },               // OEM specific
-        /* 0x0e0 */ { kKeyNone },               // OEM specific
-        /* 0x0e1 */ { kKeyNone },               // OEM specific
-        /* 0x0e2 */ { kKeyNone },               // OEM specific
-        /* 0x0e3 */ { kKeyNone },               // OEM specific
-        /* 0x0e4 */ { kKeyNone },               // OEM specific
-        /* 0x0e5 */ { kKeyNone },               // unassigned
-        /* 0x0e6 */ { kKeyNone },               // OEM specific
-        /* 0x0e7 */ { kKeyNone },               // unassigned
-        /* 0x0e8 */ { kKeyNone },               // unassigned
-        /* 0x0e9 */ { kKeyNone },               // OEM specific
-        /* 0x0ea */ { kKeyNone },               // OEM specific
-        /* 0x0eb */ { kKeyNone },               // OEM specific
-        /* 0x0ec */ { kKeyNone },               // OEM specific
-        /* 0x0ed */ { kKeyNone },               // OEM specific
-        /* 0x0ee */ { kKeyNone },               // OEM specific
-        /* 0x0ef */ { kKeyNone },               // OEM specific
-        /* 0x0f0 */ { kKeyNone },               // OEM specific
-        /* 0x0f1 */ { kKeyNone },               // OEM specific
-        /* 0x0f2 */ { kKeyNone },               // OEM specific
-        /* 0x0f3 */ { kKeyNone },               // OEM specific
-        /* 0x0f4 */ { kKeyNone },               // OEM specific
-        /* 0x0f5 */ { kKeyNone },               // OEM specific
-        /* 0x0f6 */ { kKeyNone },               // VK_ATTN                      
-        /* 0x0f7 */ { kKeyNone },               // VK_CRSEL                     
-        /* 0x0f8 */ { kKeyNone },               // VK_EXSEL                     
-        /* 0x0f9 */ { kKeyNone },               // VK_EREOF                     
-        /* 0x0fa */ { kKeyNone },               // VK_PLAY                      
-        /* 0x0fb */ { kKeyNone },               // VK_ZOOM                      
-        /* 0x0fc */ { kKeyNone },               // reserved
-        /* 0x0fd */ { kKeyNone },               // VK_PA1                       
-        /* 0x0fe */ { kKeyNone },               // VK_OEM_CLEAR         
-        /* 0x0ff */ { kKeyNone },               // reserved
-
-        /* 0x100 */ { kKeyNone },               // reserved
-        /* 0x101 */ { kKeyNone },               // VK_LBUTTON
-        /* 0x102 */ { kKeyNone },               // VK_RBUTTON
-        /* 0x103 */ { kKeyBreak },              // VK_CANCEL
-        /* 0x104 */ { kKeyNone },               // VK_MBUTTON
-        /* 0x105 */ { kKeyNone },               // VK_XBUTTON1
-        /* 0x106 */ { kKeyNone },               // VK_XBUTTON2
-        /* 0x107 */ { kKeyNone },               // undefined
-        /* 0x108 */ { kKeyNone },               // VK_BACK
-        /* 0x109 */ { kKeyNone },               // VK_TAB
-        /* 0x10a */ { kKeyNone },               // undefined
-        /* 0x10b */ { kKeyNone },               // undefined
-        /* 0x10c */ { kKeyClear },              // VK_CLEAR
-        /* 0x10d */ { kKeyKP_Enter },   // VK_RETURN
-        /* 0x10e */ { kKeyNone },               // undefined
-        /* 0x10f */ { kKeyNone },               // undefined
-        /* 0x110 */ { kKeyShift_R },    // VK_SHIFT
-        /* 0x111 */ { kKeyControl_R },  // VK_CONTROL
-        /* 0x112 */ { kKeyAlt_R },              // VK_MENU
-        /* 0x113 */ { kKeyNone },               // VK_PAUSE
-        /* 0x114 */ { kKeyNone },               // VK_CAPITAL
-        /* 0x115 */ { kKeyNone },               // VK_KANA                      
-        /* 0x116 */ { kKeyNone },               // VK_HANGUL            
-        /* 0x117 */ { kKeyNone },               // VK_JUNJA                     
-        /* 0x118 */ { kKeyNone },               // VK_FINAL                     
-        /* 0x119 */ { kKeyNone },               // VK_KANJI                     
-        /* 0x11a */ { kKeyNone },               // undefined
-        /* 0x11b */ { kKeyNone },               // VK_ESCAPE
-        /* 0x11c */ { kKeyNone },               // VK_CONVERT           
-        /* 0x11d */ { kKeyNone },               // VK_NONCONVERT        
-        /* 0x11e */ { kKeyNone },               // VK_ACCEPT            
-        /* 0x11f */ { kKeyNone },               // VK_MODECHANGE        
-        /* 0x120 */ { kKeyNone },               // VK_SPACE
-        /* 0x121 */ { kKeyPageUp },             // VK_PRIOR
-        /* 0x122 */ { kKeyPageDown },   // VK_NEXT
-        /* 0x123 */ { kKeyEnd },                // VK_END
-        /* 0x124 */ { kKeyHome },               // VK_HOME
-        /* 0x125 */ { kKeyLeft },               // VK_LEFT
-        /* 0x126 */ { kKeyUp },                 // VK_UP
-        /* 0x127 */ { kKeyRight },              // VK_RIGHT
-        /* 0x128 */ { kKeyDown },               // VK_DOWN
-        /* 0x129 */ { kKeySelect },             // VK_SELECT
-        /* 0x12a */ { kKeyNone },               // VK_PRINT
-        /* 0x12b */ { kKeyExecute },    // VK_EXECUTE
-        /* 0x12c */ { kKeyPrint },              // VK_SNAPSHOT
-        /* 0x12d */ { kKeyInsert },             // VK_INSERT
-        /* 0x12e */ { kKeyDelete },             // VK_DELETE
-        /* 0x12f */ { kKeyHelp },               // VK_HELP
-        /* 0x130 */ { kKeyNone },               // VK_0
-        /* 0x131 */ { kKeyNone },               // VK_1
-        /* 0x132 */ { kKeyNone },               // VK_2
-        /* 0x133 */ { kKeyNone },               // VK_3
-        /* 0x134 */ { kKeyNone },               // VK_4
-        /* 0x135 */ { kKeyNone },               // VK_5
-        /* 0x136 */ { kKeyNone },               // VK_6
-        /* 0x137 */ { kKeyNone },               // VK_7
-        /* 0x138 */ { kKeyNone },               // VK_8
-        /* 0x139 */ { kKeyNone },               // VK_9
-        /* 0x13a */ { kKeyNone },               // undefined
-        /* 0x13b */ { kKeyNone },               // undefined
-        /* 0x13c */ { kKeyNone },               // undefined
-        /* 0x13d */ { kKeyNone },               // undefined
-        /* 0x13e */ { kKeyNone },               // undefined
-        /* 0x13f */ { kKeyNone },               // undefined
-        /* 0x140 */ { kKeyNone },               // undefined
-        /* 0x141 */ { kKeyNone },               // VK_A
-        /* 0x142 */ { kKeyNone },               // VK_B
-        /* 0x143 */ { kKeyNone },               // VK_C
-        /* 0x144 */ { kKeyNone },               // VK_D
-        /* 0x145 */ { kKeyNone },               // VK_E
-        /* 0x146 */ { kKeyNone },               // VK_F
-        /* 0x147 */ { kKeyNone },               // VK_G
-        /* 0x148 */ { kKeyNone },               // VK_H
-        /* 0x149 */ { kKeyNone },               // VK_I
-        /* 0x14a */ { kKeyNone },               // VK_J
-        /* 0x14b */ { kKeyNone },               // VK_K
-        /* 0x14c */ { kKeyNone },               // VK_L
-        /* 0x14d */ { kKeyNone },               // VK_M
-        /* 0x14e */ { kKeyNone },               // VK_N
-        /* 0x14f */ { kKeyNone },               // VK_O
-        /* 0x150 */ { kKeyNone },               // VK_P
-        /* 0x151 */ { kKeyNone },               // VK_Q
-        /* 0x152 */ { kKeyNone },               // VK_R
-        /* 0x153 */ { kKeyNone },               // VK_S
-        /* 0x154 */ { kKeyNone },               // VK_T
-        /* 0x155 */ { kKeyNone },               // VK_U
-        /* 0x156 */ { kKeyNone },               // VK_V
-        /* 0x157 */ { kKeyNone },               // VK_W
-        /* 0x158 */ { kKeyNone },               // VK_X
-        /* 0x159 */ { kKeyNone },               // VK_Y
-        /* 0x15a */ { kKeyNone },               // VK_Z
-        /* 0x15b */ { kKeySuper_L },    // VK_LWIN
-        /* 0x15c */ { kKeySuper_R },    // VK_RWIN
-        /* 0x15d */ { kKeyMenu },               // VK_APPS
-        /* 0x15e */ { kKeyNone },               // undefined
-        /* 0x15f */ { kKeyNone },               // VK_SLEEP
-        /* 0x160 */ { kKeyNone },               // VK_NUMPAD0
-        /* 0x161 */ { kKeyNone },               // VK_NUMPAD1
-        /* 0x162 */ { kKeyNone },               // VK_NUMPAD2
-        /* 0x163 */ { kKeyNone },               // VK_NUMPAD3
-        /* 0x164 */ { kKeyNone },               // VK_NUMPAD4
-        /* 0x165 */ { kKeyNone },               // VK_NUMPAD5
-        /* 0x166 */ { kKeyNone },               // VK_NUMPAD6
-        /* 0x167 */ { kKeyNone },               // VK_NUMPAD7
-        /* 0x168 */ { kKeyNone },               // VK_NUMPAD8
-        /* 0x169 */ { kKeyNone },               // VK_NUMPAD9
-        /* 0x16a */ { kKeyNone },               // VK_MULTIPLY
-        /* 0x16b */ { kKeyNone },               // VK_ADD
-        /* 0x16c */ { kKeyKP_Separator },// VK_SEPARATOR
-        /* 0x16d */ { kKeyNone },               // VK_SUBTRACT
-        /* 0x16e */ { kKeyNone },               // VK_DECIMAL
-        /* 0x16f */ { kKeyKP_Divide },  // VK_DIVIDE
-        /* 0x170 */ { kKeyNone },               // VK_F1
-        /* 0x171 */ { kKeyNone },               // VK_F2
-        /* 0x172 */ { kKeyNone },               // VK_F3
-        /* 0x173 */ { kKeyNone },               // VK_F4
-        /* 0x174 */ { kKeyNone },               // VK_F5
-        /* 0x175 */ { kKeyNone },               // VK_F6
-        /* 0x176 */ { kKeyNone },               // VK_F7
-        /* 0x177 */ { kKeyNone },               // VK_F8
-        /* 0x178 */ { kKeyNone },               // VK_F9
-        /* 0x179 */ { kKeyNone },               // VK_F10
-        /* 0x17a */ { kKeyNone },               // VK_F11
-        /* 0x17b */ { kKeyNone },               // VK_F12
-        /* 0x17c */ { kKeyF13 },                // VK_F13
-        /* 0x17d */ { kKeyF14 },                // VK_F14
-        /* 0x17e */ { kKeyF15 },                // VK_F15
-        /* 0x17f */ { kKeyF16 },                // VK_F16
-        /* 0x180 */ { kKeyF17 },                // VK_F17
-        /* 0x181 */ { kKeyF18 },                // VK_F18
-        /* 0x182 */ { kKeyF19 },                // VK_F19
-        /* 0x183 */ { kKeyF20 },                // VK_F20
-        /* 0x184 */ { kKeyF21 },                // VK_F21
-        /* 0x185 */ { kKeyF22 },                // VK_F22
-        /* 0x186 */ { kKeyF23 },                // VK_F23
-        /* 0x187 */ { kKeyF24 },                // VK_F24
-        /* 0x188 */ { kKeyNone },               // unassigned
-        /* 0x189 */ { kKeyNone },               // unassigned
-        /* 0x18a */ { kKeyNone },               // unassigned
-        /* 0x18b */ { kKeyNone },               // unassigned
-        /* 0x18c */ { kKeyNone },               // unassigned
-        /* 0x18d */ { kKeyNone },               // unassigned
-        /* 0x18e */ { kKeyNone },               // unassigned
-        /* 0x18f */ { kKeyNone },               // unassigned
-        /* 0x190 */ { kKeyNumLock },    // VK_NUMLOCK
-        /* 0x191 */ { kKeyNone },               // VK_SCROLL
-        /* 0x192 */ { kKeyNone },               // unassigned
-        /* 0x193 */ { kKeyNone },               // unassigned
-        /* 0x194 */ { kKeyNone },               // unassigned
-        /* 0x195 */ { kKeyNone },               // unassigned
-        /* 0x196 */ { kKeyNone },               // unassigned
-        /* 0x197 */ { kKeyNone },               // unassigned
-        /* 0x198 */ { kKeyNone },               // unassigned
-        /* 0x199 */ { kKeyNone },               // unassigned
-        /* 0x19a */ { kKeyNone },               // unassigned
-        /* 0x19b */ { kKeyNone },               // unassigned
-        /* 0x19c */ { kKeyNone },               // unassigned
-        /* 0x19d */ { kKeyNone },               // unassigned
-        /* 0x19e */ { kKeyNone },               // unassigned
-        /* 0x19f */ { kKeyNone },               // unassigned
-        /* 0x1a0 */ { kKeyShift_L },    // VK_LSHIFT
-        /* 0x1a1 */ { kKeyShift_R },    // VK_RSHIFT
-        /* 0x1a2 */ { kKeyControl_L },  // VK_LCONTROL
-        /* 0x1a3 */ { kKeyControl_R },  // VK_RCONTROL
-        /* 0x1a4 */ { kKeyAlt_L },              // VK_LMENU
-        /* 0x1a5 */ { kKeyAlt_R },              // VK_RMENU
-        /* 0x1a6 */ { kKeyWWWBack },    // VK_BROWSER_BACK
-        /* 0x1a7 */ { kKeyWWWForward }, // VK_BROWSER_FORWARD
-        /* 0x1a8 */ { kKeyWWWRefresh }, // VK_BROWSER_REFRESH
-        /* 0x1a9 */ { kKeyWWWStop },    // VK_BROWSER_STOP
-        /* 0x1aa */ { kKeyWWWSearch },  // VK_BROWSER_SEARCH
-        /* 0x1ab */ { kKeyWWWFavorites },// VK_BROWSER_FAVORITES
-        /* 0x1ac */ { kKeyWWWHome },    // VK_BROWSER_HOME
-        /* 0x1ad */ { kKeyAudioMute },  // VK_VOLUME_MUTE
-        /* 0x1ae */ { kKeyAudioDown },  // VK_VOLUME_DOWN
-        /* 0x1af */ { kKeyAudioUp },    // VK_VOLUME_UP
-        /* 0x1b0 */ { kKeyAudioNext },  // VK_MEDIA_NEXT_TRACK
-        /* 0x1b1 */ { kKeyAudioPrev },  // VK_MEDIA_PREV_TRACK
-        /* 0x1b2 */ { kKeyAudioStop },  // VK_MEDIA_STOP
-        /* 0x1b3 */ { kKeyAudioPlay },  // VK_MEDIA_PLAY_PAUSE
-        /* 0x1b4 */ { kKeyAppMail },    // VK_LAUNCH_MAIL
-        /* 0x1b5 */ { kKeyAppMedia },   // VK_LAUNCH_MEDIA_SELECT
-        /* 0x1b6 */ { kKeyAppUser1 },   // VK_LAUNCH_APP1
-        /* 0x1b7 */ { kKeyAppUser2 },   // VK_LAUNCH_APP2
-        /* 0x1b8 */ { kKeyNone },               // unassigned
-        /* 0x1b9 */ { kKeyNone },               // unassigned
-        /* 0x1ba */ { kKeyNone },               // OEM specific
-        /* 0x1bb */ { kKeyNone },               // OEM specific
-        /* 0x1bc */ { kKeyNone },               // OEM specific
-        /* 0x1bd */ { kKeyNone },               // OEM specific
-        /* 0x1be */ { kKeyNone },               // OEM specific
-        /* 0x1bf */ { kKeyNone },               // OEM specific
-        /* 0x1c0 */ { kKeyNone },               // OEM specific
-        /* 0x1c1 */ { kKeyNone },               // unassigned
-        /* 0x1c2 */ { kKeyNone },               // unassigned
-        /* 0x1c3 */ { kKeyNone },               // unassigned
-        /* 0x1c4 */ { kKeyNone },               // unassigned
-        /* 0x1c5 */ { kKeyNone },               // unassigned
-        /* 0x1c6 */ { kKeyNone },               // unassigned
-        /* 0x1c7 */ { kKeyNone },               // unassigned
-        /* 0x1c8 */ { kKeyNone },               // unassigned
-        /* 0x1c9 */ { kKeyNone },               // unassigned
-        /* 0x1ca */ { kKeyNone },               // unassigned
-        /* 0x1cb */ { kKeyNone },               // unassigned
-        /* 0x1cc */ { kKeyNone },               // unassigned
-        /* 0x1cd */ { kKeyNone },               // unassigned
-        /* 0x1ce */ { kKeyNone },               // unassigned
-        /* 0x1cf */ { kKeyNone },               // unassigned
-        /* 0x1d0 */ { kKeyNone },               // unassigned
-        /* 0x1d1 */ { kKeyNone },               // unassigned
-        /* 0x1d2 */ { kKeyNone },               // unassigned
-        /* 0x1d3 */ { kKeyNone },               // unassigned
-        /* 0x1d4 */ { kKeyNone },               // unassigned
-        /* 0x1d5 */ { kKeyNone },               // unassigned
-        /* 0x1d6 */ { kKeyNone },               // unassigned
-        /* 0x1d7 */ { kKeyNone },               // unassigned
-        /* 0x1d8 */ { kKeyNone },               // unassigned
-        /* 0x1d9 */ { kKeyNone },               // unassigned
-        /* 0x1da */ { kKeyNone },               // unassigned
-        /* 0x1db */ { kKeyNone },               // OEM specific
-        /* 0x1dc */ { kKeyNone },               // OEM specific
-        /* 0x1dd */ { kKeyNone },               // OEM specific
-        /* 0x1de */ { kKeyNone },               // OEM specific
-        /* 0x1df */ { kKeyNone },               // OEM specific
-        /* 0x1e0 */ { kKeyNone },               // OEM specific
-        /* 0x1e1 */ { kKeyNone },               // OEM specific
-        /* 0x1e2 */ { kKeyNone },               // OEM specific
-        /* 0x1e3 */ { kKeyNone },               // OEM specific
-        /* 0x1e4 */ { kKeyNone },               // OEM specific
-        /* 0x1e5 */ { kKeyNone },               // unassigned
-        /* 0x1e6 */ { kKeyNone },               // OEM specific
-        /* 0x1e7 */ { kKeyNone },               // unassigned
-        /* 0x1e8 */ { kKeyNone },               // unassigned
-        /* 0x1e9 */ { kKeyNone },               // OEM specific
-        /* 0x1ea */ { kKeyNone },               // OEM specific
-        /* 0x1eb */ { kKeyNone },               // OEM specific
-        /* 0x1ec */ { kKeyNone },               // OEM specific
-        /* 0x1ed */ { kKeyNone },               // OEM specific
-        /* 0x1ee */ { kKeyNone },               // OEM specific
-        /* 0x1ef */ { kKeyNone },               // OEM specific
-        /* 0x1f0 */ { kKeyNone },               // OEM specific
-        /* 0x1f1 */ { kKeyNone },               // OEM specific
-        /* 0x1f2 */ { kKeyNone },               // OEM specific
-        /* 0x1f3 */ { kKeyNone },               // OEM specific
-        /* 0x1f4 */ { kKeyNone },               // OEM specific
-        /* 0x1f5 */ { kKeyNone },               // OEM specific
-        /* 0x1f6 */ { kKeyNone },               // VK_ATTN                      
-        /* 0x1f7 */ { kKeyNone },               // VK_CRSEL                     
-        /* 0x1f8 */ { kKeyNone },               // VK_EXSEL                     
-        /* 0x1f9 */ { kKeyNone },               // VK_EREOF                     
-        /* 0x1fa */ { kKeyNone },               // VK_PLAY                      
-        /* 0x1fb */ { kKeyNone },               // VK_ZOOM                      
-        /* 0x1fc */ { kKeyNone },               // reserved
-        /* 0x1fd */ { kKeyNone },               // VK_PA1                       
-        /* 0x1fe */ { kKeyNone },               // VK_OEM_CLEAR         
-        /* 0x1ff */ { kKeyNone }                // reserved
+const KeyID                             CPMKeyState::s_virtualKey[0x42] =
+{
+        /* 0x000 */ kKeyNone,           // reserved
+        /* 0x001 */ kKeyNone,           // VK_BUTTON1              VK_BUTTON1          0x0001         
+        /* 0x002 */ kKeyNone,           // VK_BUTTON2              VK_BUTTON2          0x0002         
+        /* 0x003 */ kKeyNone,           // VK_BUTTON3              VK_BUTTON3          0x0003         
+        /* 0x004 */ kKeyBreak,          // VK_BREAK                VK_BREAK            0x0004         
+        /* 0x005 */ kKeyBackSpace,      // VK_BACKSPACE
+        /* 0x006 */ kKeyTab,            // VK_TAB
+        /* 0x007 */ kKeyLeftTab,        // VK_BACKTAB -- ???
+        /* 0x008 */ kKeyReturn,         // VK_NEWLINE
+        /* 0x009 */ kKeyShift_L,        // VK_SHIFT
+        /* 0x00a */ kKeyControl_L,      // VK_CTRL             0x000a         
+        /* 0x00b */ kKeyAlt_L,          // VK_ALT              0x000b         
+        /* 0x00c */ kKeyAltGr,          // VK_ALTGRAF          0x000c         
+        /* 0x00d */ kKeyPause,          // VK_PAUSE            0x000d         
+        /* 0x00e */ kKeyCapsLock,       // VK_CAPSLOCK         0x000e         
+        /* 0x00f */ kKeyEscape,         // VK_ESC              0x000f         
+        /* 0x010 */ kKeyNone,           // VK_SPACE            0x0010         
+        /* 0x011 */ kKeyPageUp,         // VK_PAGEUP           0x0011         
+        /* 0x012 */ kKeyPageDown,       // VK_PAGEDOWN         0x0012         
+        /* 0x013 */ kKeyEnd,            // VK_END              0x0013         
+        /* 0x014 */ kKeyHome,           // VK_HOME             0x0014         
+        /* 0x015 */ kKeyLeft,           // VK_LEFT             0x0015         
+        /* 0x016 */ kKeyUp,                     // VK_UP               0x0016         
+        /* 0x017 */ kKeyRight,          // VK_RIGHT            0x0017         
+        /* 0x018 */ kKeyDown,           // VK_DOWN             0x0018         
+        /* 0x019 */ kKeyNone,           // VK_PRINTSCRN            0x0019     
+        /* 0x01a */ kKeyInsert,         // VK_INSERT           0x001a         
+        /* 0x01b */ kKeyDelete,         // VK_DELETE           0x001b         
+        /* 0x01c */ kKeyScrollLock,     // VK_SCRLLOCK         0x001c         
+        /* 0x01d */ kKeyNumLock,        // VK_NUMLOCK          0x001d         
+        /* 0x01e */ kKeyKP_Enter,       // VK_ENTER            0x001e         
+        /* 0x01f */ kKeySysReq,         // VK_SYSRQ            0x001f         
+        /* 0x020 */ kKeyF1,                     // VK_F1               0x0020         
+        /* 0x021 */ kKeyF2,                     // VK_F2               0x0021         
+        /* 0x022 */ kKeyF3,                     // VK_F3               0x0022         
+        /* 0x023 */ kKeyF4,                     // VK_F4               0x0023         
+        /* 0x024 */ kKeyF5,                     // VK_F5               0x0024         
+        /* 0x025 */ kKeyF6,                     // VK_F6               0x0025         
+        /* 0x026 */ kKeyF7,                     // VK_F7               0x0026         
+        /* 0x027 */ kKeyF8,                     // VK_F8               0x0027         
+        /* 0x028 */ kKeyF9,                     // VK_F9               0x0028         
+        /* 0x029 */ kKeyF10,            // VK_F10              0x0029         
+        /* 0x02a */ kKeyF11,            // VK_F11              0x002a         
+        /* 0x02b */ kKeyF12,            // VK_F12              0x002b         
+        /* 0x02c */ kKeyF13,            // VK_F13              0x002c         
+        /* 0x02d */ kKeyF14,            // VK_F14              0x002d         
+        /* 0x02e */ kKeyF15,            // VK_F15              0x002e         
+        /* 0x02f */ kKeyF16,            // VK_F16              0x002f         
+        /* 0x030 */ kKeyF17,            // VK_F17              0x0030         
+        /* 0x031 */ kKeyF18,            // VK_F18              0x0031         
+        /* 0x032 */ kKeyF19,            // VK_F19              0x0032         
+        /* 0x033 */ kKeyF20,            // VK_F20              0x0033         
+        /* 0x034 */ kKeyF21,            // VK_F21              0x0034         
+        /* 0x035 */ kKeyF22,            // VK_F22              0x0035         
+        /* 0x036 */ kKeyF23,            // VK_F23              0x0036         
+        /* 0x037 */ kKeyF24,            // VK_F24              0x0037         
+        /* 0x038 */ kKeyNone,           // VK_ENDDRAG          0x0038         
+        /* 0x039 */ kKeyClear,          // VK_CLEAR            0x0039         
+        /* 0x03a */ kKeyNone,           // VK_EREOF            0x003a         
+        /* 0x03b */ kKeyNone,           // VK_PA1              0x003b         
+        /* 0x03c */ kKeyNone,           // VK_ATTN             0x003c         
+        /* 0x03d */ kKeyNone,           // VK_CRSEL            0x003d         
+        /* 0x03e */ kKeyNone,           // VK_EXSEL            0x003e         
+        /* 0x03f */ kKeyNone,           // VK_COPY             0x003f         
+        /* 0x040 */ kKeyNone,           // VK_BLK1             0x0040         
+        /* 0x041 */ kKeyNone            // VK_BLK2             0x0041         
 };
 
 struct CWin32Modifiers {
 public:
-        UINT                            m_vk;
+        ULONG                           m_vk;
         KeyModifierMask         m_mask;
 };
@@ -560 +106 @@
 {
         { VK_SHIFT,    KeyModifierShift   },
-        { VK_LSHIFT,   KeyModifierShift   },
-        { VK_RSHIFT,   KeyModifierShift   },
-        { VK_CONTROL,  KeyModifierControl },
-        { VK_LCONTROL, KeyModifierControl },
-        { VK_RCONTROL, KeyModifierControl },
-        { VK_MENU,     KeyModifierAlt     },
-        { VK_LMENU,    KeyModifierAlt     },
-        { VK_RMENU,    KeyModifierAlt     },
-        { VK_LWIN,     KeyModifierSuper   },
-        { VK_RWIN,     KeyModifierSuper   }
+        { VK_CTRL,     KeyModifierControl },
+        { VK_ALT,      KeyModifierAlt     },
+        { VK_ALTGRAF,  KeyModifierAltGr     },
 };
 
-CMSWindowsKeyState::CMSWindowsKeyState(CMSWindowsDesks* desks,
-                                void* eventTarget) :
-        m_is95Family(CArchMiscWindows::isWindows95Family()),
+CPMKeyState::CPMKeyState(void* eventTarget) :
         m_eventTarget(eventTarget),
-        m_desks(desks),
-        m_keyLayout(GetKeyboardLayout(0)),
         m_fixTimer(NULL),
         m_lastDown(0),
@@ -584 +119 @@
         m_originalSavedModifiers(0)
 {
-        // look up symbol that's available on winNT family but not win95
-        HMODULE userModule = GetModuleHandle("user32.dll");
-        m_ToUnicodeEx = (ToUnicodeEx_t)GetProcAddress(userModule, "ToUnicodeEx");
-}
-
-CMSWindowsKeyState::~CMSWindowsKeyState()
+
+}
+
+CPMKeyState::~CPMKeyState()
 {
         disable();
@@ -595 +128 @@
 
 void
-CMSWindowsKeyState::disable()
+CPMKeyState::disable()
 {
         if (m_fixTimer != NULL) {
@@ -606 +139 @@
 
 KeyButton
-CMSWindowsKeyState::virtualKeyToButton(UINT virtualKey) const
+CPMKeyState::virtualKeyToButton(ULONG virtualKey) const
 {
         return m_virtualKeyToButton[virtualKey & 0xffu];
 }
 
-void
-CMSWindowsKeyState::setKeyLayout(HKL keyLayout)
-{
-        m_keyLayout = keyLayout;
-}
-
 bool
-CMSWindowsKeyState::testAutoRepeat(bool press, bool isRepeat, KeyButton button)
+CPMKeyState::testAutoRepeat(bool press, bool isRepeat, KeyButton button)
 {
         if (!isRepeat) {
@@ -633 +160 @@
 
 void
-CMSWindowsKeyState::saveModifiers()
+CPMKeyState::saveModifiers()
 {
         m_savedModifiers         = getActiveModifiers();
@@ -640 +167 @@
 
 void
-CMSWindowsKeyState::useSavedModifiers(bool enable)
+CPMKeyState::useSavedModifiers(bool enable)
 {
         if (enable != m_useSavedModifiers) {
@@ -654 +181 @@
 
 KeyID
-CMSWindowsKeyState::mapKeyFromEvent(WPARAM charAndVirtKey,
-                                LPARAM info, KeyModifierMask* maskOut) const
-{
-        static const KeyModifierMask s_controlAlt =
-                KeyModifierControl | KeyModifierAlt;
+CPMKeyState::mapKeyFromEvent(MPARAM charAndVirtKey, MPARAM info, KeyModifierMask* maskOut) const
+{
+        static const KeyModifierMask s_controlAlt = KeyModifierControl | KeyModifierAlt;
 
         // extract character, virtual key, and if we didn't use AltGr
@@ -708 +233 @@
 
 bool
-CMSWindowsKeyState::didGroupsChange() const
+CPMKeyState::didGroupsChange() const
 {
         GroupList groups;
@@ -715 +240 @@
 
 UINT
-CMSWindowsKeyState::mapKeyToVirtualKey(KeyID key) const
+CPMKeyState::mapKeyToVirtualKey(KeyID key) const
 {
         if (key == kKeyNone) {
@@ -730 +255 @@
 
 void
-CMSWindowsKeyState::onKey(KeyButton button, bool down, KeyModifierMask newState)
+CPMKeyState::onKey(KeyButton button, bool down, KeyModifierMask newState)
 {
         // handle win32 brokenness and forward to superclass
@@ -739 +264 @@
 
 void
-CMSWindowsKeyState::sendKeyEvent(void* target,
+CPMKeyState::sendKeyEvent(void* target,
                                                         bool press, bool isAutoRepeat,
                                                         KeyID key, KeyModifierMask mask,
@@ -765 +290 @@
 
 void
-CMSWindowsKeyState::fakeKeyDown(KeyID id, KeyModifierMask mask,
+CPMKeyState::fakeKeyDown(KeyID id, KeyModifierMask mask,
                                 KeyButton button)
 {
@@ -772 +297 @@
 
 void
-CMSWindowsKeyState::fakeKeyRepeat(KeyID id, KeyModifierMask mask,
+CPMKeyState::fakeKeyRepeat(KeyID id, KeyModifierMask mask,
                                 SInt32 count, KeyButton button)
 {
@@ -779 +304 @@
 
 bool
-CMSWindowsKeyState::fakeCtrlAltDel()
-{
-        if (!m_is95Family) {
-                // to fake ctrl+alt+del on the NT family we broadcast a suitable
-                // hotkey to all windows on the winlogon desktop.  however, the
-                // current thread must be on that desktop to do the broadcast
-                // and we can't switch just any thread because some own windows
-                // or hooks.  so start a new thread to do the real work.
-                CThread cad(new CFunctionJob(&CMSWindowsKeyState::ctrlAltDelThread));
-                cad.wait();
-        }
-        else {
-                // simulate ctrl+alt+del
-                fakeKeyDown(kKeyDelete, KeyModifierControl | KeyModifierAlt,
-                                                        virtualKeyToButton(VK_DELETE));
-        }
-        return true;
-}
-
-void
-CMSWindowsKeyState::ctrlAltDelThread(void*)
-{
-        // get the Winlogon desktop at whatever privilege we can
-        HDESK desk = OpenDesktop("Winlogon", 0, FALSE, MAXIMUM_ALLOWED);
-        if (desk != NULL) {
-                if (SetThreadDesktop(desk)) {
-                        PostMessage(HWND_BROADCAST, WM_HOTKEY, 0,
-                                                MAKELPARAM(MOD_CONTROL | MOD_ALT, VK_DELETE));
-                }
-                else {
-                        LOG((CLOG_DEBUG "can't switch to Winlogon desk: %d", GetLastError()));
-                }
-                CloseDesktop(desk);
-        }
-        else {
-                LOG((CLOG_DEBUG "can't open Winlogon desk: %d", GetLastError()));
-        }
+CPMKeyState::fakeCtrlAltDel()
+{
+    fakeKeyDown(kKeyDelete, KeyModifierControl | KeyModifierAlt, virtualKeyToButton(VK_DELETE));
 }
 
 KeyModifierMask
-CMSWindowsKeyState::pollActiveModifiers() const
+CPMKeyState::pollActiveModifiers() const
 {
         KeyModifierMask state = 0;
@@ -832 +323 @@
 
         // we can get toggle modifiers from the system
-        if ((GetKeyState(VK_CAPITAL) & 0x01) != 0) {
+        if (WinGetKeyState(HWND_DESKTOP, VK_CAPITAL) & 1) {
                 state |= KeyModifierCapsLock;
         }
-        if ((GetKeyState(VK_NUMLOCK) & 0x01) != 0) {
+        if (WinGetKeyState(HWND_DESKTOP, VK_NUMLOCK) & 1) {
                 state |= KeyModifierNumLock;
         }
-        if ((GetKeyState(VK_SCROLL) & 0x01) != 0) {
+        if (WinGetKeyState(HWND_DESKTOP, VK_SCROLL) & 1) {
                 state |= KeyModifierScrollLock;
         }
@@ -846 +337 @@
 
 SInt32
-CMSWindowsKeyState::pollActiveGroup() const
+CPMKeyState::pollActiveGroup() const
 {
         // determine the thread that'll receive this event
         HWND  targetWindow = GetForegroundWindow();
-        DWORD targetThread = GetWindowThreadProcessId(targetWindow, NULL);
+        ULONG targetThread = GetWindowThreadProcessId(targetWindow, NULL);
 
         // get keyboard layout for the thread
@@ -866 +357 @@
 
 void
-CMSWindowsKeyState::pollPressedKeys(KeyButtonSet& pressedKeys) const
+CPMKeyState::pollPressedKeys(KeyButtonSet& pressedKeys) const
 {
         BYTE keyState[256];
@@ -878 +369 @@
 
 void
-CMSWindowsKeyState::getKeyMap(CKeyMap& keyMap)
+CPMKeyState::getKeyMap(CKeyMap& keyMap)
 {
         // update keyboard groups
@@ -1185 +676 @@
 
 void
-CMSWindowsKeyState::fakeKey(const Keystroke& keystroke)
+CPMKeyState::fakeKey(const Keystroke& keystroke)
 {
         switch (keystroke.m_type) {
@@ -1241 +732 @@
 
 KeyModifierMask&
-CMSWindowsKeyState::getActiveModifiersRValue()
+CPMKeyState::getActiveModifiersRValue()
 {
         if (m_useSavedModifiers) {
@@ -1252 +743 @@
 
 bool
-CMSWindowsKeyState::getGroups(GroupList& groups) const
+CPMKeyState::getGroups(GroupList& groups) const
 {
         // get keyboard layouts
@@ -1275 +766 @@
 
 void
-CMSWindowsKeyState::setWindowGroup(SInt32 group)
+CPMKeyState::setWindowGroup(SInt32 group)
 {
         HWND targetWindow = GetForegroundWindow();
@@ -1294 +785 @@
 
 void
-CMSWindowsKeyState::fixKeys()
+CPMKeyState::fixKeys()
 {
         // fake key releases for the windows keys if we think they're
@@ -1347 +838 @@
                 m_fixTimer = EVENTQUEUE->newTimer(0.1, NULL);
                 EVENTQUEUE->adoptHandler(CEvent::kTimer, m_fixTimer,
-                                                        new TMethodEventJob<CMSWindowsKeyState>(
-                                                                this, &CMSWindowsKeyState::handleFixKeys));
+                                                        new TMethodEventJob<CPMKeyState>(
+                                                                this, &CPMKeyState::handleFixKeys));
         }
         else if (!fix && m_fixTimer != NULL) {
@@ -1359 +850 @@
 
 void
-CMSWindowsKeyState::handleFixKeys(const CEvent&, void*)
+CPMKeyState::handleFixKeys(const CEvent&, void*)
 {
         fixKeys();
@@ -1365 +856 @@
 
 KeyID
-CMSWindowsKeyState::getKeyID(UINT virtualKey, KeyButton button)
+CPMKeyState::getKeyID(UINT virtualKey, KeyButton button)
 {
         if ((button & 0x100u) != 0) {
@@ -1374 +865 @@
 
 KeyID
-CMSWindowsKeyState::getIDForKey(CKeyMap::KeyItem& item,
+CPMKeyState::getIDForKey(CKeyMap::KeyItem& item,
                                 KeyButton button, UINT virtualKey,
                                 PBYTE keyState, HKL hkl) const
@@ -1412 +903 @@
 
 void
-CMSWindowsKeyState::addKeyEntry(CKeyMap& keyMap, CKeyMap::KeyItem& item)
+CPMKeyState::addKeyEntry(CKeyMap& keyMap, CKeyMap::KeyItem& item)
 {
         keyMap.addKeyEntry(item);

trunk/synergy/lib/platform/CPMKeyState.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2003 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef CMSWINDOWSKEYSTATE_H
-#define CMSWINDOWSKEYSTATE_H
+#ifndef CPMKEYSTATE_H
+#define CPMKEYSTATE_H
 
 #include "CKeyState.h"
 #include "CString.h"
 #include "stdvector.h"
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
+#define INCL_ERRORS
+#define INCL_BASE
+#define INCL_PM
+#include <os2.h>
 
 class CEvent;
 class CEventQueueTimer;
-class CMSWindowsDesks;
 
 //! Microsoft Windows key mapper
@@ -30 +32 @@
 This class maps KeyIDs to keystrokes.
 */
-class CMSWindowsKeyState : public CKeyState {
+class CPMKeyState : public CKeyState {
 public:
-        CMSWindowsKeyState(CMSWindowsDesks* desks, void* eventTarget);
-        virtual ~CMSWindowsKeyState();
+        CPMKeyState(void* eventTarget);
+        virtual ~CPMKeyState();
 
         //! @name manipulators
@@ -44 +46 @@
         */
         void                            disable();
-
-        //! Set the active keyboard layout
-        /*!
-        Uses \p keyLayout when querying the keyboard.
-        */
-        void                            setKeyLayout(HKL keyLayout);
 
         //! Test and set autorepeat state
@@ -87 +83 @@
         Returns the button for the \p virtualKey.
         */
-        KeyButton                       virtualKeyToButton(UINT virtualKey) const;
+        KeyButton                       virtualKeyToButton(ULONG virtualKey) const;
 
         //! Map key event to a key
@@ -94 +90 @@
         to a modifier mask.
         */
-        KeyID                           mapKeyFromEvent(WPARAM charAndVirtKey,
-                                                        LPARAM info, KeyModifierMask* maskOut) const;
+        KeyID                           mapKeyFromEvent(MPARAM charAndVirtKey, MPARAM info, KeyModifierMask* maskOut) const;
 
         //! Check if keyboard groups have changed
@@ -109 +104 @@
         key.
         */
-        UINT                            mapKeyToVirtualKey(KeyID key) const;
+        ULONG                           mapKeyToVirtualKey(KeyID key) const;
 
         //! Map virtual key and button to KeyID
@@ -117 +112 @@
         no such key.
         */
-        static KeyID            getKeyID(UINT virtualKey, KeyButton button);
+        static KeyID            getKeyID(ULONG virtualKey, KeyButton button);
 
         //@}
@@ -148 +143 @@
 
 private:
-        typedef std::vector<HKL> GroupList;
-
-        // send ctrl+alt+del hotkey event on NT family
-        static void                     ctrlAltDelThread(void*);
-
-        bool                            getGroups(GroupList&) const;
-        void                            setWindowGroup(SInt32 group);
-
         void                            fixKeys();
         void                            handleFixKeys(const CEvent&, void*);
 
         KeyID                           getIDForKey(CKeyMap::KeyItem& item,
-                                                        KeyButton button, UINT virtualKey,
-                                                        PBYTE keyState, HKL hkl) const;
+                                                        KeyButton button, ULONG virtualKey,
+                                                        PBYTE keyState) const;
 
         void                            addKeyEntry(CKeyMap& keyMap, CKeyMap::KeyItem& item);
@@ -167 +154 @@
 private:
         // not implemented
-        CMSWindowsKeyState(const CMSWindowsKeyState&);
-        CMSWindowsKeyState& operator=(const CMSWindowsKeyState&);
+        CPMKeyState(const CPMKeyState&);
+        CPMKeyState& operator=(const CPMKeyState&);
 
 private:
-        typedef std::map<HKL, SInt32> GroupMap;
-        typedef std::map<KeyID, UINT> KeyToVKMap;
+        typedef std::map<KeyID, ULONG> KeyToVKMap;
 
-        bool                            m_is95Family;
         void*                           m_eventTarget;
-        CMSWindowsDesks*        m_desks;
-        HKL                                     m_keyLayout;
-        UINT                            m_buttonToVK[512];
-        UINT                            m_buttonToNumpadVK[512];
+        ULONG                           m_buttonToVK[512];
+        ULONG                           m_buttonToNumpadVK[512];
         KeyButton                       m_virtualKeyToButton[256];
         KeyToVKMap                      m_keyToVKMap;
@@ -185 +168 @@
         // the timer used to check for fixing key state
         CEventQueueTimer*       m_fixTimer;
-
-        // the groups (keyboard layouts)
-        GroupList                       m_groups;
-        GroupMap                        m_groupMap;
 
         // the last button that we generated a key down event for.  this
@@ -201 +180 @@
         KeyModifierMask         m_originalSavedModifiers;
 
-        // pointer to ToUnicodeEx.  on win95 family this will be NULL.
-        typedef int (WINAPI *ToUnicodeEx_t)(UINT wVirtKey,
-                                                                                UINT wScanCode,
-                                                                                PBYTE lpKeyState,
-                                                                                LPWSTR pwszBuff,
-                                                                                int cchBuff,
-                                                                                UINT wFlags,
-                                                                                HKL dwhkl);
-        ToUnicodeEx_t           m_ToUnicodeEx;
-
-        static const KeyID      s_virtualKey[];
+        static const KeyID      s_virtualKey[0x42];
 };
 

trunk/synergy/lib/platform/CPMScreen.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2002 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "CMSWindowsScreen.h"
-#include "CMSWindowsClipboard.h"
-#include "CMSWindowsDesks.h"
-#include "CMSWindowsEventQueueBuffer.h"
-#include "CMSWindowsKeyState.h"
-#include "CMSWindowsScreenSaver.h"
+#include "CPMScreen.h"
+#include "CPMClipboard.h"
+#include "CPMEventQueueBuffer.h"
+#include "CPMKeyState.h"
+#include "CPMScreenSaver.h"
 #include "CClipboard.h"
 #include "CKeyMap.h"
@@ -32 +32 @@
 #include "TMethodJob.h"
 #include "CArch.h"
-#include "CArchMiscWindows.h"
+#include "CPMUtil.h"
 #include <string.h>
-#include <pbt.h>
 
 //
-// add backwards compatible multihead support (and suppress bogus warning).
-// this isn't supported on MinGW yet AFAICT.
+// CPMScreen
 //
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable: 4706) // assignment within conditional
-#define COMPILE_MULTIMON_STUBS
-#include <multimon.h>
-#pragma warning(pop)
-#endif
-
-// X button stuff
-#if !defined(WM_XBUTTONDOWN)
-#define WM_XBUTTONDOWN          0x020B
-#define WM_XBUTTONUP            0x020C
-#define WM_XBUTTONDBLCLK        0x020D
-#define WM_NCXBUTTONDOWN        0x00AB
-#define WM_NCXBUTTONUP          0x00AC
-#define WM_NCXBUTTONDBLCLK      0x00AD
-#define MOUSEEVENTF_XDOWN       0x0080
-#define MOUSEEVENTF_XUP         0x0100
-#define XBUTTON1                        0x0001
-#define XBUTTON2                        0x0002
-#endif
-#if !defined(VK_XBUTTON1)
-#define VK_XBUTTON1                     0x05
-#define VK_XBUTTON2                     0x06
-#endif
-
-// WM_POWERBROADCAST stuff
-#if !defined(PBT_APMRESUMEAUTOMATIC)
-#define PBT_APMRESUMEAUTOMATIC  0x0012
-#endif
-
-//
-// CMSWindowsScreen
-//
-
-HINSTANCE                               CMSWindowsScreen::s_instance = NULL;
-CMSWindowsScreen*               CMSWindowsScreen::s_screen   = NULL;
-
-CMSWindowsScreen::CMSWindowsScreen(bool isPrimary) :
+
+CPMScreen*              CPMScreen::s_screen   = NULL;
+
+CPMScreen::CPMScreen(bool isPrimary) :
         m_isPrimary(isPrimary),
-        m_is95Family(CArchMiscWindows::isWindows95Family()),
         m_isOnScreen(m_isPrimary),
         m_class(0),
         m_x(0), m_y(0),
-        m_w(0), m_h(0),
+        m_cx(0), m_cy(0),
         m_xCenter(0), m_yCenter(0),
         m_multimon(false),
@@ -92 +54 @@
         m_markReceived(0),
         m_fixTimer(NULL),
-        m_keyLayout(NULL),
         m_screensaver(NULL),
         m_screensaverNotify(false),
         m_screensaverActive(false),
-        m_window(NULL),
-        m_nextClipboardWindow(NULL),
+        m_window(NULLHANDLE),
+        m_nextClipboardWindow(NULLHANDLE),
         m_ownClipboard(false),
-        m_desks(NULL),
-        m_hookLibrary(NULL),
+        m_hmodHook(NULLHANDLE),
         m_init(NULL),
         m_cleanup(NULL),
@@ -107 +67 @@
         m_setMode(NULL),
         m_keyState(NULL),
-        m_hasMouse(GetSystemMetrics(SM_MOUSEPRESENT) != 0),
+        m_hasMouse(WinQuerySysValue(HWND_DESKTOP, SV_MOUSEPRESENT) != FALSE),
         m_showingMouse(false)
 {
-        assert(s_instance != NULL);
-        assert(s_screen   == NULL);
+        assert(s_screen == NULL);
 
         s_screen = this;
         try {
                 if (m_isPrimary) {
-                        m_hookLibrary = openHookLibrary("synrgyhk");
-                }
-                m_screensaver = new CMSWindowsScreenSaver();
-                m_desks       = new CMSWindowsDesks(m_isPrimary,
-                                                        m_hookLibrary, m_screensaver,
-                                                        new TMethodJob<CMSWindowsScreen>(this,
-                                                                &CMSWindowsScreen::updateKeysCB));
-                m_keyState    = new CMSWindowsKeyState(m_desks, getEventTarget());
+                        m_hmodHook = openHookLibrary("synrgyhk");
+                }
+                m_screensaver = new CPMScreenSaver();
+                m_keyState    = new CPMKeyState(getEventTarget());
                 updateScreenShape();
                 m_class       = createWindowClass();
                 m_window      = createWindow(m_class, "Synergy");
                 forceShowCursor();
-                LOG((CLOG_DEBUG "screen shape: %d,%d %dx%d %s", m_x, m_y, m_w, m_h, m_multimon ? "(multi-monitor)" : ""));
+                LOG((CLOG_DEBUG "screen shape: %d,%d %dx%d %s", m_x, m_y, m_cx, m_cy, m_multimon ? "(multi-monitor)" : ""));
                 LOG((CLOG_DEBUG "window is 0x%08x", m_window));
         }
         catch (...) {
                 delete m_keyState;
-                delete m_desks;
                 delete m_screensaver;
                 destroyWindow(m_window);
                 destroyClass(m_class);
-                closeHookLibrary(m_hookLibrary);
+                closeHookLibrary(m_hmodHook);
                 s_screen = NULL;
                 throw;
@@ -144 +98 @@
         // install event handlers
         EVENTQUEUE->adoptHandler(CEvent::kSystem, IEventQueue::getSystemTarget(),
-                                                        new TMethodEventJob<CMSWindowsScreen>(this,
-                                                                &CMSWindowsScreen::handleSystemEvent));
+                                                        new TMethodEventJob<CPMScreen>(this,
+                                                                &CPMScreen::handleSystemEvent));
 
         // install the platform event queue
-        EVENTQUEUE->adoptBuffer(new CMSWindowsEventQueueBuffer);
-}
-
-CMSWindowsScreen::~CMSWindowsScreen()
+        EVENTQUEUE->adoptBuffer(new CPMEventQueueBuffer);
+}
+
+CPMScreen::~CPMScreen()
 {
         assert(s_screen != NULL);
@@ -159 +113 @@
         EVENTQUEUE->removeHandler(CEvent::kSystem, IEventQueue::getSystemTarget());
         delete m_keyState;
-        delete m_desks;
         delete m_screensaver;
         destroyWindow(m_window);
         destroyClass(m_class);
-        closeHookLibrary(m_hookLibrary);
+        closeHookLibrary(m_hmodHook);
         s_screen = NULL;
 }
 
 void
-CMSWindowsScreen::init(HINSTANCE instance)
-{
-        assert(s_instance == NULL);
-        assert(instance   != NULL);
-
-        s_instance = instance;
-}
-
-HINSTANCE
-CMSWindowsScreen::getInstance()
-{
-        return s_instance;
-}
-
-void
-CMSWindowsScreen::enable()
+CPMScreen::enable()
 {
         assert(m_isOnScreen == m_isPrimary);
@@ -190 +128 @@
         m_fixTimer = EVENTQUEUE->newTimer(1.0, NULL);
         EVENTQUEUE->adoptHandler(CEvent::kTimer, m_fixTimer,
-                                                        new TMethodEventJob<CMSWindowsScreen>(this,
-                                                                &CMSWindowsScreen::handleFixes));
+                                                         new TMethodEventJob<CPMScreen>(this, &CPMScreen::handleFixes));
 
         // install our clipboard snooper
-        m_nextClipboardWindow = SetClipboardViewer(m_window);
-
+    HAB hab = CPMUtil::getHAB();
+        m_nextClipboardWindow = WinQueryClipbrdViewer(hab);
+    WinSetClipbrdViewer(hab, m_window);
+
+/// @todo start here!
         // track the active desk and (re)install the hooks
         m_desks->enable();
@@ -201 +141 @@
         if (m_isPrimary) {
                 // set jump zones
-                m_setZone(m_x, m_y, m_w, m_h, getJumpZoneSize());
+                m_setZone(m_x, m_y, m_cx, m_cy, getJumpZoneSize());
 
                 // watch jump zones
                 m_setMode(kHOOK_WATCH_JUMP_ZONE);
         }
-        else {
-                // prevent the system from entering power saving modes.  if
-                // it did we'd be forced to disconnect from the server and
-                // the server would not be able to wake us up.
-                CArchMiscWindows::addBusyState(CArchMiscWindows::kSYSTEM);
-        }
-}
-
-void
-CMSWindowsScreen::disable()
+}
+
+void
+CPMScreen::disable()
 {
         // stop tracking the active desk
@@ -223 +157 @@
                 // disable hooks
                 m_setMode(kHOOK_DISABLE);
-
-                // enable special key sequences on win95 family
-                enableSpecialKeys(true);
-        }
-        else {
-                // allow the system to enter power saving mode
-                CArchMiscWindows::removeBusyState(CArchMiscWindows::kSYSTEM |
-                                                        CArchMiscWindows::kDISPLAY);
         }
 
@@ -237 +163 @@
 
         // stop snooping the clipboard
-        ChangeClipboardChain(m_window, m_nextClipboardWindow);
+        WinSetClipbrdViewer(m_window, m_nextClipboardWindow);
         m_nextClipboardWindow = NULL;
 
@@ -252 +178 @@
 
 void
-CMSWindowsScreen::enter()
+CPMScreen::enter()
 {
         m_desks->enter();
         if (m_isPrimary) {
-                // enable special key sequences on win95 family
-                enableSpecialKeys(true);
-
                 // watch jump zones
                 m_setMode(kHOOK_WATCH_JUMP_ZONE);
@@ -272 +195 @@
 
 bool
-CMSWindowsScreen::leave()
-{
-        // get keyboard layout of foreground window.  we'll use this
-        // keyboard layout for translating keys sent to clients.
-        HWND window  = GetForegroundWindow();
-        DWORD thread = GetWindowThreadProcessId(window, NULL);
-        m_keyLayout  = GetKeyboardLayout(thread);
-
-        // tell the key mapper about the keyboard layout
-        m_keyState->setKeyLayout(m_keyLayout);
-
-        // tell desk that we're leaving and tell it the keyboard layout
-        m_desks->leave(m_keyLayout);
-
+CPMScreen::leave()
+{
         if (m_isPrimary) {
                 // warp to center
                 warpCursor(m_xCenter, m_yCenter);
 
-                // disable special key sequences on win95 family
-                enableSpecialKeys(false);
-
                 // all messages prior to now are invalid
                 nextMark();
@@ -312 +220 @@
 
 bool
-CMSWindowsScreen::setClipboard(ClipboardID, const IClipboard* src)
-{
-        CMSWindowsClipboard dst(m_window);
+CPMScreen::setClipboard(ClipboardID, const IClipboard* src)
+{
+        CPMClipboard dst(m_window);
         if (src != NULL) {
                 // save clipboard data
                 return CClipboard::copy(&dst, src);
         }
-        else {
-                // assert clipboard ownership
-                if (!dst.open(0)) {
-                        return false;
-                }
-                dst.empty();
-                dst.close();
-                return true;
-        }
-}
-
-void
-CMSWindowsScreen::checkClipboards()
-{
-        // if we think we own the clipboard but we don't then somebody
-        // grabbed the clipboard on this screen without us knowing.
-        // tell the server that this screen grabbed the clipboard.
-        //
-        // this works around bugs in the clipboard viewer chain.
-        // sometimes NT will simply never send WM_DRAWCLIPBOARD
-        // messages for no apparent reason and rebooting fixes the
-        // problem.  since we don't want a broken clipboard until the
-        // next reboot we do this double check.  clipboard ownership
-        // won't be reflected on other screens until we leave but at
-        // least the clipboard itself will work.
-        if (m_ownClipboard && !CMSWindowsClipboard::isOwnedBySynergy()) {
+    // assert clipboard ownership
+    if (!dst.open(0)) {
+        return false;
+    }
+    dst.empty();
+    dst.close();
+    return true;
+}
+
+void
+CPMScreen::checkClipboards()
+{
+    // be careful, even if we don't have the NT bugs.
+        if (m_ownClipboard && !CPMClipboard::isOwnedBySynergy()) {
                 LOG((CLOG_DEBUG "clipboard changed: lost ownership and no notification received"));
                 m_ownClipboard = false;
@@ -353 +249 @@
 
 void
-CMSWindowsScreen::openScreensaver(bool notify)
-{
-        assert(m_screensaver != NULL);
-
+CPMScreen::openScreensaver(bool notify)
+{
         m_screensaverNotify = notify;
-        if (m_screensaverNotify) {
-                m_desks->installScreensaverHooks(true);
-        }
-        else {
+        if (!m_screensaverNotify) {
                 m_screensaver->disable();
         }
@@ -367 +258 @@
 
 void
-CMSWindowsScreen::closeScreensaver()
-{
-        if (m_screensaver != NULL) {
-                if (m_screensaverNotify) {
-                        m_desks->installScreensaverHooks(false);
-                }
-                else {
-                        m_screensaver->enable();
-                }
-        }
-        m_screensaverNotify = false;
-}
-
-void
-CMSWindowsScreen::screensaver(bool activate)
-{
-        assert(m_screensaver != NULL);
-
-        if (activate) {
-                m_screensaver->activate();
-        }
-        else {
-                m_screensaver->deactivate();
-        }
-}
-
-void
-CMSWindowsScreen::resetOptions()
-{
-        m_desks->resetOptions();
-}
-
-void
-CMSWindowsScreen::setOptions(const COptionsList& options)
-{
-        m_desks->setOptions(options);
-}
-
-void
-CMSWindowsScreen::setSequenceNumber(UInt32 seqNum)
+CPMScreen::closeScreensaver()
+{
+        if (!m_screensaverNotify) {
+                m_screensaver->enable();
+        }
+}
+
+void
+CPMScreen::screensaver(bool activate)
+{
+    if (activate) {
+        m_screensaver->activate();
+    }
+    else {
+        m_screensaver->deactivate();
+    }
+}
+
+void
+CPMScreen::resetOptions()
+{
+//example    m_xtestIsXineramaUnaware = true;
+}
+
+void
+CPMScreen::setOptions(const COptionsList& options)
+{
+    for (UInt32 i = 0, n = options.size(); i < n; i += 2) {
+//example        if (options[i] == kOptionXTestXineramaUnaware) {
+//example            m_xtestIsXineramaUnaware = (options[i + 1] != 0);
+//example            LOG((CLOG_DEBUG1 "XTest is Xinerama unaware %s", m_xtestIsXineramaUnaware ? "true" : "false"));
+//example        }
+    }
+}
+
+void
+CPMScreen::setSequenceNumber(UInt32 seqNum)
 {
         m_sequenceNumber = seqNum;
@@ -412 +300 @@
 
 bool
-CMSWindowsScreen::isPrimary() const
+CPMScreen::isPrimary() const
 {
         return m_isPrimary;
@@ -418 +306 @@
 
 void*
-CMSWindowsScreen::getEventTarget() const
-{
-        return const_cast<CMSWindowsScreen*>(this);
-}
-
-bool
-CMSWindowsScreen::getClipboard(ClipboardID, IClipboard* dst) const
-{
-        CMSWindowsClipboard src(m_window);
-        CClipboard::copy(dst, &src);
-        return true;
-}
-
-void
-CMSWindowsScreen::getShape(SInt32& x, SInt32& y, SInt32& w, SInt32& h) const
+CPMScreen::getEventTarget() const
+{
+        return const_cast<CPMScreen*>(this);
+}
+
+bool
+CPMScreen::getClipboard(ClipboardID, IClipboard* dst) const
+{
+        CPMClipboard src(m_window);
+        return CClipboard::copy(dst, &src);
+}
+
+void
+CPMScreen::getShape(SInt32& x, SInt32& y, SInt32& cx, SInt32& cy) const
 {
         assert(m_class != 0);
@@ -438 +325 @@
         x = m_x;
         y = m_y;
-        w = m_w;
-        h = m_h;
-}
-
-void
-CMSWindowsScreen::getCursorPos(SInt32& x, SInt32& y) const
-{
-        m_desks->getCursorPos(x, y);
-}
-
-void
-CMSWindowsScreen::reconfigure(UInt32 activeSides)
-{
-        assert(m_isPrimary);
-
-        LOG((CLOG_DEBUG "active sides: %x", activeSides));
-        m_setSides(activeSides);
-}
-
-void
-CMSWindowsScreen::warpCursor(SInt32 x, SInt32 y)
+        cx= m_cx;
+        cy = m_cy;
+}
+
+void
+CPMScreen::getCursorPos(SInt32& x, SInt32& y) const
+{
+    CURSORINFO Info;
+    if (WinQueryCursorInfo(HWND_DESKTOP, &Info)) {
+        x = Info.x;
+        y = m_cy - Info.y;
+    } else {
+        x = 0;
+        y = 0;
+    }
+}
+
+void
+CPMScreen::reconfigure(UInt32 activeSides)
+{
+    // do nothing.
+}
+
+void
+CPMScreen::warpCursor(SInt32 x, SInt32 y)
 {
         // warp mouse
@@ -464 +355 @@
 
         // remove all input events before and including warp
-        MSG msg;
-        while (PeekMessage(&msg, NULL, SYNERGY_MSG_INPUT_FIRST,
-                                                                SYNERGY_MSG_INPUT_LAST, PM_REMOVE)) {
+        QMSG qmsg;
+        while (WinPeekMsg(m_hab, &qmsg, NULLHANDLE, SYNERGY_MSG_INPUT_FIRST, SYNERGY_MSG_INPUT_LAST, PM_REMOVE)) {
                 // do nothing
         }
@@ -476 +366 @@
 
 UInt32
-CMSWindowsScreen::registerHotKey(KeyID key, KeyModifierMask mask)
+CPMScreen::registerHotKey(KeyID key, KeyModifierMask mask)
 {
         // only allow certain modifiers
@@ -490 +380 @@
         }
 
+#if 1
+    LOG((CLOG_WARN "not implemented id=%04x mask=%04x", key, mask));
+    return 0;
+#else
         // convert to win32
         UINT modifiers = 0;
@@ -545 +439 @@
         LOG((CLOG_DEBUG "registered hotkey %s (id=%04x mask=%04x) as id=%d", CKeyMap::formatKey(key, mask).c_str(), key, mask, id));
         return id;
-}
-
-void
-CMSWindowsScreen::unregisterHotKey(UInt32 id)
+#endif 
+}
+
+void
+CPMScreen::unregisterHotKey(UInt32 id)
 {
         // look up hotkey
@@ -558 +453 @@
         // unregister with OS
         bool err;
+#if 1
+    err = true;
+#else
         if (i->second.getVirtualKey() != 0) {
                 err = !UnregisterHotKey(NULL, id);
-        }
-        else {
+        } else {
                 err = false;
         }
+#endif
         if (err) {
                 LOG((CLOG_WARN "failed to unregister hotkey id=%d", id));
@@ -578 +476 @@
 
 void
-CMSWindowsScreen::fakeInputBegin()
+CPMScreen::fakeInputBegin()
 {
         assert(m_isPrimary);
@@ -589 +487 @@
 
 void
-CMSWindowsScreen::fakeInputEnd()
+CPMScreen::fakeInputEnd()
 {
         assert(m_isPrimary);
@@ -600 +498 @@
 
 SInt32
-CMSWindowsScreen::getJumpZoneSize() const
+CPMScreen::getJumpZoneSize() const
 {
         return 1;
@@ -606 +504 @@
 
 bool
-CMSWindowsScreen::isAnyMouseButtonDown() const
+CPMScreen::isAnyMouseButtonDown() const
 {
         static const char* buttonToName[] = {
@@ -628 +526 @@
 
 void
-CMSWindowsScreen::getCursorCenter(SInt32& x, SInt32& y) const
+CPMScreen::getCursorCenter(SInt32& x, SInt32& y) const
 {
         x = m_xCenter;
@@ -635 +533 @@
 
 void
-CMSWindowsScreen::fakeMouseButton(ButtonID id, bool press) const
+CPMScreen::fakeMouseButton(ButtonID id, bool press) const
 {
         m_desks->fakeMouseButton(id, press);
@@ -641 +539 @@
 
 void
-CMSWindowsScreen::fakeMouseMove(SInt32 x, SInt32 y) const
+CPMScreen::fakeMouseMove(SInt32 x, SInt32 y) const
 {
         m_desks->fakeMouseMove(x, y);
@@ -647 +545 @@
 
 void
-CMSWindowsScreen::fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const
+CPMScreen::fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const
 {
         m_desks->fakeMouseRelativeMove(dx, dy);
@@ -653 +551 @@
 
 void
-CMSWindowsScreen::fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const
+CPMScreen::fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const
 {
         m_desks->fakeMouseWheel(xDelta, yDelta);
@@ -659 +557 @@
 
 void
-CMSWindowsScreen::updateKeys()
+CPMScreen::updateKeys()
 {
         m_desks->updateKeys();
@@ -665 +563 @@
 
 void
-CMSWindowsScreen::fakeKeyDown(KeyID id, KeyModifierMask mask,
+CPMScreen::fakeKeyDown(KeyID id, KeyModifierMask mask,
                                 KeyButton button)
 {
@@ -673 +571 @@
 
 void
-CMSWindowsScreen::fakeKeyRepeat(KeyID id, KeyModifierMask mask,
+CPMScreen::fakeKeyRepeat(KeyID id, KeyModifierMask mask,
                                 SInt32 count, KeyButton button)
 {
@@ -681 +579 @@
 
 void
-CMSWindowsScreen::fakeKeyUp(KeyButton button)
+CPMScreen::fakeKeyUp(KeyButton button)
 {
         CPlatformScreen::fakeKeyUp(button);
@@ -688 +586 @@
 
 void
-CMSWindowsScreen::fakeAllKeysUp()
+CPMScreen::fakeAllKeysUp()
 {
         CPlatformScreen::fakeAllKeysUp();
@@ -695 +593 @@
 
 HINSTANCE
-CMSWindowsScreen::openHookLibrary(const char* name)
+CPMScreen::openHookLibrary(const char* name)
 {
         // load the hook library
@@ -729 +627 @@
 
 void
-CMSWindowsScreen::closeHookLibrary(HINSTANCE hookLibrary) const
+CPMScreen::closeHookLibrary(HINSTANCE hookLibrary) const
 {
         if (hookLibrary != NULL) {
@@ -737 +635 @@
 }
 
-HCURSOR
-CMSWindowsScreen::createBlankCursor() const
-{
-        // create a transparent cursor
-        int cw = GetSystemMetrics(SM_CXCURSOR);
-        int ch = GetSystemMetrics(SM_CYCURSOR);
-        UInt8* cursorAND = new UInt8[ch * ((cw + 31) >> 2)];
-        UInt8* cursorXOR = new UInt8[ch * ((cw + 31) >> 2)];
-        memset(cursorAND, 0xff, ch * ((cw + 31) >> 2));
-        memset(cursorXOR, 0x00, ch * ((cw + 31) >> 2));
-        HCURSOR c = CreateCursor(s_instance, 0, 0, cw, ch, cursorAND, cursorXOR);
-        delete[] cursorXOR;
-        delete[] cursorAND;
-        return c;
-}
-
-void
-CMSWindowsScreen::destroyCursor(HCURSOR cursor) const
-{
-        if (cursor != NULL) {
-                DestroyCursor(cursor);
-        }
-}
-
 ATOM
-CMSWindowsScreen::createWindowClass() const
+CPMScreen::createWindowClass() const
 {
         WNDCLASSEX classInfo;
         classInfo.cbSize        = sizeof(classInfo);
         classInfo.style         = CS_DBLCLKS | CS_NOCLOSE;
-        classInfo.lpfnWndProc   = &CMSWindowsScreen::wndProc;
+        classInfo.lpfnWndProc   = &CPMScreen::wndProc;
         classInfo.cbClsExtra    = 0;
         classInfo.cbWndExtra    = 0;
@@ -781 +655 @@
 
 void
-CMSWindowsScreen::destroyClass(ATOM windowClass) const
+CPMScreen::destroyClass(ATOM windowClass) const
 {
         if (windowClass != 0) {
@@ -789 +663 @@
 
 HWND
-CMSWindowsScreen::createWindow(ATOM windowClass, const char* name) const
+CPMScreen::createWindow(ATOM windowClass, const char* name) const
 {
         HWND window = CreateWindowEx(WS_EX_TOPMOST |
@@ -809 +683 @@
 
 void
-CMSWindowsScreen::destroyWindow(HWND hwnd) const
+CPMScreen::destroyWindow(HWND hwnd) const
 {
         if (hwnd != NULL) {
@@ -817 +691 @@
 
 void
-CMSWindowsScreen::sendEvent(CEvent::Type type, void* data)
+CPMScreen::sendEvent(CEvent::Type type, void* data)
 {
         EVENTQUEUE->addEvent(CEvent(type, getEventTarget(), data));
@@ -823 +697 @@
 
 void
-CMSWindowsScreen::sendClipboardEvent(CEvent::Type type, ClipboardID id)
+CPMScreen::sendClipboardEvent(CEvent::Type type, ClipboardID id)
 {
         CClipboardInfo* info   = (CClipboardInfo*)malloc(sizeof(CClipboardInfo));
@@ -832 +706 @@
 
 void
-CMSWindowsScreen::handleSystemEvent(const CEvent& event, void*)
+CPMScreen::handleSystemEvent(const CEvent& event, void*)
 {
         MSG* msg = reinterpret_cast<MSG*>(event.getData());
@@ -848 +722 @@
 
 void
-CMSWindowsScreen::updateButtons()
+CPMScreen::updateButtons()
 {
         int numButtons               = GetSystemMetrics(SM_CMOUSEBUTTONS);
@@ -862 +736 @@
 
 IKeyState*
-CMSWindowsScreen::getKeyState() const
+CPMScreen::getKeyState() const
 {
         return m_keyState;
@@ -868 +742 @@
 
 bool
-CMSWindowsScreen::onPreDispatch(HWND hwnd,
+CPMScreen::onPreDispatch(HWND hwnd,
                                 UINT message, WPARAM wParam, LPARAM lParam)
 {
@@ -889 +763 @@
 
 bool
-CMSWindowsScreen::onPreDispatchPrimary(HWND,
+CPMScreen::onPreDispatchPrimary(HWND,
                                 UINT message, WPARAM wParam, LPARAM lParam)
 {
@@ -946 +820 @@
 
 bool
-CMSWindowsScreen::onEvent(HWND, UINT msg,
+CPMScreen::onEvent(HWND, UINT msg,
                                 WPARAM wParam, LPARAM lParam, LRESULT* result)
 {
@@ -1006 +880 @@
                 *result = TRUE;
                 return true;
-
-        case WM_DEVICECHANGE:
-                forceShowCursor();
-                break;
-
-        case WM_SETTINGCHANGE:
-                if (wParam == SPI_SETMOUSEKEYS) {
-                        forceShowCursor();
-                }
-                break;
         }
 
@@ -1022 +886 @@
 
 bool
-CMSWindowsScreen::onMark(UInt32 mark)
+CPMScreen::onMark(UInt32 mark)
 {
         m_markReceived = mark;
@@ -1029 +893 @@
 
 bool
-CMSWindowsScreen::onKey(WPARAM wParam, LPARAM lParam)
+CPMScreen::onKey(WPARAM wParam, LPARAM lParam)
 {
         static const KeyModifierMask s_ctrlAlt =
@@ -1172 +1036 @@
 
 bool
-CMSWindowsScreen::onHotKey(WPARAM wParam, LPARAM lParam)
+CPMScreen::onHotKey(WPARAM wParam, LPARAM lParam)
 {
         // get the key info
@@ -1219 +1083 @@
 
 bool
-CMSWindowsScreen::onMouseButton(WPARAM wParam, LPARAM lParam)
+CPMScreen::onMouseButton(WPARAM wParam, LPARAM lParam)
 {
         // get which button
-        bool pressed    = mapPressFromEvent(wParam, lParam);
-        ButtonID button = mapButtonFromEvent(wParam, lParam);
+        bool pressed    = mapPressFromEvent((ULONG)wParam, lParam);
+        ButtonID button = mapButtonFromEvent((ULONG)wParam, lParam);
 
         // keep our shadow key state up to date
@@ -1258 +1122 @@
 
 bool
-CMSWindowsScreen::onMouseMove(SInt32 mx, SInt32 my)
+CPMScreen::onMouseMove(SInt32 mx, SInt32 my)
 {
         // compute motion delta (relative to the last known
@@ -1292 +1156 @@
                 static SInt32 bogusZoneSize = 10;
                 if (-x + bogusZoneSize > m_xCenter - m_x ||
-                         x + bogusZoneSize > m_x + m_w - m_xCenter ||
+                         x + bogusZoneSize > m_x + m_cx - m_xCenter ||
                         -y + bogusZoneSize > m_yCenter - m_y ||
-                         y + bogusZoneSize > m_y + m_h - m_yCenter) {
+                         y + bogusZoneSize > m_y + m_cy - m_yCenter) {
                         LOG((CLOG_DEBUG "dropped bogus motion %+d,%+d", x, y));
                 }
@@ -1307 +1171 @@
 
 bool
-CMSWindowsScreen::onMouseWheel(SInt32 xDelta, SInt32 yDelta)
+CPMScreen::onMouseWheel(SInt32 xDelta, SInt32 yDelta)
 {
         // ignore message if posted prior to last mark change
@@ -1318 +1182 @@
 
 bool
-CMSWindowsScreen::onScreensaver(bool activated)
+CPMScreen::onScreensaver(bool activated)
 {
         // ignore this message if there are any other screen saver
@@ -1358 +1222 @@
 
 bool
-CMSWindowsScreen::onDisplayChange()
+CPMScreen::onDisplayChange()
 {
         // screen resolution may have changed.  save old shape.
-        SInt32 xOld = m_x, yOld = m_y, wOld = m_w, hOld = m_h;
+        SInt32 xOld = m_x, yOld = m_y, wOld = m_cx, hOld = m_cy;
 
         // update shape
@@ -1367 +1231 @@
 
         // do nothing if resolution hasn't changed
-        if (xOld != m_x || yOld != m_y || wOld != m_w || hOld != m_h) {
+        if (xOld != m_x || yOld != m_y || wOld != m_cx || hOld != m_cy) {
                 if (m_isPrimary) {
                         // warp mouse to center if off screen
@@ -1376 +1240 @@
                         // tell hook about resize if on screen
                         else {
-                                m_setZone(m_x, m_y, m_w, m_h, getJumpZoneSize());
+                                m_setZone(m_x, m_y, m_cx, m_cy, getJumpZoneSize());
                         }
                 }
@@ -1383 +1247 @@
                 sendEvent(getShapeChangedEvent());
 
-                LOG((CLOG_DEBUG "screen shape: %d,%d %dx%d %s", m_x, m_y, m_w, m_h, m_multimon ? "(multi-monitor)" : ""));
+                LOG((CLOG_DEBUG "screen shape: %d,%d %dx%d %s", m_x, m_y, m_cx, m_cy, m_multimon ? "(multi-monitor)" : ""));
         }
 
@@ -1390 +1254 @@
 
 bool
-CMSWindowsScreen::onClipboardChange()
+CPMScreen::onClipboardChange()
 {
         // now notify client that somebody changed the clipboard (unless
         // we're the owner).
-        if (!CMSWindowsClipboard::isOwnedBySynergy()) {
+        if (!CPMClipboard::isOwnedBySynergy()) {
                 if (m_ownClipboard) {
                         LOG((CLOG_DEBUG "clipboard changed: lost ownership"));
@@ -1411 +1275 @@
 
 void
-CMSWindowsScreen::warpCursorNoFlush(SInt32 x, SInt32 y)
+CPMScreen::warpCursorNoFlush(SInt32 x, SInt32 y)
 {
         // send an event that we can recognize before the mouse warp
-        PostThreadMessage(GetCurrentThreadId(), SYNERGY_MSG_PRE_WARP, x, y);
+    WinPostQueueMsg(m_hmq, SYNERGY_MSG_PRE_WARP, (MPARAM)x, (MPARAM)y);
 
         // warp mouse.  hopefully this inserts a mouse motion event
         // between the previous message and the following message.
-        SetCursorPos(x, y);
+    WinSetPointerPos(HWND_DESKTOP, x, y);
 
         // yield the CPU.  there's a race condition when warping:
@@ -1439 +1303 @@
 
         // send an event that we can recognize after the mouse warp
-        PostThreadMessage(GetCurrentThreadId(), SYNERGY_MSG_POST_WARP, 0, 0);
-}
-
-void
-CMSWindowsScreen::nextMark()
+    WinPostQueueMsg(m_hmq, SYNERGY_MSG_POST_WARP, 0, 0);
+}
+
+void
+CPMScreen::nextMark()
 {
         // next mark
@@ -1449 +1313 @@
 
         // mark point in message queue where the mark was changed
-        PostThreadMessage(GetCurrentThreadId(), SYNERGY_MSG_MARK, m_mark, 0);
-}
-
-bool
-CMSWindowsScreen::ignore() const
+    WinPostQueueMsg(m_hmq, SYNERGY_MSG_MARK, (MPARAM)m_mark, 0);
+}
+
+bool
+CPMScreen::ignore() const
 {
         return (m_mark != m_markReceived);
@@ -1459 +1323 @@
 
 void
-CMSWindowsScreen::updateScreenShape()
+CPMScreen::updateScreenShape()
 {
         // get shape
-        m_x = GetSystemMetrics(SM_XVIRTUALSCREEN);
-        m_y = GetSystemMetrics(SM_YVIRTUALSCREEN);
-        m_w = GetSystemMetrics(SM_CXVIRTUALSCREEN);
-        m_h = GetSystemMetrics(SM_CYVIRTUALSCREEN);
+        m_x = 0;
+        m_y = 0;
+        m_cx = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
+        m_cy = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
 
         // get center for cursor
-        m_xCenter = GetSystemMetrics(SM_CXSCREEN) >> 1;
-        m_yCenter = GetSystemMetrics(SM_CYSCREEN) >> 1;
+        m_xCenter = m_cx / 2;
+        m_yCenter = m_cy / 2;
 
         // check for multiple monitors
-        m_multimon = (m_w != GetSystemMetrics(SM_CXSCREEN) ||
-                                  m_h != GetSystemMetrics(SM_CYSCREEN));
-
-        // tell the desks
-        m_desks->setShape(m_x, m_y, m_w, m_h, m_xCenter, m_yCenter, m_multimon);
-}
-
-void
-CMSWindowsScreen::handleFixes(const CEvent&, void*)
-{
-        // fix clipboard chain
-        fixClipboardViewer();
-
+        m_multimon = false;
+}
+
+void
+CPMScreen::handleFixes(const CEvent&, void*)
+{
         // update keys if keyboard layouts have changed
         if (m_keyState->didGroupsChange()) {
@@ -1491 +1348 @@
 }
 
-void
-CMSWindowsScreen::fixClipboardViewer()
-{
-        // XXX -- disable this code for now.  somehow it can cause an infinite
-        // recursion in the WM_DRAWCLIPBOARD handler.  either we're sending
-        // the message to our own window or some window farther down the chain
-        // forwards the message to our window or a window farther up the chain.
-        // i'm not sure how that could happen.  the m_nextClipboardWindow = NULL
-        // was not in the code that infinite loops and may fix the bug but i
-        // doubt it.
-        return;
-        ChangeClipboardChain(m_window, m_nextClipboardWindow);
-        m_nextClipboardWindow = NULL;
-        m_nextClipboardWindow = SetClipboardViewer(m_window);
-}
-
-void
-CMSWindowsScreen::enableSpecialKeys(bool enable) const
-{
-        // enable/disable ctrl+alt+del, alt+tab, etc on win95 family.
-        // since the win95 family doesn't support low-level hooks, we
-        // use this undocumented feature to suppress normal handling
-        // of certain key combinations.
-        if (m_is95Family) {
-                DWORD dummy = 0;
-                SystemParametersInfo(SPI_SETSCREENSAVERRUNNING,
-                                                        enable ? FALSE : TRUE, &dummy, 0);
-        }
-}
-
 ButtonID
-CMSWindowsScreen::mapButtonFromEvent(WPARAM msg, LPARAM button) const
-{
+CPMScreen::mapButtonFromEvent(ULONG msg, MPARAM button) const
+{
+    /** @todo query which is left and which is right. */
+
         switch (msg) {
-        case WM_LBUTTONDOWN:
-        case WM_LBUTTONDBLCLK:
-        case WM_LBUTTONUP:
-        case WM_NCLBUTTONDOWN:
-        case WM_NCLBUTTONDBLCLK:
-        case WM_NCLBUTTONUP:
-                return kButtonLeft;
-
-        case WM_MBUTTONDOWN:
-        case WM_MBUTTONDBLCLK:
-        case WM_MBUTTONUP:
-        case WM_NCMBUTTONDOWN:
-        case WM_NCMBUTTONDBLCLK:
-        case WM_NCMBUTTONUP:
-                return kButtonMiddle;
-
-        case WM_RBUTTONDOWN:
-        case WM_RBUTTONDBLCLK:
-        case WM_RBUTTONUP:
-        case WM_NCRBUTTONDOWN:
-        case WM_NCRBUTTONDBLCLK:
-        case WM_NCRBUTTONUP:
-                return kButtonRight;
-
-        case WM_XBUTTONDOWN:
-        case WM_XBUTTONDBLCLK:
-        case WM_XBUTTONUP:
-        case WM_NCXBUTTONDOWN:
-        case WM_NCXBUTTONDBLCLK:
-        case WM_NCXBUTTONUP:
-                switch (button) {
-                case XBUTTON1:
-                        if (GetSystemMetrics(SM_CMOUSEBUTTONS) >= 4) {
-                                return kButtonExtra0 + 0;
-                        }
-                        break;
-
-                case XBUTTON2:
-                        if (GetSystemMetrics(SM_CMOUSEBUTTONS) >= 5) {
-                                return kButtonExtra0 + 1;
-                        }
-                        break;
-                }
-                return kButtonNone;
-
-        default:
-                return kButtonNone;
-        }
-}
-
-bool
-CMSWindowsScreen::mapPressFromEvent(WPARAM msg, LPARAM) const
+        case WM_BUTTON1DOWN:
+        case WM_BUTTON1UP:
+        case WM_BUTTON1DBLCLK:
+        case WM_BUTTON1CLICK: //??
+                    return kButtonLeft;
+
+        case WM_BUTTON2DOWN:
+        case WM_BUTTON2UP:
+        case WM_BUTTON2DBLCLK:
+        case WM_BUTTON2CLICK: //??
+            return kButtonLeft;
+
+        case WM_BUTTON3DOWN:
+        case WM_BUTTON3UP:
+        case WM_BUTTON3DBLCLK:
+        case WM_BUTTON3CLICK: //??
+            return kButtonMiddle;
+        default:
+                return kButtonNone;
+        }
+}
+
+bool
+CPMScreen::mapPressFromEvent(ULONG msg, LPARAM) const
 {
         switch (msg) {
-        case WM_LBUTTONDOWN:
-        case WM_MBUTTONDOWN:
-        case WM_RBUTTONDOWN:
-        case WM_XBUTTONDOWN:
-        case WM_LBUTTONDBLCLK:
-        case WM_MBUTTONDBLCLK:
-        case WM_RBUTTONDBLCLK:
-        case WM_XBUTTONDBLCLK:
-        case WM_NCLBUTTONDOWN:
-        case WM_NCMBUTTONDOWN:
-        case WM_NCRBUTTONDOWN:
-        case WM_NCXBUTTONDOWN:
-        case WM_NCLBUTTONDBLCLK:
-        case WM_NCMBUTTONDBLCLK:
-        case WM_NCRBUTTONDBLCLK:
-        case WM_NCXBUTTONDBLCLK:
-                return true;
-
-        case WM_LBUTTONUP:
-        case WM_MBUTTONUP:
-        case WM_RBUTTONUP:
-        case WM_XBUTTONUP:
-        case WM_NCLBUTTONUP:
-        case WM_NCMBUTTONUP:
-        case WM_NCRBUTTONUP:
-        case WM_NCXBUTTONUP:
-                return false;
-
-        default:
-                return false;
-        }
-}
-
-void
-CMSWindowsScreen::updateKeysCB(void*)
+        case WM_BUTTON1DOWN:
+        case WM_BUTTON1CLICK: //??
+        case WM_BUTTON1DBLCLK:
+        case WM_BUTTON2DOWN:
+        case WM_BUTTON2DBLCLK:
+        case WM_BUTTON2CLICK: //??
+        case WM_BUTTON3DOWN:
+        case WM_BUTTON3DBLCLK:
+        case WM_BUTTON3CLICK: //??
+            return true;
+        case WM_BUTTON1UP:
+        case WM_BUTTON2UP:
+        case WM_BUTTON3UP:
+            return false;
+        default:
+            return false;
+        }
+}
+
+void
+CPMScreen::updateKeysCB(void*)
 {
         // record which keys we think are down
@@ -1646 +1433 @@
 
 void
-CMSWindowsScreen::forceShowCursor()
-{
-        // check for mouse
-        m_hasMouse = (GetSystemMetrics(SM_MOUSEPRESENT) != 0);
+CPMScreen::forceShowCursor()
+{
+        // check for mouse - probably not required.
+        m_hasMouse = WinQuerySysValue(HWND_DESKTOP, SV_MOUSEPRESENT) != FALSE;
 
         // decide if we should show the mouse
@@ -1656 +1443 @@
         // show/hide the mouse
         if (showMouse != m_showingMouse) {
-                if (showMouse) {
-                        m_oldMouseKeys.cbSize = sizeof(m_oldMouseKeys);
-                        m_gotOldMouseKeys =
-                                (SystemParametersInfo(SPI_GETMOUSEKEYS,
-                                                        m_oldMouseKeys.cbSize,  &m_oldMouseKeys, 0) != 0);
-                        if (m_gotOldMouseKeys) {
-                                m_mouseKeys    = m_oldMouseKeys;
-                                m_showingMouse = true;
-                                updateForceShowCursor();
-                        }
-                }
-                else {
-                        if (m_gotOldMouseKeys) {
-                                SystemParametersInfo(SPI_SETMOUSEKEYS,
-                                                        m_oldMouseKeys.cbSize,
-                                                        &m_oldMouseKeys, SPIF_SENDCHANGE);
-                                m_showingMouse = false;
-                        }
-                }
-        }
-}
-
-void
-CMSWindowsScreen::updateForceShowCursor()
-{
-        DWORD oldFlags = m_mouseKeys.dwFlags;
-
-        // turn on MouseKeys
-        m_mouseKeys.dwFlags = MKF_AVAILABLE | MKF_MOUSEKEYSON;
-
-        // make sure MouseKeys is active in whatever state the NumLock is
-        // not currently in.
-        if ((m_keyState->getActiveModifiers() & KeyModifierNumLock) != 0) {
-                m_mouseKeys.dwFlags |= MKF_REPLACENUMBERS;
-        }
-
-        // update MouseKeys
-        if (oldFlags != m_mouseKeys.dwFlags) {
-                SystemParametersInfo(SPI_SETMOUSEKEYS,
-                                                        m_mouseKeys.cbSize, &m_mouseKeys, SPIF_SENDCHANGE);
-        }
-}
-
-LRESULT CALLBACK
-CMSWindowsScreen::wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+        WinShowPointer(HWND_DESKTOP, showMouse);
+        m_showingMouse = WinQuerySysValue(HWND_DESKTOP, SV_POINTERLEVEL) != 0;
+        }
+}
+
+void
+CPMScreen::updateForceShowCursor()
+{
+    //???
+}
+
+HRESULT EXPENTRY
+CPMScreen::wndProc(HWND hwnd, UINT msg, MPARAM mp1, MPARAM mp2)
 {
         assert(s_screen != NULL);
 
-        LRESULT result = 0;
-        if (!s_screen->onEvent(hwnd, msg, wParam, lParam, &result)) {
-                result = DefWindowProc(hwnd, msg, wParam, lParam);
-        }
-
-        return result;
+        HRESULT mr = 0;
+        if (!s_screen->onEvent(hwnd, msg, mp1, mp2, &result)) {
+                mr = WinDefWindowProc(hwnd, msg, mp1, mp2);
+        }
+
+        return mr;
 }
 
 
 //
-// CMSWindowsScreen::CHotKeyItem
+// CPMScreen::CHotKeyItem
 //
 
-CMSWindowsScreen::CHotKeyItem::CHotKeyItem(UINT keycode, UINT mask) :
+CPMScreen::CHotKeyItem::CHotKeyItem(UINT keycode, UINT mask) :
         m_keycode(keycode),
         m_mask(mask)
@@ -1725 +1480 @@
 
 UINT
-CMSWindowsScreen::CHotKeyItem::getVirtualKey() const
+CPMScreen::CHotKeyItem::getVirtualKey() const
 {
         return m_keycode;
@@ -1731 +1486 @@
 
 bool
-CMSWindowsScreen::CHotKeyItem::operator<(const CHotKeyItem& x) const
+CPMScreen::CHotKeyItem::operator<(const CHotKeyItem& x) const
 {
         return (m_keycode < x.m_keycode ||

trunk/synergy/lib/platform/CPMScreen.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2002 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef CMSWINDOWSSCREEN_H
-#define CMSWINDOWSSCREEN_H
+#ifndef CPMSCREEN_H
+#define CPMSCREEN_H
 
 #include "CPlatformScreen.h"
-#include "CSynergyHook.h"
+#include "CPMSynergyHook.h"
 #include "CCondVar.h"
 #include "CMutex.h"
 #include "CString.h"
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
+#define INCL_ERRORS
+#define INCL_BASE
+#define INCL_PM
+#include <os2.h>
+
 
 class CEventQueueTimer;
-class CMSWindowsDesks;
-class CMSWindowsKeyState;
-class CMSWindowsScreenSaver;
+class CPMDesks;
+class CPMKeyState;
+class CPMScreenSaver;
 class CThread;
 
-//! Implementation of IPlatformScreen for Microsoft Windows
-class CMSWindowsScreen : public CPlatformScreen {
+//! Implementation of IPlatformScreen for PM
+class CPMScreen : public CPlatformScreen {
 public:
-        CMSWindowsScreen(bool isPrimary);
-        virtual ~CMSWindowsScreen();
-
-        //! @name manipulators
-        //@{
-
-        //! Initialize
-        /*!
-        Saves the application's HINSTANCE.  This \b must be called by
-        WinMain with the HINSTANCE it was passed.
-        */
-        static void                     init(HINSTANCE);
-
-        //@}
-        //! @name accessors
-        //@{
-
-        //! Get instance
-        /*!
-        Returns the application instance handle passed to init().
-        */
-        static HINSTANCE        getInstance();
-
-        //@}
+        CPMScreen(bool isPrimary);
+        virtual ~CPMScreen();
 
         // IScreen overrides
         virtual void*           getEventTarget() const;
         virtual bool            getClipboard(ClipboardID id, IClipboard*) const;
-        virtual void            getShape(SInt32& x, SInt32& y,
-                                                        SInt32& width, SInt32& height) const;
+        virtual void            getShape(SInt32& x, SInt32& y, SInt32& cx, SInt32& cy) const;
         virtual void            getCursorPos(SInt32& x, SInt32& y) const;
 
@@ -115 +96 @@
 private:
         // initialization and shutdown operations
-        HINSTANCE                       openHookLibrary(const char* name);
-        void                            closeHookLibrary(HINSTANCE hookLibrary) const;
-        HCURSOR                         createBlankCursor() const;
-        void                            destroyCursor(HCURSOR cursor) const;
+        HMODULE                         openHookLibrary(const char* name);
+        void                            closeHookLibrary(HMODULE hookLibrary) const;
         ATOM                            createWindowClass() const;
         ATOM                            createDeskWindowClass(bool isPrimary) const;
@@ -131 +110 @@
         // handle message before it gets dispatched.  returns true iff
         // the message should not be dispatched.
-        bool                            onPreDispatch(HWND, UINT, WPARAM, LPARAM);
+        bool                            onPreDispatch(HWND, ULONG, MPARAM, MPARAM);
 
         // handle message before it gets dispatched.  returns true iff
         // the message should not be dispatched.
-        bool                            onPreDispatchPrimary(HWND, UINT, WPARAM, LPARAM);
+        bool                            onPreDispatchPrimary(HWND, ULONG, MPARAM, MPARAM);
 
         // handle message.  returns true iff handled and optionally sets
         // \c *result (which defaults to 0).
-        bool                            onEvent(HWND, UINT, WPARAM, LPARAM, LRESULT* result);
+        bool                            onEvent(HWND, ULONG, MPARAM, MPARAM, MRESULT*);
 
         // message handlers
         bool                            onMark(UInt32 mark);
-        bool                            onKey(WPARAM, LPARAM);
-        bool                            onHotKey(WPARAM, LPARAM);
-        bool                            onMouseButton(WPARAM, LPARAM);
+        bool                            onKey(MPARAM, MPARAM);
+        bool                            onHotKey(MPARAM, MPARAM);
+        bool                            onMouseButton(MPARAM, MPARAM);
         bool                            onMouseMove(SInt32 x, SInt32 y);
         bool                            onMouseWheel(SInt32 xDelta, SInt32 yDelta);
@@ -167 +146 @@
         void                            handleFixes(const CEvent&, void*);
 
-        // fix the clipboard viewer chain
-        void                            fixClipboardViewer();
-
         // enable/disable special key combinations so we can catch/pass them
         void                            enableSpecialKeys(bool) const;
 
         // map a button event to a button ID
-        ButtonID                        mapButtonFromEvent(WPARAM msg, LPARAM button) const;
+        ButtonID                        mapButtonFromEvent(ULONG msg, MPARAM button) const;
 
         // map a button event to a press (true) or release (false)
-        bool                            mapPressFromEvent(WPARAM msg, LPARAM button) const;
+        bool                            mapPressFromEvent(ULONG msg, MPARAM button) const;
 
         // job to update the key state
@@ -193 +169 @@
 
         // our window proc
-        static LRESULT CALLBACK wndProc(HWND, UINT, WPARAM, LPARAM);
+        static MRESULT EXPENTRY wndProc(HWND, ULONG, MPARAM, MPARAM);
 
 private:
         struct CHotKeyItem {
         public:
-                CHotKeyItem(UINT vk, UINT modifiers);
-
-                UINT                    getVirtualKey() const;
+                CHotKeyItem(ULONG vk, ULONG modifiers);
+
+                ULONG                   getVirtualKey() const;
 
                 bool                    operator<(const CHotKeyItem&) const;
 
         private:
-                UINT                    m_keycode;
-                UINT                    m_mask;
+                ULONG                   m_keycode;
+                ULONG                   m_mask;
         };
         typedef std::map<UInt32, CHotKeyItem> HotKeyMap;
@@ -212 +188 @@
         typedef std::map<CHotKeyItem, UInt32> HotKeyToIDMap;
 
-        static HINSTANCE        s_instance;
-
         // true if screen is being used as a primary screen, false otherwise
         bool                            m_isPrimary;
-
-        // true if windows 95/98/me
-        bool                            m_is95Family;
-
-        // true if mouse has entered the screen
         bool                            m_isOnScreen;
 
@@ -228 +197 @@
         // screen shape stuff
         SInt32                          m_x, m_y;
-        SInt32                          m_w, m_h;
+        SInt32                          m_cx, m_cy;
         SInt32                          m_xCenter, m_yCenter;
 
@@ -245 +214 @@
 
         // the main loop's thread id
-        DWORD                           m_threadID;
+        int                                     m_threadID;
 
         // timer for periodically checking stuff that requires polling
         CEventQueueTimer*       m_fixTimer;
 
-        // the keyboard layout to use when off primary screen
-        HKL                                     m_keyLayout;
-
         // screen saver stuff
-        CMSWindowsScreenSaver*  m_screensaver;
+        CPMScreenSaver* m_screensaver;
         bool                                    m_screensaverNotify;
         bool                                    m_screensaverActive;
@@ -264 +230 @@
         bool                            m_ownClipboard;
 
-        // one desk per desktop and a cond var to communicate with it
-        CMSWindowsDesks*        m_desks;
-
         // hook library stuff
-        HINSTANCE                       m_hookLibrary;
+        HMODULE                         m_hmodHook;
         InitFunc                        m_init;
         CleanupFunc                     m_cleanup;
@@ -276 +239 @@
 
         // keyboard stuff
-        CMSWindowsKeyState*     m_keyState;
+        CPMKeyState*            m_keyState;
 
         // hot key stuff
@@ -286 +249 @@
         bool                            m_buttons[1 + kButtonExtra0 + 1];
 
-        // the system shows the mouse cursor when an internal display count
-        // is >= 0.  this count is maintained per application but there's
-        // apparently a system wide count added to the application's count.
-        // this system count is 0 if there's a mouse attached to the system
-        // and -1 otherwise.  the MouseKeys accessibility feature can modify
-        // this system count by making the system appear to have a mouse.
-        //
-        // m_hasMouse is true iff there's a mouse attached to the system or
-        // MouseKeys is simulating one.  we track this so we can force the
-        // cursor to be displayed when the user has entered this screen.
-        // m_showingMouse is true when we're doing that.
         bool                            m_hasMouse;
         bool                            m_showingMouse;
-        bool                            m_gotOldMouseKeys;
-        MOUSEKEYS                       m_mouseKeys;
-        MOUSEKEYS                       m_oldMouseKeys;
-
-        static CMSWindowsScreen*        s_screen;
+
+        static CPMScreen*       s_screen;
 };
 

trunk/synergy/lib/platform/CPMScreenSaver.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2002 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "CMSWindowsScreenSaver.h"
-#include "CMSWindowsScreen.h"
-#include "CThread.h"
-#include "CLog.h"
-#include "TMethodJob.h"
-#include "CArch.h"
-#include "CArchMiscWindows.h"
-#include <malloc.h>
-#include <tchar.h>
-
-#if !defined(SPI_GETSCREENSAVERRUNNING)
-#define SPI_GETSCREENSAVERRUNNING 114
-#endif
-
-static const TCHAR* g_isSecureNT = "ScreenSaverIsSecure";
-static const TCHAR* g_isSecure9x = "ScreenSaveUsePassword";
-static const TCHAR* const g_pathScreenSaverIsSecure[] = {
-        "Control Panel",
-        "Desktop",
-        NULL
-};
+#include "CPMScreenSaver.h"
 
 //
-// CMSWindowsScreenSaver
+// CPMScreenSaver
 //
 
-CMSWindowsScreenSaver::CMSWindowsScreenSaver() :
-        m_wasSecure(false),
-        m_wasSecureAnInt(false),
-        m_process(NULL),
-        m_watch(NULL),
-        m_threadID(0),
-        m_active(false)
+CPMScreenSaver::CPMScreenSaver()
 {
-        // detect OS
-        m_is95Family = false;
-        m_is95       = false;
-        m_isNT       = false;
-        OSVERSIONINFO info;
-        info.dwOSVersionInfoSize = sizeof(info);
-        if (GetVersionEx(&info)) {
-                m_is95Family = (info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS);
-                if (info.dwPlatformId   == VER_PLATFORM_WIN32_NT &&
-                        info.dwMajorVersion <= 4) {
-                        m_isNT = true;
-                }
-                else if (info.dwPlatformId  == VER_PLATFORM_WIN32_WINDOWS &&
-                                info.dwMajorVersion == 4 &&
-                                info.dwMinorVersion == 0) {
-                        m_is95 = true;
-                }
-        }
-
-        // check if screen saver is enabled
-        SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, &m_wasEnabled, 0);
 }
 
-CMSWindowsScreenSaver::~CMSWindowsScreenSaver()
+CPMScreenSaver::~CPMScreenSaver()
 {
-        unwatchProcess();
+}
+
+void
+CPMScreenSaver::enable()
+{
+}
+
+void
+CPMScreenSaver::disable()
+{
+}
+
+void
+CPMScreenSaver::activate()
+{
+}
+
+void
+CPMScreenSaver::deactivate()
+{
 }
 
 bool
-CMSWindowsScreenSaver::checkStarted(UINT msg, WPARAM wParam, LPARAM lParam)
+CPMScreenSaver::isActive() const
 {
-        // if already started then say it didn't just start
-        if (m_active) {
-                return false;
-        }
-
-        // screen saver may have started.  look for it and get
-        // the process.  if we can't find it then assume it
-        // didn't really start.  we wait a moment before
-        // looking to give the screen saver a chance to start.
-        // this shouldn't be a problem since we only get here
-        // if the screen saver wants to kick in, meaning that
-        // the system is idle or the user deliberately started
-        // the screen saver.
-        Sleep(250);
-
-        // set parameters common to all screen saver handling
-        m_threadID = GetCurrentThreadId();
-        m_msg      = msg;
-        m_wParam   = wParam;
-        m_lParam   = lParam;
-
-        // we handle the screen saver differently for the windows
-        // 95 and nt families.
-        if (m_is95Family) {
-                // on windows 95 we wait for the screen saver process
-                // to terminate.  get the process.
-                DWORD processID = findScreenSaver();
-                HANDLE process = OpenProcess(SYNCHRONIZE, FALSE, processID);
-                if (process == NULL) {
-                        // didn't start
-                        LOG((CLOG_DEBUG2 "can't open screen saver process"));
-                        return false;
-                }
-
-                // watch for the process to exit
-                watchProcess(process);
-        }
-        else {
-                // on the windows nt family we wait for the desktop to
-                // change until it's neither the Screen-Saver desktop
-                // nor a desktop we can't open (the login desktop).
-                // since windows will send the request-to-start-screen-
-                // saver message even when the screen saver is disabled
-                // we first check that the screen saver is indeed active
-                // before watching for it to stop.
-                if (!isActive()) {
-                        LOG((CLOG_DEBUG2 "can't open screen saver desktop"));
-                        return false;
-                }
-
-                watchDesktop();
-        }
-
-        return true;
+    return false;
 }
 
-void
-CMSWindowsScreenSaver::enable()
-{
-        SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, m_wasEnabled, 0, 0);
-
-        // restore password protection
-        if (m_wasSecure) {
-                setSecure(true, m_wasSecureAnInt);
-        }
-
-        // restore display power down
-        CArchMiscWindows::removeBusyState(CArchMiscWindows::kDISPLAY);
-}
-
-void
-CMSWindowsScreenSaver::disable()
-{
-        SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, &m_wasEnabled, 0);
-        SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE, 0, 0);
-
-        // disable password protected screensaver
-        m_wasSecure = isSecure(&m_wasSecureAnInt);
-        if (m_wasSecure) {
-                setSecure(false, m_wasSecureAnInt);
-        }
-
-        // disable display power down
-        CArchMiscWindows::addBusyState(CArchMiscWindows::kDISPLAY);
-}
-
-void
-CMSWindowsScreenSaver::activate()
-{
-        // don't activate if already active
-        if (!isActive()) {
-                // activate
-                HWND hwnd = GetForegroundWindow();
-                if (hwnd != NULL) {
-                        PostMessage(hwnd, WM_SYSCOMMAND, SC_SCREENSAVE, 0);
-                }
-                else {
-                        // no foreground window.  pretend we got the event instead.
-                        DefWindowProc(NULL, WM_SYSCOMMAND, SC_SCREENSAVE, 0);
-                }
-
-                // restore power save when screen saver activates
-                CArchMiscWindows::removeBusyState(CArchMiscWindows::kDISPLAY);
-        }
-}
-
-void
-CMSWindowsScreenSaver::deactivate()
-{
-        bool killed = false;
-        if (!m_is95Family) {
-                // NT runs screen saver in another desktop
-                HDESK desktop = OpenDesktop("Screen-saver", 0, FALSE,
-                                                                DESKTOP_READOBJECTS | DESKTOP_WRITEOBJECTS);
-                if (desktop != NULL) {
-                        EnumDesktopWindows(desktop,
-                                                                &CMSWindowsScreenSaver::killScreenSaverFunc,
-                                                                reinterpret_cast<LPARAM>(&killed));
-                        CloseDesktop(desktop);
-                }
-        }
-
-        // if above failed or wasn't tried, try the windows 95 way
-        if (!killed) {
-                // find screen saver window and close it
-                HWND hwnd = FindWindow("WindowsScreenSaverClass", NULL);
-                if (hwnd == NULL) {
-                        // win2k may use a different class
-                        hwnd = FindWindow("Default Screen Saver", NULL);
-                }
-                if (hwnd != NULL) {
-                        PostMessage(hwnd, WM_CLOSE, 0, 0);
-                }
-        }
-
-        // force timer to restart
-        SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, &m_wasEnabled, 0);
-        SystemParametersInfo(SPI_SETSCREENSAVEACTIVE,
-                                                                !m_wasEnabled, 0, SPIF_SENDWININICHANGE);
-        SystemParametersInfo(SPI_SETSCREENSAVEACTIVE,
-                                                                 m_wasEnabled, 0, SPIF_SENDWININICHANGE);
-
-        // disable display power down
-        CArchMiscWindows::removeBusyState(CArchMiscWindows::kDISPLAY);
-}
-
-bool
-CMSWindowsScreenSaver::isActive() const
-{
-        if (m_is95) {
-                return (FindWindow("WindowsScreenSaverClass", NULL) != NULL);
-        }
-        else if (m_isNT) {
-                // screen saver runs on a separate desktop
-                HDESK desktop = OpenDesktop("Screen-saver", 0, FALSE, MAXIMUM_ALLOWED);
-                if (desktop == NULL && GetLastError() != ERROR_ACCESS_DENIED) {
-                        // desktop doesn't exist so screen saver is not running
-                        return false;
-                }
-
-                // desktop exists.  this should indicate that the screen saver
-                // is running but an OS bug can cause a valid handle to be
-                // returned even if the screen saver isn't running (Q230117).
-                // we'll try to enumerate the windows on the desktop and, if
-                // there are any, we assume the screen saver is running.  (note
-                // that if we don't have permission to enumerate then we'll
-                // assume that the screen saver is not running.)  that'd be
-                // easy enough except there's another OS bug (Q198590) that can
-                // cause EnumDesktopWindows() to enumerate the windows of
-                // another desktop if the requested desktop has no windows.  to
-                // work around that we have to verify that the enumerated
-                // windows are, in fact, on the expected desktop.
-                CFindScreenSaverInfo info;
-                info.m_desktop = desktop;
-                info.m_window  = NULL;
-                EnumDesktopWindows(desktop,
-                                                                &CMSWindowsScreenSaver::findScreenSaverFunc,
-                                                                reinterpret_cast<LPARAM>(&info));
-
-                // done with desktop
-                CloseDesktop(desktop);
-
-                // screen saver is running if a window was found
-                return (info.m_window != NULL);
-        }
-        else {
-                BOOL running;
-                SystemParametersInfo(SPI_GETSCREENSAVERRUNNING, 0, &running, 0);
-                return (running != FALSE);
-        }
-}
-
-BOOL CALLBACK
-CMSWindowsScreenSaver::findScreenSaverFunc(HWND hwnd, LPARAM arg)
-{
-        CFindScreenSaverInfo* info = reinterpret_cast<CFindScreenSaverInfo*>(arg);
-
-        if (info->m_desktop != NULL) {
-                DWORD threadID = GetWindowThreadProcessId(hwnd, NULL);
-                HDESK desktop  = GetThreadDesktop(threadID);
-                if (desktop != NULL && desktop != info->m_desktop) {
-                        // stop enumerating -- wrong desktop
-                        return FALSE;
-                }
-        }
-
-        // found a window
-        info->m_window = hwnd;
-
-        // don't need to enumerate further
-        return FALSE;
-}
-
-BOOL CALLBACK
-CMSWindowsScreenSaver::killScreenSaverFunc(HWND hwnd, LPARAM arg)
-{
-        if (IsWindowVisible(hwnd)) {
-                HINSTANCE instance = (HINSTANCE)GetWindowLong(hwnd, GWL_HINSTANCE);
-                if (instance != CMSWindowsScreen::getInstance()) {
-                        PostMessage(hwnd, WM_CLOSE, 0, 0);
-                        *reinterpret_cast<bool*>(arg) = true;
-                }
-        }
-        return TRUE;
-}
-
-DWORD
-CMSWindowsScreenSaver::findScreenSaver()
-{
-        // try windows 95 way
-        HWND hwnd = FindWindow("WindowsScreenSaverClass", NULL);
-
-        // get process ID of process that owns the window, if found
-        if (hwnd != NULL) {
-                DWORD processID;
-                GetWindowThreadProcessId(hwnd, &processID);
-                return processID;
-        }
-
-        // not found
-        return 0;
-}
-
-void
-CMSWindowsScreenSaver::watchDesktop()
-{
-        // stop watching previous process/desktop
-        unwatchProcess();
-
-        // watch desktop in another thread
-        LOG((CLOG_DEBUG "watching screen saver desktop"));
-        m_active = true;
-        m_watch  = new CThread(new TMethodJob<CMSWindowsScreenSaver>(this,
-                                                                &CMSWindowsScreenSaver::watchDesktopThread));
-}
-
-void
-CMSWindowsScreenSaver::watchProcess(HANDLE process)
-{
-        // stop watching previous process/desktop
-        unwatchProcess();
-
-        // watch new process in another thread
-        if (process != NULL) {
-                LOG((CLOG_DEBUG "watching screen saver process"));
-                m_process = process;
-                m_active  = true;
-                m_watch   = new CThread(new TMethodJob<CMSWindowsScreenSaver>(this,
-                                                                &CMSWindowsScreenSaver::watchProcessThread));
-        }
-}
-
-void
-CMSWindowsScreenSaver::unwatchProcess()
-{
-        if (m_watch != NULL) {
-                LOG((CLOG_DEBUG "stopped watching screen saver process/desktop"));
-                m_watch->cancel();
-                m_watch->wait();
-                delete m_watch;
-                m_watch  = NULL;
-                m_active = false;
-        }
-        if (m_process != NULL) {
-                CloseHandle(m_process);
-                m_process = NULL;
-        }
-}
-
-void
-CMSWindowsScreenSaver::watchDesktopThread(void*)
-{
-        DWORD reserved = 0;
-        TCHAR* name    = NULL;
-
-        for (;;) {
-                // wait a bit
-                ARCH->sleep(0.2);
-
-                if (m_isNT) {
-                        // get current desktop
-                        HDESK desk = OpenInputDesktop(0, FALSE, GENERIC_READ);
-                        if (desk == NULL) {
-                                // can't open desktop so keep waiting
-                                continue;
-                        }
-
-                        // get current desktop name length
-                        DWORD size;
-                        GetUserObjectInformation(desk, UOI_NAME, NULL, 0, &size);
-
-                        // allocate more space for the name, if necessary
-                        if (size > reserved) {
-                                reserved = size;
-                                name     = (TCHAR*)alloca(reserved + sizeof(TCHAR));
-                        }
-
-                        // get current desktop name
-                        GetUserObjectInformation(desk, UOI_NAME, name, size, &size);
-                        CloseDesktop(desk);
-
-                        // compare name to screen saver desktop name
-                        if (_tcsicmp(name, TEXT("Screen-saver")) == 0) {
-                                // still the screen saver desktop so keep waiting
-                                continue;
-                        }
-                }
-                else {
-                        // 2000/XP have a sane way to detect a runnin screensaver.
-                        BOOL running;
-                        SystemParametersInfo(SPI_GETSCREENSAVERRUNNING, 0, &running, 0);
-                        if (running) {
-                                continue;
-                        }
-                }
-
-                // send screen saver deactivation message
-                m_active = false;
-                PostThreadMessage(m_threadID, m_msg, m_wParam, m_lParam);
-                return;
-        }
-}
-
-void
-CMSWindowsScreenSaver::watchProcessThread(void*)
-{
-        for (;;) {
-                CThread::testCancel();
-                if (WaitForSingleObject(m_process, 50) == WAIT_OBJECT_0) {
-                        // process terminated
-                        LOG((CLOG_DEBUG "screen saver died"));
-
-                        // send screen saver deactivation message
-                        m_active = false;
-                        PostThreadMessage(m_threadID, m_msg, m_wParam, m_lParam);
-                        return;
-                }
-        }
-}
-
-void
-CMSWindowsScreenSaver::setSecure(bool secure, bool saveSecureAsInt)
-{
-        HKEY hkey =
-                CArchMiscWindows::addKey(HKEY_CURRENT_USER, g_pathScreenSaverIsSecure);
-        if (hkey == NULL) {
-                return;
-        }
-
-        const TCHAR* isSecure = m_is95Family ? g_isSecure9x : g_isSecureNT;
-        if (saveSecureAsInt) {
-                CArchMiscWindows::setValue(hkey, isSecure, secure ? 1 : 0);
-        }
-        else {
-                CArchMiscWindows::setValue(hkey, isSecure, secure ? "1" : "0");
-        }
-
-        CArchMiscWindows::closeKey(hkey);
-}
-
-bool
-CMSWindowsScreenSaver::isSecure(bool* wasSecureFlagAnInt) const
-{
-        // get the password protection setting key
-        HKEY hkey =
-                CArchMiscWindows::openKey(HKEY_CURRENT_USER, g_pathScreenSaverIsSecure);
-        if (hkey == NULL) {
-                return false;
-        }
-
-        // get the value.  the value may be an int or a string, depending
-        // on the version of windows.
-        bool result;
-        const TCHAR* isSecure = m_is95Family ? g_isSecure9x : g_isSecureNT;
-        switch (CArchMiscWindows::typeOfValue(hkey, isSecure)) {
-        default:
-                result = false;
-                break;
-
-        case CArchMiscWindows::kUINT: {
-                DWORD value =
-                        CArchMiscWindows::readValueInt(hkey, isSecure);
-                *wasSecureFlagAnInt = true;
-                result = (value != 0);
-                break;
-        }
-
-        case CArchMiscWindows::kSTRING: {
-                std::string value =
-                        CArchMiscWindows::readValueString(hkey, isSecure);
-                *wasSecureFlagAnInt = false;
-                result = (value != "0");
-                break;
-        }
-        }
-
-        CArchMiscWindows::closeKey(hkey);
-        return result;
-}

trunk/synergy/lib/platform/CPMScreenSaver.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2002 Chris Schoeneman
+ * Copyright (C) 2006 Knut St Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef CMSWINDOWSSCREENSAVER_H
-#define CMSWINDOWSSCREENSAVER_H
+#ifndef CPMSCREENSAVER_H
+#define CPMSCREENSAVER_H
 
 #include "IScreenSaver.h"
 #include "CString.h"
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
+#define INCL_ERRORS
+#define INCL_BASE
+#define INCL_PM
+#include <os2.h>
 
 class CThread;
 
-//! Microsoft windows screen saver implementation
-class CMSWindowsScreenSaver : public IScreenSaver {
+//! PM screen saver implementation (stub)
+class CPMScreenSaver : public IScreenSaver {
 public:
-        CMSWindowsScreenSaver();
-        virtual ~CMSWindowsScreenSaver();
-
-        //! @name manipulators
-        //@{
-
-        //! Check if screen saver started
-        /*!
-        Check if the screen saver really started.  Returns false if it
-        hasn't, true otherwise.  When the screen saver stops, \c msg will
-        be posted to the current thread's message queue with the given
-        parameters.
-        */
-        bool                            checkStarted(UINT msg, WPARAM, LPARAM);
-
-        //@}
+        CPMScreenSaver();
+        virtual ~CPMScreenSaver();
 
         // IScreenSaver overrides
@@ -51 +40 @@
 
 private:
-        class CFindScreenSaverInfo {
-        public:
-                HDESK                   m_desktop;
-                HWND                    m_window;
-        };
-
-        static BOOL CALLBACK    findScreenSaverFunc(HWND hwnd, LPARAM lParam);
-        static BOOL CALLBACK    killScreenSaverFunc(HWND hwnd, LPARAM lParam);
-
-        DWORD                           findScreenSaver();
-        void                            watchDesktop();
-        void                            watchProcess(HANDLE process);
-        void                            unwatchProcess();
-        void                            watchDesktopThread(void*);
-        void                            watchProcessThread(void*);
-
-        void                            setSecure(bool secure, bool saveSecureAsInt);
-        bool                            isSecure(bool* wasSecureAnInt) const;
-
-private:
-        bool                            m_is95Family;
-        bool                            m_is95;
-        bool                            m_isNT;
-        BOOL                            m_wasEnabled;
-        bool                            m_wasSecure;
-        bool                            m_wasSecureAnInt;
-
-        HANDLE                          m_process;
-        CThread*                        m_watch;
-        DWORD                           m_threadID;
-        UINT                            m_msg;
-        WPARAM                          m_wParam;
-        LPARAM                          m_lParam;
-
-        // checkActive state.  true if the screen saver is being watched
-        // for deactivation (and is therefore active).
-        bool                            m_active;
 };
 

trunk/synergy/lib/platform/CPMSynergyHook.h

@@ -17 +17 @@
 
 #include "BasicTypes.h"
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
+#define INCL_BASE
+#define INCL_ERRORS
+#define INCL_PM
+#include <os2.h>
 
 #if defined(SYNRGYHK_EXPORTS)
-#define CSYNERGYHOOK_API __declspec(dllexport)
+# define CSYNERGYHOOK_API __declspec(dllexport)
 #else
-#define CSYNERGYHOOK_API __declspec(dllimport)
+# define CSYNERGYHOOK_API __declspec(dllimport)
 #endif
 
-#define SYNERGY_MSG_MARK                        WM_APP + 0x0011 // mark id; <unused>
-#define SYNERGY_MSG_KEY                         WM_APP + 0x0012 // vk code; key data
-#define SYNERGY_MSG_MOUSE_BUTTON        WM_APP + 0x0013 // button msg; <unused>
-#define SYNERGY_MSG_MOUSE_WHEEL         WM_APP + 0x0014 // delta; <unused>
-#define SYNERGY_MSG_MOUSE_MOVE          WM_APP + 0x0015 // x; y
-#define SYNERGY_MSG_POST_WARP           WM_APP + 0x0016 // <unused>; <unused>
-#define SYNERGY_MSG_PRE_WARP            WM_APP + 0x0017 // x; y
-#define SYNERGY_MSG_SCREEN_SAVER        WM_APP + 0x0018 // activated; <unused>
-#define SYNERGY_MSG_DEBUG                       WM_APP + 0x0019 // data, data
+#define SYNERGY_MSG_MARK                        WM_USER + 0x0011        // mark id; <unused>
+#define SYNERGY_MSG_KEY                         WM_USER + 0x0012        // vk code; key data
+#define SYNERGY_MSG_MOUSE_BUTTON        WM_USER + 0x0013        // button msg; <unused>
+#define SYNERGY_MSG_MOUSE_WHEEL         WM_USER + 0x0014        // delta; <unused>
+#define SYNERGY_MSG_MOUSE_MOVE          WM_USER + 0x0015        // x; y
+#define SYNERGY_MSG_POST_WARP           WM_USER + 0x0016        // <unused>; <unused>
+#define SYNERGY_MSG_PRE_WARP            WM_USER + 0x0017        // x; y
+#define SYNERGY_MSG_SCREEN_SAVER        WM_USER + 0x0018        // activated; <unused>
+#define SYNERGY_MSG_DEBUG                       WM_USER + 0x0019        // data, data
 #define SYNERGY_MSG_INPUT_FIRST         SYNERGY_MSG_KEY
 #define SYNERGY_MSG_INPUT_LAST          SYNERGY_MSG_PRE_WARP
@@ -56 +58 @@
 };
 
-typedef int                             (*InitFunc)(DWORD targetQueueThreadID);
+typedef int                             (*InitFunc)(HMQ hmq, int tid, int pid);
 typedef int                             (*CleanupFunc)(void);
 typedef EHookResult             (*InstallFunc)(void);
@@ -66 +68 @@
 typedef void                    (*SetModeFunc)(int);
 
-CSYNERGYHOOK_API int    init(DWORD);
+CSYNERGYHOOK_API int    init(HMQ hmq, int tid, int pid);
 CSYNERGYHOOK_API int    cleanup(void);
 CSYNERGYHOOK_API EHookResult    install(void);
@@ -73 +75 @@
 CSYNERGYHOOK_API int    uninstallScreenSaver(void);
 CSYNERGYHOOK_API void   setSides(UInt32 sides);
-CSYNERGYHOOK_API void   setZone(SInt32 x, SInt32 y, SInt32 w, SInt32 h,
-                                                        SInt32 jumpZoneSize);
+CSYNERGYHOOK_API void   setZone(SInt32 x, SInt32 y, SInt32 cx, SInt32 cy, SInt32 jumpZoneSize);
 CSYNERGYHOOK_API void   setMode(EHookMode mode);
 

trunk/synergy/lib/platform/CPMUtil.cpp

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#include "CMSWindowsUtil.h"
+#include "CPMUtil.h"
 #include "CStringUtil.h"
 #include <stdio.h>
 
 //
-// CMSWindowsUtil
+// CPMUtil
 //
 
 CString
-CMSWindowsUtil::getString(HINSTANCE instance, DWORD id)
+CPMUtil::getString(HMODULE hmod, ULONG id)
 {
-        char buffer[1024];
-        int size = static_cast<int>(sizeof(buffer) / sizeof(buffer[0]));
-        char* msg = buffer;
+        char szBuf[1024];
 
         // load string
-        int n = LoadString(instance, id, msg, size);
-        msg[n] = '\0';
-        if (n < size) {
-                return msg;
+        LONG cch = WinLoadString(WinQueryAnchorBlock(HWND_DESKTOP), hmod, id, sizeof(szBuf), (PSZ)szBuf);
+        if(cch < 0) {
+                szBuf[cch] = '\0';
+                char *psz = szBuf;
+                return psz;
         }
-
-        // not enough buffer space.  keep trying larger buffers until
-        // we get the whole string.
-        msg = NULL;
-        do {
-                size <<= 1;
-                delete[] msg;
-                char* msg = new char[size];
-                n = LoadString(instance, id, msg, size);
-        } while (n == size);
-        msg[n] = '\0';
-
-        CString result(msg);
-        delete[] msg;
-        return result;
+        return "";
 }
 
 CString
-CMSWindowsUtil::getErrorString(HINSTANCE hinstance, DWORD error, DWORD id)
+CPMUtil::getErrorString(HMODULE hmod, ULONG error, ULONG id)
 {
+#if 1
+        char szMsg[80];
+        snprintf(szMsg, sizeof(szMsg), "sys error %#lx (%d)\n", error, error);
+        char *pszMsg = szMsg;
+        return CString(pszMsg);
+
+#else
         char* buffer;
         if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
@@ -73 +66 @@
                 return result;
         }
+#endif 
 }
+
+HAB CPMUtil::getHAB(void)
+{
+    return WinQueryAnchorBlock(HWND_DESKTOP);
+}
+

trunk/synergy/lib/platform/CPMUtil.h

@@ -2 +2 @@
  * synergy -- mouse and keyboard sharing utility
  * Copyright (C) 2004 Chris Schoeneman
+ * Copyright (C) 2006 Knut St. Osmundsen
  * 
  * This package is free software; you can redistribute it and/or
@@ -13 +14 @@
  */
 
-#ifndef CMSWINDOWSUTIL_H
-#define CMSWINDOWSUTIL_H
+#ifndef CPMUTIL_H
+#define CPMUTIL_H
 
 #include "CString.h"
-#define WINDOWS_LEAN_AND_MEAN
-#include <windows.h>
+#define INCL_BASE
+#define INCL_ERRORS
+#define INCL_PM
+#include <os2.h>
 
-class CMSWindowsUtil {
+class CPMUtil {
 public:
         //! Get message string
@@ -26 +29 @@
         Gets a string for \p id from the string table of \p instance.
         */
-        static CString          getString(HINSTANCE instance, DWORD id);
+        static CString          getString(HMODULE hmod, ULONG id);
 
         //! Get error string
@@ -33 +36 @@
         found return the string for \p id, replacing ${1} with \p error.
         */
-        static CString          getErrorString(HINSTANCE, DWORD error, DWORD id);
+        static CString          getErrorString(HMODULE hmod, ULONG error, ULONG id);
+    
+    static HAB          getHAB(void);
+
 };