engine.cpp

   1 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r
   2 // engine.cpp\r
   3 \r
   4 \r
   5 #include "misc.h"\r
   6 \r
   7 #include "engine.h"\r
   8 #include "errormessage.h"\r
   9 #include "hook.h"\r
  10 #include "mayurc.h"\r
  11 #include "windowstool.h"\r
  12 \r
  13 #include <iomanip>\r
  14 \r
  15 #include <process.h>\r
  16 \r
  17 \r
  18 // check focus window\r
  19 void Engine::checkFocusWindow()\r
  20 {\r
  21         int count = 0;\r
  22 \r
  23 restart:\r
  24         count ++;\r
  25 \r
  26         HWND hwndFore = GetForegroundWindow();\r
  27         DWORD threadId = GetWindowThreadProcessId(hwndFore, NULL);\r
  28 \r
  29         if (hwndFore) {\r
  30                 {\r
  31                         Acquire a(&m_cs);\r
  32                         if (m_currentFocusOfThread &&\r
  33                                         m_currentFocusOfThread->m_threadId == threadId &&\r
  34                                         m_currentFocusOfThread->m_hwndFocus == m_hwndFocus)\r
  35                                 return;\r
  36 \r
  37                         m_emacsEditKillLine.reset();\r
  38 \r
  39                         // erase dead thread\r
  40                         if (!m_detachedThreadIds.empty()) {\r
  41                                 for (DetachedThreadIds::iterator i = m_detachedThreadIds.begin();\r
  42                                                 i != m_detachedThreadIds.end(); i ++) {\r
  43                                         FocusOfThreads::iterator j = m_focusOfThreads.find((*i));\r
  44                                         if (j != m_focusOfThreads.end()) {\r
  45                                                 FocusOfThread *fot = &((*j).second);\r
  46                                                 Acquire a(&m_log, 1);\r
  47                                                 m_log << _T("RemoveThread") << std::endl;\r
  48                                                 m_log << _T("\tHWND:\t") << std::hex << (int)fot->m_hwndFocus\r
  49                                                 << std::dec << std::endl;\r
  50                                                 m_log << _T("\tTHREADID:") << fot->m_threadId << std::endl;\r
  51                                                 m_log << _T("\tCLASS:\t") << fot->m_className << std::endl;\r
  52                                                 m_log << _T("\tTITLE:\t") << fot->m_titleName << std::endl;\r
  53                                                 m_log << std::endl;\r
  54                                                 m_focusOfThreads.erase(j);\r
  55                                         }\r
  56                                 }\r
  57                                 m_detachedThreadIds.erase\r
  58                                 (m_detachedThreadIds.begin(), m_detachedThreadIds.end());\r
  59                         }\r
  60 \r
  61                         FocusOfThreads::iterator i = m_focusOfThreads.find(threadId);\r
  62                         if (i != m_focusOfThreads.end()) {\r
  63                                 m_currentFocusOfThread = &((*i).second);\r
  64                                 if (!m_currentFocusOfThread->m_isConsole || 2 <= count) {\r
  65                                         if (m_currentFocusOfThread->m_keymaps.empty())\r
  66                                                 setCurrentKeymap(NULL);\r
  67                                         else\r
  68                                                 setCurrentKeymap(*m_currentFocusOfThread->m_keymaps.begin());\r
  69                                         m_hwndFocus = m_currentFocusOfThread->m_hwndFocus;\r
  70                                         checkShow(m_hwndFocus);\r
  71 \r
  72                                         Acquire a(&m_log, 1);\r
  73                                         m_log << _T("FocusChanged") << std::endl;\r
  74                                         m_log << _T("\tHWND:\t")\r
  75                                         << std::hex << (int)m_currentFocusOfThread->m_hwndFocus\r
  76                                         << std::dec << std::endl;\r
  77                                         m_log << _T("\tTHREADID:")\r
  78                                         << m_currentFocusOfThread->m_threadId << std::endl;\r
  79                                         m_log << _T("\tCLASS:\t")\r
  80                                         << m_currentFocusOfThread->m_className << std::endl;\r
  81                                         m_log << _T("\tTITLE:\t")\r
  82                                         << m_currentFocusOfThread->m_titleName << std::endl;\r
  83                                         m_log << std::endl;\r
  84                                         return;\r
  85                                 }\r
  86                         }\r
  87                 }\r
  88 \r
  89                 _TCHAR className[GANA_MAX_ATOM_LENGTH];\r
  90                 if (GetClassName(hwndFore, className, NUMBER_OF(className))) {\r
  91                         if (_tcsicmp(className, _T("ConsoleWindowClass")) == 0) {\r
  92                                 _TCHAR titleName[1024];\r
  93                                 if (GetWindowText(hwndFore, titleName, NUMBER_OF(titleName)) == 0)\r
  94                                         titleName[0] = _T('\0');\r
  95                                 setFocus(hwndFore, threadId, className, titleName, true);\r
  96                                 Acquire a(&m_log, 1);\r
  97                                 m_log << _T("HWND:\t") << std::hex << reinterpret_cast<int>(hwndFore)\r
  98                                 << std::dec << std::endl;\r
  99                                 m_log << _T("THREADID:") << threadId << std::endl;\r
 100                                 m_log << _T("CLASS:\t") << className << std::endl;\r
 101                                 m_log << _T("TITLE:\t") << titleName << std::endl << std::endl;\r
 102                                 goto restart;\r
 103                         }\r
 104                 }\r
 105         }\r
 106 \r
 107         Acquire a(&m_cs);\r
 108         if (m_globalFocus.m_keymaps.empty()) {\r
 109                 Acquire a(&m_log, 1);\r
 110                 m_log << _T("NO GLOBAL FOCUS") << std::endl;\r
 111                 m_currentFocusOfThread = NULL;\r
 112                 setCurrentKeymap(NULL);\r
 113         } else {\r
 114                 if (m_currentFocusOfThread != &m_globalFocus) {\r
 115                         Acquire a(&m_log, 1);\r
 116                         m_log << _T("GLOBAL FOCUS") << std::endl;\r
 117                         m_currentFocusOfThread = &m_globalFocus;\r
 118                         setCurrentKeymap(m_globalFocus.m_keymaps.front());\r
 119                 }\r
 120         }\r
 121         m_hwndFocus = NULL;\r
 122 }\r
 123 \r
 124 \r
 125 \r
 126 // is modifier pressed ?\r
 127 bool Engine::isPressed(Modifier::Type i_mt)\r
 128 {\r
 129         const Keymap::ModAssignments &ma = m_currentKeymap->getModAssignments(i_mt);\r
 130         for (Keymap::ModAssignments::const_iterator i = ma.begin();\r
 131                         i != ma.end(); ++ i)\r
 132                 if ((*i).m_key->m_isPressed)\r
 133                         return true;\r
 134         return false;\r
 135 }\r
 136 \r
 137 \r
 138 // fix modifier key (if fixed, return true)\r
 139 bool Engine::fixModifierKey(ModifiedKey *io_mkey, Keymap::AssignMode *o_am)\r
 140 {\r
 141         // for all modifier ...\r
 142         for (int i = Modifier::Type_begin; i != Modifier::Type_end; ++ i) {\r
 143                 // get modifier assignments (list of modifier keys)\r
 144                 const Keymap::ModAssignments &ma =\r
 145                         m_currentKeymap->getModAssignments(static_cast<Modifier::Type>(i));\r
 146 \r
 147                 for (Keymap::ModAssignments::const_iterator\r
 148                                 j = ma.begin(); j != ma.end(); ++ j)\r
 149                         if (io_mkey->m_key == (*j).m_key) { // is io_mkey a modifier ?\r
 150                                 {\r
 151                                         Acquire a(&m_log, 1);\r
 152                                         m_log << _T("* Modifier Key") << std::endl;\r
 153                                 }\r
 154                                 // set dontcare for this modifier\r
 155                                 io_mkey->m_modifier.dontcare(static_cast<Modifier::Type>(i));\r
 156                                 *o_am = (*j).m_assignMode;\r
 157                                 return true;\r
 158                         }\r
 159         }\r
 160         *o_am = Keymap::AM_notModifier;\r
 161         return false;\r
 162 }\r
 163 \r
 164 \r
 165 // output to m_log\r
 166 void Engine::outputToLog(const Key *i_key, const ModifiedKey &i_mkey,\r
 167                                                  int i_debugLevel)\r
 168 {\r
 169         size_t i;\r
 170         Acquire a(&m_log, i_debugLevel);\r
 171 \r
 172         // output scan codes\r
 173         for (i = 0; i < i_key->getScanCodesSize(); ++ i) {\r
 174                 if (i_key->getScanCodes()[i].m_flags & ScanCode::E0) m_log << _T("E0-");\r
 175                 if (i_key->getScanCodes()[i].m_flags & ScanCode::E1) m_log << _T("E1-");\r
 176                 if (!(i_key->getScanCodes()[i].m_flags & ScanCode::E0E1))\r
 177                         m_log << _T("   ");\r
 178                 m_log << _T("0x") << std::hex << std::setw(2) << std::setfill(_T('0'))\r
 179                 << static_cast<int>(i_key->getScanCodes()[i].m_scan)\r
 180                 << std::dec << _T(" ");\r
 181         }\r
 182 \r
 183         if (!i_mkey.m_key) { // key corresponds to no phisical key\r
 184                 m_log << std::endl;\r
 185                 return;\r
 186         }\r
 187 \r
 188         m_log << _T("  ") << i_mkey << std::endl;\r
 189 }\r
 190 \r
 191 \r
 192 // describe bindings\r
 193 void Engine::describeBindings()\r
 194 {\r
 195         Acquire a(&m_log, 0);\r
 196 \r
 197         Keymap::DescribeParam dp;\r
 198         for (KeymapPtrList::iterator i = m_currentFocusOfThread->m_keymaps.begin();\r
 199                         i != m_currentFocusOfThread->m_keymaps.end(); ++ i)\r
 200                 (*i)->describe(m_log, &dp);\r
 201         m_log << std::endl;\r
 202 }\r
 203 \r
 204 \r
 205 // update m_lastPressedKey\r
 206 void Engine::updateLastPressedKey(Key *i_key)\r
 207 {\r
 208         m_lastPressedKey[1] = m_lastPressedKey[0];\r
 209         m_lastPressedKey[0] = i_key;\r
 210 }\r
 211 \r
 212 // set current keymap\r
 213 void Engine::setCurrentKeymap(const Keymap *i_keymap, bool i_doesAddToHistory)\r
 214 {\r
 215         if (i_doesAddToHistory) {\r
 216                 m_keymapPrefixHistory.push_back(const_cast<Keymap *>(m_currentKeymap));\r
 217                 if (MAX_KEYMAP_PREFIX_HISTORY < m_keymapPrefixHistory.size())\r
 218                         m_keymapPrefixHistory.pop_front();\r
 219         } else\r
 220                 m_keymapPrefixHistory.clear();\r
 221         m_currentKeymap = i_keymap;\r
 222 }\r
 223 \r
 224 \r
 225 // get current modifiers\r
 226 Modifier Engine::getCurrentModifiers(Key *i_key, bool i_isPressed)\r
 227 {\r
 228         Modifier cmods;\r
 229         cmods.add(m_currentLock);\r
 230 \r
 231         cmods.press(Modifier::Type_Shift  , isPressed(Modifier::Type_Shift  ));\r
 232         cmods.press(Modifier::Type_Alt    , isPressed(Modifier::Type_Alt    ));\r
 233         cmods.press(Modifier::Type_Control, isPressed(Modifier::Type_Control));\r
 234         cmods.press(Modifier::Type_Windows, isPressed(Modifier::Type_Windows));\r
 235         cmods.press(Modifier::Type_Up     , !i_isPressed);\r
 236         cmods.press(Modifier::Type_Down   , i_isPressed);\r
 237 \r
 238         cmods.press(Modifier::Type_Repeat , false);\r
 239         if (m_lastPressedKey[0] == i_key) {\r
 240                 if (i_isPressed)\r
 241                         cmods.press(Modifier::Type_Repeat, true);\r
 242                 else\r
 243                         if (m_lastPressedKey[1] == i_key)\r
 244                                 cmods.press(Modifier::Type_Repeat, true);\r
 245         }\r
 246 \r
 247         for (int i = Modifier::Type_Mod0; i <= Modifier::Type_Mod9; ++ i)\r
 248                 cmods.press(static_cast<Modifier::Type>(i),\r
 249                                         isPressed(static_cast<Modifier::Type>(i)));\r
 250 \r
 251         return cmods;\r
 252 }\r
 253 \r
 254 \r
 255 // generate keyboard event for a key\r
 256 void Engine::generateKeyEvent(Key *i_key, bool i_doPress, bool i_isByAssign)\r
 257 {\r
 258         // check if key is event\r
 259         bool isEvent = false;\r
 260         for (Key **e = Event::events; *e; ++ e)\r
 261                 if (*e == i_key) {\r
 262                         isEvent = true;\r
 263                         break;\r
 264                 }\r
 265 \r
 266         bool isAlreadyReleased = false;\r
 267 \r
 268         if (!isEvent) {\r
 269                 if (i_doPress && !i_key->m_isPressedOnWin32)\r
 270                         ++ m_currentKeyPressCountOnWin32;\r
 271                 else if (!i_doPress) {\r
 272                         if (i_key->m_isPressedOnWin32)\r
 273                                 -- m_currentKeyPressCountOnWin32;\r
 274                         else\r
 275                                 isAlreadyReleased = true;\r
 276                 }\r
 277                 i_key->m_isPressedOnWin32 = i_doPress;\r
 278 \r
 279                 if (i_isByAssign)\r
 280                         i_key->m_isPressedByAssign = i_doPress;\r
 281 \r
 282                 Key *sync = m_setting->m_keyboard.getSyncKey();\r
 283 \r
 284                 if (!isAlreadyReleased || i_key == sync) {\r
 285                         KEYBOARD_INPUT_DATA kid = { 0, 0, 0, 0, 0 };\r
 286                         const ScanCode *sc = i_key->getScanCodes();\r
 287                         for (size_t i = 0; i < i_key->getScanCodesSize(); ++ i) {\r
 288                                 kid.MakeCode = sc[i].m_scan;\r
 289                                 kid.Flags = sc[i].m_flags;\r
 290                                 if (!i_doPress)\r
 291                                         kid.Flags |= KEYBOARD_INPUT_DATA::BREAK;\r
 292 #ifdef NO_DRIVER\r
 293                                 injectInput(&kid, NULL);\r
 294 #else // !NO_DRIVER\r
 295                                 DWORD len;\r
 296                                 WriteFile(m_device, &kid, sizeof(kid), &len, &m_ol);\r
 297                                 CHECK_TRUE( GetOverlappedResult(m_device, &m_ol, &len, TRUE) );\r
 298 #endif // !NO_DRIVER\r
 299                         }\r
 300 \r
 301                         m_lastGeneratedKey = i_doPress ? i_key : NULL;\r
 302                 }\r
 303         }\r
 304 \r
 305         {\r
 306                 Acquire a(&m_log, 1);\r
 307                 m_log << _T("\t\t    =>\t");\r
 308                 if (isAlreadyReleased)\r
 309                         m_log << _T("(already released) ");\r
 310         }\r
 311         ModifiedKey mkey(i_key);\r
 312         mkey.m_modifier.on(Modifier::Type_Up, !i_doPress);\r
 313         mkey.m_modifier.on(Modifier::Type_Down, i_doPress);\r
 314         outputToLog(i_key, mkey, 1);\r
 315 }\r
 316 \r
 317 \r
 318 // genete event\r
 319 void Engine::generateEvents(Current i_c, const Keymap *i_keymap, Key *i_event)\r
 320 {\r
 321         // generate\r
 322         i_c.m_keymap = i_keymap;\r
 323         i_c.m_mkey.m_key = i_event;\r
 324         if (const Keymap::KeyAssignment *keyAssign =\r
 325                                 i_c.m_keymap->searchAssignment(i_c.m_mkey)) {\r
 326                 {\r
 327                         Acquire a(&m_log, 1);\r
 328                         m_log << std::endl << _T("           ")\r
 329                         << i_event->getName() << std::endl;\r
 330                 }\r
 331                 generateKeySeqEvents(i_c, keyAssign->m_keySeq, Part_all);\r
 332         }\r
 333 }\r
 334 \r
 335 \r
 336 // genete modifier events\r
 337 void Engine::generateModifierEvents(const Modifier &i_mod)\r
 338 {\r
 339         {\r
 340                 Acquire a(&m_log, 1);\r
 341                 m_log << _T("* Gen Modifiers\t{") << std::endl;\r
 342         }\r
 343 \r
 344         for (int i = Modifier::Type_begin; i < Modifier::Type_BASIC; ++ i) {\r
 345                 Keyboard::Mods &mods =\r
 346                         m_setting->m_keyboard.getModifiers(static_cast<Modifier::Type>(i));\r
 347 \r
 348                 if (i_mod.isDontcare(static_cast<Modifier::Type>(i)))\r
 349                         // no need to process\r
 350                         ;\r
 351                 else if (i_mod.isPressed(static_cast<Modifier::Type>(i)))\r
 352                         // we have to press this modifier\r
 353                 {\r
 354                         bool noneIsPressed = true;\r
 355                         bool noneIsPressedByAssign = true;\r
 356                         for (Keyboard::Mods::iterator i = mods.begin(); i != mods.end(); ++ i) {\r
 357                                 if ((*i)->m_isPressedOnWin32)\r
 358                                         noneIsPressed = false;\r
 359                                 if ((*i)->m_isPressedByAssign)\r
 360                                         noneIsPressedByAssign = false;\r
 361                         }\r
 362                         if (noneIsPressed) {\r
 363                                 if (noneIsPressedByAssign)\r
 364                                         generateKeyEvent(mods.front(), true, false);\r
 365                                 else\r
 366                                         for (Keyboard::Mods::iterator\r
 367                                                         i = mods.begin(); i != mods.end(); ++ i)\r
 368                                                 if ((*i)->m_isPressedByAssign)\r
 369                                                         generateKeyEvent((*i), true, false);\r
 370                         }\r
 371                 }\r
 372 \r
 373                 else\r
 374                         // we have to release this modifier\r
 375                 {\r
 376                         // avoid such sequences as  "Alt U-ALt" or "Windows U-Windows"\r
 377                         if (i == Modifier::Type_Alt || i == Modifier::Type_Windows) {\r
 378                                 for (Keyboard::Mods::iterator j = mods.begin(); j != mods.end(); ++ j)\r
 379                                         if ((*j) == m_lastGeneratedKey) {\r
 380                                                 Keyboard::Mods *mods =\r
 381                                                         &m_setting->m_keyboard.getModifiers(Modifier::Type_Shift);\r
 382                                                 if (mods->size() == 0)\r
 383                                                         mods = &m_setting->m_keyboard.getModifiers(\r
 384                                                                            Modifier::Type_Control);\r
 385                                                 if (0 < mods->size()) {\r
 386                                                         generateKeyEvent(mods->front(), true, false);\r
 387                                                         generateKeyEvent(mods->front(), false, false);\r
 388                                                 }\r
 389                                                 break;\r
 390                                         }\r
 391                         }\r
 392 \r
 393                         for (Keyboard::Mods::iterator j = mods.begin(); j != mods.end(); ++ j) {\r
 394                                 if ((*j)->m_isPressedOnWin32)\r
 395                                         generateKeyEvent((*j), false, false);\r
 396                         }\r
 397                 }\r
 398         }\r
 399 \r
 400         {\r
 401                 Acquire a(&m_log, 1);\r
 402                 m_log << _T("\t\t}") << std::endl;\r
 403         }\r
 404 }\r
 405 \r
 406 \r
 407 // generate keyboard events for action\r
 408 void Engine::generateActionEvents(const Current &i_c, const Action *i_a,\r
 409                                                                   bool i_doPress)\r
 410 {\r
 411         switch (i_a->getType()) {\r
 412                 // key\r
 413         case Action::Type_key: {\r
 414                 const ModifiedKey &mkey\r
 415                 = reinterpret_cast<ActionKey *>(\r
 416                           const_cast<Action *>(i_a))->m_modifiedKey;\r
 417 \r
 418                 // release\r
 419                 if (!i_doPress &&\r
 420                                 (mkey.m_modifier.isOn(Modifier::Type_Up) ||\r
 421                                  mkey.m_modifier.isDontcare(Modifier::Type_Up)))\r
 422                         generateKeyEvent(mkey.m_key, false, true);\r
 423 \r
 424                 // press\r
 425                 else if (i_doPress &&\r
 426                                  (mkey.m_modifier.isOn(Modifier::Type_Down) ||\r
 427                                   mkey.m_modifier.isDontcare(Modifier::Type_Down))) {\r
 428                         Modifier modifier = mkey.m_modifier;\r
 429                         modifier.add(i_c.m_mkey.m_modifier);\r
 430                         generateModifierEvents(modifier);\r
 431                         generateKeyEvent(mkey.m_key, true, true);\r
 432                 }\r
 433                 break;\r
 434         }\r
 435 \r
 436         // keyseq\r
 437         case Action::Type_keySeq: {\r
 438                 const ActionKeySeq *aks = reinterpret_cast<const ActionKeySeq *>(i_a);\r
 439                 generateKeySeqEvents(i_c, aks->m_keySeq,\r
 440                                                          i_doPress ? Part_down : Part_up);\r
 441                 break;\r
 442         }\r
 443 \r
 444         // function\r
 445         case Action::Type_function: {\r
 446                 const ActionFunction *af = reinterpret_cast<const ActionFunction *>(i_a);\r
 447                 bool is_up = (!i_doPress &&\r
 448                                           (af->m_modifier.isOn(Modifier::Type_Up) ||\r
 449                                            af->m_modifier.isDontcare(Modifier::Type_Up)));\r
 450                 bool is_down = (i_doPress &&\r
 451                                                 (af->m_modifier.isOn(Modifier::Type_Down) ||\r
 452                                                  af->m_modifier.isDontcare(Modifier::Type_Down)));\r
 453 \r
 454                 if (!is_down && !is_up)\r
 455                         break;\r
 456 \r
 457                 {\r
 458                         Acquire a(&m_log, 1);\r
 459                         m_log << _T("\t\t     >\t") << af->m_functionData;\r
 460                 }\r
 461 \r
 462                 FunctionParam param;\r
 463                 param.m_isPressed = i_doPress;\r
 464                 param.m_hwnd = m_currentFocusOfThread->m_hwndFocus;\r
 465                 param.m_c = i_c;\r
 466                 param.m_doesNeedEndl = true;\r
 467                 param.m_af = af;\r
 468 \r
 469                 param.m_c.m_mkey.m_modifier.on(Modifier::Type_Up, !i_doPress);\r
 470                 param.m_c.m_mkey.m_modifier.on(Modifier::Type_Down, i_doPress);\r
 471 \r
 472                 af->m_functionData->exec(this, &param);\r
 473 \r
 474                 if (param.m_doesNeedEndl) {\r
 475                         Acquire a(&m_log, 1);\r
 476                         m_log << std::endl;\r
 477                 }\r
 478                 break;\r
 479         }\r
 480         }\r
 481 }\r
 482 \r
 483 \r
 484 // generate keyboard events for keySeq\r
 485 void Engine::generateKeySeqEvents(const Current &i_c, const KeySeq *i_keySeq,\r
 486                                                                   Part i_part)\r
 487 {\r
 488         const KeySeq::Actions &actions = i_keySeq->getActions();\r
 489         if (actions.empty())\r
 490                 return;\r
 491         if (i_part == Part_up)\r
 492                 generateActionEvents(i_c, actions[actions.size() - 1], false);\r
 493         else {\r
 494                 size_t i;\r
 495                 for (i = 0 ; i < actions.size() - 1; ++ i) {\r
 496                         generateActionEvents(i_c, actions[i], true);\r
 497                         generateActionEvents(i_c, actions[i], false);\r
 498                 }\r
 499                 generateActionEvents(i_c, actions[i], true);\r
 500                 if (i_part == Part_all)\r
 501                         generateActionEvents(i_c, actions[i], false);\r
 502         }\r
 503 }\r
 504 \r
 505 \r
 506 // generate keyboard events for current key\r
 507 void Engine::generateKeyboardEvents(const Current &i_c)\r
 508 {\r
 509         if (++ m_generateKeyboardEventsRecursionGuard ==\r
 510                         MAX_GENERATE_KEYBOARD_EVENTS_RECURSION_COUNT) {\r
 511                 Acquire a(&m_log);\r
 512                 m_log << _T("error: too deep keymap recursion.  there may be a loop.")\r
 513                 << std::endl;\r
 514                 return;\r
 515         }\r
 516 \r
 517         const Keymap::KeyAssignment *keyAssign\r
 518         = i_c.m_keymap->searchAssignment(i_c.m_mkey);\r
 519         if (!keyAssign) {\r
 520                 const KeySeq *keySeq = i_c.m_keymap->getDefaultKeySeq();\r
 521                 ASSERT( keySeq );\r
 522                 generateKeySeqEvents(i_c, keySeq, i_c.isPressed() ? Part_down : Part_up);\r
 523         } else {\r
 524                 if (keyAssign->m_modifiedKey.m_modifier.isOn(Modifier::Type_Up) ||\r
 525                                 keyAssign->m_modifiedKey.m_modifier.isOn(Modifier::Type_Down))\r
 526                         generateKeySeqEvents(i_c, keyAssign->m_keySeq, Part_all);\r
 527                 else\r
 528                         generateKeySeqEvents(i_c, keyAssign->m_keySeq,\r
 529                                                                  i_c.isPressed() ? Part_down : Part_up);\r
 530         }\r
 531         m_generateKeyboardEventsRecursionGuard --;\r
 532 }\r
 533 \r
 534 \r
 535 // generate keyboard events for current key\r
 536 void Engine::beginGeneratingKeyboardEvents(\r
 537         const Current &i_c, bool i_isModifier)\r
 538 {\r
 539         //             (1)             (2)             (3)  (4)   (1)\r
 540         // up/down:    D-              U-              D-   U-    D-\r
 541         // keymap:     m_currentKeymap m_currentKeymap X    X     m_currentKeymap\r
 542         // memo:       &Prefix(X)      ...             ...  ...   ...\r
 543         // m_isPrefix: false           true            true false false\r
 544 \r
 545         Current cnew(i_c);\r
 546 \r
 547         bool isPhysicallyPressed\r
 548         = cnew.m_mkey.m_modifier.isPressed(Modifier::Type_Down);\r
 549 \r
 550         // substitute\r
 551         ModifiedKey mkey = m_setting->m_keyboard.searchSubstitute(cnew.m_mkey);\r
 552         if (mkey.m_key) {\r
 553                 cnew.m_mkey = mkey;\r
 554                 if (isPhysicallyPressed) {\r
 555                         cnew.m_mkey.m_modifier.off(Modifier::Type_Up);\r
 556                         cnew.m_mkey.m_modifier.on(Modifier::Type_Down);\r
 557                 } else {\r
 558                         cnew.m_mkey.m_modifier.on(Modifier::Type_Up);\r
 559                         cnew.m_mkey.m_modifier.off(Modifier::Type_Down);\r
 560                 }\r
 561                 for (int i = Modifier::Type_begin; i != Modifier::Type_end; ++ i) {\r
 562                         Modifier::Type type = static_cast<Modifier::Type>(i);\r
 563                         if (cnew.m_mkey.m_modifier.isDontcare(type) &&\r
 564                                         !i_c.m_mkey.m_modifier.isDontcare(type))\r
 565                                 cnew.m_mkey.m_modifier.press(\r
 566                                         type, i_c.m_mkey.m_modifier.isPressed(type));\r
 567                 }\r
 568 \r
 569                 {\r
 570                         Acquire a(&m_log, 1);\r
 571                         m_log << _T("* substitute") << std::endl;\r
 572                 }\r
 573                 outputToLog(mkey.m_key, cnew.m_mkey, 1);\r
 574         }\r
 575 \r
 576         // for prefix key\r
 577         const Keymap *tmpKeymap = m_currentKeymap;\r
 578         if (i_isModifier || !m_isPrefix) ;\r
 579         else if (isPhysicallyPressed)                   // when (3)\r
 580                 m_isPrefix = false;\r
 581         else if (!isPhysicallyPressed)          // when (2)\r
 582                 m_currentKeymap = m_currentFocusOfThread->m_keymaps.front();\r
 583 \r
 584         // for m_emacsEditKillLine function\r
 585         m_emacsEditKillLine.m_doForceReset = !i_isModifier;\r
 586 \r
 587         // generate key event !\r
 588         m_generateKeyboardEventsRecursionGuard = 0;\r
 589         if (isPhysicallyPressed)\r
 590                 generateEvents(cnew, cnew.m_keymap, &Event::before_key_down);\r
 591         generateKeyboardEvents(cnew);\r
 592         if (!isPhysicallyPressed)\r
 593                 generateEvents(cnew, cnew.m_keymap, &Event::after_key_up);\r
 594 \r
 595         // for m_emacsEditKillLine function\r
 596         if (m_emacsEditKillLine.m_doForceReset)\r
 597                 m_emacsEditKillLine.reset();\r
 598 \r
 599         // for prefix key\r
 600         if (i_isModifier)\r
 601                 ;\r
 602         else if (!m_isPrefix)                           // when (1), (4)\r
 603                 m_currentKeymap = m_currentFocusOfThread->m_keymaps.front();\r
 604         else if (!isPhysicallyPressed)          // when (2)\r
 605                 m_currentKeymap = tmpKeymap;\r
 606 }\r
 607 \r
 608 \r
 609 #ifdef NO_DRIVER\r
 610 unsigned int Engine::injectInput(const KEYBOARD_INPUT_DATA *i_kid, const KBDLLHOOKSTRUCT *i_kidRaw)\r
 611 {\r
 612         INPUT kid;\r
 613         if (i_kid->Flags & KEYBOARD_INPUT_DATA::E1) {\r
 614                 kid.type = INPUT_MOUSE;\r
 615                 {\r
 616                         Acquire a(&m_cskidq);\r
 617                         kid.mi.dx = m_msllHookCurrent.pt.x;\r
 618                         kid.mi.dy = m_msllHookCurrent.pt.y;\r
 619                         kid.mi.time = m_msllHookCurrent.time;\r
 620                 }\r
 621                 kid.mi.mouseData = 0;\r
 622                 kid.mi.dwExtraInfo = 0;\r
 623                 kid.mi.dwFlags = MOUSEEVENTF_ABSOLUTE;\r
 624                 switch (i_kid->MakeCode) {\r
 625                 case 1:\r
 626                         if (i_kid->Flags & KEYBOARD_INPUT_DATA::BREAK) {\r
 627                                 kid.mi.dwFlags |= MOUSEEVENTF_LEFTUP;\r
 628                         } else {\r
 629                                 kid.mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;\r
 630                         }\r
 631                         break;\r
 632                 case 2:\r
 633                         if (i_kid->Flags & KEYBOARD_INPUT_DATA::BREAK) {\r
 634                                 kid.mi.dwFlags |= MOUSEEVENTF_RIGHTUP;\r
 635                         } else {\r
 636                                 kid.mi.dwFlags |= MOUSEEVENTF_RIGHTDOWN;\r
 637                         }\r
 638                         break;\r
 639                 case 3:\r
 640                         if (i_kid->Flags & KEYBOARD_INPUT_DATA::BREAK) {\r
 641                                 kid.mi.dwFlags |= MOUSEEVENTF_MIDDLEUP;\r
 642                         } else {\r
 643                                 kid.mi.dwFlags |= MOUSEEVENTF_MIDDLEDOWN;\r
 644                         }\r
 645                         break;\r
 646                 case 4:\r
 647                         if (i_kid->Flags & KEYBOARD_INPUT_DATA::BREAK) {\r
 648                                 return 1;\r
 649                         } else {\r
 650                                 kid.mi.mouseData = WHEEL_DELTA;\r
 651                                 kid.mi.dwFlags |= MOUSEEVENTF_WHEEL;\r
 652                         }\r
 653                         break;\r
 654                 case 5:\r
 655                         if (i_kid->Flags & KEYBOARD_INPUT_DATA::BREAK) {\r
 656                                 return 1;\r
 657                         } else {\r
 658                                 kid.mi.mouseData = -WHEEL_DELTA;\r
 659                                 kid.mi.dwFlags |= MOUSEEVENTF_WHEEL;\r
 660                         }\r
 661                         break;\r
 662                 default:\r
 663                         return 1;\r
 664                         break;\r
 665                 }\r
 666         } else {\r
 667                 kid.type = INPUT_KEYBOARD;\r
 668                 kid.ki.wVk = 0;\r
 669                 kid.ki.wScan = i_kid->MakeCode;\r
 670                 kid.ki.dwFlags = KEYEVENTF_SCANCODE;\r
 671                 kid.ki.time = i_kidRaw ? i_kidRaw->time : 0;\r
 672                 kid.ki.dwExtraInfo = i_kidRaw ? i_kidRaw->dwExtraInfo : 0;\r
 673                 if (i_kid->Flags & KEYBOARD_INPUT_DATA::BREAK) {\r
 674                         kid.ki.dwFlags |= KEYEVENTF_KEYUP;\r
 675                 }\r
 676                 if (i_kid->Flags & KEYBOARD_INPUT_DATA::E0) {\r
 677                         kid.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;\r
 678                 }\r
 679         }\r
 680         SendInput(1, &kid, sizeof(kid));\r
 681         return 1;\r
 682 }\r
 683 #endif // NO_DRIVER\r
 684 \r
 685 \r
 686 // pop all pressed key on win32\r
 687 void Engine::keyboardResetOnWin32()\r
 688 {\r
 689         for (Keyboard::KeyIterator\r
 690                         i = m_setting->m_keyboard.getKeyIterator();  *i; ++ i) {\r
 691                 if ((*i)->m_isPressedOnWin32)\r
 692                         generateKeyEvent((*i), false, true);\r
 693         }\r
 694 }\r
 695 \r
 696 \r
 697 #ifdef NO_DRIVER\r
 698 unsigned int WINAPI Engine::keyboardDetour(Engine *i_this, WPARAM i_wParam, LPARAM i_lParam)\r
 699 {\r
 700         return i_this->keyboardDetour(reinterpret_cast<KBDLLHOOKSTRUCT*>(i_lParam));\r
 701 }\r
 702 \r
 703 unsigned int Engine::keyboardDetour(KBDLLHOOKSTRUCT *i_kid)\r
 704 {\r
 705 #if 0\r
 706         Acquire a(&m_log, 1);\r
 707         m_log << std::hex\r
 708         << _T("keyboardDetour: vkCode=") << i_kid->vkCode\r
 709         << _T(" scanCode=") << i_kid->scanCode\r
 710         << _T(" flags=") << i_kid->flags << std::endl;\r
 711 #endif\r
 712         if (i_kid->flags & LLKHF_INJECTED) {\r
 713                 return 0;\r
 714         } else {\r
 715                 Key key;\r
 716                 KEYBOARD_INPUT_DATA kid;\r
 717 \r
 718                 kid.UnitId = 0;\r
 719                 kid.MakeCode = i_kid->scanCode;\r
 720                 kid.Flags = 0;\r
 721                 if (i_kid->flags & LLKHF_UP) {\r
 722                         kid.Flags |= KEYBOARD_INPUT_DATA::BREAK;\r
 723                 }\r
 724                 if (i_kid->flags & LLKHF_EXTENDED) {\r
 725                         kid.Flags |= KEYBOARD_INPUT_DATA::E0;\r
 726                 }\r
 727                 kid.Reserved = 0;\r
 728                 kid.ExtraInformation = 0;\r
 729 \r
 730                 Acquire a(&m_cskidq);\r
 731                 m_kidq.push_back(kid);\r
 732                 SetEvent(m_readEvent);\r
 733                 return 1;\r
 734         }\r
 735 }\r
 736 \r
 737 unsigned int WINAPI Engine::mouseDetour(Engine *i_this, WPARAM i_wParam, LPARAM i_lParam)\r
 738 {\r
 739         return i_this->mouseDetour(i_wParam, reinterpret_cast<MSLLHOOKSTRUCT*>(i_lParam));\r
 740 }\r
 741 \r
 742 unsigned int Engine::mouseDetour(WPARAM i_message, MSLLHOOKSTRUCT *i_mid)\r
 743 {\r
 744         if (i_mid->flags & LLMHF_INJECTED || !m_setting->m_mouseEvent) {\r
 745                 return 0;\r
 746         } else {\r
 747                 KEYBOARD_INPUT_DATA kid;\r
 748 \r
 749                 kid.UnitId = 0;\r
 750                 kid.Flags = KEYBOARD_INPUT_DATA::E1;\r
 751                 kid.Reserved = 0;\r
 752                 kid.ExtraInformation = 0;\r
 753                 switch (i_message) {\r
 754                 case WM_LBUTTONUP:\r
 755                         kid.Flags |= KEYBOARD_INPUT_DATA::BREAK;\r
 756                 case WM_LBUTTONDOWN:\r
 757                         kid.MakeCode = 1;\r
 758                         break;\r
 759                 case WM_RBUTTONUP:\r
 760                         kid.Flags |= KEYBOARD_INPUT_DATA::BREAK;\r
 761                 case WM_RBUTTONDOWN:\r
 762                         kid.MakeCode = 2;\r
 763                         break;\r
 764                 case WM_MBUTTONUP:\r
 765                         kid.Flags |= KEYBOARD_INPUT_DATA::BREAK;\r
 766                 case WM_MBUTTONDOWN:\r
 767                         kid.MakeCode = 3;\r
 768                         break;\r
 769                 case WM_MOUSEWHEEL:\r
 770                         if (i_mid->mouseData & (1<<31)) {\r
 771                                 kid.MakeCode = 5;\r
 772                         } else {\r
 773                                 kid.MakeCode = 4;\r
 774                         }\r
 775                         break;\r
 776                 case WM_LBUTTONDBLCLK:\r
 777                 case WM_RBUTTONDBLCLK:\r
 778                 case WM_MBUTTONDBLCLK:\r
 779                 case WM_MOUSEHWHEEL:\r
 780                 case WM_XBUTTONDOWN:\r
 781                 case WM_XBUTTONUP:\r
 782                 case WM_XBUTTONDBLCLK:\r
 783                 case WM_MOUSEMOVE:\r
 784                 default:\r
 785                         return 0;\r
 786                         break;\r
 787                 }\r
 788 \r
 789                 Acquire a(&m_cskidq);\r
 790 \r
 791                 m_msllHookCurrent.pt.x = i_mid->pt.x;\r
 792                 m_msllHookCurrent.pt.y = i_mid->pt.y;\r
 793                 m_msllHookCurrent.mouseData = i_mid->mouseData;\r
 794                 m_msllHookCurrent.flags = i_mid->flags;\r
 795                 m_msllHookCurrent.time = i_mid->time;\r
 796                 m_msllHookCurrent.dwExtraInfo = i_mid->dwExtraInfo;\r
 797 \r
 798                 m_kidq.push_back(kid);\r
 799                 SetEvent(m_readEvent);\r
 800 \r
 801                 return 1;\r
 802         }\r
 803 }\r
 804 #endif // NO_DRIVER\r
 805 \r
 806 // keyboard handler thread\r
 807 unsigned int WINAPI Engine::keyboardHandler(void *i_this)\r
 808 {\r
 809         reinterpret_cast<Engine *>(i_this)->keyboardHandler();\r
 810         _endthreadex(0);\r
 811         return 0;\r
 812 }\r
 813 void Engine::keyboardHandler()\r
 814 {\r
 815         // initialize ok\r
 816         CHECK_TRUE( SetEvent(m_threadEvent) );\r
 817 \r
 818         // loop\r
 819         Key key;\r
 820         while (!m_doForceTerminate) {\r
 821                 KEYBOARD_INPUT_DATA kid;\r
 822 \r
 823 #ifndef NO_DRIVER\r
 824                 DWORD len;\r
 825 #endif // !NO_DRIVER\r
 826                 {\r
 827                         Acquire a(&m_log, 1);\r
 828                         m_log << _T("begin ReadFile();") << std::endl;\r
 829                 }\r
 830 #ifdef NO_DRIVER\r
 831                 if (1) {\r
 832 #else // !NO_DRIVER\r
 833                 if (!ReadFile(m_device, &kid, sizeof(kid), &len, &m_ol)) {\r
 834                         if (GetLastError() != ERROR_IO_PENDING)\r
 835                                 continue;\r
 836 #endif // !NO_DRIVER\r
 837 \r
 838                         HANDLE handles[] = { m_readEvent, m_interruptThreadEvent };\r
 839 rewait:\r
 840                         switch (MsgWaitForMultipleObjects(NUMBER_OF(handles), &handles[0],\r
 841                                                                                           FALSE, INFINITE, QS_POSTMESSAGE)) {\r
 842                         case WAIT_OBJECT_0:                     // m_readEvent\r
 843 #ifdef NO_DRIVER\r
 844                                 {\r
 845                                         Acquire a(&m_cskidq);\r
 846                                         if (m_kidq.empty()) {\r
 847                                                 goto rewait;\r
 848                                         }\r
 849                                         kid = m_kidq.front();\r
 850                                         m_kidq.pop_front();\r
 851                                         if (!m_kidq.empty()) {\r
 852                                                 SetEvent(m_readEvent);\r
 853                                         }\r
 854                                 }\r
 855 #else // !NO_DRIVER\r
 856                                 if (!GetOverlappedResult(m_device, &m_ol, &len, FALSE))\r
 857                                         continue;\r
 858 #endif // !NO_DRIVER\r
 859                                 break;\r
 860 \r
 861                         case WAIT_OBJECT_0 + 1:                 // m_interruptThreadEvent\r
 862                                 CancelIo(m_device);\r
 863                                 switch (m_interruptThreadReason) {\r
 864                                 default: {\r
 865                                         ASSERT( false );\r
 866                                         Acquire a(&m_log, 0);\r
 867                                         m_log << _T("internal error: m_interruptThreadReason == ")\r
 868                                         << m_interruptThreadReason << std::endl;\r
 869                                         break;\r
 870                                 }\r
 871 \r
 872                                 case InterruptThreadReason_Terminate:\r
 873                                         goto break_while;\r
 874 \r
 875                                 case InterruptThreadReason_Pause: {\r
 876                                         CHECK_TRUE( SetEvent(m_threadEvent) );\r
 877                                         while (WaitForMultipleObjects(1, &m_interruptThreadEvent,\r
 878                                                                                                   FALSE, INFINITE) != WAIT_OBJECT_0)\r
 879                                                 ;\r
 880                                         switch (m_interruptThreadReason) {\r
 881                                         case InterruptThreadReason_Terminate:\r
 882                                                 goto break_while;\r
 883 \r
 884                                         case InterruptThreadReason_Resume:\r
 885                                                 break;\r
 886 \r
 887                                         default:\r
 888                                                 ASSERT( false );\r
 889                                                 break;\r
 890                                         }\r
 891                                         CHECK_TRUE( SetEvent(m_threadEvent) );\r
 892                                         break;\r
 893                                 }\r
 894                                 }\r
 895                                 break;\r
 896 \r
 897                         case WAIT_OBJECT_0 + NUMBER_OF(handles): {\r
 898                                 MSG message;\r
 899 \r
 900                                 while (PeekMessage(&message, NULL, 0, 0, PM_REMOVE)) {\r
 901                                         switch (message.message) {\r
 902                                         case WM_APP + 201: {\r
 903                                                 if (message.wParam) {\r
 904                                                         m_currentLock.on(Modifier::Type_Touchpad);\r
 905                                                         m_currentLock.on(Modifier::Type_TouchpadSticky);\r
 906                                                 } else\r
 907                                                         m_currentLock.off(Modifier::Type_Touchpad);\r
 908                                                 Acquire a(&m_log, 1);\r
 909                                                 m_log << _T("touchpad: ") << message.wParam\r
 910                                                 << _T(".") << (message.lParam & 0xffff)\r
 911                                                 << _T(".") << (message.lParam >> 16 & 0xffff)\r
 912                                                 << std::endl;\r
 913                                                 break;\r
 914                                         }\r
 915                                         default:\r
 916                                                 break;\r
 917                                         }\r
 918                                 }\r
 919                                 goto rewait;\r
 920                         }\r
 921 \r
 922                         default:\r
 923                                 ASSERT( false );\r
 924                                 continue;\r
 925                         }\r
 926                 }\r
 927                 {\r
 928                         Acquire a(&m_log, 1);\r
 929                         m_log << _T("end ReadFile();") << std::endl;\r
 930                 }\r
 931 \r
 932                 checkFocusWindow();\r
 933 \r
 934                 if (!m_setting ||       // m_setting has not been loaded\r
 935                                 !m_isEnabled) { // disabled\r
 936                         if (m_isLogMode) {\r
 937                                 Key key;\r
 938                                 key.addScanCode(ScanCode(kid.MakeCode, kid.Flags));\r
 939                                 outputToLog(&key, ModifiedKey(), 0);\r
 940                         } else {\r
 941 #ifdef NO_DRIVER\r
 942                                 injectInput(&kid, NULL);\r
 943 #else // !NO_DRIVER\r
 944                                 WriteFile(m_device, &kid, sizeof(kid), &len, &m_ol);\r
 945                                 GetOverlappedResult(m_device, &m_ol, &len, TRUE);\r
 946 #endif // !NO_DRIVER\r
 947                         }\r
 948                         updateLastPressedKey(NULL);\r
 949                         continue;\r
 950                 }\r
 951 \r
 952                 Acquire a(&m_cs);\r
 953 \r
 954                 if (!m_currentFocusOfThread ||\r
 955                                 !m_currentKeymap) {\r
 956 #ifndef NO_DRIVER\r
 957                         WriteFile(m_device, &kid, sizeof(kid), &len, &m_ol);\r
 958                         GetOverlappedResult(m_device, &m_ol, &len, TRUE);\r
 959 #endif // !NO_DRIVER\r
 960                         Acquire a(&m_log, 0);\r
 961                         if (!m_currentFocusOfThread)\r
 962                                 m_log << _T("internal error: m_currentFocusOfThread == NULL")\r
 963                                 << std::endl;\r
 964                         if (!m_currentKeymap)\r
 965                                 m_log << _T("internal error: m_currentKeymap == NULL")\r
 966                                 << std::endl;\r
 967                         updateLastPressedKey(NULL);\r
 968                         continue;\r
 969                 }\r
 970 \r
 971                 Current c;\r
 972                 c.m_keymap = m_currentKeymap;\r
 973                 c.m_i = m_currentFocusOfThread->m_keymaps.begin();\r
 974 \r
 975                 // search key\r
 976                 key.addScanCode(ScanCode(kid.MakeCode, kid.Flags));\r
 977                 c.m_mkey = m_setting->m_keyboard.searchKey(key);\r
 978                 if (!c.m_mkey.m_key) {\r
 979                         c.m_mkey.m_key = m_setting->m_keyboard.searchPrefixKey(key);\r
 980                         if (c.m_mkey.m_key)\r
 981                                 continue;\r
 982                 }\r
 983 \r
 984                 // press the key and update counter\r
 985                 bool isPhysicallyPressed\r
 986                 = !(key.getScanCodes()[0].m_flags & ScanCode::BREAK);\r
 987                 if (c.m_mkey.m_key) {\r
 988                         if (!c.m_mkey.m_key->m_isPressed && isPhysicallyPressed)\r
 989                                 ++ m_currentKeyPressCount;\r
 990                         else if (c.m_mkey.m_key->m_isPressed && !isPhysicallyPressed)\r
 991                                 -- m_currentKeyPressCount;\r
 992                         c.m_mkey.m_key->m_isPressed = isPhysicallyPressed;\r
 993                 }\r
 994 \r
 995                 // create modifiers\r
 996                 c.m_mkey.m_modifier = getCurrentModifiers(c.m_mkey.m_key,\r
 997                                                           isPhysicallyPressed);\r
 998                 Keymap::AssignMode am;\r
 999                 bool isModifier = fixModifierKey(&c.m_mkey, &am);\r
1000                 if (m_isPrefix) {\r
1001                         if (isModifier && m_doesIgnoreModifierForPrefix)\r
1002                                 am = Keymap::AM_true;\r
1003                         if (m_doesEditNextModifier) {\r
1004                                 Modifier modifier = m_modifierForNextKey;\r
1005                                 modifier.add(c.m_mkey.m_modifier);\r
1006                                 c.m_mkey.m_modifier = modifier;\r
1007                         }\r
1008                 }\r
1009 \r
1010                 if (m_isLogMode) {\r
1011                         outputToLog(&key, c.m_mkey, 0);\r
1012                         if (kid.Flags & KEYBOARD_INPUT_DATA::E1) {\r
1013                                 // through mouse event even if log mode\r
1014                                 injectInput(&kid, NULL);\r
1015                         }\r
1016                 } else if (am == Keymap::AM_true) {\r
1017                         {\r
1018                                 Acquire a(&m_log, 1);\r
1019                                 m_log << _T("* true modifier") << std::endl;\r
1020                         }\r
1021                         // true modifier doesn't generate scan code\r
1022                         outputToLog(&key, c.m_mkey, 1);\r
1023                 } else if (am == Keymap::AM_oneShot || am == Keymap::AM_oneShotRepeatable) {\r
1024                         {\r
1025                                 Acquire a(&m_log, 1);\r
1026                                 if (am == Keymap::AM_oneShot)\r
1027                                         m_log << _T("* one shot modifier") << std::endl;\r
1028                                 else\r
1029                                         m_log << _T("* one shot repeatable modifier") << std::endl;\r
1030                         }\r
1031                         // oneShot modifier doesn't generate scan code\r
1032                         outputToLog(&key, c.m_mkey, 1);\r
1033                         if (isPhysicallyPressed) {\r
1034                                 if (am == Keymap::AM_oneShotRepeatable  // the key is repeating\r
1035                                                 && m_oneShotKey.m_key == c.m_mkey.m_key) {\r
1036                                         if (m_oneShotRepeatableRepeatCount <\r
1037                                                         m_setting->m_oneShotRepeatableDelay) {\r
1038                                                 ; // delay\r
1039                                         } else {\r
1040                                                 Current cnew = c;\r
1041                                                 beginGeneratingKeyboardEvents(cnew, false);\r
1042                                         }\r
1043                                         ++ m_oneShotRepeatableRepeatCount;\r
1044                                 } else {\r
1045                                         m_oneShotKey = c.m_mkey;\r
1046                                         m_oneShotRepeatableRepeatCount = 0;\r
1047                                 }\r
1048                         } else {\r
1049                                 if (m_oneShotKey.m_key) {\r
1050                                         Current cnew = c;\r
1051                                         cnew.m_mkey.m_modifier = m_oneShotKey.m_modifier;\r
1052                                         cnew.m_mkey.m_modifier.off(Modifier::Type_Up);\r
1053                                         cnew.m_mkey.m_modifier.on(Modifier::Type_Down);\r
1054                                         beginGeneratingKeyboardEvents(cnew, false);\r
1055 \r
1056                                         cnew = c;\r
1057                                         cnew.m_mkey.m_modifier = m_oneShotKey.m_modifier;\r
1058                                         cnew.m_mkey.m_modifier.on(Modifier::Type_Up);\r
1059                                         cnew.m_mkey.m_modifier.off(Modifier::Type_Down);\r
1060                                         beginGeneratingKeyboardEvents(cnew, false);\r
1061                                 }\r
1062                                 m_oneShotKey.m_key = NULL;\r
1063                                 m_oneShotRepeatableRepeatCount = 0;\r
1064                         }\r
1065                 } else if (c.m_mkey.m_key)\r
1066                         // normal key\r
1067                 {\r
1068                         outputToLog(&key, c.m_mkey, 1);\r
1069                         if (isPhysicallyPressed)\r
1070                                 m_oneShotKey.m_key = NULL;\r
1071                         beginGeneratingKeyboardEvents(c, isModifier);\r
1072                 }\r
1073 \r
1074                 // if counter is zero, reset modifiers and keys on win32\r
1075                 if (m_currentKeyPressCount <= 0) {\r
1076                         {\r
1077                                 Acquire a(&m_log, 1);\r
1078                                 m_log << _T("* No key is pressed") << std::endl;\r
1079                         }\r
1080                         generateModifierEvents(Modifier());\r
1081                         if (0 < m_currentKeyPressCountOnWin32)\r
1082                                 keyboardResetOnWin32();\r
1083                         m_currentKeyPressCount = 0;\r
1084                         m_currentKeyPressCountOnWin32 = 0;\r
1085                         m_oneShotKey.m_key = NULL;\r
1086                         if (m_currentLock.isOn(Modifier::Type_Touchpad) == false)\r
1087                                 m_currentLock.off(Modifier::Type_TouchpadSticky);\r
1088                 }\r
1089 \r
1090                 key.initialize();\r
1091                 updateLastPressedKey(isPhysicallyPressed ? c.m_mkey.m_key : NULL);\r
1092         }\r
1093 break_while:\r
1094         CHECK_TRUE( SetEvent(m_threadEvent) );\r
1095 }\r
1096 \r
1097 \r
1098 Engine::Engine(tomsgstream &i_log)\r
1099                 : m_hwndAssocWindow(NULL),\r
1100                 m_setting(NULL),\r
1101                 m_device(INVALID_HANDLE_VALUE),\r
1102                 m_didMayuStartDevice(false),\r
1103                 m_threadEvent(NULL),\r
1104                 m_mayudVersion(_T("unknown")),\r
1105                 m_keyboardHandler(installKeyboardHook, Engine::keyboardDetour),\r
1106                 m_mouseHandler(installMouseHook, Engine::mouseDetour),\r
1107                 m_readEvent(NULL),\r
1108                 m_interruptThreadEvent(NULL),\r
1109                 m_sts4mayu(NULL),\r
1110                 m_cts4mayu(NULL),\r
1111                 m_doForceTerminate(false),\r
1112                 m_isLogMode(false),\r
1113                 m_isEnabled(true),\r
1114                 m_isSynchronizing(false),\r
1115                 m_eSync(NULL),\r
1116                 m_generateKeyboardEventsRecursionGuard(0),\r
1117                 m_currentKeyPressCount(0),\r
1118                 m_currentKeyPressCountOnWin32(0),\r
1119                 m_lastGeneratedKey(NULL),\r
1120                 m_oneShotRepeatableRepeatCount(0),\r
1121                 m_isPrefix(false),\r
1122                 m_currentKeymap(NULL),\r
1123                 m_currentFocusOfThread(NULL),\r
1124                 m_hwndFocus(NULL),\r
1125                 m_afShellExecute(NULL),\r
1126                 m_variable(0),\r
1127                 m_log(i_log) {\r
1128         for (size_t i = 0; i < NUMBER_OF(m_lastPressedKey); ++ i)\r
1129                 m_lastPressedKey[i] = NULL;\r
1130 \r
1131         // set default lock state\r
1132         for (int i = 0; i < Modifier::Type_end; ++ i)\r
1133                 m_currentLock.dontcare(static_cast<Modifier::Type>(i));\r
1134         for (int i = Modifier::Type_Lock0; i <= Modifier::Type_Lock9; ++ i)\r
1135                 m_currentLock.release(static_cast<Modifier::Type>(i));\r
1136 \r
1137 #ifndef NO_DRIVER\r
1138         if (!open()) {\r
1139                 throw ErrorMessage() << loadString(IDS_driverNotInstalled);\r
1140         }\r
1141 #endif // !NO_DRIVER\r
1142 \r
1143 #ifndef NO_DRIVER\r
1144         {\r
1145                 TCHAR versionBuf[256];\r
1146                 DWORD length = 0;\r
1147 \r
1148                 if (DeviceIoControl(m_device, IOCTL_MAYU_GET_VERSION, NULL, 0,\r
1149                                                         versionBuf, sizeof(versionBuf), &length, NULL)\r
1150                                 && length\r
1151                                 && length < sizeof(versionBuf))                 // fail safe\r
1152                         m_mayudVersion = tstring(versionBuf, length / 2);\r
1153         }\r
1154 #endif // !NO_DRIVER\r
1155         // create event for sync\r
1156         CHECK_TRUE( m_eSync = CreateEvent(NULL, FALSE, FALSE, NULL) );\r
1157         // create named pipe for &SetImeString\r
1158         m_hookPipe = CreateNamedPipe(addSessionId(HOOK_PIPE_NAME).c_str(),\r
1159                                                                  PIPE_ACCESS_OUTBOUND,\r
1160                                                                  PIPE_TYPE_BYTE, 1,\r
1161                                                                  0, 0, 0, NULL);\r
1162         StrExprArg::setEngine(this);\r
1163 \r
1164         m_msllHookCurrent.pt.x = 0;\r
1165         m_msllHookCurrent.pt.y = 0;\r
1166         m_msllHookCurrent.mouseData = 0;\r
1167         m_msllHookCurrent.flags = 0;\r
1168         m_msllHookCurrent.time = 0;\r
1169         m_msllHookCurrent.dwExtraInfo = 0;\r
1170 }\r
1171 \r
1172 \r
1173 // open mayu device\r
1174 bool Engine::open() {\r
1175         // open mayu m_device\r
1176 #ifndef NO_DRIVER\r
1177         m_device = CreateFile(MAYU_DEVICE_FILE_NAME, GENERIC_READ | GENERIC_WRITE,\r
1178                                                   0, NULL, OPEN_EXISTING,\r
1179                                                   FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);\r
1180 #endif // !NO_DRIVER\r
1181 \r
1182         if (m_device != INVALID_HANDLE_VALUE) {\r
1183                 return true;\r
1184         }\r
1185 \r
1186 #ifndef NO_DRIVER\r
1187         // start mayud\r
1188         SC_HANDLE hscm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);\r
1189         if (hscm) {\r
1190                 SC_HANDLE hs = OpenService(hscm, MAYU_DRIVER_NAME, SERVICE_START);\r
1191                 if (hs) {\r
1192                         StartService(hs, 0, NULL);\r
1193                         CloseServiceHandle(hs);\r
1194                         m_didMayuStartDevice = true;\r
1195                 }\r
1196                 CloseServiceHandle(hscm);\r
1197         }\r
1198 \r
1199         // open mayu m_device\r
1200         m_device = CreateFile(MAYU_DEVICE_FILE_NAME, GENERIC_READ | GENERIC_WRITE,\r
1201                                                   0, NULL, OPEN_EXISTING,\r
1202                                                   FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);\r
1203 #endif // !NO_DRIVER\r
1204         return (m_device != INVALID_HANDLE_VALUE);\r
1205 }\r
1206 \r
1207 \r
1208 // close mayu device\r
1209 void Engine::close() {\r
1210         if (m_device != INVALID_HANDLE_VALUE) {\r
1211 #ifndef NO_DRIVER\r
1212                 CHECK_TRUE( CloseHandle(m_device) );\r
1213 #endif // !NO_DRIVER\r
1214         }\r
1215         m_device = INVALID_HANDLE_VALUE;\r
1216 }\r
1217 \r
1218 \r
1219 // start keyboard handler thread\r
1220 void Engine::start() {\r
1221         m_keyboardHandler.start(this);\r
1222         m_mouseHandler.start(this);\r
1223         CHECK_TRUE( m_threadEvent = CreateEvent(NULL, FALSE, FALSE, NULL) );\r
1224 \r
1225         CHECK_TRUE( m_readEvent = CreateEvent(NULL, FALSE, FALSE, NULL) );\r
1226         CHECK_TRUE( m_interruptThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL) );\r
1227         m_ol.Offset = 0;\r
1228         m_ol.OffsetHigh = 0;\r
1229         m_ol.hEvent = m_readEvent;\r
1230 \r
1231         CHECK_TRUE( m_threadHandle = (HANDLE)_beginthreadex(NULL, 0, keyboardHandler, this, 0, &m_threadId) );\r
1232         CHECK( WAIT_OBJECT_0 ==, WaitForSingleObject(m_threadEvent, INFINITE) );\r
1233 }\r
1234 \r
1235 \r
1236 // stop keyboard handler thread\r
1237 void Engine::stop() {\r
1238         if (m_threadEvent) {\r
1239                 m_doForceTerminate = true;\r
1240                 do {\r
1241                         m_interruptThreadReason = InterruptThreadReason_Terminate;\r
1242                         SetEvent(m_interruptThreadEvent);\r
1243                         //DWORD buf;\r
1244                         //M_DeviceIoControl(m_device, IOCTL_MAYU_DETOUR_CANCEL,\r
1245                         //                &buf, sizeof(buf), &buf, sizeof(buf), &buf, NULL);\r
1246 \r
1247                         // wait for message handler thread terminate\r
1248                 } while (WaitForSingleObject(m_threadEvent, 100) != WAIT_OBJECT_0);\r
1249                 CHECK_TRUE( CloseHandle(m_threadEvent) );\r
1250                 m_threadEvent = NULL;\r
1251                 WaitForSingleObject(m_threadHandle, 100);\r
1252                 CHECK_TRUE( CloseHandle(m_threadHandle) );\r
1253                 m_threadHandle = NULL;\r
1254 \r
1255                 // stop mayud\r
1256                 if (m_didMayuStartDevice) {\r
1257                         SC_HANDLE hscm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);\r
1258                         if (hscm) {\r
1259                                 SC_HANDLE hs = OpenService(hscm, MAYU_DRIVER_NAME, SERVICE_STOP);\r
1260                                 if (hs) {\r
1261                                         SERVICE_STATUS ss;\r
1262                                         ControlService(hs, SERVICE_CONTROL_STOP, &ss);\r
1263                                         CloseServiceHandle(hs);\r
1264                                 }\r
1265                                 CloseServiceHandle(hscm);\r
1266                         }\r
1267                 }\r
1268 \r
1269                 CHECK_TRUE( CloseHandle(m_readEvent) );\r
1270                 m_readEvent = NULL;\r
1271                 CHECK_TRUE( CloseHandle(m_interruptThreadEvent) );\r
1272                 m_interruptThreadEvent = NULL;\r
1273         }\r
1274         m_mouseHandler.stop();\r
1275         m_keyboardHandler.stop();\r
1276 }\r
1277 \r
1278 bool Engine::pause() {\r
1279         if (m_device != INVALID_HANDLE_VALUE) {\r
1280                 do {\r
1281                         m_interruptThreadReason = InterruptThreadReason_Pause;\r
1282                         SetEvent(m_interruptThreadEvent);\r
1283                 } while (WaitForSingleObject(m_threadEvent, 100) != WAIT_OBJECT_0);\r
1284 #ifndef NO_DRIVER\r
1285                 close();\r
1286 #endif // !NO_DRIVER\r
1287         }\r
1288         return true;\r
1289 }\r
1290 \r
1291 \r
1292 bool Engine::resume() {\r
1293         if (m_device == INVALID_HANDLE_VALUE) {\r
1294 #ifndef NO_DRIVER\r
1295                 if (!open()) {\r
1296                         return false;                           // FIXME\r
1297                 }\r
1298 #endif // !NO_DRIVER\r
1299                 do {\r
1300                         m_interruptThreadReason = InterruptThreadReason_Resume;\r
1301                         SetEvent(m_interruptThreadEvent);\r
1302                 } while (WaitForSingleObject(m_threadEvent, 100) != WAIT_OBJECT_0);\r
1303         }\r
1304         return true;\r
1305 }\r
1306 \r
1307 \r
1308 bool Engine::prepairQuit() {\r
1309         // terminate and unload DLL for ThumbSense support if loaded\r
1310         manageTs4mayu(_T("sts4mayu.dll"), _T("SynCOM.dll"),\r
1311                                   false, &m_sts4mayu);\r
1312         manageTs4mayu(_T("cts4mayu.dll"), _T("TouchPad.dll"),\r
1313                                   false, &m_cts4mayu);\r
1314         return true;\r
1315 }\r
1316 \r
1317 \r
1318 Engine::~Engine() {\r
1319         stop();\r
1320         CHECK_TRUE( CloseHandle(m_eSync) );\r
1321 \r
1322         // close m_device\r
1323 #ifndef NO_DRIVER\r
1324         close();\r
1325 #endif // !NO_DRIVER\r
1326         // destroy named pipe for &SetImeString\r
1327         if (m_hookPipe && m_hookPipe != INVALID_HANDLE_VALUE) {\r
1328                 DisconnectNamedPipe(m_hookPipe);\r
1329                 CHECK_TRUE( CloseHandle(m_hookPipe) );\r
1330         }\r
1331 }\r
1332 \r
1333 \r
1334 void Engine::manageTs4mayu(TCHAR *i_ts4mayuDllName,\r
1335                                                    TCHAR *i_dependDllName,\r
1336                                                    bool i_load, HMODULE *i_pTs4mayu) {\r
1337         Acquire a(&m_log, 0);\r
1338 \r
1339         if (i_load == false) {\r
1340                 if (*i_pTs4mayu) {\r
1341                         bool (WINAPI *pTs4mayuTerm)();\r
1342 \r
1343                         pTs4mayuTerm = (bool (WINAPI*)())GetProcAddress(*i_pTs4mayu, "ts4mayuTerm");\r
1344                         if (pTs4mayuTerm() == true)\r
1345                                 FreeLibrary(*i_pTs4mayu);\r
1346                         *i_pTs4mayu = NULL;\r
1347                         m_log << i_ts4mayuDllName <<_T(" unloaded") << std::endl;\r
1348                 }\r
1349         } else {\r
1350                 if (*i_pTs4mayu) {\r
1351                         m_log << i_ts4mayuDllName << _T(" already loaded") << std::endl;\r
1352                 } else {\r
1353                         if (SearchPath(NULL, i_dependDllName, NULL, 0, NULL, NULL) == 0) {\r
1354                                 m_log << _T("load ") << i_ts4mayuDllName\r
1355                                 << _T(" failed: can't find ") << i_dependDllName\r
1356                                 << std::endl;\r
1357                         } else {\r
1358                                 *i_pTs4mayu = LoadLibrary(i_ts4mayuDllName);\r
1359                                 if (*i_pTs4mayu == NULL) {\r
1360                                         m_log << _T("load ") << i_ts4mayuDllName\r
1361                                         << _T(" failed: can't find it") << std::endl;\r
1362                                 } else {\r
1363                                         bool (WINAPI *pTs4mayuInit)(UINT);\r
1364 \r
1365                                         pTs4mayuInit = (bool (WINAPI*)(UINT))GetProcAddress(*i_pTs4mayu, "ts4mayuInit");\r
1366                                         if (pTs4mayuInit(m_threadId) == true)\r
1367                                                 m_log << i_ts4mayuDllName <<_T(" loaded") << std::endl;\r
1368                                         else\r
1369                                                 m_log << i_ts4mayuDllName\r
1370                                                 <<_T(" load failed: can't initialize") << std::endl;\r
1371                                 }\r
1372                         }\r
1373                 }\r
1374         }\r
1375 }\r
1376 \r
1377 \r
1378 // set m_setting\r
1379 bool Engine::setSetting(Setting *i_setting) {\r
1380         Acquire a(&m_cs);\r
1381         if (m_isSynchronizing)\r
1382                 return false;\r
1383 \r
1384         if (m_setting) {\r
1385                 for (Keyboard::KeyIterator i = m_setting->m_keyboard.getKeyIterator();\r
1386                                 *i; ++ i) {\r
1387                         Key *key = i_setting->m_keyboard.searchKey(*(*i));\r
1388                         if (key) {\r
1389                                 key->m_isPressed = (*i)->m_isPressed;\r
1390                                 key->m_isPressedOnWin32 = (*i)->m_isPressedOnWin32;\r
1391                                 key->m_isPressedByAssign = (*i)->m_isPressedByAssign;\r
1392                         }\r
1393                 }\r
1394                 if (m_lastGeneratedKey)\r
1395                         m_lastGeneratedKey =\r
1396                                 i_setting->m_keyboard.searchKey(*m_lastGeneratedKey);\r
1397                 for (size_t i = 0; i < NUMBER_OF(m_lastPressedKey); ++ i)\r
1398                         if (m_lastPressedKey[i])\r
1399                                 m_lastPressedKey[i] =\r
1400                                         i_setting->m_keyboard.searchKey(*m_lastPressedKey[i]);\r
1401         }\r
1402 \r
1403         m_setting = i_setting;\r
1404 \r
1405         manageTs4mayu(_T("sts4mayu.dll"), _T("SynCOM.dll"),\r
1406                                   m_setting->m_sts4mayu, &m_sts4mayu);\r
1407         manageTs4mayu(_T("cts4mayu.dll"), _T("TouchPad.dll"),\r
1408                                   m_setting->m_cts4mayu, &m_cts4mayu);\r
1409 \r
1410         g_hookData->m_correctKanaLockHandling = m_setting->m_correctKanaLockHandling;\r
1411         if (m_currentFocusOfThread) {\r
1412                 for (FocusOfThreads::iterator i = m_focusOfThreads.begin();\r
1413                                 i != m_focusOfThreads.end(); i ++) {\r
1414                         FocusOfThread *fot = &(*i).second;\r
1415                         m_setting->m_keymaps.searchWindow(&fot->m_keymaps,\r
1416                                                                                           fot->m_className, fot->m_titleName);\r
1417                 }\r
1418         }\r
1419         m_setting->m_keymaps.searchWindow(&m_globalFocus.m_keymaps, _T(""), _T(""));\r
1420         if (m_globalFocus.m_keymaps.empty()) {\r
1421                 Acquire a(&m_log, 0);\r
1422                 m_log << _T("internal error: m_globalFocus.m_keymap is empty")\r
1423                 << std::endl;\r
1424         }\r
1425         m_currentFocusOfThread = &m_globalFocus;\r
1426         setCurrentKeymap(m_globalFocus.m_keymaps.front());\r
1427         m_hwndFocus = NULL;\r
1428         return true;\r
1429 }\r
1430 \r
1431 \r
1432 void Engine::checkShow(HWND i_hwnd) {\r
1433         // update show style of window\r
1434         // this update should be done in hook DLL, but to\r
1435         // avoid update-loss for some applications(such as\r
1436         // cmd.exe), we update here.\r
1437         bool isMaximized = false;\r
1438         bool isMinimized = false;\r
1439         bool isMDIMaximized = false;\r
1440         bool isMDIMinimized = false;\r
1441         while (i_hwnd) {\r
1442 #ifdef MAYU64\r
1443                 LONG_PTR exStyle = GetWindowLongPtr(i_hwnd, GWL_EXSTYLE);\r
1444 #else\r
1445                 LONG exStyle = GetWindowLong(i_hwnd, GWL_EXSTYLE);\r
1446 #endif\r
1447                 if (exStyle & WS_EX_MDICHILD) {\r
1448                         WINDOWPLACEMENT placement;\r
1449                         placement.length = sizeof(WINDOWPLACEMENT);\r
1450                         if (GetWindowPlacement(i_hwnd, &placement)) {\r
1451                                 switch (placement.showCmd) {\r
1452                                 case SW_SHOWMAXIMIZED:\r
1453                                         isMDIMaximized = true;\r
1454                                         break;\r
1455                                 case SW_SHOWMINIMIZED:\r
1456                                         isMDIMinimized = true;\r
1457                                         break;\r
1458                                 case SW_SHOWNORMAL:\r
1459                                 default:\r
1460                                         break;\r
1461                                 }\r
1462                         }\r
1463                 }\r
1464 \r
1465 #ifdef MAYU64\r
1466                 LONG_PTR style = GetWindowLongPtr(i_hwnd, GWL_STYLE);\r
1467 #else\r
1468                 LONG style = GetWindowLong(i_hwnd, GWL_STYLE);\r
1469 #endif\r
1470                 if ((style & WS_CHILD) == 0) {\r
1471                         WINDOWPLACEMENT placement;\r
1472                         placement.length = sizeof(WINDOWPLACEMENT);\r
1473                         if (GetWindowPlacement(i_hwnd, &placement)) {\r
1474                                 switch (placement.showCmd) {\r
1475                                 case SW_SHOWMAXIMIZED:\r
1476                                         isMaximized = true;\r
1477                                         break;\r
1478                                 case SW_SHOWMINIMIZED:\r
1479                                         isMinimized = true;\r
1480                                         break;\r
1481                                 case SW_SHOWNORMAL:\r
1482                                 default:\r
1483                                         break;\r
1484                                 }\r
1485                         }\r
1486                 }\r
1487                 i_hwnd = GetParent(i_hwnd);\r
1488         }\r
1489         setShow(isMDIMaximized, isMDIMinimized, true);\r
1490         setShow(isMaximized, isMinimized, false);\r
1491 }\r
1492 \r
1493 \r
1494 // focus\r
1495 bool Engine::setFocus(HWND i_hwndFocus, DWORD i_threadId,\r
1496                                           const tstringi &i_className, const tstringi &i_titleName,\r
1497                                           bool i_isConsole) {\r
1498         Acquire a(&m_cs);\r
1499         if (m_isSynchronizing)\r
1500                 return false;\r
1501         if (i_hwndFocus == NULL)\r
1502                 return true;\r
1503 \r
1504         // remove newly created thread's id from m_detachedThreadIds\r
1505         if (!m_detachedThreadIds.empty()) {\r
1506                 DetachedThreadIds::iterator i;\r
1507                 bool retry;\r
1508                 do {\r
1509                         retry = false;\r
1510                         for (i = m_detachedThreadIds.begin();\r
1511                                         i != m_detachedThreadIds.end(); ++ i)\r
1512                                 if (*i == i_threadId) {\r
1513                                         m_detachedThreadIds.erase(i);\r
1514                                         retry = true;\r
1515                                         break;\r
1516                                 }\r
1517                 } while (retry);\r
1518         }\r
1519 \r
1520         FocusOfThread *fot;\r
1521         FocusOfThreads::iterator i = m_focusOfThreads.find(i_threadId);\r
1522         if (i != m_focusOfThreads.end()) {\r
1523                 fot = &(*i).second;\r
1524                 if (fot->m_hwndFocus == i_hwndFocus &&\r
1525                                 fot->m_isConsole == i_isConsole &&\r
1526                                 fot->m_className == i_className &&\r
1527                                 fot->m_titleName == i_titleName)\r
1528                         return true;\r
1529         } else {\r
1530                 i = m_focusOfThreads.insert(\r
1531                                 FocusOfThreads::value_type(i_threadId, FocusOfThread())).first;\r
1532                 fot = &(*i).second;\r
1533                 fot->m_threadId = i_threadId;\r
1534         }\r
1535         fot->m_hwndFocus = i_hwndFocus;\r
1536         fot->m_isConsole = i_isConsole;\r
1537         fot->m_className = i_className;\r
1538         fot->m_titleName = i_titleName;\r
1539 \r
1540         if (m_setting) {\r
1541                 m_setting->m_keymaps.searchWindow(&fot->m_keymaps,\r
1542                                                                                   i_className, i_titleName);\r
1543                 ASSERT(0 < fot->m_keymaps.size());\r
1544         } else\r
1545                 fot->m_keymaps.clear();\r
1546         checkShow(i_hwndFocus);\r
1547         return true;\r
1548 }\r
1549 \r
1550 \r
1551 // lock state\r
1552 bool Engine::setLockState(bool i_isNumLockToggled,\r
1553                                                   bool i_isCapsLockToggled,\r
1554                                                   bool i_isScrollLockToggled,\r
1555                                                   bool i_isKanaLockToggled,\r
1556                                                   bool i_isImeLockToggled,\r
1557                                                   bool i_isImeCompToggled) {\r
1558         Acquire a(&m_cs);\r
1559         if (m_isSynchronizing)\r
1560                 return false;\r
1561         m_currentLock.on(Modifier::Type_NumLock, i_isNumLockToggled);\r
1562         m_currentLock.on(Modifier::Type_CapsLock, i_isCapsLockToggled);\r
1563         m_currentLock.on(Modifier::Type_ScrollLock, i_isScrollLockToggled);\r
1564         m_currentLock.on(Modifier::Type_KanaLock, i_isKanaLockToggled);\r
1565         m_currentLock.on(Modifier::Type_ImeLock, i_isImeLockToggled);\r
1566         m_currentLock.on(Modifier::Type_ImeComp, i_isImeCompToggled);\r
1567         return true;\r
1568 }\r
1569 \r
1570 \r
1571 // show\r
1572 bool Engine::setShow(bool i_isMaximized, bool i_isMinimized,\r
1573                                          bool i_isMDI) {\r
1574         Acquire a(&m_cs);\r
1575         if (m_isSynchronizing)\r
1576                 return false;\r
1577         Acquire b(&m_log, 1);\r
1578         Modifier::Type max, min;\r
1579         if (i_isMDI == true) {\r
1580                 max = Modifier::Type_MdiMaximized;\r
1581                 min = Modifier::Type_MdiMinimized;\r
1582         } else {\r
1583                 max = Modifier::Type_Maximized;\r
1584                 min = Modifier::Type_Minimized;\r
1585         }\r
1586         m_currentLock.on(max, i_isMaximized);\r
1587         m_currentLock.on(min, i_isMinimized);\r
1588         m_log << _T("Set show to ") << (i_isMaximized ? _T("Maximized") :\r
1589                                                                         i_isMinimized ? _T("Minimized") : _T("Normal"));\r
1590         if (i_isMDI == true) {\r
1591                 m_log << _T(" (MDI)");\r
1592         }\r
1593         m_log << std::endl;\r
1594         return true;\r
1595 }\r
1596 \r
1597 \r
1598 // sync\r
1599 bool Engine::syncNotify() {\r
1600         Acquire a(&m_cs);\r
1601         if (!m_isSynchronizing)\r
1602                 return false;\r
1603         CHECK_TRUE( SetEvent(m_eSync) );\r
1604         return true;\r
1605 }\r
1606 \r
1607 \r
1608 // thread detach notify\r
1609 bool Engine::threadDetachNotify(DWORD i_threadId) {\r
1610         Acquire a(&m_cs);\r
1611         m_detachedThreadIds.push_back(i_threadId);\r
1612         return true;\r
1613 }\r
1614 \r
1615 \r
1616 // get help message\r
1617 void Engine::getHelpMessages(tstring *o_helpMessage, tstring *o_helpTitle) {\r
1618         Acquire a(&m_cs);\r
1619         *o_helpMessage = m_helpMessage;\r
1620         *o_helpTitle = m_helpTitle;\r
1621 }\r
1622 \r
1623 \r
1624 // command notify\r
1625 void Engine::commandNotify(\r
1626         HWND i_hwnd, UINT i_message, WPARAM i_wParam, LPARAM i_lParam) {\r
1627         Acquire b(&m_log, 0);\r
1628         HWND hf = m_hwndFocus;\r
1629         if (!hf)\r
1630                 return;\r
1631 \r
1632         if (GetWindowThreadProcessId(hf, NULL) ==\r
1633                         GetWindowThreadProcessId(m_hwndAssocWindow, NULL))\r
1634                 return; // inhibit the investigation of MADO TSUKAI NO YUUTSU\r
1635 \r
1636         const _TCHAR *target = NULL;\r
1637         int number_target = 0;\r
1638 \r
1639         if (i_hwnd == hf)\r
1640                 target = _T("ToItself");\r
1641         else if (i_hwnd == GetParent(hf))\r
1642                 target = _T("ToParentWindow");\r
1643         else {\r
1644                 // Function::toMainWindow\r
1645                 HWND h = hf;\r
1646                 while (true) {\r
1647                         HWND p = GetParent(h);\r
1648                         if (!p)\r
1649                                 break;\r
1650                         h = p;\r
1651                 }\r
1652                 if (i_hwnd == h)\r
1653                         target = _T("ToMainWindow");\r
1654                 else {\r
1655                         // Function::toOverlappedWindow\r
1656                         HWND h = hf;\r
1657                         while (h) {\r
1658 #ifdef MAYU64\r
1659                                 LONG_PTR style = GetWindowLongPtr(h, GWL_STYLE);\r
1660 #else\r
1661                                 LONG style = GetWindowLong(h, GWL_STYLE);\r
1662 #endif\r
1663                                 if ((style & WS_CHILD) == 0)\r
1664                                         break;\r
1665                                 h = GetParent(h);\r
1666                         }\r
1667                         if (i_hwnd == h)\r
1668                                 target = _T("ToOverlappedWindow");\r
1669                         else {\r
1670                                 // number\r
1671                                 HWND h = hf;\r
1672                                 for (number_target = 0; h; number_target ++, h = GetParent(h))\r
1673                                         if (i_hwnd == h)\r
1674                                                 break;\r
1675                                 return;\r
1676                         }\r
1677                 }\r
1678         }\r
1679 \r
1680         m_log << _T("&PostMessage(");\r
1681         if (target)\r
1682                 m_log << target;\r
1683         else\r
1684                 m_log << number_target;\r
1685         m_log << _T(", ") << i_message\r
1686         << _T(", 0x") << std::hex << i_wParam\r
1687         << _T(", 0x") << i_lParam << _T(") # hwnd = ")\r
1688         << reinterpret_cast<int>(i_hwnd) << _T(", ")\r
1689         << _T("message = ") << std::dec;\r
1690         if (i_message == WM_COMMAND)\r
1691                 m_log << _T("WM_COMMAND, ");\r
1692         else if (i_message == WM_SYSCOMMAND)\r
1693                 m_log << _T("WM_SYSCOMMAND, ");\r
1694         else\r
1695                 m_log << i_message << _T(", ");\r
1696         m_log << _T("wNotifyCode = ") << HIWORD(i_wParam) << _T(", ")\r
1697         << _T("wID = ") << LOWORD(i_wParam) << _T(", ")\r
1698         << _T("hwndCtrl = 0x") << std::hex << i_lParam << std::dec << std::endl;\r
1699 }\r
1700 \r
1701 unsigned int WINAPI Engine::InputHandler::run(void *i_this)\r
1702 {\r
1703         reinterpret_cast<InputHandler*>(i_this)->run();\r
1704         _endthreadex(0);\r
1705         return 0;\r
1706 }\r
1707 \r
1708 Engine::InputHandler::InputHandler(INSTALL_HOOK i_installHook, INPUT_DETOUR i_inputDetour)\r
1709         : m_installHook(i_installHook), m_inputDetour(i_inputDetour)\r
1710 {\r
1711         CHECK_TRUE(m_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL));\r
1712         CHECK_TRUE(m_hThread = (HANDLE)_beginthreadex(NULL, 0, run, this, CREATE_SUSPENDED, &m_threadId));\r
1713 }\r
1714 \r
1715 Engine::InputHandler::~InputHandler()\r
1716 {\r
1717         CloseHandle(m_hEvent);\r
1718 }\r
1719 \r
1720 void Engine::InputHandler::run()\r
1721 {\r
1722         MSG msg;\r
1723 \r
1724         CHECK_FALSE(m_installHook(m_inputDetour, m_engine, true));\r
1725         PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);\r
1726         SetEvent(m_hEvent);\r
1727 \r
1728         while (GetMessage(&msg, NULL, 0, 0)) {\r
1729                 // nothing to do...\r
1730         }\r
1731 \r
1732         CHECK_FALSE(m_installHook(m_inputDetour, m_engine, false));\r
1733 \r
1734         return;\r
1735 }\r
1736 \r
1737 int Engine::InputHandler::start(Engine *i_engine)\r
1738 {\r
1739         m_engine = i_engine;\r
1740         ResumeThread(m_hThread);\r
1741         WaitForSingleObject(m_hEvent, INFINITE);\r
1742         return 0;\r
1743 }\r
1744 \r
1745 int Engine::InputHandler::stop()\r
1746 {\r
1747         PostThreadMessage(m_threadId, WM_QUIT, 0, 0);\r
1748         WaitForSingleObject(m_hThread, INFINITE);\r
1749         return 0;\r
1750 }\r