Changeset 2755 for trunk

Timestamp:

Jul 31, 2006, 5:21:38 AM (19 years ago)

Author:

bird

Message:

bedtime

Location:

trunk/synergy

Files:

• Makefile.kmk (modified) (2 diffs)
• lib/platform/CPMEventQueueBuffer.cpp (modified) (5 diffs)
• lib/platform/CPMKeyState.cpp (modified) (18 diffs)
• lib/platform/CPMKeyState.h (modified) (3 diffs)
• lib/platform/CPMScreen.cpp (modified) (53 diffs)
• lib/platform/CPMScreen.h (modified) (7 diffs)
• lib/platform/CPMSynergyHook.cpp (modified) (3 diffs)
• lib/platform/CPMSynergyHook.def (added)
• lib/platform/CPMSynergyHook.h (modified) (2 diffs)
• lib/platform/CPMSynergyHookData.asm (added)

trunk/synergy/Makefile.kmk

@@ -163 +163 @@
         lib/platform/CPMEventQueueBuffer.cpp \
         lib/platform/CPMScreenSaver.cpp \
+        lib/platform/CPMScreen.cpp \
+        lib/platform/CPMKeyState.cpp \
         lib/platform/CPMUtil.cpp
 # todo:
-#       lib/platform/CPMKeyState.cpp \
-#       lib/platform/CPMScreen.cpp
 platform_SOURCES.nt = \
         lib/platform/CMSWindowsClipboard.cpp \
@@ -235 +235 @@
 
 
+#
+# The hook DLLs.
+#
+DLLS = synrgyhk
+
+synrgyhk_DEFS = SYNRGYHK_EXPORTS
+synrgyhk_ASTOOL.os2 = NASM
+synrgyhk_ASFLAGS.os2 = -f obj
+synrgyhk_SOURCES.nt = \
+        lib/platform/CSynergyHook.cpp
+synrgyhk_SOURCES.os2 = \
+        lib/platform/CPMSynergyHook.cpp \
+        lib/platform/CPMSynergyHookData.asm \
+        lib/platform/CPMSynergyHook.def
+
 include $(PATH_KBUILD)/footer.kmk

trunk/synergy/lib/platform/CPMEventQueueBuffer.cpp

@@ -3 +3 @@
  * Copyright (C) 2004 Chris Schoeneman
  * Copyright (C) 2006 Knut St. Osmundsen
- * 
+ *
  * This package is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * found in the file COPYING that should have accompanied this file.
- * 
+ *
  * This package is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -59 +59 @@
 CPMEventQueueBuffer::waitForEvent(double timeout)
 {
-        // check if messages are available first. 
+        // check if messages are available first.
     ULONG fStatus = WinQueryQueueStatus(HWND_DESKTOP);
     if (!fStatus) {
         // convert timeout and wait.
-        ULONG ulPMTimeout = timeout < 0.0 
+        ULONG ulPMTimeout = timeout < 0.0
                           ? SEM_INDEFINITE_WAIT
                           : (ULONG)(1000.0 * timeout);
@@ -85 +85 @@
                 return kSystem;
         }
-        
+
     if (m_event.msg == m_userEvent) {
                 dataID = (UInt32)(uintptr_t)m_event.mp1;
                 return kUser;
         }
-    
+
     event = CEvent(CEvent::kSystem, IEventQueue::getSystemTarget(), &m_event);
     return kSystem;
@@ -105 +105 @@
 {
     ULONG fStatus = WinQueryQueueStatus(HWND_DESKTOP);
-        return fStatus != 0; 
+        return fStatus != 0;
 }
 
@@ -120 +120 @@
 }
 
+/*
+ * Local Variables:
+ *  mode: c
+ *  c-file-style: "k&r"
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ *  indent-tabs-mode: t
+ * End:
+ */
+

trunk/synergy/lib/platform/CPMKeyState.cpp

@@ -3 +3 @@
  * Copyright (C) 2003 Chris Schoeneman
  * Copyright (C) 2006 Knut St. Osmundsen
- * 
+ *
  * This package is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * found in the file COPYING that should have accompanied this file.
- * 
+ *
  * This package is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -30 +30 @@
 {
         /* 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         
+        /* 0x001 */ kKeyNone,           // VK_BUTTON1
+        /* 0x002 */ kKeyNone,           // VK_BUTTON2
+        /* 0x003 */ kKeyNone,           // VK_BUTTON3
+        /* 0x004 */ kKeyBreak,          // VK_BREAK
         /* 0x005 */ kKeyBackSpace,      // VK_BACKSPACE
         /* 0x006 */ kKeyTab,            // VK_TAB
@@ -39 +39 @@
         /* 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         
+        /* 0x00a */ kKeyControl_L,      // VK_CTRL
+        /* 0x00b */ kKeyAlt_L,          // VK_ALT
+        /* 0x00c */ kKeyAltGr,          // VK_ALTGRAF
+        /* 0x00d */ kKeyPause,          // VK_PAUSE
+        /* 0x00e */ kKeyCapsLock,       // VK_CAPSLOCK
+        /* 0x00f */ kKeyEscape,         // VK_ESC
+        /* 0x010 */ kKeyNone,           // VK_SPACE
+        /* 0x011 */ kKeyPageUp,         // VK_PAGEUP
+        /* 0x012 */ kKeyPageDown,       // VK_PAGEDOWN
+        /* 0x013 */ kKeyEnd,            // VK_END
+        /* 0x014 */ kKeyHome,           // VK_HOME
+        /* 0x015 */ kKeyLeft,           // VK_LEFT
+        /* 0x016 */ kKeyUp,                     // VK_UP
+        /* 0x017 */ kKeyRight,          // VK_RIGHT
+        /* 0x018 */ kKeyDown,           // VK_DOWN
+        /* 0x019 */ kKeyNone,           // VK_PRINTSCRN
+        /* 0x01a */ kKeyInsert,         // VK_INSERT
+        /* 0x01b */ kKeyDelete,         // VK_DELETE
+        /* 0x01c */ kKeyScrollLock,     // VK_SCRLLOCK
+        /* 0x01d */ kKeyNumLock,        // VK_NUMLOCK
+        /* 0x01e */ kKeyKP_Enter,       // VK_ENTER
+        /* 0x01f */ kKeySysReq,         // VK_SYSRQ
+        /* 0x020 */ kKeyF1,                     // VK_F1
+        /* 0x021 */ kKeyF2,                     // VK_F2
+        /* 0x022 */ kKeyF3,                     // VK_F3
+        /* 0x023 */ kKeyF4,                     // VK_F4
+        /* 0x024 */ kKeyF5,                     // VK_F5
+        /* 0x025 */ kKeyF6,                     // VK_F6
+        /* 0x026 */ kKeyF7,                     // VK_F7
+        /* 0x027 */ kKeyF8,                     // VK_F8
+        /* 0x028 */ kKeyF9,                     // VK_F9
+        /* 0x029 */ kKeyF10,            // VK_F10
+        /* 0x02a */ kKeyF11,            // VK_F11
+        /* 0x02b */ kKeyF12,            // VK_F12
+        /* 0x02c */ kKeyF13,            // VK_F13
+        /* 0x02d */ kKeyF14,            // VK_F14
+        /* 0x02e */ kKeyF15,            // VK_F15
+        /* 0x02f */ kKeyF16,            // VK_F16
+        /* 0x030 */ kKeyF17,            // VK_F17
+        /* 0x031 */ kKeyF18,            // VK_F18
+        /* 0x032 */ kKeyF19,            // VK_F19
+        /* 0x033 */ kKeyF20,            // VK_F20
+        /* 0x034 */ kKeyF21,            // VK_F21
+        /* 0x035 */ kKeyF22,            // VK_F22
+        /* 0x036 */ kKeyF23,            // VK_F23
+        /* 0x037 */ kKeyF24,            // VK_F24
+        /* 0x038 */ kKeyNone,           // VK_ENDDRAG
+        /* 0x039 */ kKeyClear,          // VK_CLEAR
+        /* 0x03a */ kKeyNone,           // VK_EREOF
+        /* 0x03b */ kKeyNone,           // VK_PA1
+        /* 0x03c */ kKeyNone,           // VK_ATTN
+        /* 0x03d */ kKeyNone,           // VK_CRSEL
+        /* 0x03e */ kKeyNone,           // VK_EXSEL
+        /* 0x03f */ kKeyNone,           // VK_COPY
+        /* 0x040 */ kKeyNone,           // VK_BLK1
+        /* 0x041 */ kKeyNone            // VK_BLK2
 };
 
@@ -114 +114 @@
         m_eventTarget(eventTarget),
         m_fixTimer(NULL),
-        m_lastDown(0),
+        m_lastDown(kKeyNone),
         m_useSavedModifiers(false),
         m_savedModifiers(0),
@@ -135 +135 @@
                 m_fixTimer = NULL;
         }
-        m_lastDown = 0;
+        m_lastDown = kKeyNone;
 }
 
@@ -147 +147 @@
 CPMKeyState::testAutoRepeat(bool press, bool isRepeat, KeyButton button)
 {
-        if (!isRepeat) {
-                isRepeat = (press && m_lastDown != 0 && button == m_lastDown);
-        }
-        if (press) {
-                m_lastDown = button;
-        }
-        else {
-                m_lastDown = 0;
-        }
+        if (!isRepeat)
+                isRepeat = press && button == m_lastDown && button != kKeyNone;
+        m_lastDown = press ? button : kKeyNone;
         return isRepeat;
 }
@@ -174 +168 @@
                         // transfer any modifier state changes to CKeyState's state
                         KeyModifierMask mask = m_originalSavedModifiers ^ m_savedModifiers;
-                        getActiveModifiersRValue() =
-                                (getActiveModifiers() & ~mask) | (m_savedModifiers & mask);
+                        getActiveModifiersRValue() = (getActiveModifiers() & ~mask) | (m_savedModifiers & mask);
                 }
         }
@@ -181 +174 @@
 
 KeyID
-CPMKeyState::mapKeyFromEvent(MPARAM charAndVirtKey, MPARAM info, KeyModifierMask* maskOut) const
-{
+CPMKeyState::mapKeyFromEvent(USHORT fsFlags, UCHAR ucRepeat, UCHAR ucScanCode, USHORT usch, USHORT usvk, KeyModifierMask* maskOut) const
+{
+#if 0 /** @todo */
         static const KeyModifierMask s_controlAlt = KeyModifierControl | KeyModifierAlt;
 
@@ -228 +222 @@
                 *maskOut = active;
         }
-
         return id;
-}
-
-bool
-CPMKeyState::didGroupsChange() const
-{
-        GroupList groups;
-        return (getGroups(groups) && groups != m_groups);
-}
-
-UINT
+#else
+        return kKeyNone;
+#endif
+}
+
+ULONG
 CPMKeyState::mapKeyToVirtualKey(KeyID key) const
 {
-        if (key == kKeyNone) {
+        if (key == kKeyNone)
                 return 0;
-        }
         KeyToVKMap::const_iterator i = m_keyToVKMap.find(key);
-        if (i == m_keyToVKMap.end()) {
+        if (i == m_keyToVKMap.end())
                 return 0;
-        }
-        else {
-                return i->second;
-        }
+        return i->second;
 }
 
@@ -272 +257 @@
                 // send key
                 if (press && !isAutoRepeat) {
-                        CKeyState::sendKeyEvent(target, true, false,
-                                                        key, mask, 1, button);
+                        CKeyState::sendKeyEvent(target, true, false, key, mask, 1, button);
                         if (count > 0) {
                                 --count;
@@ -279 +263 @@
                 }
                 if (count >= 1) {
-                        CKeyState::sendKeyEvent(target, true, true,
-                                                        key, mask, count, button);
+                        CKeyState::sendKeyEvent(target, true, true, key, mask, count, button);
                 }
         }
@@ -290 +273 @@
 
 void
-CPMKeyState::fakeKeyDown(KeyID id, KeyModifierMask mask,
-                                KeyButton button)
+CPMKeyState::fakeKeyDown(KeyID id, KeyModifierMask mask, KeyButton button)
 {
         CKeyState::fakeKeyDown(id, mask, button);
@@ -297 +279 @@
 
 void
-CPMKeyState::fakeKeyRepeat(KeyID id, KeyModifierMask mask,
-                                SInt32 count, KeyButton button)
+CPMKeyState::fakeKeyRepeat(KeyID id, KeyModifierMask mask, SInt32 count, KeyButton button)
 {
         CKeyState::fakeKeyRepeat(id, mask, count, button);
@@ -323 +304 @@
 
         // we can get toggle modifiers from the system
-        if (WinGetKeyState(HWND_DESKTOP, VK_CAPITAL) & 1) {
+        if (WinGetKeyState(HWND_DESKTOP, VK_CAPSLOCK) & 1)
                 state |= KeyModifierCapsLock;
-        }
-        if (WinGetKeyState(HWND_DESKTOP, VK_NUMLOCK) & 1) {
+        if (WinGetKeyState(HWND_DESKTOP, VK_NUMLOCK) & 1)
                 state |= KeyModifierNumLock;
-        }
-        if (WinGetKeyState(HWND_DESKTOP, VK_SCROLL) & 1) {
+        if (WinGetKeyState(HWND_DESKTOP, VK_SCRLLOCK) & 1)
                 state |= KeyModifierScrollLock;
-        }
-
         return state;
 }
@@ -623 +600 @@
                                                         }
                                                 }
-                                                
+
                                                 // save each key.  the map will automatically discard
                                                 // duplicates, like an unshift and shifted version of
@@ -742 +719 @@
 }
 
