xkeymacsdll/xkeymacsdll.cpp

   1 // xkeymacsdll.cpp : Defines the initialization routines for the DLL.\r
   2 //\r
   3 \r
   4 #include "xkeymacsdll.h"\r
   5 #include "Utils.h"\r
   6 #include "Commands.h"\r
   7 #include "CmdTable.h"\r
   8 #include "../xkeymacs/resource.h"\r
   9 #include <math.h>\r
  10 #include <Imm.h>\r
  11 #include <vector>\r
  12 \r
  13 #ifdef _DEBUG\r
  14 #define new DEBUG_NEW\r
  15 #undef THIS_FILE\r
  16 static char THIS_FILE[] = __FILE__;\r
  17 #endif\r
  18 \r
  19 struct Modifier {\r
  20         LPCTSTR name;\r
  21         int id;\r
  22 };\r
  23 \r
  24 static const Modifier Modifiers[] = {\r
  25 //      { _T("A-"), ALT },\r
  26         { _T("C-"), CONTROL},\r
  27 //      { _T("H-"), HYPER },\r
  28         { _T("M-"), META },\r
  29         { _T("S-"), SHIFT },\r
  30 //      { _T("s-"), SUPER },\r
  31         { _T("Ctrl+"), WIN_CTRL },\r
  32         { _T("Alt+"), WIN_ALT },\r
  33         { _T("Win+"), WIN_WIN },\r
  34 };\r
  35 static const int MAX_MODIFIER = _countof(Modifiers);\r
  36 \r
  37 static const struct {\r
  38         BYTE bVk;\r
  39         LPCTSTR name;\r
  40 } KeyNames[] = {\r
  41 //      { VK_LBUTTON,           _T("mouse-1") },                                // does not work well\r
  42 //      { VK_RBUTTON,           _T("mouse-3") },                                // does not work well\r
  43         { VK_CANCEL,            _T("break") },\r
  44 //      { VK_MBUTTON,           _T("mouse-2") },                                // does not work well\r
  45         { VK_BACK,                      _T("backspace") },\r
  46         { VK_TAB,                       _T("tab") },\r
  47         { VK_RETURN,            _T("return") },\r
  48         { VK_CAPITAL,           _T("capslock") },\r
  49         { VK_KANA,                      _T("kana") },\r
  50         { VK_KANJI,                     _T("kanji") },\r
  51         { VK_ESCAPE,            _T("escape") },\r
  52         { VK_CONVERT,           _T("convert") },\r
  53         { VK_NONCONVERT,        _T("nonconvert") },\r
  54 //      { VK_SPACE,                     _T("SPC") },                                    // [? ]\r
  55         { VK_PRIOR,                     _T("prior") },\r
  56         { VK_NEXT,                      _T("next") },\r
  57         { VK_END,                       _T("end") },\r
  58         { VK_HOME,                      _T("home") },\r
  59         { VK_LEFT,                      _T("left") },\r
  60         { VK_UP,                        _T("up") },\r
  61         { VK_RIGHT,                     _T("right") },\r
  62         { VK_DOWN,                      _T("down") },\r
  63         { VK_SELECT,            _T("select") },\r
  64         { VK_PRINT,                     _T("print") },\r
  65         { VK_EXECUTE,           _T("execute") },\r
  66         { VK_SNAPSHOT,          _T("printscreen") },                    // work as print\r
  67         { VK_INSERT,            _T("insert") },\r
  68         { VK_DELETE,            _T("delete") },\r
  69         { VK_LWIN,                      _T("lwindow") },\r
  70         { VK_RWIN,                      _T("rwindow") },\r
  71         { VK_APPS,                      _T("apps") },\r
  72         { VK_SLEEP,                     _T("sleep") },\r
  73         { VK_NUMPAD0,           _T("kp-0") },\r
  74         { VK_NUMPAD1,           _T("kp-1") },\r
  75         { VK_NUMPAD2,           _T("kp-2") },\r
  76         { VK_NUMPAD3,           _T("kp-3") },\r
  77         { VK_NUMPAD4,           _T("kp-4") },\r
  78         { VK_NUMPAD5,           _T("kp-5") },\r
  79         { VK_NUMPAD6,           _T("kp-6") },\r
  80         { VK_NUMPAD7,           _T("kp-7") },\r
  81         { VK_NUMPAD8,           _T("kp-8") },\r
  82         { VK_NUMPAD9,           _T("kp-9") },\r
  83         { VK_MULTIPLY,          _T("kp-multiply") },\r
  84         { VK_ADD,                       _T("kp-add") },\r
  85         { VK_SUBTRACT,          _T("kp-subtract") },\r
  86         { VK_DECIMAL,           _T("kp-decimal") },\r
  87         { VK_DIVIDE,            _T("kp-divide") },\r
  88 //      { VK_F1,                        _T("f1") },                                             // FIXME\r
  89 //      { VK_F2,                        _T("f2") },                                             // Move at the end of definition of function keys to keep away confliction f1/f2 and f1?/f2? by _tcsncmp() i.e. strncmp()\r
  90         { VK_F3,                        _T("f3") },\r
  91         { VK_F4,                        _T("f4") },\r
  92         { VK_F5,                        _T("f5") },\r
  93         { VK_F6,                        _T("f6") },\r
  94         { VK_F7,                        _T("f7") },\r
  95         { VK_F8,                        _T("f8") },\r
  96         { VK_F9,                        _T("f9") },\r
  97         { VK_F10,                       _T("f10") },\r
  98         { VK_F11,                       _T("f11") },\r
  99         { VK_F12,                       _T("f12") },\r
 100         { VK_F13,                       _T("f13") },\r
 101         { VK_F14,                       _T("f14") },\r
 102         { VK_F15,                       _T("f15") },\r
 103         { VK_F16,                       _T("f16") },\r
 104         { VK_F17,                       _T("f17") },\r
 105         { VK_F18,                       _T("f18") },\r
 106         { VK_F19,                       _T("f19") },\r
 107         { VK_F20,                       _T("f20") },\r
 108         { VK_F21,                       _T("f21") },\r
 109         { VK_F22,                       _T("f22") },\r
 110         { VK_F23,                       _T("f23") },\r
 111         { VK_F24,                       _T("f24") },\r
 112         { VK_F1,                        _T("f1") },\r
 113         { VK_F2,                        _T("f2") },\r
 114         { VK_NUMLOCK,           _T("kp-numlock") },\r
 115         { VK_SCROLL,            _T("scroll") },\r
 116         { 0xa6,                         _T("browser-back") },                   // VK_BROWSER_BACK\r
 117         { 0xa7,                         _T("browser-forward") },                // VK_BROWSER_FORWARD\r
 118         { 0xa8,                         _T("browser-refresh") },                // VK_BROWSER_REFRESH\r
 119         { 0xa9,                         _T("browser-stop") },                   // VK_BROWSER_STOP\r
 120         { 0xaa,                         _T("browser-search") },                 // VK_BROWSER_SEARCH\r
 121         { 0xab,                         _T("browser-favorites") },              // VK_BROWSER_FAVORITES\r
 122         { 0xac,                         _T("browser-home") },                   // VK_BROWSER_HOME\r
 123         { 0xad,                         _T("volume-mute") },                    // VK_VOLUME_MUTE\r
 124         { 0xae,                         _T("volume-down") },                    // VK_VOLUME_DOWN\r
 125         { 0xaf,                         _T("volume-up") },                              // VK_VOLUME_UP\r
 126         { 0xb0,                         _T("media-next-track") },               // VK_MEDIA_NEXT_TRACK\r
 127         { 0xb1,                         _T("media-prev-track") },               // VK_MEDIA_PREV_TRACK\r
 128         { 0xb2,                         _T("media-stop") },                             // VK_MEDIA_STOP\r
 129         { 0xb3,                         _T("media-play-pause") },               // VK_MEDIA_PLAY_PAUSE\r
 130         { 0xb4,                         _T("launch-mail") },                    // VK_LAUNCH_MAIL\r
 131         { 0xb5,                         _T("launch-media-select") },    // VK_LAUNCH_MEDIA_SELECT\r
 132         { 0xb6,                         _T("launch-1") },                               // VK_LAUNCH_APP1\r
 133         { 0xb7,                         _T("launch-2") },                               // VK_LAUNCH_APP2\r
 134 };\r
 135 static const int MAX_KEYNAME = _countof(KeyNames);\r
 136 \r
 137 static AFX_EXTENSION_MODULE XkeymacsdllDLL = { NULL, NULL };\r
 138 \r
 139 static HINSTANCE g_hDllInst = NULL;\r
 140 static DWORD g_TlsIndex = 0;\r
 141 \r
 142 extern "C" int APIENTRY\r
 143 DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)\r
 144 {\r
 145         g_hDllInst = hInstance;\r
 146         LPVOID lpData;\r
 147         \r
 148         // Remove this if you use lpReserved\r
 149         UNREFERENCED_PARAMETER(lpReserved);\r
 150 \r
 151         switch (dwReason) {\r
 152         case DLL_PROCESS_ATTACH:\r
 153                 TRACE0("XKEYMACSDLL.DLL Initializing!\n");\r
 154 \r
 155                 // Extension DLL one-time initialization\r
 156                 if (!AfxInitExtensionModule(XkeymacsdllDLL, hInstance)) {\r
 157                         return 0;\r
 158                 }\r
 159 \r
 160                 // Insert this DLL into the resource chain\r
 161                 // NOTE: If this Extension DLL is being implicitly linked to by\r
 162                 //  an MFC Regular DLL (such as an ActiveX Control)\r
 163                 //  instead of an MFC application, then you will want to\r
 164                 //  remove this line from DllMain and put it in a separate\r
 165                 //  function exported from this Extension DLL.  The Regular DLL\r
 166                 //  that uses this Extension DLL should then explicitly call that\r
 167                 //  function to initialize this Extension DLL.  Otherwise,\r
 168                 //  the CDynLinkLibrary object will not be attached to the\r
 169                 //  Regular DLL's resource chain, and serious problems will\r
 170                 //  result.\r
 171 \r
 172                 try {\r
 173                         new CDynLinkLibrary(XkeymacsdllDLL);\r
 174                 }\r
 175                 catch (CMemoryException* e) {\r
 176                         e->Delete();\r
 177 //                      CUtils::Log("DllMain: 'new' threw an exception");\r
 178                 }\r
 179 \r
 180                 if ((g_TlsIndex = TlsAlloc()) == TLS_OUT_OF_INDEXES)\r
 181                         return FALSE;\r
 182                 // fall through\r
 183         case DLL_THREAD_ATTACH:\r
 184                 if ((lpData = LocalAlloc(LPTR, sizeof(HHOOK))) != NULL)\r
 185                         TlsSetValue(g_TlsIndex, lpData);\r
 186                 break;\r
 187         case DLL_PROCESS_DETACH:\r
 188                 TRACE0("XKEYMACSDLL.DLL Terminating!\n");\r
 189                 // Terminate the library before destructors are called\r
 190                 AfxTermExtensionModule(XkeymacsdllDLL);\r
 191                 CXkeymacsDll::ReleaseKeyboardHook();\r
 192                 if ((lpData = TlsGetValue(g_TlsIndex)) != NULL)\r
 193                         LocalFree(lpData);\r
 194                 TlsFree(g_TlsIndex);\r
 195                 break;\r
 196         case DLL_THREAD_DETACH:\r
 197                 CXkeymacsDll::ReleaseKeyboardHook();\r
 198                 if ((lpData = TlsGetValue(g_TlsIndex)) != NULL)\r
 199                         LocalFree(lpData);\r
 200                 break;\r
 201         }\r
 202         return 1;   // ok\r
 203 }\r
 204 \r
 205 //////////////////////////////////////////////////////////////////////\r
 206 // CXkeymacsDll Class\r
 207 //////////////////////////////////////////////////////////////////////\r
 208 \r
 209 #pragma data_seg(".xkmcs")\r
 210 Config CXkeymacsDll::m_Config = {0};\r
 211 bool CXkeymacsDll::m_bEnableKeyboardHook = false;\r
 212 BOOL CXkeymacsDll::m_bHook = TRUE;\r
 213 DWORD CXkeymacsDll::m_nHookAltRelease = 0;\r
 214 BOOL CXkeymacsDll::m_bRightShift = FALSE;\r
 215 BOOL CXkeymacsDll::m_bRightControl = FALSE;\r
 216 BOOL CXkeymacsDll::m_bRightAlt = FALSE;\r
 217 TCHAR CXkeymacsDll::m_M_xTip[128] = "";\r
 218 BYTE CXkeymacsDll::m_nOriginal[MAX_COMMAND_TYPE][MAX_KEY] = {'\0'};\r
 219 int CXkeymacsDll::m_nAccelerate = 0;\r
 220 int CXkeymacsDll::m_nKeyboardSpeed = 31;\r
 221 HCURSOR CXkeymacsDll::m_hCurrentCursor = NULL;\r
 222 BOOL CXkeymacsDll::m_bCursor = FALSE;\r
 223 HCURSOR CXkeymacsDll::m_hCursor[MAX_STATUS] = {'\0'};\r
 224 #pragma data_seg()\r
 225 \r
 226 AppConfig* CXkeymacsDll::m_CurrentConfig = NULL;\r
 227 HHOOK CXkeymacsDll::m_hHookCallWnd = NULL;\r
 228 HHOOK CXkeymacsDll::m_hHookCallWndRet = NULL;\r
 229 HHOOK CXkeymacsDll::m_hHookGetMessage = NULL;\r
 230 HHOOK CXkeymacsDll::m_hHookShell = NULL;\r
 231 CList<CClipboardSnap *, CClipboardSnap *> CXkeymacsDll::m_oKillRing;\r
 232 int CXkeymacsDll::m_nKillRing = 0;\r
 233 KbdMacro* CXkeymacsDll::m_kbdMacro = NULL;\r
 234 \r
 235 BOOL CXkeymacsDll::SaveConfig()\r
 236 {\r
 237         TCHAR szTmp[MAX_PATH];\r
 238         if (!GetTempPath(MAX_PATH, szTmp))\r
 239                 return FALSE;\r
 240         if (_tmakepath_s(szTmp, NULL, szTmp, _T("xkeymacs"), _T("tmp")))\r
 241                 return FALSE;\r
 242         HANDLE hFile = CreateFile(szTmp, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);\r
 243         if (hFile == INVALID_HANDLE_VALUE)\r
 244                 return FALSE;\r
 245         DWORD written;\r
 246         BOOL res = WriteFile(hFile, &m_Config, sizeof(m_Config), &written, NULL) && written == sizeof(m_Config);\r
 247         CloseHandle(hFile);\r
 248         return res;\r
 249 }\r
 250 \r
 251 BOOL CXkeymacsDll::LoadConfig()\r
 252 {\r
 253         TCHAR szTmp[MAX_PATH];\r
 254         if (!GetTempPath(MAX_PATH, szTmp))\r
 255                 return FALSE;\r
 256         if (_tmakepath_s(szTmp, NULL, szTmp, _T("xkeymacs"), _T("tmp")))\r
 257                 return FALSE;\r
 258         HANDLE hFile = CreateFile(szTmp, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);\r
 259         if (hFile == INVALID_HANDLE_VALUE)\r
 260                 return FALSE;\r
 261         DWORD read;\r
 262         BOOL res = ReadFile(hFile, &m_Config, sizeof(m_Config), &read, NULL) && read == sizeof(m_Config);\r
 263         CloseHandle(hFile);\r
 264         return res;\r
 265 }\r
 266 \r
 267 void CXkeymacsDll::SetConfig(const Config& config)\r
 268 {\r
 269         m_Config = config;\r
 270 }\r
 271 \r
 272 void CXkeymacsDll::SetHooks()\r
 273 {\r
 274         m_hHookCallWnd = SetWindowsHookEx(WH_CALLWNDPROC, CallWndProc, g_hDllInst, 0);\r
 275         m_hHookCallWndRet = SetWindowsHookEx(WH_CALLWNDPROCRET, CallWndRetProc, g_hDllInst, 0);\r
 276         m_hHookGetMessage = SetWindowsHookEx(WH_GETMESSAGE, GetMsgProc, g_hDllInst, 0);\r
 277         m_hHookShell = SetWindowsHookEx(WH_SHELL, ShellProc, g_hDllInst, 0);\r
 278         m_bEnableKeyboardHook = true;\r
 279 }\r
 280 \r
 281 void CXkeymacsDll::SetKeyboardHook(DWORD threadId)\r
 282 {\r
 283         LPVOID lpData = TlsGetValue(g_TlsIndex);\r
 284         if (!lpData) {\r
 285                 lpData = LocalAlloc(LPTR, sizeof(HHOOK));\r
 286                 if (!lpData)\r
 287                         return;\r
 288                 if (!TlsSetValue(g_TlsIndex, lpData))\r
 289                         return;\r
 290         }\r
 291         HHOOK *phHook = reinterpret_cast<HHOOK *>(lpData);\r
 292         if (!*phHook)\r
 293                 *phHook = SetWindowsHookEx(WH_KEYBOARD, KeyboardProc, g_hDllInst, threadId ? threadId : GetCurrentThreadId());\r
 294 }\r
 295 \r
 296 inline void unhook(HHOOK &hh)\r
 297 {\r
 298         if (hh)\r
 299                 UnhookWindowsHookEx(hh);\r
 300         hh = NULL;\r
 301 }\r
 302 \r
 303 void CXkeymacsDll::ResetHooks() \r
 304 {\r
 305         ReleaseHooks();\r
 306         SetHooks();\r
 307 }\r
 308 \r
 309 void CXkeymacsDll::ReleaseHooks()\r
 310 {\r
 311         unhook(m_hHookCallWnd);\r
 312         unhook(m_hHookCallWndRet);\r
 313         unhook(m_hHookGetMessage);\r
 314         unhook(m_hHookShell);\r
 315         m_bEnableKeyboardHook = false;\r
 316 }\r
 317 \r
 318 void CXkeymacsDll::ReleaseKeyboardHook()\r
 319 {\r
 320         HHOOK *phHook = reinterpret_cast<HHOOK *>(TlsGetValue(g_TlsIndex));\r
 321         if (phHook)\r
 322                 unhook(*phHook);\r
 323 }\r
 324 \r
 325 void CXkeymacsDll::ToggleKeyboardHookState()\r
 326 {\r
 327         m_bHook = !m_bHook;\r
 328         ShowKeyboardHookState();\r
 329 }\r
 330 \r
 331 BOOL CXkeymacsDll::IsKeyboardHook()\r
 332 {\r
 333         return m_bHook;\r
 334 }\r
 335 \r
 336 void CXkeymacsDll::ShowKeyboardHookState()\r
 337 {\r
 338         IconMsg msg = {MAIN_ICON,};\r
 339         if (m_bHook) {\r
 340                 if (CCommands::IsTemporarilyDisableXKeymacs()) {\r
 341                         msg.nState = STATUS_DISABLE_TMP;\r
 342                         m_hCurrentCursor = m_hCursor[STATUS_DISABLE_TMP];\r
 343                 } else {\r
 344                         msg.nState = STATUS_ENABLE;\r
 345                         m_hCurrentCursor = m_hCursor[STATUS_ENABLE];\r
 346                 }\r
 347         } else {\r
 348                 msg.nState = STATUS_DISABLE_WOCQ;\r
 349         }\r
 350         if (m_CurrentConfig->SettingStyle == SETTING_DISABLE\r
 351          || (!_tcsicmp(m_CurrentConfig->AppName, _T("Default"))\r
 352           && CUtils::IsDefaultIgnoreApplication())) {\r
 353                 msg.nState = STATUS_DISABLE;\r
 354                 m_hCurrentCursor = m_hCursor[STATUS_DISABLE];\r
 355         }\r
 356         SendIconMessage(&msg, 1);\r
 357         DoSetCursor();\r
 358 }\r
 359 \r
 360 LRESULT CALLBACK CXkeymacsDll::CallWndProc(int nCode, WPARAM wParam, LPARAM lParam)\r
 361 {\r
 362         SetKeyboardHook();\r
 363         if (nCode >= 0) {\r
 364                 const CWPSTRUCT *cwps = reinterpret_cast<CWPSTRUCT *>(lParam);\r
 365                 switch (cwps->message) {\r
 366                 case WM_IME_STARTCOMPOSITION:\r
 367                         InitKeyboardProc(true);\r
 368                         break;\r
 369                 case WM_IME_ENDCOMPOSITION:\r
 370                         InitKeyboardProc(false);\r
 371                         break;\r
 372                 case WM_SETFOCUS:\r
 373                         if (cwps->hwnd == GetForegroundWindow()) {\r
 374                                 InitKeyboardProc(false);\r
 375                                 ShowKeyboardHookState();\r
 376                         }\r
 377                         break;\r
 378                 case WM_NCACTIVATE:\r
 379                         if (cwps->wParam && cwps->hwnd == GetForegroundWindow()) {\r
 380                                 InitKeyboardProc(false);\r
 381                                 ShowKeyboardHookState();\r
 382                         }\r
 383                         break;\r
 384                 }\r
 385         }\r
 386         return CallNextHookEx(NULL, nCode, wParam, lParam);\r
 387 }\r
 388 \r
 389 LRESULT CALLBACK CXkeymacsDll::CallWndRetProc(int nCode, WPARAM wParam, LPARAM lParam)\r
 390 {\r
 391         SetKeyboardHook();\r
 392         if (nCode >= 0) {\r
 393                 const CWPRETSTRUCT *cwprets = reinterpret_cast<CWPRETSTRUCT *>(lParam);\r
 394                 switch (cwprets->message) {\r
 395                 case WM_SETTEXT:\r
 396                         if (cwprets->hwnd == GetForegroundWindow())\r
 397                                 InitKeyboardProc(false);\r
 398                         break;\r
 399                 case WM_SETCURSOR:\r
 400                         DoSetCursor();\r
 401                         break;\r
 402                 }\r
 403         }\r
 404         return CallNextHookEx(NULL, nCode, wParam, lParam);\r
 405 }\r
 406 \r
 407 LRESULT CALLBACK CXkeymacsDll::GetMsgProc(int nCode, WPARAM wParam, LPARAM lParam)\r
 408 {\r
 409         SetKeyboardHook();\r
 410         if (nCode >= 0) {\r
 411                 const MSG *msg = reinterpret_cast<MSG *>(lParam);\r
 412                 switch (msg->message) {\r
 413                 case WM_IME_STARTCOMPOSITION:\r
 414                         InitKeyboardProc(true);\r
 415                         break;\r
 416                 case WM_IME_ENDCOMPOSITION:\r
 417                         InitKeyboardProc(false);\r
 418                         break;\r
 419                 }\r
 420         }\r
 421         return CallNextHookEx(NULL, nCode, wParam, lParam);\r
 422 }\r
 423 \r
 424 LRESULT CALLBACK CXkeymacsDll::ShellProc(int nCode, WPARAM wParam, LPARAM lParam)\r
 425 {\r
 426         if (nCode == HSHELL_WINDOWACTIVATED) {\r
 427                 SetKeyboardHook(GetWindowThreadProcessId(reinterpret_cast<HWND>(wParam), NULL));\r
 428                 TCHAR className[CLASS_NAME_LENGTH];\r
 429                 GetClassName(reinterpret_cast<HWND>(wParam), className, CLASS_NAME_LENGTH);\r
 430                 if (!_tcsicmp(className, _T("ConsoleWindowClass"))) {\r
 431                         InitKeyboardProc(false);\r
 432                         ShowKeyboardHookState();\r
 433                 }\r
 434         }\r
 435         return CallNextHookEx(NULL, nCode, wParam, lParam);\r
 436 }\r
 437 \r
 438 void CXkeymacsDll::InitKeyboardProc(bool imeState)\r
 439 {\r
 440         AppName::Init();\r
 441         AppName::SetIMEState(imeState);\r
 442 \r
 443         if (m_CurrentConfig == NULL ||\r
 444                         _tcsnicmp(m_CurrentConfig->AppName, AppName::GetAppName(), 0xF) ||      // PROCESSENTRY32 has only 0xF bytes of Name\r
 445                         !CUtils::IsMatchWindowText(m_CurrentConfig->WindowText)) {\r
 446                 m_CurrentConfig = NULL;\r
 447                 for (int nAppID = 0; nAppID < MAX_APP; ++nAppID) {\r
 448                         AppConfig* appConfig = m_Config.AppConfig + nAppID;\r
 449                         if (_tcsnicmp(appConfig->AppName, AppName::GetAppName(), 0xF) || !CUtils::IsMatchWindowText(appConfig->WindowText))\r
 450                                 continue;\r
 451                         if (m_CurrentConfig == NULL)\r
 452                                 m_CurrentConfig = appConfig;\r
 453                         else {\r
 454                                 LPCTSTR curText = m_CurrentConfig->WindowText;\r
 455                                 LPCTSTR newText = appConfig->WindowText;\r
 456                                 int curType = CUtils::GetWindowTextType(curText);\r
 457                                 int newType = CUtils::GetWindowTextType(newText);\r
 458                                 if (curType < newType || curType == newType && _tcscmp(curText, newText) <= 0)\r
 459                                         m_CurrentConfig = appConfig;\r
 460                         }\r
 461                 }\r
 462                 if (m_CurrentConfig == NULL)\r
 463                         m_CurrentConfig = GetAppConfig(_T("Default"), m_Config.AppConfig);\r
 464         }\r
 465         if (m_CurrentConfig->SettingStyle != SETTING_DISABLE &&\r
 466                         (_tcsicmp(m_CurrentConfig->AppName, _T("Default")) || !CUtils::IsDefaultIgnoreApplication()) &&\r
 467                         !imeState && CUtils::IsDialog() && m_CurrentConfig->UseDialogSetting)\r
 468                 // Use Dialog Setting\r
 469                 m_CurrentConfig = GetAppConfig(_T("Dialog"), m_CurrentConfig);\r
 470 \r
 471         IconMsg msg[3] = {\r
 472                 {CX_ICON, OFF_ICON, ""},\r
 473                 {MX_ICON, OFF_ICON, ""},\r
 474                 {META_ICON, OFF_ICON, ""}\r
 475         };\r
 476         SendIconMessage(msg, 3);\r
 477         CCommands::SetMark(FALSE);\r
 478         CCommands::SetTemporarilyDisableXKeymacs(FALSE);\r
 479         CCommands::Reset();\r
 480 }\r
 481 \r
 482 AppConfig* CXkeymacsDll::GetAppConfig(LPCTSTR name, AppConfig* fallback)\r
 483 {\r
 484         for (int i = 0; i < MAX_APP; ++i)\r
 485                 if (!_tcsicmp(m_Config.AppConfig[i].AppName, name))\r
 486                         return m_Config.AppConfig + i;\r
 487         return fallback;\r
 488 }\r
 489 \r
 490 LRESULT CALLBACK CXkeymacsDll::KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)\r
 491 {\r
 492         BYTE nOrigKey = static_cast<BYTE>(wParam);\r
 493         bool bRelease = (HIWORD(lParam) & KF_UP) != 0;\r
 494         bool bExtended = (HIWORD(lParam) & KF_EXTENDED) != 0;\r
 495         BYTE nKey = nOrigKey;\r
 496 \r
 497         static BOOL bLocked = FALSE;\r
 498         static const BYTE RECURSIVE_KEY = 0x07;\r
 499         static int (*fLastCommand)() = NULL;\r
 500         static BYTE nOneShotModifier[MAX_KEY] = {'\0'};\r
 501         static BOOL bCherryOneShotModifier = FALSE;\r
 502 \r
 503 //      CUtils::Log(_T("nCode = %#x, nKey = %#x, lParam = %#x"), nCode, nOrigKey, lParam);\r
 504 \r
 505         if (!m_bEnableKeyboardHook || m_CurrentConfig == NULL || CUtils::IsXkeymacs() ||\r
 506                         nCode < 0 || nCode == HC_NOREMOVE)\r
 507                 return CallNextHookEx(NULL, nCode, wParam, lParam);\r
 508 \r
 509 //      CUtils::Log(_T("nKey = %#x, ext = %d, rel = %d, pre = %d, %#hx, %#hx"), nOrigKey,\r
 510 //              (HIWORD(lParam) & KF_EXTENDED) ? 1 : 0, (HIWORD(lParam) & KF_UP) ? 1 : 0, (HIWORD(lParam) & KF_REPEAT) ? 1 : 0,\r
 511 //              GetKeyState(nOrigKey), GetAsyncKeyState(nOrigKey));\r
 512 \r
 513         if (nOrigKey == RECURSIVE_KEY) {\r
 514                 if (bRelease)\r
 515                         goto HOOK_RECURSIVE_KEY;\r
 516                 else\r
 517                         goto RECURSIVE_COMMAND;\r
 518         }\r
 519 \r
 520         CancelMarkWithShift(nOrigKey, bRelease);\r
 521 \r
 522         switch (nKey) {\r
 523         case VK_CONTROL:\r
 524                 nKey = bExtended ? VK_RCONTROL : VK_LCONTROL;\r
 525                 break;\r
 526         case VK_MENU:\r
 527                 nKey = bExtended ? VK_RMENU : VK_LMENU;\r
 528                 break;\r
 529         case VK_SHIFT:\r
 530                 nKey = bExtended ? VK_RSHIFT : VK_LSHIFT;\r
 531                 break;\r
 532         }\r
 533 \r
 534 #define fCommand(nType) (CmdTable::Command(m_CurrentConfig->CmdID[(nType)][nKey]))\r
 535 #define FuncID (m_CurrentConfig->FuncID[nType][nKey])\r
 536 \r
 537         if (bRelease) {\r
 538                 switch (nOrigKey) {\r
 539                 case VK_MENU:\r
 540                         if (m_nHookAltRelease) {\r
 541                                 if (m_nHookAltRelease & ~HOOK_ALT_LATER)\r
 542                                         m_nHookAltRelease--;\r
 543                                 else if (m_nHookAltRelease & HOOK_ALT_LATER)\r
 544                                         m_nHookAltRelease = 0;\r
 545                                 goto HOOK;\r
 546                         }\r
 547                         // pass through\r
 548                 case VK_LWIN:\r
 549                 case VK_RWIN:\r
 550                 case VK_APPS:\r
 551                         for (int i = 0; i < MAX_COMMAND_TYPE; ++i) {\r
 552                                 int (*fCommand)() = fCommand(i);\r
 553                                 if (fCommand && !(nOrigKey == VK_MENU && fCommand == CCommands::MetaAlt))\r
 554                                         goto HOOK;\r
 555                         }\r
 556                 }\r
 557                 if (nOneShotModifier[nKey]) {\r
 558                         ReleaseKey(nOneShotModifier[nKey]);\r
 559                         nOneShotModifier[nKey] = 0;\r
 560                         if (bCherryOneShotModifier) {\r
 561                                 bCherryOneShotModifier = FALSE;\r
 562                                 Kdu(nKey);\r
 563                         }\r
 564                 }\r
 565                 goto DO_NOTHING;\r
 566         }\r
 567 \r
 568         if (m_CurrentConfig->SettingStyle == SETTING_DISABLE)\r
 569                 goto DO_NOTHING;\r
 570 \r
 571         // Do Nothing for Meadow, Mule for Win32, ... if those use default setting.\r
 572         if (!_tcsicmp(m_CurrentConfig->AppName, _T("Default")) && CUtils::IsDefaultIgnoreApplication())\r
 573                 goto DO_NOTHING;\r
 574 \r
 575         switch (IsPassThrough(nKey)) {\r
 576         case GOTO_DO_NOTHING:\r
 577                 goto DO_NOTHING;\r
 578         case GOTO_HOOK:\r
 579                 goto HOOK;\r
 580         case CONTINUE:\r
 581                 break;\r
 582         }\r
 583 \r
 584         // set command type\r
 585         int nType = IsDown(VK_SHIFT) * SHIFT | IsControl() * CONTROL | IsMeta() * META | CCommands::bC_x() * CONTROLX;\r
 586         // Ignore undefined C-x ?\r
 587         if (nType & CONTROLX && fCommand(nType) == NULL && FuncID < 0) {\r
 588                 if (m_CurrentConfig->IgnoreUndefC_x) {\r
 589                         CCommands::Reset(GOTO_HOOK);\r
 590                         goto HOOK;\r
 591                 }\r
 592                 nType &= ~CONTROLX;\r
 593         }\r
 594         // Ignore undefined Meta Ctrl+?\r
 595         if (CCommands::bM_() && nType & CONTROL) {\r
 596                 if (fCommand(nType) == NULL && FuncID < 0) {\r
 597                         if (m_CurrentConfig->IgnoreUndefMetaCtrl) {\r
 598                                 if (CheckOriginal(CONTROL, nKey))\r
 599                                         goto DO_NOTHING;\r
 600                                 CCommands::Reset(GOTO_HOOK);\r
 601                                 goto HOOK;\r
 602                         }\r
 603                         nType &= ~META;\r
 604                 }\r
 605         }\r
 606 \r
 607         int nVirtualType = GetModifierState(FALSE);\r
 608         if (nOrigKey == VK_CONTROL)\r
 609                 nVirtualType &= ~CONTROL;\r
 610         if (nOrigKey == VK_MENU)\r
 611                 nVirtualType &= ~META;\r
 612         if (CheckOriginal(nVirtualType, nOrigKey))\r
 613                 goto DO_NOTHING;\r
 614 \r
 615         int (*fCommand)() = fCommand(nType);\r
 616         if (fCommand == CCommands::EnableOrDisableXKeymacs) {\r
 617                 ToggleKeyboardHookState();\r
 618                 goto HOOK;\r
 619         }\r
 620         if (fCommand == CCommands::EnableXKeymacs) {\r
 621                 if (!m_bHook)\r
 622                         ToggleKeyboardHookState();\r
 623                 goto HOOK;\r
 624         }\r
 625         if (fCommand == CCommands::DisableXKeymacs) {\r
 626                 if (m_bHook)\r
 627                         ToggleKeyboardHookState();\r
 628                 goto HOOK;\r
 629         }\r
 630         if (!m_bHook)\r
 631                 goto DO_NOTHING;\r
 632 \r
 633         if (CCommands::bM_x() && !bRelease) {\r
 634                 static size_t index = 0;\r
 635                 static TCHAR szPath[MAX_PATH] = {'\0'};\r
 636                 if (fCommand == CCommands::BackwardChar) {\r
 637                         if (index)\r
 638                                 --index;\r
 639                         goto HOOKX;\r
 640                 } else if (fCommand == CCommands::BeginningOfLine) {\r
 641                         index = 0;\r
 642                         goto HOOKX;\r
 643                 } else if (fCommand == CCommands::DeleteBackwardChar) {\r
 644                         if (index) {\r
 645                                 --index;\r
 646                                 memmove(szPath + index, szPath + index + 1, MAX_PATH - index);\r
 647                                 SetM_xTip(szPath);\r
 648                         }\r
 649                         goto HOOKX;\r
 650                 } else if (fCommand == CCommands::DeleteChar) {\r
 651                         if (index < _tcslen(szPath)) {\r
 652                                 memmove(szPath + index, szPath + index + 1, MAX_PATH - index);\r
 653                                 SetM_xTip(szPath);\r
 654                         }\r
 655                         goto HOOKX;\r
 656                 } else if (fCommand == CCommands::EndOfLine) {\r
 657                         index = _tcslen(szPath);\r
 658                         goto HOOKX;\r
 659                 } else if (fCommand == CCommands::ForwardChar) {\r
 660                         if (index < _tcslen(szPath))\r
 661                                 ++index;\r
 662                         goto HOOKX;\r
 663                 } else if (fCommand == CCommands::KeyboardQuit) {\r
 664                         CCommands::bM_x(FALSE);\r
 665                         index = 0;\r
 666                         memset(szPath, 0, sizeof(szPath));\r
 667                         goto HOOK;\r
 668                 } else if (nKey == VK_RETURN || fCommand == CCommands::Newline) {\r
 669                         InvokeM_x(szPath);\r
 670                         CCommands::bM_x(FALSE);\r
 671                         index = 0;\r
 672                         memset(szPath, 0, sizeof(szPath));\r
 673                         goto HOOK;\r
 674                 } else if (nKey && index < MAX_PATH - 1) {\r
 675                         if (SHORT ascii = ConvVkey(nKey | (static_cast<BYTE>(IsDown(VK_SHIFT, FALSE)) << 8), 1)) {\r
 676 //                              CUtils::Log("M-x: %#X (%c), %#X (%c)", nKey, nKey, ascii, ascii);\r
 677                                 if (index < _tcslen(szPath))\r
 678                                         memmove(szPath + index + 1, szPath + index, MAX_PATH - index - 1);\r
 679                                 szPath[index++] = static_cast<TCHAR>(ascii);\r
 680 //                              CUtils::Log("M-x: %c(%#04x)", ascii, ascii);\r
 681                                 SetM_xTip(szPath);\r
 682                                 goto HOOKX;\r
 683                         }\r
 684                 }\r
 685         }\r
 686 \r
 687         if (CCommands::bC_u() && nType == NONE) {\r
 688                 if ('0' <= nKey && nKey <= '9') {\r
 689                         CCommands::NumericArgument(nKey - '0');\r
 690                         goto HOOK0_9;\r
 691                 }\r
 692                 if (nKey == VK_OEM_MINUS) {\r
 693                         CCommands::NumericArgumentMinus();\r
 694                         goto HOOK0_9;\r
 695                 }\r
 696         }\r
 697 \r
 698 #define OneShotModifier(type, vk, mod) \\r
 699         if (fCommand(nType & ~type) == CCommands::OneShotModifier ## mod || \\r
 700                         fCommand(nType) == CCommands::OneShotModifier ## mod ## Repeat) { \\r
 701                 nOneShotModifier[nKey] = vk; \\r
 702                 DepressKey(vk); \\r
 703                 bCherryOneShotModifier = TRUE; \\r
 704                 goto HOOK; \\r
 705         } else if (fCommand(nType & ~CONTROL) == CCommands::OneShotModifier ## mod ## Repeat) { \\r
 706                 ReleaseKey(vk); \\r
 707                 bCherryOneShotModifier = FALSE; \\r
 708                 Kdu(nKey); \\r
 709                 goto HOOK; \\r
 710         }\r
 711 \r
 712         OneShotModifier(CONTROL, VK_CONTROL, Ctrl);\r
 713         OneShotModifier(META, VK_MENU, Alt);\r
 714         OneShotModifier(SHIFT, VK_SHIFT, Shift);\r
 715         int i;\r
 716         for (i = 0; i < MAX_KEY; ++i)\r
 717                 if (nOneShotModifier[i] == nOrigKey)\r
 718                         break;\r
 719         if (i == MAX_KEY)\r
 720                 bCherryOneShotModifier = FALSE;\r
 721 \r
 722         if (0 <= FuncID && FuncID < MAX_FUNCTION && m_Config.FuncDef[FuncID][0]) {\r
 723                 CallFunction(FuncID);\r
 724                 CCommands::Reset(GOTO_HOOK);\r
 725                 goto HOOK;\r
 726         }\r
 727 #undef fCommand\r
 728 #undef FuncID\r
 729 \r
 730         if (!fCommand) {\r
 731                 if (nOrigKey == VK_CONTROL || nOrigKey == VK_MENU || nOrigKey == VK_SHIFT)\r
 732                         goto DO_NOTHING;\r
 733                 if (!(nType & SHIFT)) {\r
 734                         if (CCommands::IsSetMark()) {\r
 735                                 if (CCommands::MoveCaret(nKey, nType & CONTROL) != CONTINUE) {\r
 736                                         CCommands::ClearNumericArgument();\r
 737                                         goto HOOK;\r
 738                                 }\r
 739                                 CCommands::SetMark(FALSE);\r
 740                         }\r
 741                 }\r
 742                 if (1 < CCommands::GetNumericArgument()) {\r
 743                         Kdu(nKey, CCommands::GetNumericArgument());\r
 744                         CCommands::ClearNumericArgument();\r
 745                         goto HOOK;\r
 746                 }\r
 747                 goto DO_NOTHING;\r
 748         }\r
 749 \r
 750         if (CCommands::IsTemporarilyDisableXKeymacs()  && fCommand != CCommands::KeyboardQuit) {\r
 751                 CCommands::SetTemporarilyDisableXKeymacs(FALSE);\r
 752                 goto DO_NOTHING;\r
 753         }\r
 754 \r
 755         m_bRightControl = IsDown(VK_RCONTROL, FALSE);\r
 756         m_bRightAlt = IsDown(VK_RMENU, FALSE);\r
 757         m_bRightShift = IsDown(VK_RSHIFT, FALSE);\r
 758 \r
 759         if (bLocked)\r
 760                 goto HOOK_RECURSIVE_KEY;\r
 761         bLocked = TRUE;\r
 762         fLastCommand = fCommand;\r
 763 RECURSIVE_COMMAND:\r
 764         switch (fLastCommand()) {\r
 765         case GOTO_DO_NOTHING:\r
 766                 bLocked = FALSE;\r
 767                 goto DO_NOTHING;\r
 768         case GOTO_HOOK:\r
 769                 bLocked = FALSE;\r
 770                 goto HOOK;\r
 771         case GOTO_RECURSIVE:\r
 772                 goto RECURSIVE;\r
 773         case GOTO_HOOKX:\r
 774                 bLocked = FALSE;\r
 775                 goto HOOKX;\r
 776         case GOTO_HOOK0_9:\r
 777                 bLocked = FALSE;\r
 778                 goto HOOK0_9;\r
 779         }\r
 780 \r
 781 DO_NOTHING:\r
 782         SetModifierIcons();\r
 783         if (m_kbdMacro)\r
 784                 m_kbdMacro->Record(nKey, bRelease);\r
 785         return CallNextHookEx(NULL, nCode, wParam, lParam);\r
 786 \r
 787 RECURSIVE:\r
 788         Kdu(RECURSIVE_KEY, 1, FALSE);\r
 789         goto HOOKX;\r
 790 HOOK:\r
 791         CCommands::SetLastCommand(fLastCommand);\r
 792 HOOK0_9:\r
 793 HOOKX:\r
 794         SetModifierIcons();\r
 795 HOOK_RECURSIVE_KEY:\r
 796         return TRUE;\r
 797 }\r
 798 \r
 799 void CXkeymacsDll::CancelMarkWithShift(BYTE nKey, bool bRelease)\r
 800 {\r
 801         static bool bShift;\r
 802         if (nKey != VK_SHIFT)\r
 803                 goto exit;\r
 804         BYTE bVk = 0;\r
 805         do {\r
 806                 if (bVk == VK_SHIFT || VK_LSHIFT || VK_RSHIFT)\r
 807                         continue;\r
 808                 if (IsDown(bVk, FALSE))\r
 809                         goto exit;\r
 810         } while (++bVk);\r
 811         if (!bRelease) {\r
 812                 bShift = true;\r
 813                 return;\r
 814         }\r
 815         if (bShift)\r
 816                 CCommands::SetMark(FALSE);\r
 817 exit:\r
 818         bShift = false;\r
 819         return;\r
 820 }\r
 821 \r
 822 int CXkeymacsDll::IsPassThrough(BYTE nKey)\r
 823 {\r
 824         BYTE bVk = 0;\r
 825         const BYTE *pnID = m_CurrentConfig->CmdID[NONE]; \r
 826         do {\r
 827                 if (IsDown(bVk) && CmdTable::Command(pnID[bVk]) == CCommands::PassThrough) {\r
 828                         if (bVk == nKey)\r
 829                                 return GOTO_HOOK;\r
 830                         return GOTO_DO_NOTHING;\r
 831                 }\r
 832         } while (++bVk);\r
 833         return CONTINUE;\r
 834 }\r
 835 \r
 836 void CXkeymacsDll::InvokeM_x(LPCTSTR szPath)\r
 837 {\r
 838 //      CUtils::Log("M-x: szPath=_%s_", szPath);\r
 839         int (*fCommand)() = NULL;\r
 840         for (int i = 0; i < MAX_COMMAND; ++i)\r
 841                 if (_tcsicmp(szPath, CmdTable::Name(i)) == 0) {\r
 842                         fCommand = CmdTable::Command(i);\r
 843                         break;\r
 844                 }\r
 845         if (fCommand) {\r
 846 //              CUtils::Log("M-x: Command: _%s_", Commands[i].szCommandName);\r
 847                 fCommand();\r
 848         } else {\r
 849 //              CUtils::Log("M-x: Path: _%s_", szPath);\r
 850                 ShellExecute(NULL, NULL, szPath, NULL, NULL, SW_SHOWNORMAL);\r
 851         }\r
 852 }\r
 853 \r
 854 void CXkeymacsDll::SetModifierIcons()\r
 855 {\r
 856         IconMsg msg[6] = {\r
 857                 {MX_ICON, CCommands::bM_x(), ""},\r
 858                 {CX_ICON, CCommands::bC_x(), ""},\r
 859                 {META_ICON, CCommands::bM_(), ""},\r
 860                 {SHIFT_ICON, IsDown(VK_SHIFT, FALSE), ""},\r
 861                 {CTRL_ICON, IsControl(), ""},\r
 862                 {ALT_ICON, IsDown(VK_MENU, FALSE), ""}\r
 863         };\r
 864         _tcscpy_s(msg[0].szTip, m_M_xTip);\r
 865         SendIconMessage(msg, 6);\r
 866 }\r
 867 \r
 868 void CXkeymacsDll::SetM_xTip(LPCTSTR szPath)\r
 869 {\r
 870         _tcscpy_s(m_M_xTip, "M-x LED");\r
 871         if (szPath && _tcslen(szPath) < 128 - 5)\r
 872                 _stprintf_s(m_M_xTip, "M-x %s", szPath);\r
 873 }\r
 874 \r
 875 BOOL CXkeymacsDll::SendIconMessage(IconMsg *pMsg, DWORD num)\r
 876 {\r
 877         DWORD ack, read;\r
 878         return CallNamedPipe(ICON_PIPE, pMsg, sizeof(IconMsg) * num, &ack, sizeof(DWORD), &read, NMPWAIT_NOWAIT) && read == sizeof(DWORD);\r
 879 }\r
 880 \r
 881 void CXkeymacsDll::Kdu(BYTE bVk, DWORD n, BOOL bOriginal)\r
 882 {\r
 883         while (n--) {\r
 884                 DepressKey(bVk, bOriginal);\r
 885                 ReleaseKey(bVk);\r
 886         }\r
 887 }\r
 888 \r
 889 void CXkeymacsDll::DepressKey(BYTE bVk, BOOL bOriginal) // bVk is virtual-key code, MSDN said\r
 890 {\r
 891         if (bOriginal) {\r
 892 //              CUtils::Log(_T("i: %x, %d, %d, %d, %d, %d, %d, %d, %d"), bVk,\r
 893 //                      IsDown(VK_CONTROL), IsDown(VK_CONTROL, FALSE), IsDepressedModifier(CCommands::C_), IsDepressedModifier(CCommands::C_, FALSE),\r
 894 //                      IsDown(VK_MENU), IsDown(VK_MENU, FALSE), IsDepressedModifier(CCommands::MetaAlt), IsDepressedModifier(CCommands::MetaAlt, FALSE));\r
 895                 SetOriginal(GetModifierState(), bVk);\r
 896         }\r
 897         DoKeybd_event(bVk, 0);\r
 898 }\r
 899 \r
 900 void CXkeymacsDll::ReleaseKey(BYTE bVk) // bVk is virtual-key code, MSDN said\r
 901 {\r
 902         DoKeybd_event(bVk, KEYEVENTF_KEYUP);\r
 903 }\r
 904 \r
 905 void CXkeymacsDll::DoKeybd_event(BYTE bVk, DWORD dwFlags)\r
 906 {\r
 907         switch (bVk) {\r
 908         case VK_CONTROL:\r
 909                 if (m_bRightControl)\r
 910                         dwFlags |= KEYEVENTF_EXTENDEDKEY;\r
 911                 break;\r
 912 \r
 913         case VK_MENU:\r
 914                 if (m_bRightAlt)\r
 915                         dwFlags |= KEYEVENTF_EXTENDEDKEY;\r
 916                 break;\r
 917 \r
 918         case VK_SHIFT:\r
 919                 if (m_bRightShift)\r
 920                         bVk = VK_RSHIFT;\r
 921                 break;\r
 922         case VK_PAUSE:\r
 923                 if (IsDown(VK_CONTROL, FALSE)) // Break\r
 924                         dwFlags |= KEYEVENTF_EXTENDEDKEY;\r
 925                 break;\r
 926         case VK_INSERT:\r
 927         case VK_DELETE:\r
 928         case VK_HOME:\r
 929         case VK_END:\r
 930         case VK_NEXT:\r
 931         case VK_PRIOR:\r
 932         case VK_UP:\r
 933         case VK_DOWN:\r
 934         case VK_RIGHT:\r
 935         case VK_LEFT:\r
 936         case VK_NUMLOCK:\r
 937         case VK_PRINT:\r
 938                 dwFlags |= KEYEVENTF_EXTENDEDKEY;\r
 939                 break;\r
 940         }\r
 941 //      CUtils::Log(_T("b: %x, %x, %x, %#hx, %#hx"), bVk, dwFlags, GetMessageExtraInfo(), GetKeyState(bVk), GetAsyncKeyState(bVk));\r
 942         keybd_event(bVk, 0, dwFlags, GetMessageExtraInfo());\r
 943 //      CUtils::Log(_T("a: %x, %x, %x, %#hx, %#hx"), bVk, dwFlags, GetMessageExtraInfo(), GetKeyState(bVk), GetAsyncKeyState(bVk));\r
 944 }\r
 945 \r
 946 void CXkeymacsDll::SetOriginal(UINT nType, BYTE bVk)\r
 947 {\r
 948         m_nOriginal[nType & ~SHIFT][bVk]++;\r
 949 }\r
 950 \r
 951 int CXkeymacsDll::CheckOriginal(UINT nType, BYTE bVk)\r
 952 {\r
 953         nType &= ~SHIFT;\r
 954         if (m_nOriginal[nType][bVk])\r
 955                 return m_nOriginal[nType][bVk]--;\r
 956         return 0;\r
 957 }\r
 958 \r
 959 UINT CXkeymacsDll::GetModifierState(BOOL bPhysicalKey)\r
 960 {\r
 961         UINT result = 0;\r
 962         if (IsDown(VK_SHIFT, bPhysicalKey))\r
 963                 result |= SHIFT;\r
 964         if (IsDown(VK_CONTROL, bPhysicalKey))\r
 965                 result |= CONTROL;\r
 966         if (IsDown(VK_MENU, bPhysicalKey))\r
 967                 result |= META;\r
 968         return result;\r
 969 }\r
 970 \r
 971 void CXkeymacsDll::SetModifierState(UINT after, UINT before)\r
 972 {\r
 973         if (after & SHIFT && !(before & SHIFT))\r
 974                 DepressKey(VK_SHIFT);\r
 975         else if (!(after & SHIFT) && before & SHIFT)\r
 976                 ReleaseKey(VK_SHIFT);\r
 977 \r
 978         if (after & CONTROL && !(before & CONTROL))\r
 979                 DepressKey(VK_CONTROL);\r
 980         else if (!(after & CONTROL) && before & CONTROL) {\r
 981                 ReleaseKey(VK_CONTROL);\r
 982                 UpdateKeyboardState(VK_CONTROL, 0);\r
 983         }\r
 984 \r
 985         BOOL bHookApp =\r
 986                 CUtils::IsVisualCpp() ||  CUtils::IsVisualStudio() ||\r
 987                 CUtils::IsInternetExplorer() || CUtils::IsFirefox() || CUtils::IsChrome();\r
 988         if (after & META && !(before & META)) {\r
 989                 if (bHookApp)\r
 990                         m_nHookAltRelease |= HOOK_ALT_LATER;\r
 991                 DepressKey(VK_MENU);\r
 992         } else if (!(after & META) && before & META) {\r
 993                 if (bHookApp)\r
 994                         ++m_nHookAltRelease;\r
 995                 ReleaseKey(VK_MENU);\r
 996         }\r
 997 }\r
 998 \r
 999 BOOL CXkeymacsDll::UpdateKeyboardState(BYTE bVk, BYTE bState)\r
