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