-bool
-CPMKeyState::getGroups(GroupList& groups) const
-{
-        // get keyboard layouts
-        UInt32 newNumLayouts = GetKeyboardLayoutList(0, NULL);
-        if (newNumLayouts == 0) {
-                LOG((CLOG_DEBUG1 "can't get keyboard layouts"));
-                return false;
-        }
-        HKL* newLayouts = new HKL[newNumLayouts];
-        newNumLayouts = GetKeyboardLayoutList(newNumLayouts, newLayouts);
-        if (newNumLayouts == 0) {
-                LOG((CLOG_DEBUG1 "can't get keyboard layouts"));
-                delete[] newLayouts;
-                return false;
-        }
-
-        groups.clear();
-        groups.insert(groups.end(), newLayouts, newLayouts + newNumLayouts);
-        delete[] newLayouts;
-        return true;
-}
-
-void
-CPMKeyState::setWindowGroup(SInt32 group)
-{
-        HWND targetWindow = GetForegroundWindow();
-
-        bool sysCharSet = true;
-        // XXX -- determine if m_groups[group] can be used with the system
-        // character set.
-
-        PostMessage(targetWindow, WM_INPUTLANGCHANGEREQUEST,
-                                                                sysCharSet ? 1 : 0, (LPARAM)m_groups[group]);
-
-        // XXX -- use a short delay to let the target window process the message
-        // before it sees the keyboard events.  i'm not sure why this is
-        // necessary since the messages should arrive in order.  if we don't
-        // delay, though, some of our keyboard events may disappear.
-        Sleep(100);
-}
-
 void
 CPMKeyState::fixKeys()
@@ -822 +757 @@
                                 LOG((CLOG_DEBUG1 "event: fake key release left windows key (0x%03x)", leftButton));
                                 CKeyState::onKey(leftButton, false, state);
-                                CKeyState::sendKeyEvent(m_eventTarget, false, false,
-                                                                kKeySuper_L, state, 1, leftButton);
+                                CKeyState::sendKeyEvent(m_eventTarget, false, false, kKeySuper_L, state, 1, leftButton);
                         }
                         if (rightDown && !rightAsyncDown) {
                                 LOG((CLOG_DEBUG1 "event: fake key release right windows key (0x%03x)", rightButton));
                                 CKeyState::onKey(rightButton, false, state);
-                                CKeyState::sendKeyEvent(m_eventTarget, false, false,
-                                                                kKeySuper_R, state, 1, rightButton);
+                                CKeyState::sendKeyEvent(m_eventTarget, false, false, kKeySuper_R, state, 1, rightButton);
                         }
                 }
@@ -910 +843 @@
         }
 }
+
+/*
+ * Local Variables:
+ *  mode: c
+ *  c-file-style: "k&r"
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ *  indent-tabs-mode: t
+ * End:
+ */
+

trunk/synergy/lib/platform/CPMKeyState.h

@@ -3 +3 @@
  * Copyright (C) 2003 Chris Schoeneman
  * Copyright (C) 2006 Knut St. Osmundsen
- * 
+ *
  * This package is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * found in the file COPYING that should have accompanied this file.
- * 
+ *
  * This package is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -90 +90 @@
         to a modifier mask.
         */
-        KeyID                           mapKeyFromEvent(MPARAM charAndVirtKey, MPARAM info, KeyModifierMask* maskOut) const;
+        KeyID               mapKeyFromEvent(USHORT fsFlags, UCHAR ucRepeat, UCHAR ucScanCode, USHORT usch, USHORT usvk, KeyModifierMask* maskOut) const;
 
         //! Check if keyboard groups have changed
@@ -183 +183 @@
 };
 
+/*
+ * Local Variables:
+ *  mode: c
+ *  c-file-style: "k&r"
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ *  indent-tabs-mode: t
+ * End:
+ */
+
+
 #endif

trunk/synergy/lib/platform/CPMScreen.cpp

@@ -34 +34 @@
 #include "CPMUtil.h"
 #include <string.h>
+#include <unistd.h>
 
 //
@@ -44 +45 @@
         m_isPrimary(isPrimary),
         m_isOnScreen(m_isPrimary),
-        m_class(0),
         m_x(0), m_y(0),
         m_cx(0), m_cy(0),
@@ -53 +53 @@
         m_mark(0),
         m_markReceived(0),
-        m_fixTimer(NULL),
         m_screensaver(NULL),
         m_screensaverNotify(false),
@@ -73 +72 @@
 
         s_screen = this;
