xkeymacsdll/xkeymacsdll.cpp

   1 // xkeymacsdll.cpp : Defines the initialization routines for the DLL.\r
   2 //\r
   3 \r
   4 #include "stdafx.h"\r
   5 #include "resource.h"\r
   6 #include "Utils.h"\r
   7 #include "Commands.h"\r
   8 #include <afxdllx.h>\r
   9 #include <math.h>\r
  10 #include <Imm.h>\r
  11 \r
  12 #ifdef _DEBUG\r
  13 #define new DEBUG_NEW\r
  14 #undef THIS_FILE\r
  15 static char THIS_FILE[] = __FILE__;\r
  16 #endif\r
  17 \r
  18 struct KbdMacro\r
  19 {\r
  20         int nCode;\r
  21         WPARAM wParam;\r
  22         LPARAM lParam;\r
  23         BOOL bOriginal;\r
  24 };\r
  25 \r
  26 struct Modifier {\r
  27         LPCTSTR name;\r
  28         int id;\r
  29 };\r
  30 \r
  31 static const Modifier Modifiers[] = {\r
  32 //      { _T("A-"), ALT },\r
  33         { _T("C-"), CONTROL},\r
  34 //      { _T("H-"), HYPER },\r
  35         { _T("M-"), META },\r
  36         { _T("S-"), SHIFT },\r
  37 //      { _T("s-"), SUPER },\r
  38         { _T("Ctrl+"), WIN_CTRL },\r
  39         { _T("Alt+"), WIN_ALT },\r
  40         { _T("Win+"), WIN_WIN },\r
  41 };\r
  42 \r
  43 static const KeyName ControlCharacters[] = {\r
  44 //      { VK_LBUTTON,           _T("mouse-1") },                                // does not work well\r
  45 //      { VK_RBUTTON,           _T("mouse-3") },                                // does not work well\r
  46         { VK_CANCEL,            _T("break") },\r
  47 //      { VK_MBUTTON,           _T("mouse-2") },                                // does not work well\r
  48         { VK_BACK,                      _T("backspace") },\r
  49         { VK_TAB,                       _T("tab") },\r
  50         { VK_RETURN,            _T("return") },\r
  51         { VK_CAPITAL,           _T("capslock") },\r
  52         { VK_KANA,                      _T("kana") },\r
  53         { VK_KANJI,                     _T("kanji") },\r
  54         { VK_ESCAPE,            _T("escape") },\r
  55         { VK_CONVERT,           _T("convert") },\r
  56         { VK_NONCONVERT,        _T("nonconvert") },\r
  57 //      { VK_SPACE,                     _T("SPC") },                                    // [? ]\r
  58         { VK_PRIOR,                     _T("prior") },\r
  59         { VK_NEXT,                      _T("next") },\r
  60         { VK_END,                       _T("end") },\r
  61         { VK_HOME,                      _T("home") },\r
  62         { VK_LEFT,                      _T("left") },\r
  63         { VK_UP,                        _T("up") },\r
  64         { VK_RIGHT,                     _T("right") },\r
  65         { VK_DOWN,                      _T("down") },\r
  66         { VK_SELECT,            _T("select") },\r
  67         { VK_PRINT,                     _T("print") },\r
  68         { VK_EXECUTE,           _T("execute") },\r
  69         { VK_SNAPSHOT,          _T("printscreen") },                    // work as print\r
  70         { VK_INSERT,            _T("insert") },\r
  71         { VK_DELETE,            _T("delete") },\r
  72         { VK_LWIN,                      _T("lwindow") },\r
  73         { VK_RWIN,                      _T("rwindow") },\r
  74         { VK_APPS,                      _T("apps") },\r
  75         { VK_SLEEP,                     _T("sleep") },\r
  76         { VK_NUMPAD0,           _T("kp-0") },\r
  77         { VK_NUMPAD1,           _T("kp-1") },\r
  78         { VK_NUMPAD2,           _T("kp-2") },\r
  79         { VK_NUMPAD3,           _T("kp-3") },\r
  80         { VK_NUMPAD4,           _T("kp-4") },\r
  81         { VK_NUMPAD5,           _T("kp-5") },\r
  82         { VK_NUMPAD6,           _T("kp-6") },\r
  83         { VK_NUMPAD7,           _T("kp-7") },\r
  84         { VK_NUMPAD8,           _T("kp-8") },\r
  85         { VK_NUMPAD9,           _T("kp-9") },\r
  86         { VK_MULTIPLY,          _T("kp-multiply") },\r
  87         { VK_ADD,                       _T("kp-add") },\r
  88         { VK_SUBTRACT,          _T("kp-subtract") },\r
  89         { VK_DECIMAL,           _T("kp-decimal") },\r
  90         { VK_DIVIDE,            _T("kp-divide") },\r
  91 //      { VK_F1,                        _T("f1") },                                             // FIXME\r
  92 //      { VK_F2,                        _T("f2") },                                             // Move at the end of definition of funcgtion keys to keep away confliction f1/f2 and f1?/f2? by _tcsncmp() i.e. strncmp()\r
  93         { VK_F3,                        _T("f3") },\r
  94         { VK_F4,                        _T("f4") },\r
  95         { VK_F5,                        _T("f5") },\r
  96         { VK_F6,                        _T("f6") },\r
  97         { VK_F7,                        _T("f7") },\r
  98         { VK_F8,                        _T("f8") },\r
  99         { VK_F9,                        _T("f9") },\r
 100         { VK_F10,                       _T("f10") },\r
 101         { VK_F11,                       _T("f11") },\r
 102         { VK_F12,                       _T("f12") },\r
 103         { VK_F13,                       _T("f13") },\r
 104         { VK_F14,                       _T("f14") },\r
 105         { VK_F15,                       _T("f15") },\r
 106         { VK_F16,                       _T("f16") },\r
 107         { VK_F17,                       _T("f17") },\r
 108         { VK_F18,                       _T("f18") },\r
 109         { VK_F19,                       _T("f19") },\r
 110         { VK_F20,                       _T("f20") },\r
 111         { VK_F21,                       _T("f21") },\r
 112         { VK_F22,                       _T("f22") },\r
 113         { VK_F23,                       _T("f23") },\r
 114         { VK_F24,                       _T("f24") },\r
 115         { VK_F1,                        _T("f1") },\r
 116         { VK_F2,                        _T("f2") },\r
 117         { VK_NUMLOCK,           _T("kp-numlock") },\r
 118         { VK_SCROLL,            _T("scroll") },\r
 119         { 0xa6,                         _T("browser-back") },                   // VK_BROWSER_BACK\r
 120         { 0xa7,                         _T("browser-forward") },                // VK_BROWSER_FORWARD\r
 121         { 0xa8,                         _T("browser-refresh") },                // VK_BROWSER_REFRESH\r
 122         { 0xa9,                         _T("browser-stop") },                   // VK_BROWSER_STOP\r
 123         { 0xaa,                         _T("browser-search") },                 // VK_BROWSER_SEARCH\r
 124         { 0xab,                         _T("browser-favorites") },              // VK_BROWSER_FAVORITES\r
 125         { 0xac,                         _T("browser-home") },                   // VK_BROWSER_HOME\r
 126         { 0xad,                         _T("volume-mute") },                    // VK_VOLUME_MUTE\r
 127         { 0xae,                         _T("volume-down") },                    // VK_VOLUME_DOWN\r
 128         { 0xaf,                         _T("volume-up") },                              // VK_VOLUME_UP\r
 129         { 0xb0,                         _T("media-next-track") },               // VK_MEDIA_NEXT_TRACK\r
 130         { 0xb1,                         _T("media-prev-track") },               // VK_MEDIA_PREV_TRACK\r
 131         { 0xb2,                         _T("media-stop") },                             // VK_MEDIA_STOP\r
 132         { 0xb3,                         _T("media-play-pause") },               // VK_MEDIA_PLAY_PAUSE\r
 133         { 0xb4,                         _T("launch-mail") },                    // VK_LAUNCH_MAIL\r
 134         { 0xb5,                         _T("launch-media-select") },    // VK_LAUNCH_MEDIA_SELECT\r
 135         { 0xb6,                         _T("launch-1") },                               // VK_LAUNCH_APP1\r
 136         { 0xb7,                         _T("launch-2") },                               // VK_LAUNCH_APP2\r
 137 };\r
 138 \r
 139 static AFX_EXTENSION_MODULE XkeymacsdllDLL = { NULL, NULL };\r
 140 \r
 141 HINSTANCE g_hDllInst = NULL;\r
 142 UINT g_ImeManipulationMessage = 0;\r
 143 #pragma data_seg(".xkmcs")\r
 144 HHOOK g_hHookKeyboard = NULL;\r
 145 HHOOK g_hHookDummy = NULL;\r
 146 #pragma data_seg()\r
 147 \r
 148 inline bool IsWow64(HANDLE mod) {\r
 149         typedef BOOL (WINAPI *pfnIsWow64Process_t)(HANDLE, PBOOL);\r
 150         if (const pfnIsWow64Process_t IsWow64Process = (pfnIsWow64Process_t)GetProcAddress(GetModuleHandle(_T("kernel32")), "IsWow64Process")) {\r
 151                 BOOL b;\r
 152                 return IsWow64Process(mod, &b) && b;\r
 153         }\r
 154         return false;\r
 155 }\r
 156 \r
 157 inline bool Is64System() {\r
 158         SYSTEM_INFO info;\r
 159         GetNativeSystemInfo(&info);\r
 160         return info.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_INTEL;\r
 161 }\r
 162 \r
 163 inline bool Is64Process(HANDLE mod) {\r
 164         return Is64System() && !IsWow64(mod);\r
 165 }\r
 166 \r
 167 const bool IsDll64 = sizeof(void *) == 8;\r
 168 \r
 169 inline bool Is64ProcessHwnd(HWND hwnd) {\r
 170         DWORD pid;\r
 171         GetWindowThreadProcessId(hwnd, &pid);\r
 172         HANDLE hmod = OpenProcess(PROCESS_ALL_ACCESS, 0, pid);\r
 173         bool b = Is64Process(hmod);\r
 174         CloseHandle(hmod);\r
 175         return b;\r
 176 }\r
 177 \r
 178 extern "C" int APIENTRY\r
 179 DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)\r
 180 {\r
 181         g_hDllInst = hInstance;\r
 182         \r
 183         // Remove this if you use lpReserved\r
 184         UNREFERENCED_PARAMETER(lpReserved);\r
 185 \r
 186         switch (dwReason) {\r
 187         case DLL_PROCESS_ATTACH:\r
 188                 TRACE0("XKEYMACSDLL.DLL Initializing!\n");\r
 189                 g_ImeManipulationMessage = RegisterWindowMessage(_T("XkManipulateIME"));\r
 190 \r
 191                 // Extension DLL one-time initialization\r
 192                 if (!AfxInitExtensionModule(XkeymacsdllDLL, hInstance)) {\r
 193                         return 0;\r
 194                 }\r
 195 \r
 196                 // Insert this DLL into the resource chain\r
 197                 // NOTE: If this Extension DLL is being implicitly linked to by\r
 198                 //  an MFC Regular DLL (such as an ActiveX Control)\r
 199                 //  instead of an MFC application, then you will want to\r
 200                 //  remove this line from DllMain and put it in a separate\r
 201                 //  function exported from this Extension DLL.  The Regular DLL\r
 202                 //  that uses this Extension DLL should then explicitly call that\r
 203                 //  function to initialize this Extension DLL.  Otherwise,\r
 204                 //  the CDynLinkLibrary object will not be attached to the\r
 205                 //  Regular DLL's resource chain, and serious problems will\r
 206                 //  result.\r
 207 \r
 208                 try {\r
 209                         new CDynLinkLibrary(XkeymacsdllDLL);\r
 210                 }\r
 211                 catch (CMemoryException* e) {\r
 212                         e->Delete();\r
 213 //                      CUtils::Log("DllMain: 'new' threw an exception");\r
 214                 }\r
 215                 break;\r
 216         case DLL_PROCESS_DETACH:\r
 217                 TRACE0("XKEYMACSDLL.DLL Terminating!\n");\r
 218                 // Terminate the library before destructors are called\r
 219                 AfxTermExtensionModule(XkeymacsdllDLL);\r
 220                 break;\r
 221         }\r
 222         return 1;   // ok\r
 223 }\r
 224 \r
 225 //////////////////////////////////////////////////////////////////////\r
 226 // CXkeymacsDll Class\r
 227 //////////////////////////////////////////////////////////////////////\r
 228 \r
 229 #include "xkeymacsDll.h"\r
 230 #pragma data_seg(".xkmcs")\r
 231         BOOL    CXkeymacsDll::m_bHookAltRelease = FALSE;\r
 232         HHOOK   CXkeymacsDll::m_hHookCallWnd = NULL;\r
 233         HHOOK   CXkeymacsDll::m_hHookCallWndRet = NULL;\r
 234         HHOOK   CXkeymacsDll::m_hHookGetMessage = NULL;\r
 235         HHOOK   CXkeymacsDll::m_hHookShell = NULL;\r
 236         BOOL    CXkeymacsDll::m_bRightControl   = FALSE;\r
 237         BOOL    CXkeymacsDll::m_bRightAlt               = FALSE;\r
 238         BOOL    CXkeymacsDll::m_bRightShift             = FALSE;\r
 239         BOOL    CXkeymacsDll::m_bHook                   = TRUE;\r
 240         BOOL    CXkeymacsDll::m_bDefiningMacro  = FALSE;\r
 241         CList<CClipboardSnap *, CClipboardSnap *> CXkeymacsDll::m_oKillRing;\r
 242         CObList CXkeymacsDll::m_Macro;\r
 243         int             CXkeymacsDll::m_nKillRing = 0;\r
 244         int             CXkeymacsDll::m_nOriginal[MAX_COMMAND_TYPE][MAX_KEY] = {'\0'};\r
 245         int             CXkeymacsDll::m_nApplicationID = 0;\r
 246         int             CXkeymacsDll::m_nAccelerate = 0;\r
 247         int             CXkeymacsDll::m_nKeyboardSpeed = 31;\r
 248         HCURSOR CXkeymacsDll::m_hCursor[MAX_STATUS] = {'\0'};\r
 249         HCURSOR CXkeymacsDll::m_hCurrentCursor = NULL;\r
 250         BOOL    CXkeymacsDll::m_bCursor = FALSE;\r
 251         TCHAR   CXkeymacsDll::m_M_xTip[128] = "";\r
 252         CONFIG  CXkeymacsDll::m_Config = {0};\r
 253 #pragma data_seg()\r
 254 \r
 255 //////////////////////////////////////////////////////////////////////\r
 256 // Construction/Destruction\r
 257 //////////////////////////////////////////////////////////////////////\r
 258 \r
 259 CXkeymacsDll::CXkeymacsDll()\r
 260 {\r
 261 \r
 262 }\r
 263 \r
 264 CXkeymacsDll::~CXkeymacsDll()\r
 265 {\r
 266 \r
 267 }\r
 268 \r
 269 BOOL CXkeymacsDll::SaveConfig()\r
 270 {\r
 271         TCHAR szTmp[MAX_PATH];\r
 272         if (!GetTempPath(MAX_PATH, szTmp))\r
 273                 return FALSE;\r
 274         if (_tmakepath_s(szTmp, NULL, szTmp, _T("xkeymacs"), _T("tmp")))\r
 275                 return FALSE;\r
 276         HANDLE hFile = CreateFile(szTmp, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);\r
 277         if (hFile == INVALID_HANDLE_VALUE)\r
 278                 return FALSE;\r
 279         DWORD written;\r
 280         BOOL res = WriteFile(hFile, &m_Config, sizeof(m_Config), &written, NULL) || written != sizeof(m_Config);\r
 281         CloseHandle(hFile);\r
 282         return res;\r
 283 }\r
 284 \r
 285 BOOL CXkeymacsDll::LoadConfig()\r
 286 {\r
 287         TCHAR szTmp[MAX_PATH];\r
 288         if (!GetTempPath(MAX_PATH, szTmp))\r
 289                 return FALSE;\r
 290         if (_tmakepath_s(szTmp, NULL, szTmp, _T("xkeymacs"), _T("tmp")))\r
 291                 return FALSE;\r
 292         HANDLE hFile = CreateFile(szTmp, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);\r
 293         if (hFile == INVALID_HANDLE_VALUE)\r
 294                 return FALSE;\r
 295         DWORD read;\r
 296         BOOL res = ReadFile(hFile, &m_Config, sizeof(m_Config), &read, NULL) && read == sizeof(m_Config);\r
 297         CloseHandle(hFile);\r
 298         return res;\r
 299 }\r
 300 \r
 301 // set hooks\r
 302 LRESULT WINAPI DummyProc(int code, WPARAM wp, LPARAM lp) {\r
 303         return CallNextHookEx(0, code, wp, lp);\r
 304 }\r
 305 \r
 306 void CXkeymacsDll::SetHooks()\r
 307 {\r
 308         m_hHookCallWnd = SetWindowsHookEx(WH_CALLWNDPROC, (HOOKPROC)CallWndProc, g_hDllInst, 0);\r
 309         m_hHookCallWndRet = SetWindowsHookEx(WH_CALLWNDPROCRET, (HOOKPROC)CallWndRetProc, g_hDllInst, 0);\r
 310         m_hHookGetMessage = SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)GetMsgProc, g_hDllInst, 0);\r
 311         m_hHookShell = SetWindowsHookEx(WH_SHELL, (HOOKPROC)ShellProc, g_hDllInst, 0);\r
 312         g_hHookDummy = SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)DummyProc, g_hDllInst, 0);\r
 313         g_hHookKeyboard = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC)KeyboardProc, g_hDllInst, 0);\r
 314 }\r
 315 \r
 316 inline void unhook(HHOOK &hh) {\r
 317         if (hh)\r
 318                 UnhookWindowsHookEx(hh);\r
 319         hh = NULL;\r
 320 }\r
 321 \r
 322 void CXkeymacsDll::ResetHooks() \r
 323 {\r
 324         ReleaseHooks();\r
 325         SetHooks();\r
 326 }\r
 327 \r
 328 // release hooks\r
 329 void CXkeymacsDll::ReleaseHooks()\r
 330 {\r
 331         unhook(m_hHookCallWnd);\r
 332         unhook(m_hHookCallWndRet);\r
 333         unhook(m_hHookGetMessage);\r
 334         unhook(m_hHookShell);\r
 335         unhook(g_hHookKeyboard);\r
 336         unhook(g_hHookDummy);\r
 337 }\r
 338 \r
 339 void CXkeymacsDll::SetKeyboardHookFlag(BOOL bFlag)\r
 340 {\r
 341         m_bHook = bFlag;\r
 342         ICONMSG msg = {MAIN_ICON,};\r
 343         if (m_bHook) {\r
 344                 if (CCommands::IsTemporarilyDisableXKeymacs()) {\r
 345                         msg.nState = STATUS_DISABLE_TMP;\r
 346                         m_hCurrentCursor = m_hCursor[STATUS_DISABLE_TMP];\r
 347                 } else {\r
 348                         msg.nState = STATUS_ENABLE;\r
 349                         m_hCurrentCursor = m_hCursor[STATUS_ENABLE];\r
 350                 }\r
 351         } else {\r
 352                 msg.nState = STATUS_DISABLE_WOCQ;\r
 353         }\r
 354         if (m_Config.nSettingStyle[m_nApplicationID] == SETTING_DISABLE\r
 355          || (!_tcsicmp(m_Config.szSpecialApp[m_nApplicationID], _T("Default"))\r
 356           && CUtils::IsDefaultIgnoreApplication())) {\r
 357                 msg.nState = STATUS_DISABLE;\r
 358                 m_hCurrentCursor = m_hCursor[STATUS_DISABLE];\r
 359         }\r
 360         SendIconMessage(&msg, 1);\r
 361         DoSetCursor();\r
 362 }\r
 363 \r
 364 // if be keyboard hook, return TRUE\r
 365 BOOL CXkeymacsDll::IsKeyboardHook()\r
 366 {\r
 367         if (m_bHook) {\r
 368                 return TRUE;\r
 369         }\r
 370 \r
 371         return FALSE;\r
 372 }\r
 373 \r
 374 void CXkeymacsDll::LogCallWndProcMessage(WPARAM wParam, LPARAM lParam)\r
 375 {\r
 376         CWPSTRUCT &cwps = *(CWPSTRUCT *)lParam;\r
 377 \r
 378         switch (cwps.message) {\r
 379         case WM_PAINT:                                  // 0x000F\r
 380         case WM_MDIGETACTIVE:                   // 0x0229\r
 381         case 0x0403:\r
 382         case 0x0407:\r
 383         case 0x0418:\r
 384         case 0x043F:\r
 385         case 0x0440:\r
 386                 break;\r
 387         case WM_CREATE:                                 // 0x0001\r
 388 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_CREATE"));\r
 389                 break;\r
 390         case WM_DESTROY:                                // 0x0002\r
 391 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_DESTROY"));\r
 392                 break;\r
 393         case WM_MOVE:                                   // 0x0003\r
 394 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_MOVE");)\r
 395                 break;\r
 396         case WM_SIZE:                                   // 0x0005\r
 397 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_SIZE"));\r
 398                 break;\r
 399         case WM_GETTEXT:                                // 0x000D\r
 400 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_GETTEXT"));\r
 401                 break;\r
 402         case WM_ERASEBKGND:                             // 0x0014\r
 403 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_ERASEBKGND"));\r
 404                 break;\r
 405         case WM_WINDOWPOSCHANGING:              // 0x0046\r
 406 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_WINDOWPOSCHANGING"));\r
 407                 break;\r
 408         case WM_WINDOWPOSCHANGED:               // 0x0047\r
 409 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_WINDOWPOSCHANGED"));\r
 410                 break;\r
 411         case WM_COPYDATA:                               // 0x004A\r
 412 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_COPYDATA"));\r
 413                 break;\r
 414         case WM_NCCREATE:                               // 0x0081\r
 415 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_NCCREATE"));\r
 416                 break;\r
 417         case WM_NCDESTROY:                              // 0x0082\r
 418 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_NCDESTROY"));\r
 419                 break;\r
 420         case WM_NCCALCSIZE:                             // 0x0083\r
 421 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_NCCALCSIZE"));\r
 422                 break;\r
 423         case WM_NCPAINT:                                // 0x0085\r
 424 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_NCPAINT"));\r
 425                 break;\r
 426         case WM_IME_STARTCOMPOSITION:   // 0x010D\r
 427 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_IME_STARTCOMPOSITION"));\r
 428                 break;\r
 429         case WM_IME_ENDCOMPOSITION:             // 0x010E\r
 430 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_IME_ENDCOMPOSITION"));\r
 431                 break;\r
 432         case WM_IME_KEYLAST:                    // 0x010F\r
 433 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_IME_KEYLAST"));\r
 434                 break;\r
 435         case WM_COMMAND:                                // 0x0111\r
 436 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_COMMAND"));\r
 437                 break;\r
 438         case WM_CTLCOLOREDIT:                   // 0x0133\r
 439 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_CTLCOLOREDIT"));\r
 440                 break;\r
 441         case WM_POWERBROADCAST:                 // 0x0218\r
 442 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_POWERBROADCAST"));\r
 443                 switch (wParam) {\r
 444                 case PBT_APMQUERYSUSPEND:               // 0x0000\r
 445 //                      CUtils::Log(_T("PBT_APMQUERYSUSPEND"));\r
 446                         break;\r
 447                 case PBT_APMQUERYSTANDBY:               // 0x0001\r
 448 //                      CUtils::Log(_T("PBT_APMQUERYSTANDBY"));\r
 449                         break;\r
 450                 case PBT_APMQUERYSUSPENDFAILED: // 0x0002\r
 451 //                      CUtils::Log(_T("PBT_APMQUERYSUSPENDFAILED"));\r
 452                         break;\r
 453                 case PBT_APMQUERYSTANDBYFAILED: // 0x0003\r
 454 //                      CUtils::Log(_T("PBT_APMQUERYSTANDBYFAILED"));\r
 455                         break;\r
 456                 case PBT_APMSUSPEND:                    // 0x0004\r
 457 //                      CUtils::Log(_T("PBT_APMSUSPEND"));\r
 458                         break;\r
 459                 case PBT_APMSTANDBY:                    // 0x0005\r
 460 //                      CUtils::Log(_T("PBT_APMSTANDBY"));\r
 461                         break;\r
 462                 case PBT_APMRESUMECRITICAL:             // 0x0006\r
 463 //                      CUtils::Log(_T("PBT_APMRESUMECRITICAL"));\r
 464                         break;\r
 465                 case PBT_APMRESUMESUSPEND:              // 0x0007\r
 466 //                      CUtils::Log(_T("PBT_APMRESUMESUSPEND"));\r
 467                         break;\r
 468                 case PBT_APMRESUMESTANDBY:              // 0x0008\r
 469 //                      CUtils::Log(_T("PBT_APMRESUMESTANDBY"));\r
 470                         break;\r
 471                 case PBT_APMBATTERYLOW:                 // 0x0009\r
 472 //                      CUtils::Log(_T("PBT_APMBATTERYLOW"));\r
 473                         break;\r
 474                 case PBT_APMPOWERSTATUSCHANGE:  // 0x000A\r
 475 //                      CUtils::Log(_T("PBT_APMPOWERSTATUSCHANGE"));\r
 476                         break;\r
 477                 case PBT_APMOEMEVENT:                   // 0x000B\r
 478 //                      CUtils::Log(_T("PBT_APMOEMEVENT"));\r
 479                         break;\r
 480                 case PBT_APMRESUMEAUTOMATIC:    // 0x0012\r
 481 //                      CUtils::Log(_T("PBT_APMRESUMEAUTOMATIC"));\r
 482                         break;\r
 483                 default:\r
 484 //                      CUtils::Log(_T("PBT_OTHERS: %d"), wParam);\r
 485                         break;\r
 486                 }\r
 487                 break;\r
 488         case WM_IME_NOTIFY:                             // 0x0282\r
 489 //              CUtils::Log(_T("CallWndProc: cwps.message = WM_IME_NOTIFY"));\r
 490                 break;\r
 491         default:\r
 492 //              CUtils::Log(_T("CallWndProc: cwps.message = 0x%04X"), cwps.message);\r
 493                 break;\r
 494         }\r
 495 }\r
 496 \r
 497 LRESULT CALLBACK CXkeymacsDll::CallWndProc(int nCode, WPARAM wParam, LPARAM lParam)\r
 498 {\r
 499 //      LogCallWndProcMessage(wParam, lParam);\r
 500 \r
 501         if (0 <= nCode) {\r
 502                 CWPSTRUCT &cwps = *(CWPSTRUCT *)lParam;\r
 503                 switch (cwps.message) {\r
 504                 case WM_IME_STARTCOMPOSITION:\r
 505                         InitKeyboardProc(TRUE);\r
 506                         break;\r
 507                 case WM_IME_ENDCOMPOSITION:\r
 508                         InitKeyboardProc(FALSE);\r
 509                         break;\r
 510                 case WM_SETFOCUS:\r
 511                         if (cwps.hwnd == GetForegroundWindow()) {\r
 512                                 InitKeyboardProc(FALSE);\r
 513                                 SetKeyboardHookFlag(m_bHook);\r
 514                         }\r
 515                         break;\r
 516                 case WM_NCACTIVATE:\r
 517                         if (cwps.wParam) {\r
 518                                 if (cwps.hwnd == GetForegroundWindow()) {\r
 519                                         InitKeyboardProc(FALSE);\r
 520                                         SetKeyboardHookFlag(m_bHook);\r
 521                                 }\r
 522                         }\r
 523                         break;\r
 524                 case WM_POWERBROADCAST:\r
 525                         switch (wParam) {\r
 526                         case PBT_APMRESUMECRITICAL: // 0x0006\r
 527                         case PBT_APMRESUMESUSPEND:  // 0x0007\r
 528                         case PBT_APMRESUMESTANDBY:  // 0x0008\r
 529                                 ReleaseHooks();\r
 530                                 SetHooks();\r
 531                                 break;\r
 532                         default:\r
 533                                 break;\r
 534                         }\r
 535                         break;\r
 536                 default:\r
 537                         break;\r
 538                 }\r
 539         }\r
 540         return CallNextHookEx(m_hHookCallWnd, nCode, wParam, lParam);\r
 541 }\r
 542 \r
 543 LRESULT CALLBACK CXkeymacsDll::CallWndRetProc(int nCode, WPARAM wParam, LPARAM lParam)\r
 544 {\r
 545         if (0 <= nCode) {\r
 546                 CWPRETSTRUCT &cwprets = *(CWPRETSTRUCT *)lParam;\r
 547                 switch (cwprets.message) {\r
 548                 case WM_SETTEXT:\r
 549                         if (cwprets.hwnd == GetForegroundWindow()) {\r
 550                                 InitKeyboardProc(FALSE);\r
 551                         }\r
 552                         break;\r
 553                 case WM_SETCURSOR:\r
 554                         DoSetCursor();\r
 555                         break;\r
 556                 default:\r
 557                         break;\r
 558                 }\r
 559         }\r
 560         return CallNextHookEx(m_hHookCallWndRet, nCode, wParam, lParam);\r
 561 }\r
 562 \r
 563 LRESULT CALLBACK CXkeymacsDll::GetMsgProc(int nCode, WPARAM wParam, LPARAM lParam)\r
 564 {\r
 565         MSG &msg = (*(MSG *)lParam);\r
 566         if (msg.message == g_ImeManipulationMessage) {\r
 567                 if (wParam)\r
 568                         CCommands::DoSetInputMethodOpenStatus((INPUT_METHOD_OPEN_STATUS)msg.wParam, msg.lParam);\r
 569                 return 1;\r
 570         }\r
 571         switch (msg.message) {\r
 572         case WM_IME_STARTCOMPOSITION:\r
 573                 InitKeyboardProc(TRUE);\r
 574                 break;\r
 575         case WM_IME_ENDCOMPOSITION:\r
 576                 InitKeyboardProc(FALSE);\r
 577                 break;\r
 578         }\r
 579         return CallNextHookEx(m_hHookGetMessage, nCode, wParam, lParam);\r
 580 }\r
 581 \r
 582 LRESULT CALLBACK CXkeymacsDll::ShellProc(int nCode, WPARAM wParam, LPARAM lParam)\r
 583 {\r
 584         switch (nCode) {\r
 585         case HSHELL_WINDOWACTIVATED:\r
 586         {\r
 587                 TCHAR className[256];\r
 588                 ::GetClassName((HWND)wParam, className, 255);\r
 589                 if (!_tcsicmp(className, _T("ConsoleWindowClass"))) {\r
 590                         InitKeyboardProc(FALSE);\r
 591                         SetKeyboardHookFlag(m_bHook);\r
 592                 }\r
 593                 break;\r
 594         }\r
 595         default:\r
 596                 break;\r
 597         }\r
 598         return CallNextHookEx( m_hHookShell, nCode, wParam, lParam );\r
 599 }\r
 600 \r
 601 UINT CXkeymacsDll::GetModifierState(BOOL bPhysicalKey)\r
 602 {\r
 603         UINT result = 0;\r
 604         if (IsDown(VK_SHIFT, bPhysicalKey))\r
 605                 result |= SHIFT;\r
 606         if (IsDown(VK_CONTROL, bPhysicalKey))\r
 607                 result |= CONTROL;\r
 608         if (IsDown(VK_MENU, bPhysicalKey))\r
 609                 result |= META;\r
 610         return result;\r
 611 }\r
 612 \r
 613 void CXkeymacsDll::SetModifierState(UINT after, UINT before)\r
 614 {\r
 615         if (after & SHIFT && !(before & SHIFT))\r
 616                 DepressKey(VK_SHIFT);\r
 617         else if (!(after & SHIFT) && before & SHIFT)\r
 618                 ReleaseKey(VK_SHIFT);\r
 619 \r
 620         if (after & CONTROL && !(before & CONTROL)) {\r
 621                 UpdateKeyboardState(VK_CONTROL, 1);\r
 622                 DepressKey(VK_CONTROL);\r
 623         } else if (!(after & CONTROL) && before & CONTROL) {\r
 624                 ReleaseKey(VK_CONTROL);\r
 625                 UpdateKeyboardState(VK_CONTROL, 0);\r
 626         }\r
 627 \r
 628         if (after & META && !(before & META))\r
 629                 DepressKey(VK_MENU);\r
 630         else if (!(after & META) && before & META) {\r
 631                 if (CUtils::IsVisualStudio2010())\r
 632                         m_bHookAltRelease = TRUE;\r
 633                 ReleaseKey(VK_MENU);\r
 634         }\r
 635 }\r
 636 \r
 637 BOOL CXkeymacsDll::UpdateKeyboardState(BYTE bVk, BYTE bState)\r
 638 {\r
 639         BYTE ks[256] = {'\0'};\r
 640         if (!GetKeyboardState(ks))\r
 641                 return FALSE;\r
 642         ks[bVk] = bState;\r
 643         return SetKeyboardState(ks);\r
 644 }\r
 645 \r
 646 BOOL CXkeymacsDll::IsDown(BYTE bVk, BOOL bPhysicalKey)\r
 647 {\r
 648         return bPhysicalKey ? GetAsyncKeyState(bVk) < 0 : GetKeyState(bVk) < 0;\r
 649 }\r
 650 \r
 651 // Do keybd_event\r
 652 void CXkeymacsDll::DoKeybd_event(BYTE bVk, DWORD dwFlags)\r
 653 {\r
 654         // Set KEYEVENTF_EXTENDEDKEY if needed\r
 655         switch (bVk) {\r
 656         case VK_CONTROL:\r
 657                 if (m_bRightControl)\r
 658                         dwFlags |= KEYEVENTF_EXTENDEDKEY;\r
 659                 break;\r
 660 \r
 661         case VK_MENU:\r
 662                 if (m_bRightAlt)\r
 663                         dwFlags |= KEYEVENTF_EXTENDEDKEY;\r
 664                 break;\r
 665 \r
 666         case VK_SHIFT:\r
 667                 if (m_bRightShift) {\r
 668                         if (CUtils::IsXPorLater())\r
 669                                 bVk = VK_RSHIFT;\r
 670                         else\r
 671                                 dwFlags |= KEYEVENTF_EXTENDEDKEY;\r
 672                 }\r
 673                 break;\r
 674         case VK_PAUSE:\r
 675                 if (IsDown(VK_CONTROL, FALSE)) // Break\r
 676                         dwFlags |= KEYEVENTF_EXTENDEDKEY;\r
 677                 break;\r
 678         case VK_INSERT:\r
 679         case VK_DELETE:\r
 680         case VK_HOME:\r
 681         case VK_END:\r
 682         case VK_NEXT:\r
 683         case VK_PRIOR:\r
 684         case VK_UP:\r
 685         case VK_DOWN:\r
 686         case VK_RIGHT:\r
 687         case VK_LEFT:\r
 688         case VK_NUMLOCK:\r
 689         case VK_PRINT:\r
 690                 dwFlags |= KEYEVENTF_EXTENDEDKEY;\r
 691                 break;\r
 692         }\r
 693 //      CUtils::Log(_T("b: %x, %x, %x, %#hx, %#hx"), bVk, dwFlags, GetMessageExtraInfo(), GetKeyState(bVk), GetAsyncKeyState(bVk));\r
 694         keybd_event(bVk, 0, dwFlags, GetMessageExtraInfo());\r
 695 //      CUtils::Log(_T("a: %x, %x, %x, %#hx, %#hx"), bVk, dwFlags, GetMessageExtraInfo(), GetKeyState(bVk), GetAsyncKeyState(bVk));\r
 696 }\r
 697 \r
 698 // the key is being depressed\r
 699 void CXkeymacsDll::DepressKey(BYTE bVk, BOOL bOriginal) // bVk is virtual-key code, MSDN said\r
 700 {\r
 701         if (bOriginal) {\r
 702 //              CUtils::Log(_T("i: %x, %d, %d, %d, %d, %d, %d, %d, %d"), bVk,\r
 703 //                      IsDown(VK_CONTROL), IsDown(VK_CONTROL, FALSE), IsDepressedModifier(CCommands::C_), IsDepressedModifier(CCommands::C_, FALSE),\r
 704 //                      IsDown(VK_MENU), IsDown(VK_MENU, FALSE), IsDepressedModifier(CCommands::MetaAlt), IsDepressedModifier(CCommands::MetaAlt, FALSE));\r
 705                 Original(GetModifierState(), bVk, 1);\r
 706         }\r
 707         DoKeybd_event(bVk, 0);\r
 708 }\r
 709 \r
 710 // the key is being released\r
 711 void CXkeymacsDll::ReleaseKey(BYTE bVk) // bVk is virtual-key code, MSDN said\r
 712 {\r
 713         DoKeybd_event(bVk, KEYEVENTF_KEYUP);\r
 714 }\r
 715 \r
 716 // bVk down, bVk up\r
 717 void CXkeymacsDll::Kdu(BYTE bVk, DWORD n, BOOL bOriginal)\r
 718 {\r
 719         while (n--) {\r
 720                 DepressKey(bVk, bOriginal);\r
 721                 ReleaseKey(bVk);\r
 722         }\r
 723 }\r
 724 \r
 725 void CXkeymacsDll::InitKeyboardProc(BOOL bImeComposition)\r
 726 {\r
 727         if (CUtils::IsFindDialog()) {\r
 728                 static BOOL bImeCompositionOld = FALSE;\r
 729                 if (!bImeComposition\r
 730                  && bImeCompositionOld) {\r
 731                         DepressKey(VK_END);\r
 732                         ReleaseKey(VK_END);\r
 733                 }\r
 734                 bImeCompositionOld = bImeComposition;\r
 735         }\r
 736 \r
 737         CUtils::SetApplicationName(bImeComposition);\r
 738 \r
 739         if (_tcsnicmp(m_Config.szSpecialApp[m_nApplicationID], CUtils::GetApplicationName(), 0xF) || !IsMatchWindowText(m_Config.szWindowText[m_nApplicationID])) {     // PROCESSENTRY32 has only 0xF bytes of Name\r
 740                 m_nApplicationID = -1;\r
 741 \r
 742                 for (int nApplicationID = 0; nApplicationID < MAX_APP; ++nApplicationID) {\r
 743                         if (!_tcsnicmp(m_Config.szSpecialApp[nApplicationID], CUtils::GetApplicationName(), 0xF) && IsMatchWindowText(m_Config.szWindowText[nApplicationID])) {\r
 744 \r
 745                                 if (m_nApplicationID < 0\r
 746                                  || CUtils::GetWindowTextType(m_Config.szWindowText[m_nApplicationID]) < CUtils::GetWindowTextType(m_Config.szWindowText[nApplicationID])\r
 747                                  || CUtils::GetWindowTextType(m_Config.szWindowText[m_nApplicationID]) == CUtils::GetWindowTextType(m_Config.szWindowText[nApplicationID])\r
 748                                  && _tcscmp(m_Config.szWindowText[m_nApplicationID], m_Config.szWindowText[nApplicationID]) <= 0) {\r
 749                                         m_nApplicationID = nApplicationID;\r
 750                                 }\r
 751                         }\r
 752                 }\r
 753 \r
 754                 if (m_nApplicationID < 0) {\r
 755                         for (int nApplicationID = 0; nApplicationID < MAX_APP; ++nApplicationID) {\r
 756                                 if (!_tcsicmp(m_Config.szSpecialApp[nApplicationID], _T("Default"))) {\r
 757                                         m_nApplicationID = nApplicationID;\r
 758                                         break;\r
 759                                 }\r
 760                         }\r
 761 \r
 762                         if (m_nApplicationID < 0) {\r
 763                                 m_nApplicationID = 0;\r
 764                         }\r
 765                 }\r
 766         }\r
 767 \r
 768         if (m_Config.nSettingStyle[m_nApplicationID] != SETTING_DISABLE\r
 769          && (_tcsicmp(m_Config.szSpecialApp[m_nApplicationID], _T("Default")) || !CUtils::IsDefaultIgnoreApplication())\r
 770          && !bImeComposition\r
 771          && CUtils::IsDialog()) {\r
 772                 // Use Dialog Setting\r
 773                 if (m_Config.bUseDialogSetting[m_nApplicationID]) {\r
 774                         int nOriginalApplicationID = m_nApplicationID;\r
 775                         for (m_nApplicationID = 0; m_nApplicationID < MAX_APP; ++m_nApplicationID) {\r
 776                                 if (!_tcsicmp(m_Config.szSpecialApp[m_nApplicationID], _T("Dialog"))) {\r
 777                                         break;\r
 778                                 }\r
 779                         }\r
 780                         if (m_nApplicationID == MAX_APP) {\r
 781                                 m_nApplicationID = nOriginalApplicationID;\r
 782                         }\r
 783                 }\r
 784         }\r
 785 \r
 786         ICONMSG msg[3] = {\r
 787                 {CX_ICON, OFF_ICON, ""},\r
 788                 {MX_ICON, OFF_ICON, ""},\r
 789                 {META_ICON, OFF_ICON, ""}\r
 790         };\r
 791         SendIconMessage(msg, 3);\r
 792         CCommands::SetMark(FALSE);\r
 793         CCommands::SetTemporarilyDisableXKeymacs(FALSE);\r
 794         CCommands::Reset();\r
 795 }\r
 796 \r
 797 // emulate emacs        // cf virtual-key code\r
 798 LRESULT CALLBACK CXkeymacsDll::KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)\r
 799 {\r
 800         ASSERT(0 <= wParam && wParam <= UCHAR_MAX);\r
 801 \r
 802         int nCommandType = NONE;\r
 803         BYTE nKey = (BYTE)wParam;\r
 804 \r
 805         static BOOL bLocked = FALSE;\r
 806         static const BYTE RECURSIVE_KEY = 0x07;\r
 807         static int (*fCommand)() = NULL;\r
 808         static BYTE nOneShotModifier[MAX_KEY] = {'\0'};\r
 809         static BOOL bCherryOneShotModifier = FALSE;\r
 810 \r
 811 //      CUtils::Log(_T("nCode = %#x, nKey = %#x, lParam = %p, %d, %d"), nCode, nKey, lParam, IsDll64, Is64ProcessHwnd(GetForegroundWindow()));\r
 812 \r
 813         if (Is64ProcessHwnd(GetForegroundWindow()) != IsDll64 || CUtils::IsXkeymacs())\r
 814                 return CallNextHookEx(g_hHookKeyboard, nCode, wParam, lParam);\r
 815 \r
 816         if (nCode < 0 || nCode == HC_NOREMOVE) {\r
 817                 goto DO_NOTHING;\r
 818         }\r
 819 \r
 820         if (nKey == RECURSIVE_KEY) {\r
 821                 if (lParam & BEING_RELEASED) {\r
 822                         goto HOOK_RECURSIVE_KEY;\r
 823                 } else {\r
 824                         goto RECURSIVE_COMMAND;\r
 825                 }\r
 826         }\r
 827 \r
 828         {\r
 829                 static BOOL bShift = FALSE;\r
 830                 if (IsDepressedShiftKeyOnly(nKey)) {\r
 831                         if (lParam & BEING_RELEASED) {\r
 832                                 if (bShift) {\r
 833                                         CCommands::SetMark(FALSE);\r
 834                                 }\r
 835                         } else {\r
 836                                 bShift = TRUE;\r
 837                         }\r
 838                 } else {\r
 839                         bShift = FALSE;\r
 840                 }\r
 841         }\r
 842 \r
 843         switch (nKey) {\r
 844         case VK_CONTROL:\r
 845                 if (lParam & EXTENDED_KEY) {\r
 846                         nKey = VK_RCONTROL;\r
 847                 } else {\r
 848                         nKey = VK_LCONTROL;\r
 849                 }\r
 850                 break;\r
 851         case VK_MENU:\r
 852                 if (lParam & EXTENDED_KEY) {\r
 853                         nKey = VK_RMENU;\r
 854                 } else {\r
 855                         nKey = VK_LMENU;\r
 856                 }\r
 857                 break;\r
 858         case VK_SHIFT:\r
 859                 if (lParam & EXTENDED_KEY) {\r
 860                         nKey = VK_RSHIFT;\r
 861                 } else {\r
 862                         nKey = VK_LSHIFT;\r
 863                 }\r
 864                 break;\r
 865         default:\r
 866                 break;\r
 867         }\r
 868 \r
 869         if (lParam & BEING_RELEASED) {\r
 870                 BOOL bAlt = FALSE;\r
 871                 switch (nKey) {\r
 872                 case VK_MENU:\r
 873                 case VK_LMENU:\r
 874                 case VK_RMENU:\r
 875                         bAlt = TRUE;\r
 876                         if (m_bHookAltRelease) {\r
 877                                 m_bHookAltRelease = FALSE;\r
 878                                 goto HOOK;\r
 879                         }\r
 880                         // pass through\r
 881                 case VK_LWIN:\r
 882                 case VK_RWIN:\r
 883                 case VK_APPS:\r
 884                         for (int i = 0; i < MAX_COMMAND_TYPE; i++) {\r
 885                                 int (*func)() = Commands[m_Config.nCommandID[m_nApplicationID][i][nKey]].fCommand;\r
 886                                 if (func && !(bAlt && func == CCommands::MetaAlt))\r
 887                                         goto HOOK;\r
 888                         }\r
 889                 }\r
 890                 if (nOneShotModifier[nKey]) {\r
 891                         ReleaseKey(nOneShotModifier[nKey]);\r
 892                         nOneShotModifier[nKey] = 0;\r
 893 \r
 894                         if (bCherryOneShotModifier) {\r
 895                                 bCherryOneShotModifier = FALSE;\r
 896                                 Kdu(nKey);\r
 897                         }\r
 898                 }\r
 899                 goto DO_NOTHING;\r
 900         }\r
 901 \r
 902         if (m_Config.nSettingStyle[m_nApplicationID] == SETTING_DISABLE) {\r
 903                 goto DO_NOTHING;\r
 904         }\r
 905 \r
 906         // Do Nothing for Meadow, Mule for Win32, ... if those use default setting.\r
 907         if (!_tcsicmp(m_Config.szSpecialApp[m_nApplicationID], _T("Default"))\r
 908          && CUtils::IsDefaultIgnoreApplication()) {\r
 909                 goto DO_NOTHING;\r
 910         }\r
 911 \r
 912         switch (IsPassThrough(nKey)) {\r
 913         case GOTO_DO_NOTHING:\r
 914                 goto DO_NOTHING;\r
 915         case GOTO_HOOK:\r
 916                 goto HOOK;\r
 917         case CONTINUE:\r
 918                 break;\r
 919         default:\r
 920                 ASSERT(0);\r
 921                 break;\r
 922         }\r
 923 \r
 924         // set command type\r
 925         nCommandType = IsDown(VK_SHIFT) * SHIFT | IsControl() * CONTROL | IsMeta() * META | CCommands::bC_x() * CONTROLX;\r
 926         // Ignore undefined C-x ?\r
 927         if (nCommandType & CONTROLX) {\r
 928                 if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == NULL\r
 929                  && m_Config.nFunctionID[m_nApplicationID][nCommandType][nKey] < 0) {\r
 930                         if (m_Config.bIgnoreUndefinedC_x[m_nApplicationID]) {\r
 931                                 CCommands::Reset(GOTO_HOOK);\r
 932                                 goto HOOK;\r
 933                         }\r
 934                         nCommandType &= ~CONTROLX;\r
 935                 }\r
 936         }\r
 937         // Ignore undefined Meta Ctrl+?\r
 938         if (CCommands::bM_() && (nCommandType & CONTROL)) {\r
 939                 if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == NULL\r
 940                  && m_Config.nFunctionID[m_nApplicationID][nCommandType][nKey] < 0) {\r
 941                         if (m_Config.bIgnoreUndefinedMetaCtrl[m_nApplicationID]) {\r
 942                                 if (Original(CONTROL, nKey)) {\r
 943                                         Original(CONTROL, nKey, -1);\r
 944                                         goto DO_NOTHING;\r
 945                                 }\r
 946                                 CCommands::Reset(GOTO_HOOK);\r
 947                                 goto HOOK;\r
 948                         }\r
 949                         nCommandType &= ~META;\r
 950                 }\r
 951         }\r
 952 \r
 953         {\r
 954                 BYTE nKey = (BYTE)wParam; // VK_CONTROL is needed instead of VK_RCONTROL and VK_LCONTROL in this block just for Original()\r
 955                 int nVirtualCommandType = GetModifierState(FALSE);\r
 956                 if (nKey == VK_CONTROL)\r
 957                         nVirtualCommandType &= ~CONTROL;\r
 958                 if (nKey == VK_MENU)\r
 959                         nVirtualCommandType &= ~META;\r
 960                 if (Original(nVirtualCommandType, nKey)) {\r
 961                         Original(nVirtualCommandType, nKey, -1);\r
 962                         goto DO_NOTHING;\r
 963                 }\r
 964         }\r
 965 \r
 966         if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::EnableOrDisableXKeymacs) {\r
 967                 SetKeyboardHookFlag(!m_bHook);\r
 968                 goto HOOK;\r
 969         }\r
 970         if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::EnableXKeymacs) {\r
 971                 if (!m_bHook) {\r
 972                         SetKeyboardHookFlag(!m_bHook);\r
 973                 }\r
 974                 goto HOOK;\r
 975         }\r
 976         if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::DisableXKeymacs) {\r
 977                 if (m_bHook) {\r
 978                         SetKeyboardHookFlag(!m_bHook);\r
 979                 }\r
 980                 goto HOOK;\r
 981         }\r
 982         if (!m_bHook) {\r
 983                 goto DO_NOTHING;\r
 984         }\r
 985 \r
 986         if (CCommands::bM_x()) {\r
 987                 static unsigned int index = 0;\r
 988                 static TCHAR szPath[MAX_PATH] = {'\0'};\r
 989 \r
 990                 if (lParam & BEING_RELEASED) {\r
 991                         // ignore\r
 992                 } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::BackwardChar) {\r
 993                         if (index) {\r
 994                                 --index;\r
 995                         }\r
 996                         goto HOOKX;\r
 997                 } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::BeginningOfLine) {\r
 998                         index = 0;\r
 999                         goto HOOKX;\r
1000                 } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::DeleteBackwardChar) {\r
1001                         if (index) {\r
1002                                 --index;\r
1003                                 memmove(&szPath[index], &szPath[index + 1], _tcslen(szPath) - index);\r
1004                                 SetM_xTip(szPath);\r
1005                         }\r
1006                         goto HOOKX;\r
1007                 } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::DeleteChar) {\r
1008                         if (index < _tcslen(szPath)) {\r
1009                                 memmove(&szPath[index], &szPath[index + 1], _tcslen(szPath) - index);\r
1010                                 SetM_xTip(szPath);\r
1011                         }\r
1012                         goto HOOKX;\r
1013                 } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::EndOfLine) {\r
1014                         index = _tcslen(szPath);\r
1015                         goto HOOKX;\r
1016                 } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::ForwardChar) {\r
1017                         if (index < _tcslen(szPath)) {\r
1018                                 ++index;\r
1019                         }\r
1020                         goto HOOKX;\r
1021                 } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::KeyboardQuit) {\r
1022                         CCommands::bM_x(FALSE);\r
1023                         index = 0;\r
1024                         memset(szPath, 0, sizeof(szPath));\r
1025                         goto HOOK;\r
1026                 } else if (nKey == VK_RETURN\r
1027                                 || Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::Newline) {\r
1028                         InvokeM_x(szPath);\r
1029 \r
1030                         CCommands::bM_x(FALSE);\r
1031                         index = 0;\r
1032                         memset(szPath, 0, sizeof(szPath));\r
1033                         goto HOOK;\r
1034                 } else if (index < MAX_PATH - 1) {\r
1035                         const BOOL bIsShiftDown = IsDown(VK_SHIFT, FALSE);\r
1036                         for (TCHAR nAscii = 1; nAscii != 0; ++nAscii) { // repeat until overflow\r
1037                                 if (nKey != 0 && a2v(nAscii) == nKey && bIsShiftDown == IsShift(nAscii)) {\r
1038 //                                      CUtils::Log("M-x: %#X (%c), %#X (%c)", nKey, nKey, nAscii, nAscii);\r
1039                                         if (index < _tcslen(szPath)) {\r
1040                                                 memmove(&szPath[index + 1], &szPath[index], __min(_tcslen(szPath) - index, MAX_PATH - (index + 1) - 1));\r
1041                                         }\r
1042                                         szPath[index++] = nAscii;\r
1043 //                                      CUtils::Log("M-x: %c(%#04x)", nAscii, nAscii);\r
1044                                         SetM_xTip(szPath);\r
1045                                         goto HOOKX;\r
1046                                 }\r
1047                         }\r
1048                 }\r
1049         }\r
1050 \r
1051         if (CCommands::bC_u()) {\r
1052                 if ((nCommandType == NONE) && ('0' <= nKey) && (nKey <= '9')) {\r
1053                         CCommands::NumericArgument(nKey - '0');\r
1054                         goto HOOK0_9;\r
1055                 }\r
1056                 if ((nCommandType == NONE) && (nKey == 0xBD)) {\r
1057                         CCommands::NumericArgumentMinus();\r
1058                         goto HOOK0_9;\r
1059                 }\r
1060         }\r
1061 \r
1062         if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType & ~CONTROL][nKey]].fCommand == CCommands::OneShotModifierCtrl) {\r
1063                 nOneShotModifier[nKey] = VK_LCONTROL;\r
1064                 DepressKey(nOneShotModifier[nKey]);\r
1065                 bCherryOneShotModifier = TRUE;\r
1066                 goto HOOK;\r
1067         } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::OneShotModifierCtrlRepeat) {\r
1068                 nOneShotModifier[nKey] = VK_LCONTROL;\r
1069                 DepressKey(nOneShotModifier[nKey]);\r
1070                 bCherryOneShotModifier = TRUE;\r
1071                 goto HOOK;\r
1072         } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType & ~CONTROL][nKey]].fCommand == CCommands::OneShotModifierCtrlRepeat) {\r
1073                 ReleaseKey(nOneShotModifier[nKey]);\r
1074                 bCherryOneShotModifier = FALSE;\r
1075                 Kdu(nKey);\r
1076                 goto HOOK;\r
1077         } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType & ~META][nKey]].fCommand == CCommands::OneShotModifierAlt) {\r
1078                 nOneShotModifier[nKey] = VK_LMENU;\r
1079                 DepressKey(nOneShotModifier[nKey]);\r
1080                 bCherryOneShotModifier = TRUE;\r
1081                 goto HOOK;\r
1082         } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::OneShotModifierAltRepeat) {\r
1083                 nOneShotModifier[nKey] = VK_LMENU;\r
1084                 DepressKey(nOneShotModifier[nKey]);\r
1085                 bCherryOneShotModifier = TRUE;\r
1086                 goto HOOK;\r
1087         } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType & ~META][nKey]].fCommand == CCommands::OneShotModifierAltRepeat) {\r
1088                 ReleaseKey(nOneShotModifier[nKey]);\r
1089                 bCherryOneShotModifier = FALSE;\r
1090                 Kdu(nKey);\r
1091                 goto HOOK;\r
1092         } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType & ~SHIFT][nKey]].fCommand == CCommands::OneShotModifierShift) {\r
1093                 nOneShotModifier[nKey] = VK_SHIFT;\r
1094                 DepressKey(nOneShotModifier[nKey]);\r
1095                 bCherryOneShotModifier = TRUE;\r
1096                 goto HOOK;\r
1097         } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand == CCommands::OneShotModifierShiftRepeat) {\r
1098                 nOneShotModifier[nKey] = VK_SHIFT;\r
1099                 DepressKey(nOneShotModifier[nKey]);\r
1100                 bCherryOneShotModifier = TRUE;\r
1101                 goto HOOK;\r
1102         } else if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType & ~SHIFT][nKey]].fCommand == CCommands::OneShotModifierShiftRepeat) {\r
1103                 ReleaseKey(nOneShotModifier[nKey]);\r
1104                 bCherryOneShotModifier = FALSE;\r
1105                 Kdu(nKey);\r
1106                 goto HOOK;\r
1107         } else {\r
1108                 for (int i = 0; i < MAX_KEY; ++i) {\r
1109                         if (nOneShotModifier[i] == nKey) {\r
1110                                 break;\r
1111                         }\r
1112                 }\r
1113                 if (i == MAX_KEY) {\r
1114                         bCherryOneShotModifier = FALSE;\r
1115                 }\r
1116         }\r
1117 \r
1118         if (0 <= m_Config.nFunctionID[m_nApplicationID][nCommandType][nKey]\r
1119          && m_Config.nFunctionID[m_nApplicationID][nCommandType][nKey] < MAX_FUNCTION\r
1120          && _tcslen(m_Config.szFunctionDefinition[m_Config.nFunctionID[m_nApplicationID][nCommandType][nKey]])) {\r
1121                 CallFunction(m_Config.nFunctionID[m_nApplicationID][nCommandType][nKey]);\r
1122                 CCommands::Reset(GOTO_HOOK);\r
1123                 goto HOOK;\r
1124         }\r
1125 \r
1126         if (!Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand) {\r
1127                 if (nKey == VK_CONTROL\r
1128                  || nKey == VK_LCONTROL\r
1129                  || nKey == VK_RCONTROL\r
1130                  || nKey == VK_MENU\r
1131                  || nKey == VK_LMENU\r
1132                  || nKey == VK_RMENU\r
1133                  || nKey == VK_SHIFT\r
1134                  || nKey == VK_LSHIFT\r
1135                  || nKey == VK_RSHIFT) {\r
1136                         goto DO_NOTHING;\r
1137                 }\r
1138 \r
1139                 if (!(nCommandType & SHIFT)) {\r
1140                         if (CCommands::IsSetMark()) {\r
1141                                 if (CCommands::MoveCaret(nKey, nCommandType & CONTROL) != CONTINUE) {\r
1142                                         CCommands::ClearNumericArgument();\r
1143                                         goto HOOK;\r
1144                                 }\r
1145                                 CCommands::SetMark(FALSE);\r
1146                         }\r
1147                 }\r
1148 \r
1149                 if (1 < CCommands::GetNumericArgument()) {\r
1150                         Kdu(nKey, CCommands::GetNumericArgument());\r
1151                         CCommands::ClearNumericArgument();\r
1152                         goto HOOK;\r
1153                 }\r
1154 \r
1155                 goto DO_NOTHING;\r
1156         }\r
1157 \r
1158         if (CCommands::IsTemporarilyDisableXKeymacs()\r
1159          && Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand != CCommands::KeyboardQuit) {\r
1160                 CCommands::SetTemporarilyDisableXKeymacs(FALSE);\r
1161                 goto DO_NOTHING;\r
1162         }\r
1163 \r
1164         if (m_Config.bAtIbeamCursorOnly[m_nApplicationID][nCommandType][nKey]) {\r
1165                 CURSORINFO cursorinfo = { sizeof(cursorinfo) };\r
1166                 if (GetCursorInfo(&cursorinfo) && cursorinfo.flags && cursorinfo.hCursor != LoadCursor(NULL, IDC_IBEAM)) {\r
1167                         goto DO_NOTHING;\r
1168                 }\r
1169         }\r
1170 \r
1171         m_bRightControl = IsDown(VK_RCONTROL, FALSE);\r
1172         m_bRightAlt = IsDown(VK_RMENU, FALSE);\r
1173         m_bRightShift = IsDown(VK_RSHIFT, FALSE);\r
1174 \r
1175         if (!bLocked) {\r
1176                 bLocked = TRUE;\r
1177                 fCommand = Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][nKey]].fCommand;\r
1178 RECURSIVE_COMMAND:\r
1179                 switch (fCommand()) {\r
1180                 case GOTO_DO_NOTHING:\r
1181                         bLocked = FALSE;\r
1182                         goto DO_NOTHING;\r
1183                 case GOTO_HOOK:\r
1184                         bLocked = FALSE;\r
1185                         goto HOOK;\r
1186                 case GOTO_RECURSIVE:\r
1187                         goto RECURSIVE;\r
1188                 case GOTO_HOOKX:\r
1189                         bLocked = FALSE;\r
1190                         goto HOOKX;\r
1191                 case GOTO_HOOK0_9:\r
1192                         bLocked = FALSE;\r
1193                         goto HOOK0_9;\r
1194                 default:\r
1195                         ASSERT(0);\r
1196                         bLocked = FALSE;\r
1197                         goto DO_NOTHING;\r
1198                 }\r
1199         } else {\r
1200                 goto HOOK_RECURSIVE_KEY;\r
1201         }\r
1202 \r
1203 DO_NOTHING:\r
1204         SetModifierIcons();\r
1205         {\r
1206                 static BOOL bDefiningMacro = FALSE;\r
1207                 if (m_bDefiningMacro) {\r
1208                         static BOOL bDown[MAX_KEY] = {'\0'};\r
1209 \r
1210                         if (!bDefiningMacro) {\r
1211                                 while (m_Macro.GetHeadPosition()) {\r
1212                                         void *p = m_Macro.GetAt(m_Macro.GetHeadPosition());\r
1213                                         m_Macro.RemoveHead();\r
1214                                         delete p;\r
1215                                         p = NULL;\r
1216                                 }\r
1217                                 memset(bDown, 0, sizeof(bDown));\r
1218                         }\r
1219 \r
1220                         if ((!(lParam & BEING_RELEASED)) || bDown[wParam]) {\r
1221                                 try {\r
1222                                         KbdMacro *pKbdMacro = new KbdMacro;\r
1223                                         if (pKbdMacro) {\r
1224                                                 pKbdMacro->nCode = nCode;\r
1225                                                 pKbdMacro->wParam = wParam;\r
1226                                                 pKbdMacro->lParam = lParam;\r
1227                                                 pKbdMacro->bOriginal = TRUE;\r
1228                                                 m_Macro.AddTail((CObject *)pKbdMacro);\r
1229                                         }\r
1230                                 }\r
1231                                 catch (CMemoryException* e) {\r
1232                                         e->Delete();\r
1233 //                                      CUtils::Log("KeyboardProc: 'new' threw an exception");\r
1234                                 }\r
1235                                 if (!(lParam & BEING_RELEASED)) {\r
1236                                         bDown[wParam] = TRUE;\r
1237                                 }\r
1238                         }\r
1239                 }\r
1240                 bDefiningMacro = m_bDefiningMacro;\r
1241         }\r
1242 \r
1243         return CallNextHookEx(g_hHookKeyboard, nCode, wParam, lParam);\r
1244 \r
1245 RECURSIVE:\r
1246         Kdu(RECURSIVE_KEY, 1, FALSE);\r
1247         goto HOOKX;\r
1248 HOOK:\r
1249         CCommands::SetLastCommand(fCommand);\r
1250 HOOK0_9:\r
1251 HOOKX:\r
1252         SetModifierIcons();\r
1253 HOOK_RECURSIVE_KEY:\r
1254         return TRUE;\r
1255 }\r
1256 \r
1257 void CXkeymacsDll::SetModifierIcons()\r
1258 {\r
1259 #define IconState(x) ((x) ? ON_ICON : OFF_ICON)\r
1260         ICONMSG msg[6] = {\r
1261                 {MX_ICON, IconState(CCommands::bM_x()), ""},\r
1262                 {CX_ICON, IconState(CCommands::bC_x()), ""},\r
1263                 {META_ICON, IconState(CCommands::bM_()), ""},\r
1264                 {SHIFT_ICON, IconState(IsDown(VK_SHIFT, FALSE)), ""},\r
1265                 {CTRL_ICON, IconState(IsControl()), ""},\r
1266                 {ALT_ICON, IconState(IsDown(VK_MENU, FALSE)), ""}\r
1267         };\r
1268         _tcscpy_s(msg[0].szTip, m_M_xTip);\r
1269         SendIconMessage(msg, 6);\r
1270 }\r
1271 \r
1272 void CXkeymacsDll::SetApplicationName(int nApplicationID, CString szApplicationName)\r
1273 {\r
1274         ZeroMemory(m_Config.szSpecialApp[nApplicationID], CLASS_NAME_LENGTH);\r
1275         _tcsncpy_s(m_Config.szSpecialApp[nApplicationID], szApplicationName, _TRUNCATE);\r
1276 }\r
1277 \r
1278 void CXkeymacsDll::SetWindowText(int nApplicationID, CString szWindowText)\r
1279 {\r
1280         ZeroMemory(m_Config.szWindowText[nApplicationID], WINDOW_TEXT_LENGTH);\r
1281         _tcsncpy_s(m_Config.szWindowText[nApplicationID], szWindowText, _TRUNCATE);\r
1282 }\r
1283 \r
1284 void CXkeymacsDll::SetCommandID(int nApplicationID, int nCommandType, int nKey, int nCommandID)\r
1285 {\r
1286         m_Config.nCommandID[nApplicationID][nCommandType][nKey] = nCommandID;\r
1287 }\r
1288 \r
1289 void CXkeymacsDll::SetAtIbeamCursorOnly(int nApplicationID, int nCommandType, int nKey, BOOL bAtIbeamCursorOnly)\r
1290 {\r
1291         m_Config.bAtIbeamCursorOnly[nApplicationID][nCommandType][nKey] = bAtIbeamCursorOnly;\r
1292 }\r
1293 \r
1294 void CXkeymacsDll::SetKillRingMax(int nApplicationID, int nKillRingMax)\r
1295 {\r
1296         m_Config.nKillRingMax[nApplicationID] = nKillRingMax;\r
1297 }\r
1298 \r
1299 void CXkeymacsDll::SetUseDialogSetting(int nApplicationID, BOOL bUseDialogSetting)\r
1300 {\r
1301         m_Config.bUseDialogSetting[nApplicationID] = bUseDialogSetting;\r
1302 }\r
1303 \r
1304 // Clear data of nApplicationID\r
1305 void CXkeymacsDll::Clear(int nApplicationID)\r
1306 {\r
1307         if (0 <= nApplicationID && nApplicationID < MAX_APP) {\r
1308                 ZeroMemory(m_Config.szSpecialApp[nApplicationID], sizeof(m_Config.szSpecialApp[nApplicationID]));\r
1309                 ZeroMemory(m_Config.nCommandID[nApplicationID], sizeof(m_Config.nCommandID[nApplicationID]));\r
1310                 ZeroMemory(m_Config.bAtIbeamCursorOnly[nApplicationID], sizeof(m_Config.bAtIbeamCursorOnly[nApplicationID]));\r
1311                 m_Config.nKillRingMax[nApplicationID] = 0;\r
1312                 m_Config.bUseDialogSetting[nApplicationID] = FALSE;\r
1313                 m_Config.nSettingStyle[nApplicationID] = 0;\r
1314         } else {\r
1315                 ASSERT(0);\r
1316         }\r
1317 }\r
1318 \r
1319 BOOL CXkeymacsDll::IsValidKey(BYTE bVk)\r
1320 {\r
1321         if (bVk == 0xf0) {      // 0xf0: Eisu key. GetAsyncKeyState returns the wrong state of Eisu key.\r
1322                 return FALSE;\r
1323         }\r
1324 \r
1325         switch (bVk) {\r
1326         case VK_CONTROL:\r
1327         case VK_MENU:\r
1328         case VK_SHIFT:\r
1329                 return FALSE;\r
1330         default:\r
1331                 break;\r
1332         }\r
1333 \r
1334         return TRUE;\r
1335 }\r
1336 \r
1337 BOOL CXkeymacsDll::IsDepressedModifier(int (__cdecl *Modifier)(void), BOOL bPhysicalKey)\r
1338 {\r
1339         BYTE bVk = 0;\r
1340         do {\r
1341                 if (IsValidKey(bVk) && IsDown(bVk, bPhysicalKey) &&\r
1342                                 Commands[m_Config.nCommandID[m_nApplicationID][NONE][bVk]].fCommand == Modifier)\r
1343                         return TRUE;\r
1344         } while (++bVk);\r
1345         return FALSE;\r
1346 }\r
1347 \r
1348 BOOL CXkeymacsDll::IsDepressedShiftKeyOnly(BYTE nKey)\r
1349 {\r
1350         if (nKey != VK_SHIFT\r
1351          && nKey != VK_LSHIFT\r
1352          && nKey != VK_RSHIFT) {\r
1353                 return FALSE;\r
1354         }\r
1355 \r
1356         BYTE bVk = 0;\r
1357         do {\r
1358                 if (bVk == VK_SHIFT\r
1359                  || bVk == VK_LSHIFT\r
1360                  || bVk == VK_RSHIFT) {\r
1361                         continue;\r
1362                 }\r
1363 \r
1364                 if (IsDown(bVk, FALSE)) {\r
1365                         return FALSE;\r
1366                 }\r
1367         } while (++bVk);\r
1368         return TRUE;\r
1369 }\r
1370 \r
1371 BOOL CXkeymacsDll::IsControl()\r
1372 {\r
1373         return CCommands::bC_() || IsDepressedModifier(CCommands::C_);\r
1374 }\r
1375 \r
1376 BOOL CXkeymacsDll::IsMeta()\r
1377 {\r
1378         return CCommands::bM_() || IsDepressedModifier(CCommands::MetaAlt);\r
1379 }\r
1380 \r
1381 void CXkeymacsDll::AddKillRing(BOOL bNewData)\r
1382 {\r
1383         if (m_Config.nKillRingMax[m_nApplicationID] == 0) {\r
1384                 return;\r
1385         }\r
1386 \r
1387         CClipboardSnap *pSnap = new CClipboardSnap;\r
1388         if( !pSnap ) return;\r
1389 \r
1390         BOOL bCapture = pSnap->Capture();\r
1391         bCapture = pSnap->Capture();    // for "office drawing shape format". Can CClipboardSnap care this problem?\r
1392 \r
1393         if( bCapture ) {\r
1394                 if (bNewData) {\r
1395                         m_oKillRing.AddHead(pSnap);\r
1396                 } else {\r
1397                         if (m_oKillRing.IsEmpty()) {\r
1398                                 m_oKillRing.AddHead(pSnap);\r
1399                         } else {\r
1400                                 for (CClipboardSnap *pParent = m_oKillRing.GetHead(); pParent->GetNext(); pParent = pParent->GetNext()) {\r
1401                                         ;\r
1402                                 }\r
1403                                 pParent->SetNext(pSnap);\r
1404                         }\r
1405                 }\r
1406         } else {\r
1407                 delete pSnap;\r
1408                 pSnap = NULL;\r
1409         }\r
1410 \r
1411         m_nKillRing = 0;\r
1412 \r
1413         if (m_Config.nKillRingMax[m_nApplicationID] < m_oKillRing.GetCount()) {\r
1414                 CClipboardSnap *pSnap = m_oKillRing.GetTail();\r
1415                 delete pSnap;\r
1416                 pSnap = NULL;\r
1417                 m_oKillRing.RemoveTail();\r
1418         }\r
1419 }\r
1420 \r
1421 // Return TRUE if there is another data\r
1422 // Return FALSE if there is no more data\r
1423 CClipboardSnap* CXkeymacsDll::GetKillRing(CClipboardSnap* pSnap, BOOL bForce)\r
1424 {\r
1425         if (m_Config.nKillRingMax[m_nApplicationID] == 0) {\r
1426                 return NULL;\r
1427         }\r
1428 \r
1429         if (m_oKillRing.IsEmpty()) {\r
1430                 return NULL;\r
1431         }\r
1432 \r
1433         m_nKillRing %= m_oKillRing.GetCount();\r
1434 \r
1435         if (!bForce) {\r
1436                 CClipboardSnap oCurrentSnap;\r
1437                 oCurrentSnap.Capture();\r
1438 \r
1439                 CClipboardSnap *pKillRing = m_oKillRing.GetAt(m_oKillRing.FindIndex(m_nKillRing));\r
1440                 if (!pKillRing) {\r
1441                         return NULL;\r
1442                 }\r
1443                 for (; pKillRing->GetNext(); pKillRing = pKillRing->GetNext()) {\r
1444                         ;\r
1445                 }\r
1446                 if (*pKillRing != oCurrentSnap) {\r
1447                         return NULL;\r
1448                 }\r
1449         }\r
1450 \r
1451         if (!pSnap) {\r
1452                 pSnap = m_oKillRing.GetAt(m_oKillRing.FindIndex(m_nKillRing));\r
1453         }\r
1454         pSnap->Restore();\r
1455 \r
1456         return pSnap->GetNext();\r
1457 }\r
1458 \r
1459 void CXkeymacsDll::Original(int nCommandType, BYTE bVk, int nOriginal)\r
1460 {\r
1461         nCommandType &= ~SHIFT;\r
1462 \r
1463         switch (bVk) {\r
1464         case VK_CONTROL:\r
1465                 bVk = VK_LCONTROL;\r
1466                 break;\r
1467         case VK_MENU:\r
1468                 bVk = VK_LMENU;\r
1469                 break;\r
1470         case VK_SHIFT:\r
1471                 bVk = VK_LSHIFT;\r
1472                 break;\r
1473         default:\r
1474                 break;\r
1475         }\r
1476 \r
1477         m_nOriginal[nCommandType][bVk] += nOriginal;\r
1478 }\r
1479 \r
1480 int CXkeymacsDll::Original(int nCommandType, BYTE bVk)\r
1481 {\r
1482         nCommandType &= ~SHIFT;\r
1483 \r
1484         switch (bVk) {\r
1485         case VK_CONTROL:\r
1486                 bVk = VK_LCONTROL;\r
1487                 break;\r
1488         case VK_MENU:\r
1489                 bVk = VK_LMENU;\r
1490                 break;\r
1491         case VK_SHIFT:\r
1492                 bVk = VK_LSHIFT;\r
1493                 break;\r
1494         default:\r
1495                 break;\r
1496         }\r
1497 \r
1498         return m_nOriginal[nCommandType][bVk];\r
1499 }\r
1500 \r
1501 void CXkeymacsDll::IncreaseKillRingIndex(int nKillRing)\r
1502 {\r
1503         m_nKillRing += nKillRing;\r
1504 }\r
1505 \r
1506 // nobody use\r
1507 int CXkeymacsDll::GetMickey(int nDifferential, int nThreshold1, int nThreshold2, int nAcceleration, int nSpeed)\r
1508 {\r
1509         nDifferential = nDifferential * 10 / nSpeed;\r
1510 \r
1511         switch (nAcceleration) {\r
1512         case 2:\r
1513                 if (nThreshold2 < fabs((double)(nDifferential / 4))) {\r
1514                         nDifferential /= 4;\r
1515                         break;\r
1516                 }\r
1517                 // Do NOT write break; here.\r
1518         case 1:\r
1519                 if (nThreshold1 < fabs((double)(nDifferential / 2))) {\r
1520                         nDifferential /= 2;\r
1521                 }\r
1522                 break;\r
1523         case 0:\r
1524                 break;\r
1525         default:\r
1526                 ASSERT(0);\r
1527                 break;\r
1528         }\r
1529 \r
1530         return nDifferential;\r
1531 }\r
1532 \r
1533 void CXkeymacsDll::SetSettingStyle(int nApplicationID, int nSettingStyle)\r
1534 {\r
1535         m_Config.nSettingStyle[nApplicationID] = nSettingStyle;\r
1536 }\r
1537 \r
1538 void CXkeymacsDll::SetIgnoreUndefinedMetaCtrl(int nApplicationID, BOOL bIgnoreUndefinedMetaCtrl)\r
1539 {\r
1540         m_Config.bIgnoreUndefinedMetaCtrl[nApplicationID] = bIgnoreUndefinedMetaCtrl;\r
1541 }\r
1542 \r
1543 void CXkeymacsDll::SetIgnoreUndefinedC_x(int nApplicationID, BOOL bIgnoreUndefinedC_x)\r
1544 {\r
1545         m_Config.bIgnoreUndefinedC_x[nApplicationID] = bIgnoreUndefinedC_x;\r
1546 }\r
1547 \r
1548 void CXkeymacsDll::SetEnableCUA(int nApplicationID, BOOL bEnableCUA)\r
1549 {\r
1550         m_Config.bEnableCUA[nApplicationID] = bEnableCUA;\r
1551 }\r
1552 \r
1553 BOOL CXkeymacsDll::GetEnableCUA()\r
1554 {\r
1555         return m_Config.bEnableCUA[m_nApplicationID];\r
1556 }\r
1557 \r
1558 void CXkeymacsDll::DefiningMacro(BOOL bDefiningMacro)\r
1559 {\r
1560         m_bDefiningMacro = bDefiningMacro;\r
1561 \r
1562         if (bDefiningMacro) {   // start-kbd-macro\r
1563                 if (CCommands::bC_u()) {\r
1564                         ReleaseKey(VK_SHIFT);\r
1565                         CallMacro();\r
1566                 }\r
1567         } else {                                // end-kbd-macro\r
1568                 while (!m_Macro.IsEmpty()) {\r
1569                         KbdMacro *pKbdMacro = (KbdMacro *)m_Macro.GetTail();\r
1570                         if (pKbdMacro->lParam & BEING_RELEASED) {\r
1571                                 break;\r
1572                         } else {\r
1573                                 m_Macro.RemoveTail();\r
1574                                 delete pKbdMacro;\r
1575                                 pKbdMacro = NULL;\r
1576                         }\r
1577                 }\r
1578 \r
1579 //              CUtils::Log(_T("Macro MemMap: start"));\r
1580                 if (!m_Macro.IsEmpty()) {\r
1581                         static HANDLE hMacro = NULL;\r
1582                         if (!hMacro) {\r
1583                                 hMacro = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 0x3000, _T("macro"));\r
1584                         }\r
1585                         if (hMacro) {\r
1586 //                              CUtils::Log(_T("Macro MemMap: 1"));\r
1587                                 PVOID pView = MapViewOfFile(hMacro, FILE_MAP_ALL_ACCESS, 0, 0, 0);\r
1588 //                              CUtils::Log(_T("Macro MemMap: 2"));\r
1589                                 if (pView) {\r
1590 //                                      CUtils::Log(_T("Macro MemMap: 2.5"));\r
1591                                         for (int i = 0; i < m_Macro.GetCount(); ++i) {\r
1592 //                                              CUtils::Log(_T("Macro MemMap: 3-1 %d"), i);\r
1593                                                 KbdMacro *pKbdMacro = (KbdMacro *)m_Macro.GetAt(m_Macro.FindIndex(i));\r
1594 //                                              CUtils::Log(_T("Macro MemMap: 3-2 %d"), i);\r
1595                                                 memcpy((LPTSTR) pView + i * sizeof(KbdMacro), pKbdMacro, sizeof(KbdMacro));\r
1596 //                                              CUtils::Log(_T("Macro MemMap: 3-3 %d"), i);\r
1597                                         }\r
1598 //                                      CUtils::Log(_T("Macro MemMap: 4"));\r
1599                                         UnmapViewOfFile(pView);\r
1600 //                                      CUtils::Log(_T("Macro MemMap: 5"));\r
1601                                 } else {\r
1602 //                                      CUtils::Log(_T("Macro MemMpa: error: %d"), GetLastError());\r
1603                                 }\r
1604                         } else {\r
1605 //                              CUtils::Log(_T("Macro MemMap: 6"));\r
1606                                 ASSERT(0);\r
1607                         }\r
1608                 }\r
1609         }\r
1610 }\r
1611 \r
1612 BOOL CXkeymacsDll::DefiningMacro()\r
1613 {\r
1614         return m_bDefiningMacro;\r
1615 }\r
1616 \r
1617 /**/ \r
1618 void CXkeymacsDll::CallMacro()\r
1619 {\r
1620         UINT before = GetModifierState(FALSE);\r
1621         SetModifierState(0, before);\r
1622         for (POSITION pos = m_Macro.GetHeadPosition(); pos; ) {\r
1623                 KbdMacro *pKbdMacro = (KbdMacro *)m_Macro.GetNext(pos);\r
1624                 if (pKbdMacro->lParam & BEING_RELEASED) {\r
1625                         ReleaseKey((BYTE)pKbdMacro->wParam);\r
1626                 } else {\r
1627                         DepressKey((BYTE)pKbdMacro->wParam, pKbdMacro->bOriginal);\r
1628                 }\r
1629         }\r
1630         SetModifierState(before, 0);\r
1631 }\r
1632 \r
1633 /*\r
1634 void CXkeymacsDll::CallMacro()  // for debug\r
1635 {\r
1636         CString sz;\r
1637         for (POSITION pos = m_Macro.GetHeadPosition(); pos; ) {\r
1638                 KbdMacro_t *pKbdMacro = (KbdMacro_t *)m_Macro.GetNext(pos);\r
1639                 if (pKbdMacro->lParam & BEING_RELEASED) {\r
1640                         CString t;\r
1641                         t.Format(_T("0x%xu "), pKbdMacro->wParam);\r
1642                         sz += t;\r
1643                 } else {\r
1644                         CString t;\r
1645                         t.Format(_T("0x%xd "), pKbdMacro->wParam);\r
1646                         sz += t;\r
1647                 }\r
1648         }\r
1649 //      CUtils::Log(sz);\r
1650 }\r
1651 */\r
1652 \r
1653 void CXkeymacsDll::Set106Keyboard(BOOL b106Keyboard)\r
1654 {\r
1655         m_Config.b106Keyboard = b106Keyboard;\r
1656 }\r
1657 \r
1658 BOOL CXkeymacsDll::Is106Keyboard()\r
1659 {\r
1660         return m_Config.b106Keyboard;\r
1661 }\r
1662 \r
1663 int CXkeymacsDll::IsPassThrough(BYTE nKey)\r
1664 {\r
1665         BYTE bVk = 0;\r
1666         do {\r
1667                 if (IsDown(bVk)\r
1668                  && (Commands[m_Config.nCommandID[m_nApplicationID][NONE][bVk]].fCommand == CCommands::PassThrough)) {\r
1669                         if (bVk == nKey) {\r
1670                                 return GOTO_HOOK;\r
1671                         }\r
1672 \r
1673                         return GOTO_DO_NOTHING;\r
1674                 }\r
1675         } while (++bVk);\r
1676         return CONTINUE;\r
1677 }\r
1678 \r
1679 void CXkeymacsDll::SetKeyboardHookFlag()\r
1680 {\r
1681         SetKeyboardHookFlag(m_bHook);\r
1682 }\r
1683 \r
1684 void CXkeymacsDll::SetFunctionKey(int nFunctionID, int nApplicationID, int nCommandType, int nKey)\r
1685 {\r
1686         if (nApplicationID      < 0 || MAX_APP                  <= nApplicationID\r
1687          || nCommandType        < 0 || MAX_COMMAND_TYPE <= nCommandType\r
1688          || nKey                        < 0 || MAX_KEY                  <= nKey) {\r
1689                 return;\r
1690         }\r
1691 \r
1692         m_Config.nFunctionID[nApplicationID][nCommandType][nKey] = nFunctionID;\r
1693 }\r
1694 \r
1695 void CXkeymacsDll::ClearFunctionDefinition()\r
1696 {\r
1697         memset(m_Config.nFunctionID, -1, sizeof(m_Config.nFunctionID));\r
1698         memset(m_Config.szFunctionDefinition, 0, sizeof(m_Config.szFunctionDefinition));\r
1699 }\r
1700 \r
1701 void CXkeymacsDll::SetFunctionDefinition(int nFunctionID, CString szDefinition)\r
1702 {\r
1703         if (nFunctionID < 0 || MAX_FUNCTION <= nFunctionID) {\r
1704                 return;\r
1705         }\r
1706 \r
1707         memset(m_Config.szFunctionDefinition[nFunctionID], 0, sizeof(m_Config.szFunctionDefinition[nFunctionID]));\r
1708         _stprintf_s(m_Config.szFunctionDefinition[nFunctionID], _T("%s"), szDefinition);\r
1709 \r
1710         return;\r
1711 \r
1712 }\r
1713 \r
1714 // call an original command which is defined in dot.xkeymacs\r
1715 void CXkeymacsDll::CallFunction(int nFunctionID)\r
1716 {\r
1717         CArray<KeyBind, KeyBind> keybinds;\r
1718 \r
1719         if (nFunctionID < 0 || MAX_FUNCTION <= nFunctionID || !_tcslen(m_Config.szFunctionDefinition[nFunctionID])) {\r
1720                 return;\r
1721         }\r
1722 \r
1723         UINT before = GetModifierState(FALSE);\r
1724 \r
1725         if (m_Config.szFunctionDefinition[nFunctionID][0] == _T('"') && m_Config.szFunctionDefinition[nFunctionID][_tcslen(m_Config.szFunctionDefinition[nFunctionID]) - 1] == _T('"')) {\r
1726                 for (unsigned int i = 1; i < _tcslen(m_Config.szFunctionDefinition[nFunctionID]) - 1; ++i) {    // skip '"'\r
1727                         keybinds.Add(ParseKey(nFunctionID, i));\r
1728                 }\r
1729         } else if (m_Config.szFunctionDefinition[nFunctionID][0] == _T('[') && m_Config.szFunctionDefinition[nFunctionID][_tcslen(m_Config.szFunctionDefinition[nFunctionID]) - 1] == _T(']')) {\r
1730                 for (unsigned int i = 1; i < _tcslen(m_Config.szFunctionDefinition[nFunctionID]) - 1; ++i) {    // skip '[' and ']'\r
1731                         if (m_Config.szFunctionDefinition[nFunctionID][i] == _T('?')) { // [?f ?o ?o]\r
1732                                 ++i;\r
1733                                 keybinds.Add(ParseKey(nFunctionID, i));\r
1734                         } else {                                                                                                // [ControlCharacter]\r
1735                                 for (int nKeyID = 0; nKeyID < sizeof(ControlCharacters) / sizeof(ControlCharacters[0]); ++nKeyID) {\r
1736                                         if (!_tcsncmp(m_Config.szFunctionDefinition[nFunctionID] + i, ControlCharacters[nKeyID].name, _tcslen(ControlCharacters[nKeyID].name))) {\r
1737                                                 KeyBind keybind = {NONE, ControlCharacters[nKeyID].bVk};\r
1738                                                 keybinds.Add(keybind);\r
1739                                                 i += _tcslen(ControlCharacters[nKeyID].name);\r
1740                                                 break;\r
1741                                         }\r
1742                                 }\r
1743                         }\r
1744                 }\r
1745         } else {\r
1746                 return;\r
1747         }\r
1748 \r
1749         BOOL bM_x = FALSE;\r
1750         TCHAR szPath[MAX_PATH] = {'\0'};\r
1751         unsigned int index = 0;\r
1752         BOOL bInitialized = FALSE;\r
1753 \r
1754         for (int i = 0; i < keybinds.GetSize(); ++i) {\r
1755                 const int nCommandType = keybinds.GetAt(i).nCommandType;\r
1756                 const BYTE bVk = keybinds.GetAt(i).bVk;\r
1757 \r
1758                 if (nCommandType < MAX_COMMAND_TYPE && Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][bVk]].fCommand) {\r
1759                         if (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][bVk]].fCommand == CCommands::ExecuteExtendedCommand) {\r
1760                                 bM_x = TRUE;\r
1761                         } else if (!bInitialized) {\r
1762                                 SetModifierState(0, before);\r
1763                                 bInitialized = TRUE;\r
1764                         }\r
1765 //                      CUtils::Log("CallFunction: Command Name: %s", Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][bVk]].szCommandName);\r
1766                         while (Commands[m_Config.nCommandID[m_nApplicationID][nCommandType][bVk]].fCommand() == GOTO_RECURSIVE) {\r
1767                                 ;\r
1768                         }\r
1769                 } else if (bM_x) {\r
1770                         if (bVk == VK_RETURN) {\r
1771                                 InvokeM_x(szPath);\r
1772                         } else {\r
1773                                 for (TCHAR nAscii = 1; nAscii != 0; ++nAscii) { // repeat until overflow\r
1774                                         if (bVk != 0 && a2v(nAscii) == bVk && ((nCommandType & SHIFT) != 0) == IsShift(nAscii)) {\r
1775 //                                              CUtils::Log("M-x: %#X (%c), %#X (%c)", bVk, bVk, nAscii, nAscii);\r
1776                                                 szPath[index++] = nAscii;\r
1777                                                 break;\r
1778                                         }\r
1779                                 }\r
1780                         }\r
1781                 } else {\r
1782                         if (!bInitialized) {\r
1783                                 SetModifierState(0, before);\r
1784                                 bInitialized = TRUE;\r
1785                         }\r
1786                         if (nCommandType & WIN_WIN)\r
1787                                 DepressKey(VK_LWIN);\r
1788                         if (nCommandType & WIN_CTRL)\r
1789                                 DepressKey(VK_CONTROL);\r
1790                         if (nCommandType & WIN_ALT)\r
1791                                 DepressKey(VK_MENU);\r
1792                         if (nCommandType & SHIFT)\r
1793                                 DepressKey(VK_SHIFT);\r
1794 \r
1795                         Kdu(bVk);\r
1796 \r
1797                         if (nCommandType & SHIFT && (keybinds.GetSize() <= i + 1 || !(keybinds.GetAt(i + 1).nCommandType & SHIFT)))\r
1798                                 ReleaseKey(VK_SHIFT);\r
1799                         if (nCommandType & WIN_ALT && (keybinds.GetSize() <= i + 1 || !(keybinds.GetAt(i + 1).nCommandType & WIN_ALT)))\r
1800                                 ReleaseKey(VK_MENU);\r
1801                         if (nCommandType & WIN_CTRL && (keybinds.GetSize() <= i + 1 || !(keybinds.GetAt(i + 1).nCommandType & WIN_CTRL)))\r
1802                                 ReleaseKey(VK_CONTROL);\r
1803                         if (nCommandType & WIN_WIN && (keybinds.GetSize() <= i + 1 || !(keybinds.GetAt(i + 1).nCommandType & WIN_WIN)))\r
1804                                 ReleaseKey(VK_LWIN);\r
1805                 }\r
1806         }\r
1807 \r
1808         keybinds.RemoveAll();\r
1809 \r
1810         if (bInitialized)\r
1811                 // If these lines are invoked at M-x, a window transition does not work well.\r
1812                 SetModifierState(before, 0);\r
1813         return;\r
1814 }\r
1815 \r
1816 KeyBind CXkeymacsDll::ParseKey(const int nFunctionID, unsigned int &i)\r
1817 {\r
1818         KeyBind keybind = {NONE};\r
1819 \r
1820         if (m_Config.szFunctionDefinition[nFunctionID][i] == _T('\\')) {\r
1821                 ++i;\r
1822                 BOOL bFound = FALSE;\r
1823                 do {\r
1824                         bFound = FALSE;\r
1825                         for (int ModifierID = 0; ModifierID < sizeof(Modifiers) / sizeof(Modifiers[0]); ++ModifierID) {\r
1826                                 if (!_tcsncmp(m_Config.szFunctionDefinition[nFunctionID] + i, Modifiers[ModifierID].name, _tcslen(Modifiers[ModifierID].name))\r
1827                                  && _tcslen(Modifiers[ModifierID].name) < _tcslen(m_Config.szFunctionDefinition[nFunctionID] + i)) {\r
1828                                         keybind.nCommandType |= Modifiers[ModifierID].id;\r
1829                                         i+= _tcslen(Modifiers[ModifierID].name);\r
1830                                         bFound = TRUE;\r
1831                                 }\r
1832                         }\r
1833                 } while (bFound);\r
1834         }\r
1835         if (IsShift(m_Config.szFunctionDefinition[nFunctionID][i]) && !(keybind.nCommandType & (WIN_CTRL | WIN_ALT | WIN_WIN))) {\r
1836                 keybind.nCommandType |= SHIFT;\r
1837         }\r
1838 \r
1839         for (int nKeyID = 0; nKeyID < sizeof(ControlCharacters) / sizeof(ControlCharacters[0]); ++nKeyID) {\r
1840                 if (!_tcsncmp(m_Config.szFunctionDefinition[nFunctionID] + i, ControlCharacters[nKeyID].name, _tcslen(ControlCharacters[nKeyID].name))) {\r
1841                         i += _tcslen(ControlCharacters[nKeyID].name);\r
1842                         break;\r
1843                 }\r
1844         }\r
1845         if (nKeyID < sizeof(ControlCharacters) / sizeof(ControlCharacters[0])) {\r
1846                 keybind.bVk = ControlCharacters[nKeyID].bVk;\r
1847         } else {\r
1848                 keybind.bVk = a2v(m_Config.szFunctionDefinition[nFunctionID][i]);\r
1849         }\r
1850 \r
1851         return keybind;\r
1852 }\r
1853 \r
1854 BOOL CXkeymacsDll::IsShift(TCHAR nAscii)\r
1855 {\r
1856         switch (nAscii) {\r
1857         case _T(' '):\r
1858                 return FALSE;\r
1859         case _T('!'):\r
1860         case _T('"'):\r
1861         case _T('#'):\r
1862         case _T('$'):\r
1863         case _T('%'):\r
1864         case _T('&'):\r
1865                 return TRUE;\r
1866         case _T('\''):\r
1867                 return m_Config.b106Keyboard;\r
1868         case _T('('):\r
1869         case _T(')'):\r
1870         case _T('*'):\r
1871         case _T('+'):\r
1872                 return TRUE;\r
1873         case _T(','):\r
1874         case _T('-'):\r
1875         case _T('.'):\r
1876         case _T('/'):\r
1877         case _T('0'): case _T('1'): case _T('2'): case _T('3'): case _T('4'): case _T('5'): case _T('6'): case _T('7'): case _T('8'): case _T('9'):\r
1878                 return FALSE;\r
1879         case _T(':'):\r
1880                 return !m_Config.b106Keyboard;\r
1881         case _T(';'):\r
1882                 return FALSE;\r
1883         case _T('<'):\r
1884                 return TRUE;\r
1885         case _T('='):\r
1886                 return m_Config.b106Keyboard;\r
1887         case _T('>'):\r
1888         case _T('?'):\r
1889                 return TRUE;\r
1890         case _T('@'):\r
1891                 return !m_Config.b106Keyboard;\r
1892         case _T('A'): case _T('B'): case _T('C'): case _T('D'): case _T('E'): case _T('F'): case _T('G'): case _T('H'): case _T('I'): case _T('J'): \r
1893         case _T('K'): case _T('L'): case _T('M'): case _T('N'): case _T('O'): case _T('P'): case _T('Q'): case _T('R'): case _T('S'): case _T('T'): \r
1894         case _T('U'): case _T('V'): case _T('W'): case _T('X'): case _T('Y'): case _T('Z'): \r
1895                 return TRUE;\r
1896         case _T('['):\r
1897         case _T('\\'):\r
1898         case _T(']'):\r
1899                 return FALSE;\r
1900         case _T('^'):\r
1901                 return !m_Config.b106Keyboard;\r
1902         case _T('_'):\r
1903                 return TRUE;\r
1904         case _T('`'):\r
1905                 return m_Config.b106Keyboard;\r
1906         case _T('a'): case _T('b'): case _T('c'): case _T('d'): case _T('e'): case _T('f'): case _T('g'): case _T('h'): case _T('i'): case _T('j'): \r
1907         case _T('k'): case _T('l'): case _T('m'): case _T('n'): case _T('o'): case _T('p'): case _T('q'): case _T('r'): case _T('s'): case _T('t'): \r
1908         case _T('u'): case _T('v'): case _T('w'): case _T('x'): case _T('y'): case _T('z'): \r
1909                 return FALSE;\r
1910         case _T('{'):\r
1911         case _T('|'):\r
1912         case _T('}'):\r
1913         case _T('~'):\r
1914                 return TRUE;\r
1915         default:\r
1916                 return FALSE;\r
1917         }\r
1918 }\r
1919 \r
1920 BYTE CXkeymacsDll::a2v(TCHAR nAscii)\r
1921 {\r
1922         switch (nAscii) {\r
1923         case _T(' '):\r
1924                 return VK_SPACE;\r
1925         case _T('!'):\r
1926                 return '1';\r
1927         case _T('"'):\r
1928                 return m_Config.b106Keyboard ? '2' : (BYTE) 0xde;       // VK_OEM_7\r
1929         case _T('#'):\r
1930                 return '3';\r
1931         case _T('$'):\r
1932                 return '4';\r
1933         case _T('%'):\r
1934                 return '5';\r
1935         case _T('&'):\r
1936                 return m_Config.b106Keyboard ? '6' : '7';\r
1937         case _T('\''):\r
1938                 return m_Config.b106Keyboard ? '7' : (BYTE) 0xde;       // VK_OEM_7\r
1939         case _T('('):\r
1940                 return m_Config.b106Keyboard ? '8' : '9';\r
1941         case _T(')'):\r
1942                 return m_Config.b106Keyboard ? '9' : '0';\r
1943         case _T('*'):\r
1944                 return m_Config.b106Keyboard ? (BYTE) 0xba : '8';       // VK_OEM_1\r
1945         case _T('+'):\r
1946                 return 0xbb;    // VK_OEM_PLUS\r
1947         case _T(','):\r
1948                 return 0xbc;    // VK_OEM_COMMA\r
1949         case _T('-'):\r
1950                 return 0xbd;    // VK_OEM_MINUS\r
1951         case _T('.'):\r
1952                 return 0xbe;    // VK_OEM_PERIOD\r
1953         case _T('/'):\r
1954                 return 0xbf;    // VK_OEM_2\r
1955         case _T('0'): case _T('1'): case _T('2'): case _T('3'): case _T('4'): case _T('5'): case _T('6'): case _T('7'): case _T('8'): case _T('9'):\r
1956                 return nAscii;\r
1957         case _T(':'):\r
1958                 return 0xba;    // VK_OEM_1\r
1959         case _T(';'):\r
1960                 return m_Config.b106Keyboard ? (BYTE) 0xbb : (BYTE) 0xba;       // VK_OEM_PLUS  VK_OEM_1\r
1961         case _T('<'):\r
1962                 return 0xbc;    // VK_OEM_COMMA\r
1963         case _T('='):\r
1964                 return m_Config.b106Keyboard ? (BYTE) 0xbd : (BYTE) 0xbb;       // VK_OEM_MINUS VK_OEM_PLUS\r
1965         case _T('>'):\r
1966                 return 0xbe;    // VK_OEM_PERIOD\r
1967         case _T('?'):\r
1968                 return 0xbf;    // VK_OEM_2\r
1969         case _T('@'):\r
1970                 return m_Config.b106Keyboard ? (BYTE) 0xc0 : '2';\r
1971         case _T('A'): case _T('B'): case _T('C'): case _T('D'): case _T('E'): case _T('F'): case _T('G'): case _T('H'): case _T('I'): case _T('J'): \r
1972         case _T('K'): case _T('L'): case _T('M'): case _T('N'): case _T('O'): case _T('P'): case _T('Q'): case _T('R'): case _T('S'): case _T('T'): \r
1973         case _T('U'): case _T('V'): case _T('W'): case _T('X'): case _T('Y'): case _T('Z'): \r
1974                 return nAscii;\r
1975         case _T('['):\r
1976                 return 0xdb;    // VK_OEM_4\r
1977         case _T('\\'):\r
1978                 return 0xdc;    // VK_OEM_5\r
1979         case _T(']'):\r
1980                 return 0xdd;    // VK_OEM_6\r
1981         case _T('^'):\r
1982                 return m_Config.b106Keyboard ? (BYTE) 0xde : '6';       // VK_OEM_7\r
1983         case _T('_'):\r
1984                 return m_Config.b106Keyboard ? (BYTE) 0xe2 : (BYTE) 0xbd;       // VK_OEM_102   VK_OEM_MINUS\r
1985         case _T('`'):\r
1986                 return 0xc0;    // VK_OEM_3\r
1987         case _T('a'): case _T('b'): case _T('c'): case _T('d'): case _T('e'): case _T('f'): case _T('g'): case _T('h'): case _T('i'): case _T('j'): \r
1988         case _T('k'): case _T('l'): case _T('m'): case _T('n'): case _T('o'): case _T('p'): case _T('q'): case _T('r'): case _T('s'): case _T('t'): \r
1989         case _T('u'): case _T('v'): case _T('w'): case _T('x'): case _T('y'): case _T('z'): \r
1990                 return (BYTE) (nAscii - (_T('a') - _T('A')));\r
1991         case _T('{'):\r
1992                 return 0xdb;    // VK_OEM_4\r
1993         case _T('|'):\r
1994                 return 0xdc;    // VK_OEM_5\r
1995         case _T('}'):\r
1996                 return 0xdd;    // VK_OEM_6\r
1997         case _T('~'):\r
1998                 return m_Config.b106Keyboard ? (BYTE) 0xde : (BYTE) 0xc0;       // VK_OEM_7     VK_OEM_3\r
1999         default:\r
2000                 return 0;\r
2001         }\r
2002 }\r
2003 \r
2004 BOOL CXkeymacsDll::IsMatchWindowText(CString szWindowText)\r
2005 {\r
2006         BOOL bIsMatchWindowText = TRUE;\r
2007 \r
2008         TCHAR szCurrentWindowText[WINDOW_TEXT_LENGTH] = {'\0'};\r
2009         GetWindowText(GetForegroundWindow(), szCurrentWindowText, sizeof(szCurrentWindowText));\r
2010 \r
2011         switch (CUtils::GetWindowTextType(szWindowText)) {\r
2012         case IDS_WINDOW_TEXT_MATCH:                                                             // *foo*\r
2013                 szWindowText.Delete(0);                                                         // Delete first '*'\r
2014                 szWindowText.Delete(szWindowText.GetLength() - 1);      // Delete last '*'\r
2015                 bIsMatchWindowText = 0 <= CString(szCurrentWindowText).Find(szWindowText);\r
2016                 break;\r
2017         case IDS_WINDOW_TEXT_MATCH_FORWARD:                                             // foo*\r
2018                 szWindowText.Delete(szWindowText.GetLength() - 1);      // Delete last '*'\r
2019                 bIsMatchWindowText = 0 == CString(szCurrentWindowText).Find(szWindowText);\r
2020                 break;\r
2021         case IDS_WINDOW_TEXT_MATCH_BACKWARD:                                    // *foo\r
2022                 szWindowText.Delete(0);                                                         // Delete first '*'\r
2023                 bIsMatchWindowText = 0 <= CString(szCurrentWindowText).Find(szWindowText, CString(szCurrentWindowText).GetLength() - szWindowText.GetLength());\r
2024                 break;\r
2025         case IDS_WINDOW_TEXT_MATCH_FULL:                                                // foo\r
2026                 bIsMatchWindowText = szWindowText == CString(szCurrentWindowText);\r
2027                 break;\r
2028         case IDS_WINDOW_TEXT_IGNORE:                                                    // *\r
2029                 bIsMatchWindowText = TRUE;\r
2030                 break;\r
2031         default:\r
2032                 ASSERT(0);\r
2033                 break;\r
2034         }\r
2035 \r
2036 //      CUtils::Log(_T("IsMatchWindowText: %d, _%s_, _%s_"), bIsMatchWindowText, szCurrentWindowText, szWindowText);\r
2037         return bIsMatchWindowText;\r
2038 }\r
2039 \r
2040 void CXkeymacsDll::SetAccelerate(int nAccelerate)\r
2041 {\r
2042         m_nAccelerate = nAccelerate;\r
2043 }\r
2044 \r
2045 int CXkeymacsDll::GetAccelerate()\r
2046 {\r
2047         return m_nAccelerate;\r
2048 }\r
2049 \r
2050 void CXkeymacsDll::SetKeyboardSpeed(int nKeyboardSpeed)\r
2051 {\r
2052         m_nKeyboardSpeed = nKeyboardSpeed;\r
2053 }\r
2054 \r
2055 unsigned int CXkeymacsDll::GetMaxKeyInterval()\r
2056 {\r
2057         // m_nKeyboardSpeed == 0:       slowest repeat rate; approximately  2 characters per second\r
2058         // m_nKeyboardSpeed == 31:      fastest repeat rate; approximately 30 characters per second\r
2059         // 47 ms is max on my machine w/ KeyboardSpeed 31.\r
2060         // 1000 /  2 + 50 = 550\r
2061         // 1000 / 30 + 50 = 83\r
2062         return (unsigned int) (1000.0 / (2.0 + m_nKeyboardSpeed % 32 * 28.0 / 31.0) + 50.0);\r
2063 }\r
2064 \r
2065 void CXkeymacsDll::SetCursorData(HCURSOR hEnable, HCURSOR hDisableTMP, HCURSOR hDisableWOCQ, HICON hDisable, BOOL bEnable)\r
2066 {\r
2067         m_hCursor[STATUS_ENABLE] = hEnable;\r
2068         m_hCursor[STATUS_DISABLE_TMP] = hDisableTMP;\r
2069         m_hCursor[STATUS_DISABLE_WOCQ] = hDisableWOCQ;\r
2070         m_hCursor[STATUS_DISABLE] = hDisable;\r
2071         m_bCursor = bEnable;\r
2072 }\r
2073 \r
2074 void CXkeymacsDll::DoSetCursor()\r
2075 {\r
2076         if (m_bCursor && m_hCurrentCursor) {\r
2077                 ::SetCursor(m_hCurrentCursor);\r
2078         }\r
2079 }\r
2080 \r
2081 void CXkeymacsDll::Set326Compatible(int nApplicationID, BOOL b326Compatible)\r
2082 {\r
2083         m_Config.b326Compatible[nApplicationID] = b326Compatible;\r
2084 }\r
2085 \r
2086 BOOL CXkeymacsDll::Get326Compatible()\r
2087 {\r
2088         return m_Config.b326Compatible[m_nApplicationID];\r
2089 }\r
2090 \r
2091 void CXkeymacsDll::InvokeM_x(const TCHAR *const szPath)\r
2092 {\r
2093 //      CUtils::Log("M-x: szPath=_%s_", szPath);\r
2094         int (*fCommand)() = NULL;\r
2095 \r
2096         for (int i = 0; i < MAX_COMMAND; ++i) {\r
2097                 if (_tcsicmp(szPath, Commands[i].szCommandName) == 0) {\r
2098                         fCommand = Commands[i].fCommand;\r
2099                         break;\r
2100                 }\r
2101         }\r
2102 \r
2103         if (fCommand) {\r
2104 //              CUtils::Log("M-x: Command: _%s_", Commands[i].szCommandName);\r
2105                 fCommand();\r
2106         } else {\r
2107 //              CUtils::Log("M-x: Path: _%s_", szPath);\r
2108                 ShellExecute(NULL, NULL, szPath, NULL, NULL, SW_SHOWNORMAL);\r
2109         }\r
2110 }\r
2111 \r
2112 void CXkeymacsDll::SetM_xTip(const TCHAR *const szPath)\r
2113 {\r
2114         _tcscpy_s(m_M_xTip, "M-x LED");\r
2115         if (szPath && _tcslen(szPath) < 128 - 5)\r
2116                 _stprintf_s(m_M_xTip, "M-x %s", szPath);\r
2117 }\r
2118 \r
2119 BOOL CXkeymacsDll::SendIconMessage(ICONMSG *pMsg, DWORD num)\r
2120 {\r
2121         DWORD ack, read;\r
2122         return CallNamedPipe(ICON_PIPE, pMsg, sizeof(ICONMSG) * num, &ack, sizeof(DWORD), &read, NMPWAIT_NOWAIT);\r
2123 }\r