1000 {\r
1001         BYTE ks[256] = {'\0'};\r
1002         if (!GetKeyboardState(ks))\r
1003                 return FALSE;\r
1004         ks[bVk] = bState;\r
1005         return SetKeyboardState(ks);\r
1006 }\r
1007 \r
1008 BOOL CXkeymacsDll::IsControl()\r
1009 {\r
1010         return CCommands::bC_() || IsDepressedModifier(CCommands::C_);\r
1011 }\r
1012 \r
1013 BOOL CXkeymacsDll::IsMeta()\r
1014 {\r
1015         return CCommands::bM_() || IsDepressedModifier(CCommands::MetaAlt);\r
1016 }\r
1017 \r
1018 BOOL CXkeymacsDll::IsDepressedModifier(int (__cdecl *Modifier)(void), BOOL bPhysicalKey)\r
1019 {\r
1020         BYTE bVk = 0;\r
1021         const BYTE *pnID = m_CurrentConfig->CmdID[NONE];\r
1022         do {\r
1023                 switch (bVk) {\r
1024                 case VK_SHIFT:\r
1025                 case VK_CONTROL:\r
1026                 case VK_MENU:\r
1027                 case 0xf0: // Eisu key. GetAsyncKeyState returns the wrong state of Eisu key.\r
1028                         continue;\r
1029                 }\r
1030                 if (IsDown(bVk, bPhysicalKey) && CmdTable::Command(pnID[bVk]) == Modifier)\r
1031                         return TRUE;\r
1032         } while (++bVk);\r
1033         return FALSE;\r
1034 }\r
1035 \r
1036 BOOL CXkeymacsDll::IsDown(BYTE bVk, BOOL bPhysicalKey)\r
1037 {\r
1038         return bPhysicalKey ? GetAsyncKeyState(bVk) < 0 : GetKeyState(bVk) < 0;\r
1039 }\r
1040 \r
1041 void CXkeymacsDll::AddKillRing(BOOL bNewData)\r
1042 {\r
1043         if (m_CurrentConfig->KillRingMax == 0) {\r
1044                 return;\r
1045         }\r
1046 \r
1047         CClipboardSnap *pSnap = new CClipboardSnap;\r
1048         if( !pSnap ) return;\r
1049 \r
1050         BOOL bCapture = pSnap->Capture();\r
1051         bCapture = pSnap->Capture();    // for "office drawing shape format". Can CClipboardSnap care this problem?\r
1052 \r
1053         if( bCapture ) {\r
1054                 if (bNewData) {\r
1055                         m_oKillRing.AddHead(pSnap);\r
1056                 } else {\r
1057                         if (m_oKillRing.IsEmpty()) {\r
1058                                 m_oKillRing.AddHead(pSnap);\r
1059                         } else {\r
1060                                 CClipboardSnap *pParent;\r
1061                                 for (pParent = m_oKillRing.GetHead(); pParent->GetNext(); pParent = pParent->GetNext()) {\r
1062                                         ;\r
1063                                 }\r
1064                                 pParent->SetNext(pSnap);\r
1065                         }\r
1066                 }\r
1067         } else {\r
1068                 delete pSnap;\r
1069                 pSnap = NULL;\r
1070         }\r
1071 \r
1072         m_nKillRing = 0;\r
1073 \r
1074         if (m_CurrentConfig->KillRingMax < m_oKillRing.GetCount()) {\r
1075                 CClipboardSnap *pSnap = m_oKillRing.GetTail();\r
1076                 delete pSnap;\r
1077                 pSnap = NULL;\r
1078                 m_oKillRing.RemoveTail();\r
1079         }\r
1080 }\r
1081 \r
1082 // Return TRUE if there is another data\r
1083 // Return FALSE if there is no more data\r
1084 CClipboardSnap* CXkeymacsDll::GetKillRing(CClipboardSnap* pSnap, BOOL bForce)\r
1085 {\r
1086         if (m_CurrentConfig->KillRingMax == 0) {\r
1087                 return NULL;\r
1088         }\r
1089 \r
1090         if (m_oKillRing.IsEmpty()) {\r
1091                 return NULL;\r
1092         }\r
1093 \r
1094         m_nKillRing %= m_oKillRing.GetCount();\r
1095 \r
1096         if (!bForce) {\r
1097                 CClipboardSnap oCurrentSnap;\r
1098                 oCurrentSnap.Capture();\r
1099 \r
1100                 CClipboardSnap *pKillRing = m_oKillRing.GetAt(m_oKillRing.FindIndex(m_nKillRing));\r
1101                 if (!pKillRing) {\r
1102                         return NULL;\r
1103                 }\r
1104                 for (; pKillRing->GetNext(); pKillRing = pKillRing->GetNext()) {\r
1105                         ;\r
1106                 }\r
1107                 if (*pKillRing != oCurrentSnap) {\r
1108                         return NULL;\r
1109                 }\r
1110         }\r
1111 \r
1112         if (!pSnap) {\r
1113                 pSnap = m_oKillRing.GetAt(m_oKillRing.FindIndex(m_nKillRing));\r
1114         }\r
1115         pSnap->Restore();\r
1116 \r
1117         return pSnap->GetNext();\r
1118 }\r
1119 \r
1120 void CXkeymacsDll::IncreaseKillRingIndex(int nKillRing)\r
1121 {\r
1122         m_nKillRing += nKillRing;\r
1123 }\r
1124 \r
1125 bool CXkeymacsDll::GetEnableCUA()\r
1126 {\r
1127         return m_CurrentConfig->EnableCUA;\r
1128 }\r
1129 \r
1130 bool CXkeymacsDll::Get326Compatible()\r
1131 {\r
1132         return m_CurrentConfig->Is326Compatible;\r
1133 }\r
1134 \r
1135 bool CXkeymacsDll::Is106Keyboard()\r
1136 {\r
1137         return m_Config.Is106Keyboard;\r
1138 }\r
1139 \r
1140 void CXkeymacsDll::SetKbMacro(KbdMacro* kbdMacro)\r
1141 {\r
1142         m_kbdMacro = kbdMacro;\r
1143 }\r
1144 \r
1145 // call an original command which is defined in dot.xkeymacs\r
1146 void CXkeymacsDll::CallFunction(int FuncID)\r
1147 {\r
1148         if (FuncID < 0 || FuncID >= MAX_FUNCTION)\r
1149                 return;\r
1150         LPCTSTR def = m_Config.FuncDef[FuncID];\r
1151         if (!def[0])\r
1152                 return;\r
1153         std::vector<KeyBind> keybinds;\r
1154         LPCTSTR last = def + _tcslen(def) - 1;\r
1155         if (*def == _T('"') && *last == _T('"')) {\r
1156                 ++def; // skip '"'\r
1157                 while (def < last)\r
1158                         keybinds.push_back(ParseKey(def));\r
1159         } else if (*def == _T('[') && *last == _T(']')) {\r
1160                 while (++def < last) { // skip '[', ']', and ' '\r
1161                         if (*def == _T('?')) { // [?f ?o ?o]\r
1162                                 keybinds.push_back(ParseKey(++def));\r
1163                                 continue;\r
1164                         }\r
1165                         // [VK]\r
1166                         for (int i = 0; i < MAX_KEYNAME; ++i) {\r
1167                                 size_t keylen = _tcslen(KeyNames[i].name);\r
1168                                 if (!_tcsncmp(def, KeyNames[i].name, keylen)) {\r
1169                                         KeyBind keybind = {NONE, KeyNames[i].bVk};\r
1170                                         keybinds.push_back(keybind);\r
1171                                         def += keylen;\r
1172                                         break;\r
1173                                 }\r
1174                         }\r
1175                 }\r
1176         } else\r
1177                 return;\r
1178 \r
1179         BOOL bM_x = FALSE;\r
1180         TCHAR szPath[MAX_PATH] = {'\0'};\r
1181         unsigned int index = 0;\r
1182         BOOL bInitialized = FALSE;\r
1183         UINT before = GetModifierState(FALSE);\r
1184 \r
1185         for (std::vector<KeyBind>::const_iterator p = keybinds.begin(); p != keybinds.end(); ++p) {\r
1186                 int nType = p->nType;\r
1187                 BYTE bVk = p->bVk;\r
1188                 int (*fCommand)() = nType < MAX_COMMAND_TYPE ? CmdTable::Command(m_CurrentConfig->CmdID[nType][bVk]) : NULL;\r
1189                 if (fCommand) {\r
1190                         if (fCommand == CCommands::ExecuteExtendedCommand)\r
1191                                 bM_x = TRUE;\r
1192                         else if (!bInitialized) {\r
1193                                 SetModifierState(0, before);\r
1194                                 bInitialized = TRUE;\r
1195                         }\r
1196 //                      CUtils::Log("CallFunction: Command Name: %s", Commands[m_CurrentConfig->CmdID[nType][bVk]].szCommandName);\r
1197                         while (fCommand() == GOTO_RECURSIVE)\r
1198                                 ;\r
1199                         continue;\r
1200                 }\r
1201                 if (bM_x) {\r
1202                         if (bVk == VK_RETURN)\r
1203                                 InvokeM_x(szPath);\r
1204                         else if (bVk != 0)\r
1205                                 szPath[index++] = static_cast<TCHAR>(ConvVkey((bVk | (nType << 8)) & 0x7ff /* drop CONTROLX */, 1));\r
1206                         continue;\r
1207                 }\r
1208                 if (!bInitialized) {\r
1209                         SetModifierState(0, before);\r
1210                         bInitialized = TRUE;\r
1211                 }\r
1212                 if (nType & WIN_WIN)\r
1213                         DepressKey(VK_LWIN);\r
1214                 if (nType & WIN_CTRL)\r
1215                         DepressKey(VK_CONTROL);\r
1216                 if (nType & WIN_ALT)\r
1217                         DepressKey(VK_MENU);\r
1218                 if (nType & SHIFT)\r
1219                         DepressKey(VK_SHIFT);\r
1220                 Kdu(bVk);\r
1221                 int nNextType = (p + 1) != keybinds.end() ? (p + 1)->nType : 0;\r
1222                 if (nType & SHIFT && !(nNextType & SHIFT))\r
1223                         ReleaseKey(VK_SHIFT);\r
1224                 if (nType & WIN_ALT && !(nNextType & WIN_ALT))\r
1225                         ReleaseKey(VK_MENU);\r
1226                 if (nType & WIN_CTRL && !(nNextType & WIN_CTRL))\r
1227                         ReleaseKey(VK_CONTROL);\r
1228                 if (nType & WIN_WIN && !(nNextType & WIN_WIN))\r
1229                         ReleaseKey(VK_LWIN);\r
1230         }\r
1231 \r
1232         if (bInitialized)\r
1233                 // If this lines is invoked on M-x, a window transition does not work well.\r
1234                 SetModifierState(before, 0);\r
1235         return;\r
1236 }\r
1237 \r
1238 KeyBind CXkeymacsDll::ParseKey(LPCTSTR& def)\r
1239 {\r
1240         KeyBind keybind = {NONE};\r
1241         if (*def == _T('\\')) { // set modifiers\r
1242                 ++def;\r
1243         LOOP:\r
1244                 for (int i = 0; i < MAX_MODIFIER; ++i) {\r
1245                         size_t len = _tcslen(Modifiers[i].name);\r
1246                         if (!_tcsncmp(def, Modifiers[i].name, len)) {\r
1247                                 keybind.nType |= Modifiers[i].id;\r
1248                                 def += len;\r
1249                                 goto LOOP;\r
1250                         }\r
1251                 }\r
1252         }\r
1253         int i = 0;\r
1254         for (; i < MAX_KEYNAME; ++i) {\r
1255                 size_t len = _tcslen(KeyNames[i].name);\r
1256                 if (!_tcsncmp(def, KeyNames[i].name, len)) {\r
1257                         def += len;\r
1258                         break;\r
1259                 }\r
1260         }\r
1261         if (i < MAX_KEYNAME) {\r
1262                 keybind.bVk = KeyNames[i].bVk;\r
1263                 return keybind;\r
1264         }\r
1265         SHORT r = ConvVkey(*def++, 0);\r
1266         if (r & (1 << 8) && !(keybind.nType & (WIN_CTRL | WIN_ALT | WIN_WIN)))\r
1267                 keybind.nType |= SHIFT;\r
1268         keybind.bVk = static_cast<BYTE>(r);\r
1269         return keybind;\r
1270 }\r
1271 \r
1272 SHORT CXkeymacsDll::ConvVkey(SHORT in, int mode)\r
1273 {\r
1274         HKL h = GetKeyboardLayout(0);\r
1275         if (mode == 0) { // ASCII to VKey and state\r
1276                 SHORT r = VkKeyScanEx(static_cast<TCHAR>(in), h);\r
1277                 if (r < 0) // no key correcpont to the char\r
1278                         return 0;\r
1279                 return r & 0x7ff; // drop state flags of Hankaku and others\r
1280         }\r
1281         // VKey and state to ASCII\r
1282         const BYTE down = 0x80;\r
1283         BYTE state[256] = {0};\r
1284         if (in & (1 << 8))\r
1285                 state[VK_SHIFT] = down;\r
1286         if (in & (2 << 8))\r
1287                 state[VK_CONTROL] = down;\r
1288         if (in & (4 << 8))\r
1289                 state[VK_MENU] = down;\r
1290         UINT vkey = in & 0xff;\r
1291         state[vkey] = down;\r
1292         WORD word = 0;\r
1293         int r = ToAsciiEx(vkey, MapVirtualKeyEx(vkey, MAPVK_VK_TO_VSC, h), state, &word, 0, h);\r
1294         if (r == 0)\r
1295                 return 0;\r
1296         if (r == 1)\r
1297                 return static_cast<SHORT>(word);\r
1298         return static_cast<SHORT>(word >> 8); // drop a dead key\r
1299 }\r
1300 \r
1301 void CXkeymacsDll::SetAccelerate(int nAccelerate)\r
1302 {\r
1303         m_nAccelerate = nAccelerate;\r
1304 }\r
1305 \r
1306 int CXkeymacsDll::GetAccelerate()\r
1307 {\r
1308         return m_nAccelerate;\r
1309 }\r
1310 \r
1311 void CXkeymacsDll::SetKeyboardSpeed(int nKeyboardSpeed)\r
1312 {\r
1313         m_nKeyboardSpeed = nKeyboardSpeed;\r
1314 }\r
1315 \r
1316 unsigned int CXkeymacsDll::GetMaxKeyInterval()\r
1317 {\r
1318         // m_nKeyboardSpeed == 0:       slowest repeat rate; approximately  2 characters per second\r
1319         // m_nKeyboardSpeed == 31:      fastest repeat rate; approximately 30 characters per second\r
1320         // 47 ms is max on my machine w/ KeyboardSpeed 31.\r
1321         // 1000 /  2 + 50 = 550\r
1322         // 1000 / 30 + 50 = 83\r
1323         return (unsigned int) (1000.0 / (2.0 + m_nKeyboardSpeed % 32 * 28.0 / 31.0) + 50.0);\r
1324 }\r
1325 \r
1326 void CXkeymacsDll::SetCursorData(HCURSOR hEnable, HCURSOR hDisableTMP, HCURSOR hDisableWOCQ, HICON hDisable, BOOL bEnable)\r
1327 {\r
1328         m_hCursor[STATUS_ENABLE] = hEnable;\r
1329         m_hCursor[STATUS_DISABLE_TMP] = hDisableTMP;\r
1330         m_hCursor[STATUS_DISABLE_WOCQ] = hDisableWOCQ;\r
1331         m_hCursor[STATUS_DISABLE] = hDisable;\r
1332         m_bCursor = bEnable;\r
1333 }\r
1334 \r
1335 void CXkeymacsDll::DoSetCursor()\r
1336 {\r
1337         if (m_bCursor && m_hCurrentCursor)\r
1338                 ::SetCursor(m_hCurrentCursor);\r
1339 }\r