+
+        // query curren thread bits.
+        m_threadID = _gettid();
+        m_hab = WinQueryAnchorBlock(HWND_DESKTOP);
+        m_hmq = WinQueueFromID(m_hab, getpid(), _gettid());
+        if (m_hab == NULLHANDLE || m_hmq == NULLHANDLE) {
+                LOG((CLOG_CRIT "couldn't get the hab/hmq of the current thread!\n"));
+                throw XScreenOpenFailure();
+        }
+
         try {
-                if (m_isPrimary) {
+                if (m_isPrimary)
                         m_hmodHook = openHookLibrary("synrgyhk");
-                }
                 m_screensaver = new CPMScreenSaver();
                 m_keyState    = new CPMKeyState(getEventTarget());
                 updateScreenShape();
-                m_class       = createWindowClass();
-                m_window      = createWindow(m_class, "Synergy");
+                m_window      = createWindow("Synergy");
                 forceShowCursor();
                 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 (...) {
+        } catch (...) {
                 delete m_keyState;
                 delete m_screensaver;
                 destroyWindow(m_window);
-                destroyClass(m_class);
                 closeHookLibrary(m_hmodHook);
                 s_screen = NULL;
@@ -98 +103 @@
         // install event handlers
         EVENTQUEUE->adoptHandler(CEvent::kSystem, IEventQueue::getSystemTarget(),
-                                                        new TMethodEventJob<CPMScreen>(this,
-                                                                &CPMScreen::handleSystemEvent));
+                                                        new TMethodEventJob<CPMScreen>(this, &CPMScreen::handleSystemEvent));
 
         // install the platform event queue
@@ -115 +119 @@
         delete m_screensaver;
         destroyWindow(m_window);
-        destroyClass(m_class);
         closeHookLibrary(m_hmodHook);
         s_screen = NULL;
@@ -124 +127 @@
 {
         assert(m_isOnScreen == m_isPrimary);
-
-        // we need to poll some things to fix them
-        m_fixTimer = EVENTQUEUE->newTimer(1.0, NULL);
-        EVENTQUEUE->adoptHandler(CEvent::kTimer, m_fixTimer,
-                                                         new TMethodEventJob<CPMScreen>(this, &CPMScreen::handleFixes));
 
         // install our clipboard snooper
@@ -135 +133 @@
     WinSetClipbrdViewer(hab, m_window);
 
-/// @todo start here!
-        // track the active desk and (re)install the hooks
-        m_desks->enable();
-
         if (m_isPrimary) {
                 // set jump zones
@@ -151 +145 @@
 CPMScreen::disable()
 {
-        // stop tracking the active desk
-        m_desks->disable();
-
         if (m_isPrimary) {
                 // disable hooks
@@ -166 +157 @@
         m_nextClipboardWindow = NULL;
 
-        // uninstall fix timer
-        if (m_fixTimer != NULL) {
-                EVENTQUEUE->removeHandler(CEvent::kTimer, m_fixTimer);
-                EVENTQUEUE->deleteTimer(m_fixTimer);
-                m_fixTimer = NULL;
-        }
-
         m_isOnScreen = m_isPrimary;
         forceShowCursor();
@@ -180 +164 @@
 CPMScreen::enter()
 {
-        m_desks->enter();
+        // show the pointer (?), hide the synergy window and restore focus.
+        WinShowPointer(HWND_DESKTOP, TRUE);
+        WinSetWindowPos(m_window, HWND_BOTTOM, 0, 0, 0, 0, SWP_HIDE);
+        //?? WinSetFocus(
+        //?? WinEnableWindow
+
         if (m_isPrimary) {
                 // watch jump zones
@@ -197 +186 @@
 CPMScreen::leave()
 {
+        /// @todo save focus window.
+
         if (m_isPrimary) {
                 // warp to center
@@ -252 +243 @@
 {
         m_screensaverNotify = notify;
-        if (!m_screensaverNotify) {
+        if (!m_screensaverNotify)
                 m_screensaver->disable();
-        }
 }
 
@@ -260 +250 @@
 CPMScreen::closeScreensaver()
 {
-        if (!m_screensaverNotify) {
+        if (!m_screensaverNotify)
                 m_screensaver->enable();
-        }
 }
 
@@ -268 +257 @@
 CPMScreen::screensaver(bool activate)
 {
-    if (activate) {
+    if (activate)
         m_screensaver->activate();
-    }
-    else {
+    else
         m_screensaver->deactivate();
-    }
 }
 
@@ -321 +308 @@
 CPMScreen::getShape(SInt32& x, SInt32& y, SInt32& cx, SInt32& cy) const
 {
-        assert(m_class != 0);
-
         x = m_x;
         y = m_y;
@@ -356 +341 @@
         // remove all input events before and including warp
         QMSG qmsg;
-        while (WinPeekMsg(m_hab, &qmsg, NULLHANDLE, SYNERGY_MSG_INPUT_FIRST, SYNERGY_MSG_INPUT_LAST, PM_REMOVE)) {
+        while (WinPeekMsg(m_hab, &qmsg, NULLHANDLE, SYNERGY_PM_MSG_INPUT_FIRST, SYNERGY_PM_MSG_INPUT_LAST, PM_REMOVE)) {
                 // do nothing
         }
@@ -483 +468 @@
                 m_keyState->useSavedModifiers(true);
         }
-        m_desks->fakeInputBegin();
+        //m_desks->fakeInputBegin();
 }
 
@@ -491 +476 @@
         assert(m_isPrimary);
 
-        m_desks->fakeInputEnd();
+        //m_desks->fakeInputEnd();
         if (!m_isOnScreen) {
                 m_keyState->useSavedModifiers(false);
@@ -535 +520 @@
 CPMScreen::fakeMouseButton(ButtonID id, bool press) const
 {
-        m_desks->fakeMouseButton(id, press);
+        //m_desks->fakeMouseButton(id, press);
 }
 
@@ -541 +526 @@
 CPMScreen::fakeMouseMove(SInt32 x, SInt32 y) const
 {
-        m_desks->fakeMouseMove(x, y);
+        //m_desks->fakeMouseMove(x, y);
 }
 
@@ -547 +532 @@
 CPMScreen::fakeMouseRelativeMove(SInt32 dx, SInt32 dy) const
 {
-        m_desks->fakeMouseRelativeMove(dx, dy);
+        //m_desks->fakeMouseRelativeMove(dx, dy);
 }
 
@@ -553 +538 @@
 CPMScreen::fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const
 {
-        m_desks->fakeMouseWheel(xDelta, yDelta);
+        //m_desks->fakeMouseWheel(xDelta, yDelta);
 }
 
@@ -559 +544 @@
 CPMScreen::updateKeys()
 {
-        m_desks->updateKeys();
+        //m_desks->updateKeys();
 }
 
@@ -592 +577 @@
 }
 
-HINSTANCE
+HMODULE
 CPMScreen::openHookLibrary(const char* name)
 {
         // load the hook library
-        HINSTANCE hookLibrary = LoadLibrary(name);
-        if (hookLibrary == NULL) {
-                LOG((CLOG_ERR "Failed to load hook library;  %s.dll is missing", name));
+        HMODULE hmod;
+        APIRET rc = DosLoadModule(NULL, 0, (PCSZ)name, &hmod);
+        if (rc != NO_ERROR) {
+                LOG((CLOG_ERR "Failed to load hook library (%s), rc=%d ", name, rc));
                 throw XScreenOpenFailure();
         }
 
         // look up functions
-        m_setSides  = (SetSidesFunc)GetProcAddress(hookLibrary, "setSides");
-        m_setZone   = (SetZoneFunc)GetProcAddress(hookLibrary, "setZone");
-        m_setMode   = (SetModeFunc)GetProcAddress(hookLibrary, "setMode");
-        m_init      = (InitFunc)GetProcAddress(hookLibrary, "init");
-        m_cleanup   = (CleanupFunc)GetProcAddress(hookLibrary, "cleanup");
-        if (m_setSides             == NULL ||
-                m_setZone              == NULL ||
-                m_setMode              == NULL ||
-                m_init                 == NULL ||
-                m_cleanup              == NULL) {
-                LOG((CLOG_ERR "Invalid hook library;  use a newer %s.dll", name));
+        if (    (rc = DosQueryProcAddr(hmod, 0, (PCSZ)"_setSides",      (PPFN)&m_setSides)) != NO_ERROR
+                ||      (rc = DosQueryProcAddr(hmod, 0, (PCSZ)"_setZone",       (PPFN)&m_setZone )) != NO_ERROR
+                ||      (rc = DosQueryProcAddr(hmod, 0, (PCSZ)"_setMode",       (PPFN)&m_setMode )) != NO_ERROR
+                ||      (rc = DosQueryProcAddr(hmod, 0, (PCSZ)"_init",          (PPFN)&m_init    )) != NO_ERROR
+                ||      (rc = DosQueryProcAddr(hmod, 0, (PCSZ)"_cleanup",       (PPFN)&m_cleanup )) != NO_ERROR) {
+                LOG((CLOG_ERR "Invalid hook library;  use a newer %s.dll (rc=%d)", name, rc));
+                DosFreeModule(hmod);
                 throw XScreenOpenFailure();
         }
 
         // initialize hook library
-        if (m_init(GetCurrentThreadId()) == 0) {
-                LOG((CLOG_ERR "Cannot initialize hook library;  is synergy already running?"));
+        if (m_init(m_hmq, _gettid(), getpid()) == 0) {
+                LOG((CLOG_ERR "Cannot initialize hook library; is synergy already running?"));
+                DosFreeModule(hmod);
                 throw XScreenOpenFailure();
         }
-
-        return hookLibrary;
-}
-
-void
-CPMScreen::closeHookLibrary(HINSTANCE hookLibrary) const
-{
-        if (hookLibrary != NULL) {
-                m_cleanup();
-                FreeLibrary(hookLibrary);
-        }
-}
-
-ATOM
-CPMScreen::createWindowClass() const
-{
-        WNDCLASSEX classInfo;
-        classInfo.cbSize        = sizeof(classInfo);
-        classInfo.style         = CS_DBLCLKS | CS_NOCLOSE;
-        classInfo.lpfnWndProc   = &CPMScreen::wndProc;
-        classInfo.cbClsExtra    = 0;
-        classInfo.cbWndExtra    = 0;
-        classInfo.hInstance     = s_instance;
-        classInfo.hIcon         = NULL;
-        classInfo.hCursor       = NULL;
-        classInfo.hbrBackground = NULL;
-        classInfo.lpszMenuName  = NULL;
-        classInfo.lpszClassName = "Synergy";
-        classInfo.hIconSm       = NULL;
-        return RegisterClassEx(&classInfo);
-}
-
-void
-CPMScreen::destroyClass(ATOM windowClass) const
-{
-        if (windowClass != 0) {
-                UnregisterClass(reinterpret_cast<LPCTSTR>(windowClass), s_instance);
+        return hmod;
+}
+
+void
+CPMScreen::closeHookLibrary(HMODULE hmod) const
+{
+        if (hmod != NULL) {
+                m_cleanup(m_hab);
+                DosFreeModule(hmod);
         }
 }
 
 HWND
-CPMScreen::createWindow(ATOM windowClass, const char* name) const
-{
-        HWND window = CreateWindowEx(WS_EX_TOPMOST |
-                                                                        WS_EX_TRANSPARENT |
-                                                                        WS_EX_TOOLWINDOW,
-                                                                reinterpret_cast<LPCTSTR>(windowClass),
-                                                                name,
-                                                                WS_POPUP,
+CPMScreen::createWindow(const char* name)
+{
+        WinRegisterClass(m_hab, (PCSZ)"Synergy", CPMScreen::wndProc, CS_MOVENOTIFY, sizeof(uintptr_t));
+        HWND hwnd = WinCreateWindow(HWND_DESKTOP,
+                                                                (PCSZ)"Synergy",
+                                                                NULL,
+                                                                0, //WS_?,
                                                                 0, 0, 1, 1,
-                                                                NULL, NULL,
-                                                                s_instance,
+                                                                HWND_DESKTOP,
+                                                                NULLHANDLE,
+                                                                0,
+                                                                this,
                                                                 NULL);
-        if (window == NULL) {
-                LOG((CLOG_ERR "failed to create window: %d", GetLastError()));
+        if (hwnd == NULLHANDLE) {
+                LOG((CLOG_ERR "failed to create window: %ld", WinGetLastError(m_hab)));
                 throw XScreenOpenFailure();
         }
-        return window;
+        return hwnd;
 }
 
@@ -686 +642 @@
 {
         if (hwnd != NULL) {
-                DestroyWindow(hwnd);
+                WinDestroyWindow(hwnd);
         }
 }
@@ -708 +664 @@
 CPMScreen::handleSystemEvent(const CEvent& event, void*)
 {
-        MSG* msg = reinterpret_cast<MSG*>(event.getData());
-        assert(msg != NULL);
-
-        if (CArchMiscWindows::processDialog(msg)) {
+        PQMSG pqmsg = (PQMSG)event.getData();
+        assert(pqmsg != NULL);
+        if (onPreDispatch(pqmsg->hwnd, pqmsg->msg, pqmsg->mp1, pqmsg->mp2))
                 return;
-        }
-        if (onPreDispatch(msg->hwnd, msg->message, msg->wParam, msg->lParam)) {
-                return;
-        }
-        TranslateMessage(msg);
-        DispatchMessage(msg);
+        WinDispatchMsg(CPMUtil::getHAB(), pqmsg);
 }
 
@@ -724 +674 @@
 CPMScreen::updateButtons()
 {
-        int numButtons               = GetSystemMetrics(SM_CMOUSEBUTTONS);
         m_buttons[kButtonNone]       = false;
-        m_buttons[kButtonLeft]       = (GetKeyState(VK_LBUTTON)  < 0);
-        m_buttons[kButtonRight]      = (GetKeyState(VK_RBUTTON)  < 0);
-        m_buttons[kButtonMiddle]     = (GetKeyState(VK_MBUTTON)  < 0);
-        m_buttons[kButtonExtra0 + 0] = (numButtons >= 4) &&
-                                                                   (GetKeyState(VK_XBUTTON1) < 0);
-        m_buttons[kButtonExtra0 + 1] = (numButtons >= 5) &&
-                                                                   (GetKeyState(VK_XBUTTON2) < 0);
+        m_buttons[kButtonLeft]       = (WinGetKeyState(HWND_DESKTOP, VK_BUTTON1) & 0x8000) != 0;
+        m_buttons[kButtonRight]      = (WinGetKeyState(HWND_DESKTOP, VK_BUTTON2) & 0x8000) != 0;
+        m_buttons[kButtonMiddle]     = (WinGetKeyState(HWND_DESKTOP, VK_BUTTON3) & 0x8000) != 0;
+        m_buttons[kButtonExtra0 + 0] = false;
+        m_buttons[kButtonExtra0 + 1] = false;
 }
 
@@ -742 +689 @@
 
 bool
-CPMScreen::onPreDispatch(HWND hwnd,
-                                UINT message, WPARAM wParam, LPARAM lParam)
+CPMScreen::onPreDispatch(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
 {
         // handle event
-        switch (message) {
-        case SYNERGY_MSG_SCREEN_SAVER:
-                return onScreensaver(wParam != 0);
-
-        case SYNERGY_MSG_DEBUG:
-                LOG((CLOG_DEBUG1 "hook: 0x%08x 0x%08x", wParam, lParam));
+        switch (msg) {
+        case SYNERGY_PM_MSG_DEBUG:
+                LOG((CLOG_DEBUG1 "hook: 0x%08x 0x%08x", mp1, mp2));
                 return true;
         }
 
         if (m_isPrimary) {
-                return onPreDispatchPrimary(hwnd, message, wParam, lParam);
+                return onPreDispatchPrimary(hwnd, msg, mp1, mp2);
         }
 
@@ -763 +706 @@
 
 bool
-CPMScreen::onPreDispatchPrimary(HWND,
-                                UINT message, WPARAM wParam, LPARAM lParam)
+CPMScreen::onPreDispatchPrimary(HWND, ULONG msg, MPARAM mp1, MPARAM mp2)
 {
         // handle event
-        switch (message) {
-        case SYNERGY_MSG_MARK:
-                return onMark(static_cast<UInt32>(wParam));
-
-        case SYNERGY_MSG_KEY:
-                return onKey(wParam, lParam);
-
-        case SYNERGY_MSG_MOUSE_BUTTON:
-                return onMouseButton(wParam, lParam);
-
-        case SYNERGY_MSG_MOUSE_MOVE:
-                return onMouseMove(static_cast<SInt32>(wParam),
-                                                        static_cast<SInt32>(lParam));
-
-        case SYNERGY_MSG_MOUSE_WHEEL:
-                // XXX -- support x-axis scrolling
-                return onMouseWheel(0, static_cast<SInt32>(wParam));
-
-        case SYNERGY_MSG_PRE_WARP:
+        switch (msg) {
+        case SYNERGY_PM_MSG_MARK:
+                return onMark((uintptr_t)mp1);
+
+        case SYNERGY_PM_MSG_KEY:
+                return onKey(SHORT1FROMMP(mp1), CHAR3FROMMP(mp1), CHAR4FROMMP(mp1), SHORT1FROMMP(mp2), SHORT2FROMMP(mp2));
+
+        case SYNERGY_PM_MSG_MOUSE_BUTTON:
+                return onMouseButton(SHORT1FROMMP(mp1), (SHORT)SHORT1FROMMP(mp2), m_cy - (SHORT)SHORT2FROMMP(mp2));
+
+        case SYNERGY_PM_MSG_MOUSE_MOVE:
+                return onMouseMove(SHORT1FROMMP(mp1), (SHORT)SHORT1FROMMP(mp2), m_cy - (SHORT)SHORT2FROMMP(mp2));
+
+        case SYNERGY_PM_MSG_PRE_WARP:
                 {
-                        // save position to compute delta of next motion
-                        m_xCursor = static_cast<SInt32>(wParam);
-                        m_yCursor = static_cast<SInt32>(lParam);
-
-                        // we warped the mouse.  discard events until we find the
-                        // matching post warp event.  see warpCursorNoFlush() for
-                        // where the events are sent.  we discard the matching
+                        // Save position to compute delta of next motion
+                        m_xCursor = (SInt32)mp1;
+                        m_yCursor = (SInt32)mp2;
+
+                        // We warped the mouse. Discard events until we find the
+                        // matching post warp event. See warpCursorNoFlush() for
+                        // where the events are sent. We discard the matching
                         // post warp event and can be sure we've skipped the warp
                         // event.
-                        MSG msg;
-                        do {
-                                GetMessage(&msg, NULL, SYNERGY_MSG_MOUSE_MOVE,
-                                                                                SYNERGY_MSG_POST_WARP);
-                        } while (msg.message != SYNERGY_MSG_POST_WARP);
+                        QMSG qmsg;
+                        while (   WinGetMsg(m_hab, &qmsg, NULLHANDLE, SYNERGY_PM_MSG_MOUSE_MOVE, SYNERGY_PM_MSG_POST_WARP)
+                                   && qmsg.msg != SYNERGY_PM_MSG_POST_WARP)
+                                /* nothing */;
                 }
                 return true;
 
-        case SYNERGY_MSG_POST_WARP:
+        case SYNERGY_PM_MSG_POST_WARP:
                 LOG((CLOG_WARN "unmatched post warp"));
                 return true;
-
-        case WM_HOTKEY:
-                // we discard these messages.  we'll catch the hot key in the
-                // regular key event handling, where we can detect both key
-                // press and release.  we only register the hot key so no other
-                // app will act on the key combination.
-                break;
         }
 
@@ -820 +749 @@
 
 bool
-CPMScreen::onEvent(HWND, UINT msg,
-                                WPARAM wParam, LPARAM lParam, LRESULT* result)
+CPMScreen::onEvent(HWND, ULONG msg, MPARAM mp1, MPARAM mp2, MRESULT *result)
 {
         switch (msg) {
-        case WM_QUERYENDSESSION:
-                if (m_is95Family) {
-                        *result = TRUE;
-                        return true;
-                }
-                break;
-
-        case WM_ENDSESSION:
-                if (m_is95Family) {
-                        if (wParam == TRUE && lParam == 0) {
-                                EVENTQUEUE->addEvent(CEvent(CEvent::kQuit));
-                        }
-                        return true;
-                }
-                break;
-
         case WM_DRAWCLIPBOARD:
-                // first pass on the message
-                if (m_nextClipboardWindow != NULL) {
-                        SendMessage(m_nextClipboardWindow, msg, wParam, lParam);
-                }
+                //// first pass on the message
+                //if (m_nextClipboardWindow != NULL) {
+                //      WinSendMessage(m_nextClipboardWindow, msg, mp1, mp2);
+                //}
 
                 // now handle the message
                 return onClipboardChange();
-
-        case WM_CHANGECBCHAIN:
-                if (m_nextClipboardWindow == (HWND)wParam) {
-                        m_nextClipboardWindow = (HWND)lParam;
-                        LOG((CLOG_DEBUG "clipboard chain: new next: 0x%08x", m_nextClipboardWindow));
-                }
-                else if (m_nextClipboardWindow != NULL) {
-                        SendMessage(m_nextClipboardWindow, msg, wParam, lParam);
-                }
-                return true;
-
-        case WM_DISPLAYCHANGE:
-                return onDisplayChange();
-
-        case WM_POWERBROADCAST:
-                switch (wParam) {
-                case PBT_APMRESUMEAUTOMATIC:
-                case PBT_APMRESUMECRITICAL:
-                case PBT_APMRESUMESUSPEND:
-                        EVENTQUEUE->addEvent(CEvent(IScreen::getResumeEvent(),
-                                                        getEventTarget(), NULL,
-                                                        CEvent::kDeliverImmediately));
-                        break;
-
-                case PBT_APMSUSPEND:
-                        EVENTQUEUE->addEvent(CEvent(IScreen::getSuspendEvent(),
-                                                        getEventTarget(), NULL,
-                                                        CEvent::kDeliverImmediately));
-                        break;
-                }
-                *result = TRUE;
-                return true;
         }
 
@@ -893 +773 @@
 
 bool
-CPMScreen::onKey(WPARAM wParam, LPARAM lParam)
-{
-        static const KeyModifierMask s_ctrlAlt =
-                KeyModifierControl | KeyModifierAlt;
-
-        LOG((CLOG_DEBUG1 "event: Key char=%d, vk=0x%02x, nagr=%d, lParam=0x%08x", (wParam & 0xff00u) >> 8, wParam & 0xffu, (wParam & 0x10000u) ? 1 : 0, lParam));
+CPMScreen::onKey(USHORT fsFlags, UCHAR ucRepeat, UCHAR ucScanCode, USHORT usch, USHORT usvk)
+{
+#if 0
+        static const KeyModifierMask s_ctrlAlt = KeyModifierControl | KeyModifierAlt;
+
+        LOG((CLOG_DEBUG1 "event: Key char=%d, vk=0x%02x, nagr=%d, mp2=0x%08x", (mp1 & 0xff00u) >> 8, mp1 & 0xffu, (mp1 & 0x10000u) ? 1 : 0, mp2));
 
         // get event info
-        KeyButton button         = (KeyButton)((lParam & 0x01ff0000) >> 16);
-        bool down                = ((lParam & 0x80000000u) == 0x00000000u);
+        KeyButton button         = (KeyButton)((mp2 & 0x01ff0000) >> 16);
+        bool down                = ((mp2 & 0x80000000u) == 0x00000000u);
         bool wasDown             = isKeyDown(button);
         KeyModifierMask oldState = pollActiveModifiers();
 
         // check for autorepeat
-        if (m_keyState->testAutoRepeat(down, (lParam & 0x40000000u) == 1, button)) {
-                lParam |= 0x40000000u;
+        if (m_keyState->testAutoRepeat(down, (mp2 & 0x40000000u) == 1, button)) {
+                mp2 |= 0x40000000u;
         }
 
@@ -916 +796 @@
         // alternatively, we could just throw these events out.
         if (button == 0) {
-                button = m_keyState->virtualKeyToButton(wParam & 0xffu);
+                button = m_keyState->virtualKeyToButton(mp1 & 0xffu);
                 if (button == 0) {
                         return true;
@@ -950 +830 @@
         if (oldState != state) {
                 // modifier key was pressed/released
-                if (onHotKey(0, lParam)) {
+                if (onHotKey(0, mp2)) {
                         return true;
                 }
@@ -956 +836 @@
         else {
                 // non-modifier was pressed/released
-                if (onHotKey(wParam, lParam)) {
+                if (onHotKey(mp1, mp2)) {
                         return true;
                 }
@@ -965 +845 @@
                 // check for ctrl+alt+del.  we do not want to pass that to the
                 // client.  the user can use ctrl+alt+pause to emulate it.
-                UINT virtKey = (wParam & 0xffu);
+                UINT virtKey = (mp1 & 0xffu);
                 if (virtKey == VK_DELETE && (state & s_ctrlAlt) == s_ctrlAlt) {
                         LOG((CLOG_DEBUG "discard ctrl+alt+del"));
@@ -975 +855 @@
                         (state & s_ctrlAlt) == s_ctrlAlt) {
                         LOG((CLOG_DEBUG "emulate ctrl+alt+del"));
-                        // switch wParam and lParam to be as if VK_DELETE was
+                        // switch mp1 and mp2 to be as if VK_DELETE was
                         // pressed or released.  when mapping the key we require that
-                        // we not use AltGr (the 0x10000 flag in wParam) and we not
-                        // use the keypad delete key (the 0x01000000 flag in lParam).
-                        wParam  = VK_DELETE | 0x00010000u;
-                        lParam &= 0xfe000000;
-                        lParam |= m_keyState->virtualKeyToButton(wParam & 0xffu) << 16;
-                        lParam |= 0x01000001;
+                        // we not use AltGr (the 0x10000 flag in mp1) and we not
+                        // use the keypad delete key (the 0x01000000 flag in mp2).
+                        mp1  = VK_DELETE | 0x00010000u;
+                        mp2 &= 0xfe000000;
+                        mp2 |= m_keyState->virtualKeyToButton(mp1 & 0xffu) << 16;
+                        mp2 |= 0x01000001;
                 }
 
                 // process key
                 KeyModifierMask mask;
-                KeyID key = m_keyState->mapKeyFromEvent(wParam, lParam, &mask);
-                button    = static_cast<KeyButton>((lParam & 0x01ff0000u) >> 16);
+                KeyID key = m_keyState->mapKeyFromEvent((ULONG)mp1, (ULONG)mp2, &mask);
+                button    = static_cast<KeyButton>((mp2 & 0x01ff0000u) >> 16);
                 if (key != kKeyNone) {
                         // fix key up.  if the key isn't down according to
@@ -1023 +903 @@
                         // do it
                         m_keyState->sendKeyEvent(getEventTarget(),
-                                                        ((lParam & 0x80000000u) == 0),
-                                                        ((lParam & 0x40000000u) != 0),
-                                                        key, mask, (SInt32)(lParam & 0xffff), button);
+                                                        ((mp2 & 0x80000000u) == 0),
+                                                        ((mp2 & 0x40000000u) != 0),
+                                                        key, mask, (SInt32)(mp2 & 0xffff), button);
                 }
                 else {
@@ -1031 +911 @@
                 }
         }
-
+#endif
         return true;
 }
 
 bool
-CPMScreen::onHotKey(WPARAM wParam, LPARAM lParam)
-{
+CPMScreen::onHotKey(MPARAM mp1, MPARAM mp2)
+{
+#if 0
         // get the key info
         KeyModifierMask state = getActiveModifiers();
-        UINT virtKey   = (wParam & 0xffu);
+        UINT virtKey   = (mp1 & 0xffu);
         UINT modifiers = 0;
         if ((state & KeyModifierShift) != 0) {
@@ -1064 +945 @@
         // find what kind of event
         CEvent::Type type;
-        if ((lParam & 0x80000000u) == 0u) {
-                if ((lParam & 0x40000000u) != 0u) {
+        if ((mp2 & 0x80000000u) == 0u) {
+                if ((mp2 & 0x40000000u) != 0u) {
                         // ignore key repeats but it counts as a hot key
                         return true;
@@ -1079 +960 @@
                                                         CHotKeyInfo::alloc(i->second)));
 
+#endif
         return true;
 }
 
 bool
-CPMScreen::onMouseButton(WPARAM wParam, LPARAM lParam)
+CPMScreen::onMouseButton(ULONG msg, SInt32 ax, SInt32 ay)
 {
         // get which button
-        bool pressed    = mapPressFromEvent((ULONG)wParam, lParam);
-        ButtonID button = mapButtonFromEvent((ULONG)wParam, lParam);
+        bool pressed    = mapPressFromEvent(msg);
+        ButtonID button = mapButtonFromEvent(msg);
 
         // keep our shadow key state up to date
@@ -1122 +1004 @@
 
 bool
-CPMScreen::onMouseMove(SInt32 mx, SInt32 my)
+CPMScreen::onMouseMove(ULONG msg, SInt32 ax, SInt32 ay)
 {
         // compute motion delta (relative to the last known
         // mouse position)
-        SInt32 x = mx - m_xCursor;
-        SInt32 y = my - m_yCursor;
+        SInt32 x = ax - m_xCursor;
+        SInt32 y = ay - m_yCursor;
 
         // ignore if the mouse didn't move or if message posted prior
@@ -1136 +1018 @@
 
         // save position to compute delta of next motion
-        m_xCursor = mx;
-        m_yCursor = my;
+        m_xCursor = ax;
+        m_yCursor = ay;
 
         if (m_isOnScreen) {
                 // motion on primary screen
-                sendEvent(getMotionOnPrimaryEvent(),
-                                                        CMotionInfo::alloc(m_xCursor, m_yCursor));
+                sendEvent(getMotionOnPrimaryEvent(), CMotionInfo::alloc(m_xCursor, m_yCursor));
         }
         else {
@@ -1171 +1052 @@
 
 bool
-CPMScreen::onMouseWheel(SInt32 xDelta, SInt32 yDelta)
-{
-        // ignore message if posted prior to last mark change
-        if (!ignore()) {
-                LOG((CLOG_DEBUG1 "event: button wheel delta=%+d,%+d", xDelta, yDelta));
-                sendEvent(getWheelEvent(), CWheelInfo::alloc(xDelta, yDelta));
-        }
-        return true;
-}
-
-bool
-CPMScreen::onScreensaver(bool activated)
-{
-        // ignore this message if there are any other screen saver
-        // messages already in the queue.  this is important because
-        // our checkStarted() function has a deliberate delay, so it
-        // can't respond to events at full CPU speed and will fall
-        // behind if a lot of screen saver events are generated.
-        // that can easily happen because windows will continually
-        // send SC_SCREENSAVE until the screen saver starts, even if
-        // the screen saver is disabled!
-        MSG msg;
-        if (PeekMessage(&msg, NULL, SYNERGY_MSG_SCREEN_SAVER,
-                                                SYNERGY_MSG_SCREEN_SAVER, PM_NOREMOVE)) {
-                return true;
-        }
-
-        if (activated) {
-                if (!m_screensaverActive &&
-                        m_screensaver->checkStarted(SYNERGY_MSG_SCREEN_SAVER, FALSE, 0)) {
-                        m_screensaverActive = true;
-                        sendEvent(getScreensaverActivatedEvent());
-
-                        // enable display power down
-                        CArchMiscWindows::removeBusyState(CArchMiscWindows::kDISPLAY);
-                }
-        }
-        else {
-                if (m_screensaverActive) {
-                        m_screensaverActive = false;
-                        sendEvent(getScreensaverDeactivatedEvent());
-
-                        // disable display power down
-                        CArchMiscWindows::addBusyState(CArchMiscWindows::kDISPLAY);
-                }
-        }
-
-        return true;
-}
-
-bool
-CPMScreen::onDisplayChange()
-{
-        // screen resolution may have changed.  save old shape.
-        SInt32 xOld = m_x, yOld = m_y, wOld = m_cx, hOld = m_cy;
-
-        // update shape
-        updateScreenShape();
-
-        // do nothing if resolution hasn't changed
-        if (xOld != m_x || yOld != m_y || wOld != m_cx || hOld != m_cy) {
-                if (m_isPrimary) {
-                        // warp mouse to center if off screen
-                        if (!m_isOnScreen) {
-                                warpCursor(m_xCenter, m_yCenter);
-                        }
-
-                        // tell hook about resize if on screen
-                        else {
-                                m_setZone(m_x, m_y, m_cx, m_cy, getJumpZoneSize());
-                        }
-                }
-
-                // send new screen info
-                sendEvent(getShapeChangedEvent());
-
-                LOG((CLOG_DEBUG "screen shape: %d,%d %dx%d %s", m_x, m_y, m_cx, m_cy, m_multimon ? "(multi-monitor)" : ""));
-        }
-
-        return true;
-}
-
-bool
 CPMScreen::onClipboardChange()
 {
@@ -1278 +1076 @@
 {
         // send an event that we can recognize before the mouse warp
-    WinPostQueueMsg(m_hmq, SYNERGY_MSG_PRE_WARP, (MPARAM)x, (MPARAM)y);
+    WinPostQueueMsg(m_hmq, SYNERGY_PM_MSG_PRE_WARP, (MPARAM)x, (MPARAM)y);
 
         // warp mouse.  hopefully this inserts a mouse motion event
@@ -1303 +1101 @@
 
         // send an event that we can recognize after the mouse warp
-    WinPostQueueMsg(m_hmq, SYNERGY_MSG_POST_WARP, 0, 0);
+    WinPostQueueMsg(m_hmq, SYNERGY_PM_MSG_POST_WARP, 0, 0);
 }
 
@@ -1313 +1111 @@
 
         // mark point in message queue where the mark was changed
-    WinPostQueueMsg(m_hmq, SYNERGY_MSG_MARK, (MPARAM)m_mark, 0);
+    WinPostQueueMsg(m_hmq, SYNERGY_PM_MSG_MARK, (MPARAM)m_mark, 0);
 }
 
@@ -1339 +1137 @@
 }
 
-void
-CPMScreen::handleFixes(const CEvent&, void*)
-{
-        // update keys if keyboard layouts have changed
-        if (m_keyState->didGroupsChange()) {
-                updateKeys();
-        }
-}
-
 ButtonID
-CPMScreen::mapButtonFromEvent(ULONG msg, MPARAM button) const
+CPMScreen::mapButtonFromEvent(ULONG msg) const
 {
     /** @todo query which is left and which is right. */
@@ -1377 +1166 @@
 
 bool
-CPMScreen::mapPressFromEvent(ULONG msg, LPARAM) const
+CPMScreen::mapPressFromEvent(ULONG msg) const
 {
         switch (msg) {
@@ -1411 +1200 @@
         }
 
-        // update layouts if necessary
-        if (m_keyState->didGroupsChange()) {
-                CPlatformScreen::updateKeyMap();
-        }
-
         // now update the keyboard state
         CPlatformScreen::updateKeyState();
@@ -1454 +1238 @@
 }
 
-HRESULT EXPENTRY
-CPMScreen::wndProc(HWND hwnd, UINT msg, MPARAM mp1, MPARAM mp2)
+MRESULT EXPENTRY
+CPMScreen::wndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
 {
         assert(s_screen != NULL);
 
-        HRESULT mr = 0;
-        if (!s_screen->onEvent(hwnd, msg, mp1, mp2, &result)) {
+        MRESULT mr = 0;
+        if (!s_screen->onEvent(hwnd, msg, mp1, mp2, &mr)) {
                 mr = WinDefWindowProc(hwnd, msg, mp1, mp2);
         }
@@ -1472 +1256 @@
 //
 
-CPMScreen::CHotKeyItem::CHotKeyItem(UINT keycode, UINT mask) :
+CPMScreen::CHotKeyItem::CHotKeyItem(ULONG keycode, ULONG mask) :
         m_keycode(keycode),
         m_mask(mask)
@@ -1479 +1263 @@
 }
 
-UINT
+ULONG
 CPMScreen::CHotKeyItem::getVirtualKey() const
 {

trunk/synergy/lib/platform/CPMScreen.h

@@ -3 +3 @@
  * Copyright (C) 2002 Chris Schoeneman
  * Copyright (C) 2006 Knut St. Osmundsen
- * 
+ *
  * This package is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * found in the file COPYING that should have accompanied this file.
- * 
+ *
  * This package is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -98 +98 @@
         HMODULE                         openHookLibrary(const char* name);
         void                            closeHookLibrary(HMODULE hookLibrary) const;
-        ATOM                            createWindowClass() const;
-        ATOM                            createDeskWindowClass(bool isPrimary) const;
-        void                            destroyClass(ATOM windowClass) const;
-        HWND                            createWindow(ATOM windowClass, const char* name) const;
+        HWND                            createWindow(const char* name);
         void                            destroyWindow(HWND) const;
 
@@ -122 +119 @@
         // message handlers
         bool                            onMark(UInt32 mark);
-        bool                            onKey(MPARAM, MPARAM);
+        bool                            onKey(USHORT fsFlags, UCHAR ucRepeat, UCHAR ucScanCode, USHORT usch, USHORT usvk);
         bool                            onHotKey(MPARAM, MPARAM);
-        bool                            onMouseButton(MPARAM, MPARAM);
-        bool                            onMouseMove(SInt32 x, SInt32 y);
-        bool                            onMouseWheel(SInt32 xDelta, SInt32 yDelta);
-        bool                            onScreensaver(bool activated);
-        bool                            onDisplayChange();
+        bool                            onMouseButton(ULONG msg, SInt32 ax, SInt32 ay);
+        bool                            onMouseMove(ULONG msg, SInt32 ax, SInt32 ay);
         bool                            onClipboardChange();
 
@@ -150 +144 @@
 
         // map a button event to a button ID
-        ButtonID                        mapButtonFromEvent(ULONG msg, MPARAM button) const;
+        ButtonID                        mapButtonFromEvent(ULONG msg) const;
 
         // map a button event to a press (true) or release (false)
-        bool                            mapPressFromEvent(ULONG msg, MPARAM button) const;
+        bool                            mapPressFromEvent(ULONG msg) const;
 
         // job to update the key state
@@ -192 +186 @@
         bool                            m_isOnScreen;
 
-        // our resources
-        ATOM                            m_class;
-
         // screen shape stuff
         SInt32                          m_x, m_y;
@@ -213 +204 @@
         UInt32                          m_markReceived;
 
-        // the main loop's thread id
+        // the main loop's thread id, anchor block and message queue.
         int                                     m_threadID;
-
-        // timer for periodically checking stuff that requires polling
-        CEventQueueTimer*       m_fixTimer;
+        HAB                                     m_hab;
+        HMQ                 m_hmq;
 
         // screen saver stuff
-        CPMScreenSaver* m_screensaver;
-        bool                                    m_screensaverNotify;
-        bool                                    m_screensaverActive;
+        CPMScreenSaver*         m_screensaver;
+        bool                            m_screensaverNotify;
+        bool                            m_screensaverActive;
 
         // clipboard stuff.  our window is used mainly as a clipboard
@@ -255 +245 @@
 };
 
+/*
+ * Local Variables:
+ *  mode: c
+ *  c-file-style: "k&r"
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ *  indent-tabs-mode: t
+ * End:
+ */
+
 #endif

trunk/synergy/lib/platform/CPMSynergyHook.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
  * modify it under the terms of the GNU General Public License
  * found in the file COPYING that should have accompanied this file.
- * 
+ *
  * This package is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -13 +14 @@
  */
 
-#include "CSynergyHook.h"
+#include "CPMSynergyHook.h"
 #include "ProtocolTypes.h"
-#include <zmouse.h>
-
-//
-// debugging compile flag.  when not zero the server doesn't grab
-// the keyboard when the mouse leaves the server screen.  this
-// makes it possible to use the debugger (via the keyboard) when
-// all user input would normally be caught by the hook procedures.
-//
-#define NO_GRAB_KEYBOARD 0
-
-//
-// debugging compile flag.  when not zero the server will not
-// install low level hooks.
-//
-#define NO_LOWLEVEL_HOOKS 0
-
-//
-// extra mouse wheel stuff
-//
-
-enum EWheelSupport {
-        kWheelNone,
-        kWheelOld,
-        kWheelWin2000,
-        kWheelModern
-};
-
-// declare extended mouse hook struct.  useable on win2k
-typedef struct tagMOUSEHOOKSTRUCTWin2000 {
-        MOUSEHOOKSTRUCT mhs;
-        DWORD mouseData;
-} MOUSEHOOKSTRUCTWin2000;
-
-#if !defined(SM_MOUSEWHEELPRESENT)
-#define SM_MOUSEWHEELPRESENT 75
-#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
-
-
-//
-// globals
-//
-
-#if defined(_MSC_VER)
-#pragma comment(linker, "-section:shared,rws")
-#pragma data_seg("shared")
-#endif
-// all data in this shared section *must* be initialized
-
-static HINSTANCE                g_hinstance       = NULL;
-static DWORD                    g_processID       = 0;
-static EWheelSupport    g_wheelSupport    = kWheelNone;
-static UINT                             g_wmMouseWheel    = 0;
-static DWORD                    g_threadID        = 0;
-static HHOOK                    g_keyboard        = NULL;
-static HHOOK                    g_mouse           = NULL;
-static HHOOK                    g_getMessage      = NULL;
-static HHOOK                    g_keyboardLL      = NULL;
-static HHOOK                    g_mouseLL         = NULL;
-static bool                             g_screenSaver     = false;
-static EHookMode                g_mode            = kHOOK_DISABLE;
-static UInt32                   g_zoneSides       = 0;
-static SInt32                   g_zoneSize        = 0;
-static SInt32                   g_xScreen         = 0;
-static SInt32                   g_yScreen         = 0;
-static SInt32                   g_wScreen         = 0;
-static SInt32                   g_hScreen         = 0;
-static WPARAM                   g_deadVirtKey     = 0;
-static LPARAM                   g_deadLParam      = 0;
-static BYTE                             g_deadKeyState[256] = { 0 };
-static DWORD                    g_hookThread      = 0;
-static DWORD                    g_attachedThread  = 0;
-static bool                             g_fakeInput       = false;
-
-#if defined(_MSC_VER)
-#pragma data_seg()
-#endif
-
-// keep linker quiet about floating point stuff.  we don't use any
-// floating point operations but our includes may define some
-// (unused) floating point values.
-#ifndef _DEBUG
+#include <sys/builtin.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+//
+// globals - system wide (defined in .asm)
+//
 extern "C" {
-int _fltused=0;
-}
-#endif
-
-
-//
-// internal functions
-//
-
-static
-void
-detachThread()
-{
-        if (g_attachedThread != 0 && g_hookThread != g_attachedThread) {
-                AttachThreadInput(g_hookThread, g_attachedThread, FALSE);
-                g_attachedThread = 0;
-        }
-}
-
-static
-bool
-attachThreadToForeground()
-{
-        // only attach threads if using low level hooks.  a low level hook
-        // runs in the thread that installed the hook but we have to make
-        // changes that require being attached to the target thread (which
-        // should be the foreground window).  a regular hook runs in the
-        // thread that just removed the event from its queue so we're
-        // already in the right thread.
-        if (g_hookThread != 0) {
-                HWND window    = GetForegroundWindow();
-                DWORD threadID = GetWindowThreadProcessId(window, NULL);
-                // skip if no change
-                if (g_attachedThread != threadID) {
-                        // detach from previous thread
-                        detachThread();
-
-                        // attach to new thread
-                        if (threadID != 0 && threadID != g_hookThread) {
-                                AttachThreadInput(g_hookThread, threadID, TRUE);
-                                g_attachedThread = threadID;
-                        }
-                        return true;
-                }
-        }
-        return false;
-}
-
-#if !NO_GRAB_KEYBOARD
-static
-WPARAM
-makeKeyMsg(UINT virtKey, char c, bool noAltGr)
-{
-        return MAKEWPARAM(MAKEWORD(virtKey & 0xff, (BYTE)c), noAltGr ? 1 : 0);
-}
-
-static
-void
-keyboardGetState(BYTE keys[256])
-{
-        // we have to use GetAsyncKeyState() rather than GetKeyState() because
-        // we don't pass through most keys so the event synchronous state
-        // doesn't get updated.  we do that because certain modifier keys have
-        // side effects, like alt and the windows key.
-        SHORT key;
-        for (int i = 0; i < 256; ++i) {
-                key     = GetAsyncKeyState(i);
-                keys[i] = (BYTE)((key < 0) ? 0x80u : 0);
-        }
-        key = GetKeyState(VK_CAPITAL);
-        keys[VK_CAPITAL] = (BYTE)(((key < 0) ? 0x80 : 0) | (key & 1));
-}
-
-static
-bool
-doKeyboardHookHandler(WPARAM wParam, LPARAM lParam)
-{
-        // check for special events indicating if we should start or stop
-        // passing events through and not report them to the server.  this
-        // is used to allow the server to synthesize events locally but
-        // not pick them up as user events.
-        if (wParam == SYNERGY_HOOK_FAKE_INPUT_VIRTUAL_KEY &&
-                ((lParam >> 16) & 0xffu) == SYNERGY_HOOK_FAKE_INPUT_SCANCODE) {
-                // update flag
-                g_fakeInput = ((lParam & 0x80000000u) == 0);
-                PostThreadMessage(g_threadID, SYNERGY_MSG_DEBUG,
-                                                                0xff000000u | wParam, lParam);
-
-                // discard event
-                return true;
-        }
-
-        // if we're expecting fake input then just pass the event through
-        // and do not forward to the server
-        if (g_fakeInput) {
-                PostThreadMessage(g_threadID, SYNERGY_MSG_DEBUG,
-                                                                0xfe000000u | wParam, lParam);
-                return false;
-        }
-
-        // VK_RSHIFT may be sent with an extended scan code but right shift
-        // is not an extended key so we reset that bit.
-        if (wParam == VK_RSHIFT) {
-                lParam &= ~0x01000000u;
-        }
-
-        // tell server about event
-        PostThreadMessage(g_threadID, SYNERGY_MSG_DEBUG, wParam, lParam);
-
-        // ignore dead key release
-        if (g_deadVirtKey == wParam &&
-                (lParam & 0x80000000u) != 0) {
-                PostThreadMessage(g_threadID, SYNERGY_MSG_DEBUG,
-                                                wParam | 0x04000000, lParam);
-                return false;
-        }
-
-        // we need the keyboard state for ToAscii()
-        BYTE keys[256];
-        keyboardGetState(keys);
-
-        // ToAscii() maps ctrl+letter to the corresponding control code
-        // and ctrl+backspace to delete.  we don't want those translations
-        // so clear the control modifier state.  however, if we want to
-        // simulate AltGr (which is ctrl+alt) then we must not clear it.
-        UINT control = keys[VK_CONTROL] | keys[VK_LCONTROL] | keys[VK_RCONTROL];
-        UINT menu    = keys[VK_MENU] | keys[VK_LMENU] | keys[VK_RMENU];
-        if ((control & 0x80) == 0 || (menu & 0x80) == 0) {
-                keys[VK_LCONTROL] = 0;
-                keys[VK_RCONTROL] = 0;
-                keys[VK_CONTROL]  = 0;
-        }
-        else {
-                keys[VK_LCONTROL] = 0x80;
-                keys[VK_RCONTROL] = 0x80;
-                keys[VK_CONTROL]  = 0x80;
-                keys[VK_LMENU]    = 0x80;
-                keys[VK_RMENU]    = 0x80;
-                keys[VK_MENU]     = 0x80;
-        }
-
-        // ToAscii() needs to know if a menu is active for some reason.
-        // we don't know and there doesn't appear to be any way to find
-        // out.  so we'll just assume a menu is active if the menu key
-        // is down.
-        // FIXME -- figure out some way to check if a menu is active
-        UINT flags = 0;
-        if ((menu & 0x80) != 0)
-                flags |= 1;
-
-        // if we're on the server screen then just pass numpad keys with alt
-        // key down as-is.  we won't pick up the resulting character but the
-        // local app will.  if on a client screen then grab keys as usual;
-        // if the client is a windows system it'll synthesize the expected
-        // character.  if not then it'll probably just do nothing.
-        if (g_mode != kHOOK_RELAY_EVENTS) {
-                // we don't use virtual keys because we don't know what the
-                // state of the numlock key is.  we'll hard code the scan codes
-                // instead.  hopefully this works across all keyboards.
-                UINT sc = (lParam & 0x01ff0000u) >> 16;
-                if (menu &&
-                        (sc >= 0x47u && sc <= 0x52u && sc != 0x4au && sc != 0x4eu)) {
-                        return false;
-                }
-        }
-
-        // map the key event to a character.  we have to put the dead
-        // key back first and this has the side effect of removing it.
-        if (g_deadVirtKey != 0) {
-                WORD c = 0;
-                ToAscii(g_deadVirtKey, (g_deadLParam & 0x10ff0000u) >> 16,
-                                                                g_deadKeyState, &c, flags);
-        }
-        WORD c        = 0;
-        UINT scanCode = ((lParam & 0x10ff0000u) >> 16);
-        int n         = ToAscii(wParam, scanCode, keys, &c, flags);
-
-        // if mapping failed and ctrl and alt are pressed then try again
-        // with both not pressed.  this handles the case where ctrl and
-        // alt are being used as individual modifiers rather than AltGr.
-        // we note that's the case in the message sent back to synergy
-        // because there's no simple way to deduce it after the fact.
-        // we have to put the dead key back first, if there was one.
-        bool noAltGr = false;
-        if (n == 0 && (control & 0x80) != 0 && (menu & 0x80) != 0) {
-                noAltGr = true;
-                PostThreadMessage(g_threadID, SYNERGY_MSG_DEBUG,
-                                                        wParam | 0x05000000, lParam);
-                if (g_deadVirtKey != 0) {
-                        ToAscii(g_deadVirtKey, (g_deadLParam & 0x10ff0000u) >> 16,
-                                                        g_deadKeyState, &c, flags);
-                }
-                BYTE keys2[256];
-                for (size_t i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i) {
-                        keys2[i] = keys[i];
-                }
-                keys2[VK_LCONTROL] = 0;
-                keys2[VK_RCONTROL] = 0;
-                keys2[VK_CONTROL]  = 0;
-                keys2[VK_LMENU]    = 0;
-                keys2[VK_RMENU]    = 0;
-                keys2[VK_MENU]     = 0;
-                n = ToAscii(wParam, scanCode, keys2, &c, flags);
-        }
-
-        PostThreadMessage(g_threadID, SYNERGY_MSG_DEBUG,
-                                                        wParam | ((c & 0xff) << 8) |
-                                                        ((n & 0xff) << 16) | 0x06000000,
-                                                        lParam);
-        WPARAM charAndVirtKey = 0;
-        bool clearDeadKey = false;
-        switch (n) {
-        default:
-                // key is a dead key
-                g_deadVirtKey = wParam;
-                g_deadLParam  = lParam;
-                for (size_t i = 0; i < sizeof(keys) / sizeof(keys[0]); ++i) {
-                        g_deadKeyState[i] = keys[i];
-                }
-                break;
-
-        case 0:
-                // key doesn't map to a character.  this can happen if
-                // non-character keys are pressed after a dead key.
-                charAndVirtKey = makeKeyMsg(wParam, (char)0, noAltGr);
-                break;
-
-        case 1:
-                // key maps to a character composed with dead key
-                charAndVirtKey = makeKeyMsg(wParam, (char)LOBYTE(c), noAltGr);
-                clearDeadKey   = true;
-                break;
-
-        case 2: {
-                // previous dead key not composed.  send a fake key press
-                // and release for the dead key to our window.
-                WPARAM deadCharAndVirtKey =
-                                                        makeKeyMsg(g_deadVirtKey, (char)LOBYTE(c), noAltGr);
-                PostThreadMessage(g_threadID, SYNERGY_MSG_KEY,
-                                                        deadCharAndVirtKey, g_deadLParam & 0x7fffffffu);
-                PostThreadMessage(g_threadID, SYNERGY_MSG_KEY,
-                                                        deadCharAndVirtKey, g_deadLParam | 0x80000000u);
-
-                // use uncomposed character
-                charAndVirtKey = makeKeyMsg(wParam, (char)HIBYTE(c), noAltGr);
-                clearDeadKey   = true;
-                break;
-        }
-        }
-
-        // put back the dead key, if any, for the application to use
-        if (g_deadVirtKey != 0) {
-                ToAscii(g_deadVirtKey, (g_deadLParam & 0x10ff0000u) >> 16,
-                                                        g_deadKeyState, &c, flags);
-        }
-
-        // clear out old dead key state
-        if (clearDeadKey) {
-                g_deadVirtKey = 0;
-                g_deadLParam  = 0;
-        }
-
-        // forward message to our window.  do this whether or not we're
-        // forwarding events to clients because this'll keep our thread's
-        // key state table up to date.  that's important for querying
-        // the scroll lock toggle state.
-        // XXX -- with hot keys for actions we may only need to do this when
-        // forwarding.
-        if (charAndVirtKey != 0) {
-                PostThreadMessage(g_threadID, SYNERGY_MSG_DEBUG,
-                                                        charAndVirtKey | 0x07000000, lParam);
-                PostThreadMessage(g_threadID, SYNERGY_MSG_KEY, charAndVirtKey, lParam);
-        }
-
-        if (g_mode == kHOOK_RELAY_EVENTS) {
-                // let certain keys pass through
-                switch (wParam) {
-                case VK_CAPITAL:
-                case VK_NUMLOCK:
-                case VK_SCROLL:
-                        // pass event on.  we want to let these through to
-                        // the window proc because otherwise the keyboard
-                        // lights may not stay synchronized.
-                        break;
-
-                case VK_HANGUL:
-                        // pass these modifiers if using a low level hook, discard
-                        // them if not.
-                        if (g_hookThread == 0) {
-                                return true;
-                        }
-                        break;
-
-                default:
-                        // discard
-                        return true;
-                }
-        }
-
-        return false;
-}
-
-static
-bool
-keyboardHookHandler(WPARAM wParam, LPARAM lParam)
-{
-        attachThreadToForeground();
-        return doKeyboardHookHandler(wParam, lParam);
-}
-#endif
-
-static
-bool
-doMouseHookHandler(WPARAM wParam, SInt32 x, SInt32 y, SInt32 data)
-{
-        switch (wParam) {
-        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_LBUTTONUP:
-        case WM_MBUTTONUP:
-        case WM_RBUTTONUP:
-        case WM_XBUTTONUP:
-        case WM_NCLBUTTONDOWN:
-        case WM_NCMBUTTONDOWN:
-        case WM_NCRBUTTONDOWN:
-        case WM_NCXBUTTONDOWN:
-        case WM_NCLBUTTONDBLCLK:
-        case WM_NCMBUTTONDBLCLK:
-        case WM_NCRBUTTONDBLCLK:
-        case WM_NCXBUTTONDBLCLK:
-        case WM_NCLBUTTONUP:
-        case WM_NCMBUTTONUP:
-        case WM_NCRBUTTONUP:
-        case WM_NCXBUTTONUP:
-                // always relay the event.  eat it if relaying.
-                PostThreadMessage(g_threadID, SYNERGY_MSG_MOUSE_BUTTON, wParam, data);
-                return (g_mode == kHOOK_RELAY_EVENTS);
-
-        case WM_MOUSEWHEEL:
-                if (g_mode == kHOOK_RELAY_EVENTS) {
-                        // relay event
-                        PostThreadMessage(g_threadID, SYNERGY_MSG_MOUSE_WHEEL, data, 0);
-                }
-                return (g_mode == kHOOK_RELAY_EVENTS);
-
-        case WM_NCMOUSEMOVE:
-        case WM_MOUSEMOVE:
-                if (g_mode == kHOOK_RELAY_EVENTS) {
-                        // relay and eat event
-                        PostThreadMessage(g_threadID, SYNERGY_MSG_MOUSE_MOVE, x, y);
-                        return true;
-                }
-                else if (g_mode == kHOOK_WATCH_JUMP_ZONE) {
-                        // low level hooks can report bogus mouse positions that are
-                        // outside of the screen.  jeez.  naturally we end up getting
-                        // fake motion in the other direction to get the position back
-                        // on the screen, which plays havoc with switch on double tap.
-                        // CServer deals with that.  we'll clamp positions onto the
-                        // screen.  also, if we discard events for positions outside
-                        // of the screen then the mouse appears to get a bit jerky
-                        // near the edge.  we can either accept that or pass the bogus
-                        // events.  we'll try passing the events.
-                        bool bogus = false;
-                        if (x < g_xScreen) {
-                                x     = g_xScreen;
-                                bogus = true;
-                        }
-                        else if (x >= g_xScreen + g_wScreen) {
-                                x     = g_xScreen + g_wScreen - 1;
-                                bogus = true;
-                        }
-                        if (y < g_yScreen) {
-                                y     = g_yScreen;
-                                bogus = true;
-                        }
-                        else if (y >= g_yScreen + g_hScreen) {
-                                y     = g_yScreen + g_hScreen - 1;
-                                bogus = true;
-                        }
-
-                        // check for mouse inside jump zone
-                        bool inside = false;
-                        if (!inside && (g_zoneSides & kLeftMask) != 0) {
-                                inside = (x < g_xScreen + g_zoneSize);
-                        }
-                        if (!inside && (g_zoneSides & kRightMask) != 0) {
-                                inside = (x >= g_xScreen + g_wScreen - g_zoneSize);
-                        }
-                        if (!inside && (g_zoneSides & kTopMask) != 0) {
-                                inside = (y < g_yScreen + g_zoneSize);
-                        }
-                        if (!inside && (g_zoneSides & kBottomMask) != 0) {
-                                inside = (y >= g_yScreen + g_hScreen - g_zoneSize);
-                        }
-
-                        // relay the event
-                        PostThreadMessage(g_threadID, SYNERGY_MSG_MOUSE_MOVE, x, y);
-
-                        // if inside and not bogus then eat the event
-                        return inside && !bogus;
-                }
-        }
-
-        // pass the event
-        return false;
-}
-
-static
-bool
-mouseHookHandler(WPARAM wParam, SInt32 x, SInt32 y, SInt32 data)
-{
-//      attachThreadToForeground();
-        return doMouseHookHandler(wParam, x, y, data);
-}
-
-#if !NO_GRAB_KEYBOARD
-static
-LRESULT CALLBACK
-keyboardHook(int code, WPARAM wParam, LPARAM lParam)
-{
-        if (code >= 0) {
-                // handle the message
-                if (keyboardHookHandler(wParam, lParam)) {
-                        return 1;
-                }
-        }
-
-        return CallNextHookEx(g_keyboard, code, wParam, lParam);
-}
-#endif
-
-static
-LRESULT CALLBACK
-mouseHook(int code, WPARAM wParam, LPARAM lParam)
-{
-        if (code >= 0) {
-                // decode message
-                const MOUSEHOOKSTRUCT* info = (const MOUSEHOOKSTRUCT*)lParam;
-                SInt32 x = (SInt32)info->pt.x;
-                SInt32 y = (SInt32)info->pt.y;
-                SInt32 w = 0;
-                if (wParam == WM_MOUSEWHEEL) {
-                        // win2k and other systems supporting WM_MOUSEWHEEL in
-                        // the mouse hook are gratuitously different (and poorly
-                        // documented).  if a low-level mouse hook is in place
-                        // it should capture these events so we'll never see
-                        // them.
-                        switch (g_wheelSupport) {
-                        case kWheelModern:
-                                w = static_cast<SInt16>(LOWORD(info->dwExtraInfo));
-                                break;
-
-                        case kWheelWin2000: {
-                                const MOUSEHOOKSTRUCTWin2000* info2k =
-                                                (const MOUSEHOOKSTRUCTWin2000*)lParam;
-                                w = static_cast<SInt16>(HIWORD(info2k->mouseData));
-                                break;
-                        }
-
-                        default:
-                                break;
-                        }
-                }
-
-                // handle the message.  note that we don't handle X buttons
-                // here.  that's okay because they're only supported on
-                // win2k and winxp and up and on those platforms we'll get
-                // get the mouse events through the low level hook.
-                if (mouseHookHandler(wParam, x, y, w)) {
-                        return 1;
-                }
-        }
-
-        return CallNextHookEx(g_mouse, code, wParam, lParam);
-}
-
-static
-LRESULT CALLBACK
-getMessageHook(int code, WPARAM wParam, LPARAM lParam)
-{
-        if (code >= 0) {
-                if (g_screenSaver) {
-                        MSG* msg = reinterpret_cast<MSG*>(lParam);
-                        if (msg->message == WM_SYSCOMMAND &&
-                                msg->wParam  == SC_SCREENSAVE) {
-                                // broadcast screen saver started message
-                                PostThreadMessage(g_threadID,
-                                                                SYNERGY_MSG_SCREEN_SAVER, TRUE, 0);
-                        }
-                }
-                if (g_mode == kHOOK_RELAY_EVENTS) {
-                        MSG* msg = reinterpret_cast<MSG*>(lParam);
-                        if (g_wheelSupport == kWheelOld && msg->message == g_wmMouseWheel) {
-                                // post message to our window
-                                PostThreadMessage(g_threadID,
-                                                                SYNERGY_MSG_MOUSE_WHEEL,
-                                                                static_cast<SInt16>(msg->wParam & 0xffffu), 0);
-
-                                // zero out the delta in the message so it's (hopefully)
-                                // ignored
-                                msg->wParam = 0;
-                        }
-                }
-        }
-
-        return CallNextHookEx(g_getMessage, code, wParam, lParam);
-}
-
-#if (_WIN32_WINNT >= 0x0400) && defined(_MSC_VER) && !NO_LOWLEVEL_HOOKS
-
-//
-// low-level keyboard hook -- this allows us to capture and handle
-// alt+tab, alt+esc, ctrl+esc, and windows key hot keys.  on the down
-// side, key repeats are not reported to us.
-//
-
-#if !NO_GRAB_KEYBOARD
-static
-LRESULT CALLBACK
-keyboardLLHook(int code, WPARAM wParam, LPARAM lParam)
-{
-        if (code >= 0) {
-                // decode the message
-                KBDLLHOOKSTRUCT* info = reinterpret_cast<KBDLLHOOKSTRUCT*>(lParam);
-                WPARAM wParam = info->vkCode;
-                LPARAM lParam = 1;                                                      // repeat code
-                lParam      |= (info->scanCode << 16);          // scan code
-                if (info->flags & LLKHF_EXTENDED) {
-                        lParam  |= (1lu << 24);                                 // extended key
-                }
-                if (info->flags & LLKHF_ALTDOWN) {
-                        lParam  |= (1lu << 29);                                 // context code
-                }
-                if (info->flags & LLKHF_UP) {
-                        lParam  |= (1lu << 31);                                 // transition
-                }
-                // FIXME -- bit 30 should be set if key was already down but
-                // we don't know that info.  as a result we'll never generate
-                // key repeat events.
-
-                // handle the message
-                if (keyboardHookHandler(wParam, lParam)) {
-                        return 1;
-                }
-        }
-
-        return CallNextHookEx(g_keyboardLL, code, wParam, lParam);
-}
-#endif
-
-//
-// low-level mouse hook -- this allows us to capture and handle mouse
-// events very early.  the earlier the better.
-//
-
-static
-LRESULT CALLBACK
-mouseLLHook(int code, WPARAM wParam, LPARAM lParam)
-{
-        if (code >= 0) {
-                // decode the message
-                MSLLHOOKSTRUCT* info = reinterpret_cast<MSLLHOOKSTRUCT*>(lParam);
-                SInt32 x = static_cast<SInt32>(info->pt.x);
-                SInt32 y = static_cast<SInt32>(info->pt.y);
-                SInt32 w = static_cast<SInt16>(HIWORD(info->mouseData));
-
-                // handle the message
-                if (mouseHookHandler(wParam, x, y, w)) {
-                        return 1;
-                }
-        }
-
-        return CallNextHookEx(g_mouseLL, code, wParam, lParam);
-}
-
-#endif
-
-static
-EWheelSupport
-getWheelSupport()
-{
-        // get operating system
-        OSVERSIONINFO info;
-        info.dwOSVersionInfoSize = sizeof(info);
-        if (!GetVersionEx(&info)) {
-                return kWheelNone;
-        }
-
-        // see if modern wheel is present
-        if (GetSystemMetrics(SM_MOUSEWHEELPRESENT)) {
-                // note if running on win2k
-                if (info.dwPlatformId   == VER_PLATFORM_WIN32_NT &&
-                        info.dwMajorVersion == 5 &&
-                        info.dwMinorVersion == 0) {
-                        return kWheelWin2000;
-                }
-                return kWheelModern;
-        }
-
-        // not modern.  see if we've got old-style support.
-#if defined(MSH_WHEELSUPPORT)
-        UINT wheelSupportMsg    = RegisterWindowMessage(MSH_WHEELSUPPORT);
-        HWND wheelSupportWindow = FindWindow(MSH_WHEELMODULE_CLASS,
-                                                                                MSH_WHEELMODULE_TITLE);
-        if (wheelSupportWindow != NULL && wheelSupportMsg != 0) {
-                if (SendMessage(wheelSupportWindow, wheelSupportMsg, 0, 0) != 0) {
-                        g_wmMouseWheel = RegisterWindowMessage(MSH_MOUSEWHEEL);
-                        if (g_wmMouseWheel != 0) {
-                                return kWheelOld;
-                        }
-                }
-        }
-#endif
-
-        // assume modern.  we don't do anything special in this case
-        // except respond to WM_MOUSEWHEEL messages.  GetSystemMetrics()
-        // can apparently return FALSE even if a mouse wheel is present
-        // though i'm not sure exactly when it does that (WinME returns
-        // FALSE for my logitech USB trackball).
-        return kWheelModern;
+/** @name The synergy server/client thread
+ * @{ */
+extern HMQ                  g_hmqSynergy;
+extern int                  g_pidSynergy;
+extern int                  g_tidSynergy;
+/** @} */
+
+/** The current mode.*/
+extern EHookMode volatile   g_enmMode;
+
+/** Which sides do we have warp zones on. */
+extern UInt32               g_zoneSides;
+/** The warp zone size in pixels. */
+extern SInt32               g_zoneSize;
+/** @name The screen size.
+ * @{ */
+extern SInt32               g_xScreen;
+extern SInt32               g_yScreen;
+extern SInt32               g_cxScreen;
+extern SInt32               g_cyScreen;
+/** @} */
+
+/** Set if the hook is installed. */
+extern bool                 g_fInputHookInstalled;
+/** Set if we're faking input. */
+extern bool                 g_fFakingInput;
+
+} /* extern "C" */
+
+
+//
+// Globals - per process.
+//
+
+/** The handle of the hook dll. */
+static HMODULE  g_hmod = NULLHANDLE;
+/** The pid of the current process. */
+static int      g_pid = 0;
+
+
+/**
+ * Deal with keyboard messages.
+ *
+ * @param pQmsg     The WM_CHAR message.
+ */
+static bool InputHookKeyboardMsg(PQMSG pQmsg)
+{
+    /*
+     * Check for special events indicating if we should start or stop
+     * passing events through and not report them to the server.
+     *
+     * This is used to allow the server to synthesize events locally but
+     * not pick them up as user events.
+     */
+    if (pQmsg->mp1 == SYNERGY_PM_HOOK_FAKE_INPUT_MP1_FIXED) {
+        if (pQmsg->mp2 == SYNERGY_PM_HOOK_FAKE_INPUT_MP2_SET) {
+            g_fFakingInput = true;
+            return true;
+        }
+        if (pQmsg->mp2 == SYNERGY_PM_HOOK_FAKE_INPUT_MP2_CLEAR) {
+            g_fFakingInput = false;
+            return true;
+        }
+    }
+
+    /*
+     * If we're expecting fake input then just pass the event through
+     * and do not forward to the server
+     */
+    if (g_fFakingInput)
+        return false;
+
+    /*
+     * Send the key to the server without any more work.
+     * This is probably to simplified, but it'll have to do for now because I'm lazy.
+     */
+    WinPostQueueMsg(g_hmqSynergy, SYNERGY_PM_MSG_KEY, pQmsg->mp1, pQmsg->mp2);
+    return true;
+}
+
+
+/**
+ * Checks if the specified mouse position is in a jump zone.
+ *
+ * @returns true if we're in the jump zone, false if we aren't
+ * @param   x   X coordinate.
+ * @param   y   Y coordinate. (1st quadrant)
+ */
+static bool isInJumpZone(SInt32 x, SInt32 y)
+{
+    /* any jump zones at all? */
+    if (g_zoneSides == 0)
+        return false;
+
+    /*
+     * Normalize the coordinates.
+     */
+    bool fBogus = false;
+    if (x < g_xScreen) {
+        x     = g_xScreen;
+        fBogus = true;
+    } else if (x >= g_xScreen + g_cxScreen) {
+        x      = g_xScreen + g_cxScreen - 1;
+        fBogus = true;
+    }
+
+    if (y < g_yScreen) {
+        y      = g_yScreen;
+        fBogus = true;
+    } else if (y >= g_yScreen + g_cyScreen) {
+        y      = g_yScreen + g_cyScreen - 1;
+        fBogus = true;
+    }
+
+    /*
+     * check if the mouse is in any of the jump zones.
+     */
+    bool fJump = false;
+    if (g_zoneSides & kLeftMask)
+        fJump |= (unsigned)x - (unsigned)g_xScreen < (unsigned)g_zoneSize;
+    if (g_zoneSides & kRightMask)
+        fJump |= (unsigned)(g_xScreen + g_cxScreen) - (unsigned)x < (unsigned)g_zoneSize;
+    if (g_zoneSides & kTopMask)
+        fJump |= (unsigned)(g_yScreen + g_cyScreen) - (unsigned)y < (unsigned)g_zoneSize;
+    if (g_zoneSides & kBottomMask)
+        fJump |= (unsigned)y - (unsigned)(g_yScreen) < (unsigned)g_zoneSize;
+
+    return fJump && !fBogus;
+}
+
+
+/**
+ * The input hook procedure (any context).
+ *
+ * @returns Processed indicator; TRUE if processed and should be discarded, FALSE if should be passed on.
+ *
+ * @param   hab     The anchor block of the current thread.
+ * @param   pQmsg   The message structure containing the message we're called for.
+ * @param   fs      The removal options (PM_REMOVE / PM_NOREMOVE).
+ */
+BOOL EXPENTRY InputHook(HAB hab, PQMSG pQmsg, ULONG fs)
+{
+    /*
+     * Get hook mode and check if it's enabled.
+     */
+    const EHookMode enmMode = g_enmMode;
+    if (enmMode == kHOOK_DISABLE)
+        return FALSE;
+
+
+    switch (pQmsg->msg) {
+        /*
+         * Keyboard message.
+         */
+        case WM_CHAR:
+            if (enmMode == kHOOK_RELAY_EVENTS)
+                return InputHookKeyboardMsg(pQmsg);
+            break;
+
+        /*
+         * Mouse message.
+         */
+        case WM_MOUSEMOVE:
+            if (    enmMode == kHOOK_RELAY_EVENTS
+                ||  enmMode == kHOOK_WATCH_JUMP_ZONE) {
+                WinPostQueueMsg(g_hmqSynergy, SYNERGY_PM_MSG_MOUSE_MOVE, MPFROM2SHORT(pQmsg->msg, 0), MPFROM2SHORT(pQmsg->ptl.x, pQmsg->ptl.y));
+                return enmMode == kHOOK_RELAY_EVENTS
+                    || isInJumpZone(pQmsg->ptl.x, pQmsg->ptl.y);
+            }
+            break;
+
+        /*
+         * Mouse click message.
+         */
+        case WM_BUTTON1DOWN:
+        case WM_BUTTON1UP:
+        case WM_BUTTON1DBLCLK:
+        case WM_BUTTON2DOWN:
+        case WM_BUTTON2UP:
+        case WM_BUTTON2DBLCLK:
+        case WM_BUTTON3DOWN:
+        case WM_BUTTON3UP:
+        case WM_BUTTON3DBLCLK:
+            if (    enmMode == kHOOK_RELAY_EVENTS
+                ||  enmMode == kHOOK_WATCH_JUMP_ZONE) {
+                WinPostQueueMsg(g_hmqSynergy, SYNERGY_PM_MSG_MOUSE_BUTTON, MPFROM2SHORT(pQmsg->msg, 0), MPFROM2SHORT(pQmsg->ptl.x, pQmsg->ptl.y));
+                return enmMode == kHOOK_RELAY_EVENTS;
+            }
+            break;
+
+        /*
+         * If I understand it correctly these messages are created
+         * from the ones above and should be discarded. (If I'm wrong,
+         * we'll not be able to drag stuff or open the window list.)
+         */
+        case WM_CHORD:
+        case WM_BUTTON1MOTIONSTART:
+        case WM_BUTTON1MOTIONEND:
+        case WM_BUTTON1CLICK:
+        case WM_BUTTON2MOTIONSTART:
+        case WM_BUTTON2MOTIONEND:
+        case WM_BUTTON2CLICK:
+        case WM_BUTTON3MOTIONSTART:
+        case WM_BUTTON3MOTIONEND:
+        case WM_BUTTON3CLICK:
+            if (enmMode == kHOOK_RELAY_EVENTS) {
+                return true;
+            }
+            break;
+
+        default:
+            // log these.
+            break;
+    }
+
+    /* don't eat it. */
+    return false;
 }
 
@@ -744 +248 @@
 //
 
-BOOL WINAPI
-DllMain(HINSTANCE instance, DWORD reason, LPVOID)
-{
-        if (reason == DLL_PROCESS_ATTACH) {
-                DisableThreadLibraryCalls(instance);
-                if (g_processID == 0) {
-                        g_hinstance = instance;
-                        g_processID = GetCurrentProcessId();
-                }
-        }
-        else if (reason == DLL_PROCESS_DETACH) {
-                if (g_processID == GetCurrentProcessId()) {
-                        uninstall();
-                        uninstallScreenSaver();
-                        g_processID = 0;
-                        g_hinstance = NULL;
-                }
-        }
-        return TRUE;
-}
-
-extern "C" {
-
-int
-init(DWORD threadID)
-{
-        assert(g_hinstance != NULL);
-
-        // try to open process that last called init() to see if it's
-        // still running or if it died without cleaning up.
-        if (g_processID != 0 && g_processID != GetCurrentProcessId()) {
-                HANDLE process = OpenProcess(STANDARD_RIGHTS_REQUIRED,
-                                                                FALSE, g_processID);
-                if (process != NULL) {
-                        // old process (probably) still exists so refuse to
-                        // reinitialize this DLL (and thus steal it from the
-                        // old process).
-                        CloseHandle(process);
-                        return 0;
-                }
-
-                // clean up after old process.  the system should've already
-                // removed the hooks so we just need to reset our state.
-                g_hinstance       = GetModuleHandle("synrgyhk");
-                g_processID       = GetCurrentProcessId();
-                g_wheelSupport    = kWheelNone;
-                g_threadID        = 0;
-                g_keyboard        = NULL;
-                g_mouse           = NULL;
-                g_getMessage      = NULL;
-                g_keyboardLL      = NULL;
-                g_mouseLL         = NULL;
-                g_screenSaver     = false;
-        }
-
-        // save thread id.  we'll post messages to this thread's
-        // message queue.
-        g_threadID  = threadID;
-
-        // set defaults
-        g_mode      = kHOOK_DISABLE;
-        g_zoneSides = 0;
-        g_zoneSize  = 0;
-        g_xScreen   = 0;
-        g_yScreen   = 0;
-        g_wScreen   = 0;
-        g_hScreen   = 0;
-
-        return 1;
-}
-
-int
-cleanup(void)
-{
-        assert(g_hinstance != NULL);
-
-        if (g_processID == GetCurrentProcessId()) {
-                g_threadID = 0;
-        }
-
-        return 1;
-}
-
-EHookResult
-install()
-{
-        assert(g_hinstance  != NULL);
-        assert(g_keyboard   == NULL);
-        assert(g_mouse      == NULL);
-        assert(g_getMessage == NULL || g_screenSaver);
-
-        // must be initialized
-        if (g_threadID == 0) {
-                return kHOOK_FAILED;
-        }
-
-        // discard old dead keys
-        g_deadVirtKey = 0;
-        g_deadLParam  = 0;
-
-        // reset fake input flag
-        g_fakeInput = false;
-
-        // check for mouse wheel support
-        g_wheelSupport = getWheelSupport();
-
-        // install GetMessage hook (unless already installed)
-        if (g_wheelSupport == kWheelOld && g_getMessage == NULL) {
-                g_getMessage = SetWindowsHookEx(WH_GETMESSAGE,
-                                                                &getMessageHook,
-                                                                g_hinstance,
-                                                                0);
-        }
-
-        // install low-level hooks.  we require that they both get installed.
-#if (_WIN32_WINNT >= 0x0400) && defined(_MSC_VER) && !NO_LOWLEVEL_HOOKS
-        g_mouseLL = SetWindowsHookEx(WH_MOUSE_LL,
-                                                                &mouseLLHook,
-                                                                g_hinstance,
-                                                                0);
-#if !NO_GRAB_KEYBOARD
-        g_keyboardLL = SetWindowsHookEx(WH_KEYBOARD_LL,
-                                                                &keyboardLLHook,
-                                                                g_hinstance,
-                                                                0);
-        if (g_mouseLL == NULL || g_keyboardLL == NULL) {
-                if (g_keyboardLL != NULL) {
-                        UnhookWindowsHookEx(g_keyboardLL);
-                        g_keyboardLL = NULL;
-                }
-                if (g_mouseLL != NULL) {
-                        UnhookWindowsHookEx(g_mouseLL);
-                        g_mouseLL = NULL;
-                }
-        }
-#endif
-#endif
-
-        // install regular hooks
-        if (g_mouseLL == NULL) {
-                g_mouse = SetWindowsHookEx(WH_MOUSE,
-                                                                &mouseHook,
-                                                                g_hinstance,
-                                                                0);
-        }
-#if !NO_GRAB_KEYBOARD
-        if (g_keyboardLL == NULL) {
-                g_keyboard = SetWindowsHookEx(WH_KEYBOARD,
-                                                                &keyboardHook,
-                                                                g_hinstance,
-                                                                0);
-        }
-#endif
-
-        // check that we got all the hooks we wanted
-        if ((g_getMessage == NULL && g_wheelSupport == kWheelOld) ||
-#if !NO_GRAB_KEYBOARD
-                (g_keyboardLL == NULL && g_keyboard     == NULL) ||
-#endif
-                (g_mouseLL    == NULL && g_mouse        == NULL)) {
-                uninstall();
-                return kHOOK_FAILED;
-        }
-
-        if (g_keyboardLL != NULL || g_mouseLL != NULL) {
-                g_hookThread = GetCurrentThreadId();
-                return kHOOK_OKAY_LL;
-        }
-
-        return kHOOK_OKAY;
-}
-
-int
-uninstall(void)
-{
-        assert(g_hinstance != NULL);
-
-        // discard old dead keys
-        g_deadVirtKey = 0;
-        g_deadLParam  = 0;
-
-        // detach from thread
-        detachThread();
-
-        // uninstall hooks
-        if (g_keyboardLL != NULL) {
-                UnhookWindowsHookEx(g_keyboardLL);
-                g_keyboardLL = NULL;
-        }
-        if (g_mouseLL != NULL) {
-                UnhookWindowsHookEx(g_mouseLL);
-                g_mouseLL = NULL;
-        }
-        if (g_keyboard != NULL) {
-                UnhookWindowsHookEx(g_keyboard);
-                g_keyboard = NULL;
-        }
-        if (g_mouse != NULL) {
-                UnhookWindowsHookEx(g_mouse);
-                g_mouse = NULL;
-        }
-        if (g_getMessage != NULL && !g_screenSaver) {
-                UnhookWindowsHookEx(g_getMessage);
-                g_getMessage = NULL;
-        }
-        g_wheelSupport = kWheelNone;
-
-        return 1;
-}
-
-int
-installScreenSaver(void)
-{
-        assert(g_hinstance != NULL);
-
-        // must be initialized
-        if (g_threadID == 0) {
-                return 0;
-        }
-
-        // generate screen saver messages
-        g_screenSaver = true;
-
-        // install hook unless it's already installed
-        if (g_getMessage == NULL) {
-                g_getMessage = SetWindowsHookEx(WH_GETMESSAGE,
-                                                                &getMessageHook,
-                                                                g_hinstance,
-                                                                0);
-        }
-
-        return (g_getMessage != NULL) ? 1 : 0;
-}
-
-int
-uninstallScreenSaver(void)
-{
-        assert(g_hinstance != NULL);
-
-        // uninstall hook unless the mouse wheel hook is installed
-        if (g_getMessage != NULL && g_wheelSupport != kWheelOld) {
-                UnhookWindowsHookEx(g_getMessage);
-                g_getMessage = NULL;
-        }
-
-        // screen saver hook is no longer installed
-        g_screenSaver = false;
-
-        return 1;
-}
-
-void
-setSides(UInt32 sides)
-{
-        g_zoneSides = sides;
-}
-
-void
-setZone(SInt32 x, SInt32 y, SInt32 w, SInt32 h, SInt32 jumpZoneSize)
-{
-        g_zoneSize = jumpZoneSize;
-        g_xScreen  = x;
-        g_yScreen  = y;
-        g_wScreen  = w;
-        g_hScreen  = h;
-}
-
-void
-setMode(EHookMode mode)
-{
-        if (mode == g_mode) {
-                // no change
-                return;
-        }
-        g_mode = mode;
-}
-
-}
+/**
+ * The DLL init/term function.
+ */
+ULONG _System _DLL_InitTerm(HMODULE hmod, ULONG ulReason)
+{
+    switch (ulReason) {
+    /* init */
+    case 0:
+        g_hmod = hmod;
+        g_pid = getpid();
+        break;
+
+    /* term */
+    case 1:
+        g_pid = 0;
+        g_hmod = NULLHANDLE;
+        break;
+
+    default:
+        break;
+    }
+    return TRUE;
+}
+
+
+
+/**
+ * Initialize the hook dll (shared data mainly) in the synergy context.
+ *
+ * @returns success indicator (true/false)
+ * @param   hmqSynergy
+ * @param   tidSynergy
+ * @param   pidSynergy
+ */
+CSYNERGYHOOK_API bool init(HMQ hmqSynergy, int tidSynergy, int pidSynergy)
+{
+    /*
+     * Check that there isn't any synergy instance already running.
+     * If the verification fails, we will take the place dead synergy instance.
+     */
+    if (   g_pidSynergy
+        && g_tidSynergy
+        && DosVerifyPidTid(g_pidSynergy, g_tidSynergy) == NO_ERROR)
+        return false;
+
+    /*
+     * Initialize the globals.
+     */
+    g_hmqSynergy = hmqSynergy;
+    g_pidSynergy = pidSynergy;
+    g_tidSynergy = tidSynergy;
+
+    /* only do this if the hook is inactive. */
+    if (g_enmMode == kHOOK_DISABLE) {
+        g_enmMode      = kHOOK_DISABLE;
+        g_zoneSides = 0;
+        g_zoneSize  = 0;
+        g_xScreen   = 0;
+        g_yScreen   = 0;
+        g_cxScreen  = 0;
+        g_cyScreen  = 0;
+    }
+
+    return true;
+}
+
+
+/**
+ * Cleanup before unloading the dll (synergy context).
+ *
+ * @returns success indicator (true/false)
+ * @param   hab     The anchor block.
+ */
+CSYNERGYHOOK_API bool cleanup(HAB hab)
+{
+    assert(g_hmod != NULLHANDLE);
+
+    /*
+     * If we're the synergy process or if it's dead, shut down everything.
+     */
+    if (    (   g_pidSynergy != getpid()
+            ||  g_tidSynergy != _gettid())
+        &&  DosVerifyPidTid(g_pidSynergy, g_tidSynergy) == NO_ERROR)
+        return false;
+
+    /* parnaoia */
+    uninstall(hab);
+
+    g_hmqSynergy = NULLHANDLE;
+    g_pidSynergy = 0;
+    g_tidSynergy = 0;
+    return true;
+}
+
+
+CSYNERGYHOOK_API EHookResult install(HAB hab)
+{
+    // must be initialized
+    if (g_tidSynergy == 0) {
+        return kHOOK_FAILED;
+    }
+    assert(g_pidSynergy == getpid());
+    assert(g_tidSynergy == _gettid());
+
+    //// discard old dead keys
+    //g_deadVirtKey = 0;
+    //g_deadLParam  = 0;
+
+    //// reset fake input flag
+    //g_fakeInput = false;
+
+    /*
+     * Install the hook.
+     */
+    if (    !g_fInputHookInstalled
+        &&  WinSetHook(hab, NULLHANDLE, HK_INPUT, (PFN)InputHook, g_hmod))
+        __atomic_xchg((unsigned volatile *)&g_fInputHookInstalled, true);
+
+    if (g_fInputHookInstalled)
+        return kHOOK_OKAY;
+
+    uninstall(hab);
+    return kHOOK_FAILED;
+}
+
+
+/**
+ * Uninstall the hooks.
+ *
+ * @returns
+ * @param   hab
+ */
+CSYNERGYHOOK_API bool uninstall(HAB hab)
+{
+    assert(g_pidSynergy == getpid());
+    assert(g_tidSynergy == _gettid());
+
+    //// discard old dead keys
+    //g_deadVirtKey = 0;
+    //g_deadLParam  = 0;
+
+    /*
+     * Release the hooks.
+     */
+    if (    g_fInputHookInstalled
+        &&  WinReleaseHook(hab, NULLHANDLE, HK_INPUT, (PFN)InputHook, g_hmod))
+        __atomic_xchg((unsigned volatile *)&g_fInputHookInstalled, false);
+
+    return !g_fInputHookInstalled;
+}
+
+
+/**
+ * Sets the sides we should be watching out for jumps in.
+ *
+ * @param   sides   The new sides flags.
+ */
+CSYNERGYHOOK_API void setSides(UInt32 sides)
+{
+    assert(g_pidSynergy == getpid());
+    assert(g_tidSynergy == _gettid());
+    __atomic_xchg((unsigned volatile *)&g_zoneSides, (unsigned)sides);
+}
+
+
+/**
+ * Set the jump zone size and screen size.
+ *
+ * @param x     The screen x coordinate.
+ * @param y     The screen y coordinate.
+ * @param cx    The screen width.
+ * @param cy    The screen heigth.
+ * @param jumpZoneSize  The width of the jump zone (pixels).
+ */
+CSYNERGYHOOK_API void setZone(SInt32 x, SInt32 y, SInt32 cx, SInt32 cy, SInt32 jumpZoneSize)
+{
+    assert(g_pidSynergy == getpid());
+    assert(g_tidSynergy == _gettid());
+    __atomic_xchg((unsigned volatile *)&g_zoneSize, (unsigned)jumpZoneSize);
+    __atomic_xchg((unsigned volatile *)&g_xScreen,  (unsigned)x);
+    __atomic_xchg((unsigned volatile *)&g_yScreen,  (unsigned)y);
+    __atomic_xchg((unsigned volatile *)&g_cxScreen, (unsigned)cx);
+    __atomic_xchg((unsigned volatile *)&g_cyScreen, (unsigned)cy);
+}
+
+
+/**
+ * Check the mode of operation.
+ *
+ * @param   mode    The new mode.
+ */
+CSYNERGYHOOK_API void setMode(EHookMode mode)
+{
+    assert(g_pidSynergy == getpid());
+    assert(g_tidSynergy == _gettid());
+    if (mode != g_enmMode) {
+        switch (mode) {
+        case kHOOK_DISABLE:
+        case kHOOK_WATCH_JUMP_ZONE:
+        case kHOOK_RELAY_EVENTS:
+            __atomic_xchg((unsigned volatile *)&g_enmMode, (unsigned)mode);
+            break;
+        default:
+            __atomic_xchg((unsigned volatile *)&g_enmMode, kHOOK_DISABLE);
+            break;
+        }
+    }
+}
+

trunk/synergy/lib/platform/CPMSynergyHook.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
  * modify it under the terms of the GNU General Public License
  * found in the file COPYING that should have accompanied this file.
- * 
+ *
  * This package is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -23 +24 @@
 
 #if defined(SYNRGYHK_EXPORTS)
-# define CSYNERGYHOOK_API __declspec(dllexport)
+# define CSYNERGYHOOK_API extern "C" __declspec(dllexport)
 #else
-# define CSYNERGYHOOK_API __declspec(dllimport)
+# define CSYNERGYHOOK_API extern "C" __declspec(dllimport)
 #endif
 
-#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
-#define SYNERGY_HOOK_LAST_MSG           SYNERGY_MSG_DEBUG
+/** @name The messages posted from the input hook on the synergy message queue.
+ * @{
+ */
+#define SYNERGY_PM_MSG_MARK             WM_USER + 20    // mark id; <unused>
+#define SYNERGY_PM_MSG_KEY              WM_USER + 21    // vk code; key data
+/**
+ * mp1.s1: msg
+ * mp1.s2: 0 reserved.
+ * mp2.s1: mouse x
+ * mp2.s2: mouse y
+ */
+#define SYNERGY_PM_MSG_MOUSE_BUTTON     WM_USER + 22
+/** WM_MOUSEMOVE mp1 and mp2. */
+#define SYNERGY_PM_MSG_MOUSE_MOVE       WM_USER + 23
 
-#define SYNERGY_HOOK_FAKE_INPUT_VIRTUAL_KEY     VK_CANCEL
-#define SYNERGY_HOOK_FAKE_INPUT_SCANCODE        0
+#define SYNERGY_PM_MSG_POST_WARP        WM_USER + 24    // <unused>; <unused>
+#define SYNERGY_PM_MSG_PRE_WARP         WM_USER + 25    // x; y
+#define SYNERGY_PM_MSG_DEBUG            WM_USER + 27    // data, data
 
-extern "C" {
+#define SYNERGY_PM_MSG_FIRST            SYNERGY_PM_MSG_MARK     /**< The first message. */
+#define SYNERGY_PM_MSG_LAST             SYNERGY_PM_MSG_DEBUG    /**< The last message. */
+#define SYNERGY_PM_MSG_INPUT_FIRST      SYNERGY_PM_MSG_KEY      /**< The first input message. */
+#define SYNERGY_PM_MSG_INPUT_LAST       SYNERGY_PM_MSG_PRE_WARP /**< The last input message. */
+/** @} */
+
+#define SYNERGY_PM_HOOK_FAKE_INPUT_MP1_FIXED    MPFROM2SHORT(KC_VIRTUALKEY | KC_SCANCODE, 0)
+#define SYNERGY_PM_HOOK_FAKE_INPUT_MP2_SET      MPFROM2SHORT(0x8f70, 0x708f)
+#define SYNERGY_PM_HOOK_FAKE_INPUT_MP2_CLEAR    MPFROM2SHORT(0x9f70, 0x708f)
 
 enum EHookResult {
-        kHOOK_FAILED,
-        kHOOK_OKAY,
-        kHOOK_OKAY_LL
+    kHOOK_FAILED,
+    kHOOK_OKAY,
+    kHOOK_OKAY_LL
 };
 
 enum EHookMode {
-        kHOOK_DISABLE,
-        kHOOK_WATCH_JUMP_ZONE,
-        kHOOK_RELAY_EVENTS
+    kHOOK_DISABLE,
+    kHOOK_WATCH_JUMP_ZONE,
+    kHOOK_RELAY_EVENTS
 };
 
-typedef int                             (*InitFunc)(HMQ hmq, int tid, int pid);
-typedef int                             (*CleanupFunc)(void);
-typedef EHookResult             (*InstallFunc)(void);
-typedef int                             (*UninstallFunc)(void);
-typedef int                             (*InstallScreenSaverFunc)(void);
-typedef int                             (*UninstallScreenSaverFunc)(void);
-typedef void                    (*SetSidesFunc)(UInt32);
-typedef void                    (*SetZoneFunc)(SInt32, SInt32, SInt32, SInt32, SInt32);
-typedef void                    (*SetModeFunc)(int);
+typedef bool            (*InitFunc)(HMQ hmq, int tid, int pid);
+typedef bool            (*CleanupFunc)(HAB hab);
+typedef EHookResult     (*InstallFunc)(HAB hab);
+typedef bool            (*UninstallFunc)(HAB hab);
+typedef void            (*SetSidesFunc)(UInt32);
+typedef void            (*SetZoneFunc)(SInt32, SInt32, SInt32, SInt32, SInt32);
+typedef void            (*SetModeFunc)(int);
 
-CSYNERGYHOOK_API int    init(HMQ hmq, int tid, int pid);
-CSYNERGYHOOK_API int    cleanup(void);
-CSYNERGYHOOK_API EHookResult    install(void);
-CSYNERGYHOOK_API int    uninstall(void);
-CSYNERGYHOOK_API int    installScreenSaver(void);
-CSYNERGYHOOK_API int    uninstallScreenSaver(void);
-CSYNERGYHOOK_API void   setSides(UInt32 sides);
-CSYNERGYHOOK_API void   setZone(SInt32 x, SInt32 y, SInt32 cx, SInt32 cy, SInt32 jumpZoneSize);
-CSYNERGYHOOK_API void   setMode(EHookMode mode);
-
-}
+CSYNERGYHOOK_API bool   init(HMQ hmq, int tid, int pid);
+CSYNERGYHOOK_API bool   cleanup(HAB hab);
+CSYNERGYHOOK_API EHookResult install(HAB hab);
+CSYNERGYHOOK_API bool   uninstall(HAB hab);
+CSYNERGYHOOK_API void   setSides(UInt32 sides);
+CSYNERGYHOOK_API void   setZone(SInt32 x, SInt32 y, SInt32 cx, SInt32 cy, SInt32 jumpZoneSize);
+CSYNERGYHOOK_API void   setMode(EHookMode mode);
 
 #endif