00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include "CMSWindowsKeyState.h"
00016 #include "CMSWindowsDesks.h"
00017 #include "CThread.h"
00018 #include "CFunctionJob.h"
00019 #include "CLog.h"
00020 #include "CStringUtil.h"
00021 #include "IEventQueue.h"
00022 #include "TMethodEventJob.h"
00023 #include "CArchMiscWindows.h"
00024
00025
00026 #if !defined(VK_XBUTTON1)
00027 #define VK_XBUTTON1 0x05
00028 #define VK_XBUTTON2 0x06
00029 #endif
00030
00031
00032
00033
00034
00035
00036 const KeyID CMSWindowsKeyState::s_virtualKey[] =
00037 {
00038 { kKeyNone },
00039 { kKeyNone },
00040 { kKeyNone },
00041 { kKeyNone },
00042 { kKeyNone },
00043 { kKeyNone },
00044 { kKeyNone },
00045 { kKeyNone },
00046 { kKeyBackSpace },
00047 { kKeyTab },
00048 { kKeyNone },
00049 { kKeyNone },
00050 { kKeyClear },
00051 { kKeyReturn },
00052 { kKeyNone },
00053 { kKeyNone },
00054 { kKeyShift_L },
00055 { kKeyControl_L },
00056 { kKeyAlt_L },
00057 { kKeyPause },
00058 { kKeyCapsLock },
00059 { kKeyHangulKana },
00060 { kKeyNone },
00061 { kKeyNone },
00062 { kKeyNone },
00063 { kKeyHanjaKanzi },
00064 { kKeyNone },
00065 { kKeyEscape },
00066 { kKeyHenkan },
00067 { kKeyNone },
00068 { kKeyNone },
00069 { kKeyNone },
00070 { kKeyNone },
00071 { kKeyKP_PageUp },
00072 { kKeyKP_PageDown },
00073 { kKeyKP_End },
00074 { kKeyKP_Home },
00075 { kKeyKP_Left },
00076 { kKeyKP_Up },
00077 { kKeyKP_Right },
00078 { kKeyKP_Down },
00079 { kKeySelect },
00080 { kKeyNone },
00081 { kKeyExecute },
00082 { kKeyPrint },
00083 { kKeyKP_Insert },
00084 { kKeyKP_Delete },
00085 { kKeyHelp },
00086 { kKeyNone },
00087 { kKeyNone },
00088 { kKeyNone },
00089 { kKeyNone },
00090 { kKeyNone },
00091 { kKeyNone },
00092 { kKeyNone },
00093 { kKeyNone },
00094 { kKeyNone },
00095 { kKeyNone },
00096 { kKeyNone },
00097 { kKeyNone },
00098 { kKeyNone },
00099 { kKeyNone },
00100 { kKeyNone },
00101 { kKeyNone },
00102 { kKeyNone },
00103 { kKeyNone },
00104 { kKeyNone },
00105 { kKeyNone },
00106 { kKeyNone },
00107 { kKeyNone },
00108 { kKeyNone },
00109 { kKeyNone },
00110 { kKeyNone },
00111 { kKeyNone },
00112 { kKeyNone },
00113 { kKeyNone },
00114 { kKeyNone },
00115 { kKeyNone },
00116 { kKeyNone },
00117 { kKeyNone },
00118 { kKeyNone },
00119 { kKeyNone },
00120 { kKeyNone },
00121 { kKeyNone },
00122 { kKeyNone },
00123 { kKeyNone },
00124 { kKeyNone },
00125 { kKeyNone },
00126 { kKeyNone },
00127 { kKeyNone },
00128 { kKeyNone },
00129 { kKeySuper_L },
00130 { kKeySuper_R },
00131 { kKeyMenu },
00132 { kKeyNone },
00133 { kKeySleep },
00134 { kKeyKP_0 },
00135 { kKeyKP_1 },
00136 { kKeyKP_2 },
00137 { kKeyKP_3 },
00138 { kKeyKP_4 },
00139 { kKeyKP_5 },
00140 { kKeyKP_6 },
00141 { kKeyKP_7 },
00142 { kKeyKP_8 },
00143 { kKeyKP_9 },
00144 { kKeyKP_Multiply },
00145 { kKeyKP_Add },
00146 { kKeyKP_Separator },
00147 { kKeyKP_Subtract },
00148 { kKeyKP_Decimal },
00149 { kKeyNone },
00150 { kKeyF1 },
00151 { kKeyF2 },
00152 { kKeyF3 },
00153 { kKeyF4 },
00154 { kKeyF5 },
00155 { kKeyF6 },
00156 { kKeyF7 },
00157 { kKeyF8 },
00158 { kKeyF9 },
00159 { kKeyF10 },
00160 { kKeyF11 },
00161 { kKeyF12 },
00162 { kKeyF13 },
00163 { kKeyF14 },
00164 { kKeyF15 },
00165 { kKeyF16 },
00166 { kKeyF17 },
00167 { kKeyF18 },
00168 { kKeyF19 },
00169 { kKeyF20 },
00170 { kKeyF21 },
00171 { kKeyF22 },
00172 { kKeyF23 },
00173 { kKeyF24 },
00174 { kKeyNone },
00175 { kKeyNone },
00176 { kKeyNone },
00177 { kKeyNone },
00178 { kKeyNone },
00179 { kKeyNone },
00180 { kKeyNone },
00181 { kKeyNone },
00182 { kKeyNumLock },
00183 { kKeyScrollLock },
00184 { kKeyNone },
00185 { kKeyNone },
00186 { kKeyNone },
00187 { kKeyNone },
00188 { kKeyNone },
00189 { kKeyNone },
00190 { kKeyNone },
00191 { kKeyNone },
00192 { kKeyNone },
00193 { kKeyNone },
00194 { kKeyNone },
00195 { kKeyNone },
00196 { kKeyNone },
00197 { kKeyNone },
00198 { kKeyShift_L },
00199 { kKeyShift_R },
00200 { kKeyControl_L },
00201 { kKeyControl_R },
00202 { kKeyAlt_L },
00203 { kKeyAlt_R },
00204 { kKeyNone },
00205 { kKeyNone },
00206 { kKeyNone },
00207 { kKeyNone },
00208 { kKeyNone },
00209 { kKeyNone },
00210 { kKeyNone },
00211 { kKeyNone },
00212 { kKeyNone },
00213 { kKeyNone },
00214 { kKeyNone },
00215 { kKeyNone },
00216 { kKeyNone },
00217 { kKeyNone },
00218 { kKeyNone },
00219 { kKeyNone },
00220 { kKeyNone },
00221 { kKeyNone },
00222 { kKeyNone },
00223 { kKeyNone },
00224 { kKeyNone },
00225 { kKeyNone },
00226 { kKeyNone },
00227 { kKeyNone },
00228 { kKeyNone },
00229 { kKeyNone },
00230 { kKeyNone },
00231 { kKeyNone },
00232 { kKeyNone },
00233 { kKeyNone },
00234 { kKeyNone },
00235 { kKeyNone },
00236 { kKeyNone },
00237 { kKeyNone },
00238 { kKeyNone },
00239 { kKeyNone },
00240 { kKeyNone },
00241 { kKeyNone },
00242 { kKeyNone },
00243 { kKeyNone },
00244 { kKeyNone },
00245 { kKeyNone },
00246 { kKeyNone },
00247 { kKeyNone },
00248 { kKeyNone },
00249 { kKeyNone },
00250 { kKeyNone },
00251 { kKeyNone },
00252 { kKeyNone },
00253 { kKeyNone },
00254 { kKeyNone },
00255 { kKeyNone },
00256 { kKeyNone },
00257 { kKeyNone },
00258 { kKeyNone },
00259 { kKeyNone },
00260 { kKeyNone },
00261 { kKeyNone },
00262 { kKeyNone },
00263 { kKeyNone },
00264 { kKeyNone },
00265 { kKeyNone },
00266 { kKeyNone },
00267 { kKeyNone },
00268 { kKeyNone },
00269 { kKeyNone },
00270 { kKeyNone },
00271 { kKeyNone },
00272 { kKeyNone },
00273 { kKeyNone },
00274 { kKeyNone },
00275 { kKeyNone },
00276 { kKeyNone },
00277 { kKeyNone },
00278 { kKeyNone },
00279 { kKeyNone },
00280 { kKeyHiraganaKatakana },
00281 { kKeyZenkaku },
00282 { kKeyZenkaku },
00283 { kKeyNone },
00284 { kKeyNone },
00285 { kKeyNone },
00286 { kKeyNone },
00287 { kKeyNone },
00288 { kKeyNone },
00289 { kKeyNone },
00290 { kKeyNone },
00291 { kKeyNone },
00292 { kKeyNone },
00293 { kKeyNone },
00294
00295 { kKeyNone },
00296 { kKeyNone },
00297 { kKeyNone },
00298 { kKeyBreak },
00299 { kKeyNone },
00300 { kKeyNone },
00301 { kKeyNone },
00302 { kKeyNone },
00303 { kKeyNone },
00304 { kKeyNone },
00305 { kKeyNone },
00306 { kKeyNone },
00307 { kKeyClear },
00308 { kKeyKP_Enter },
00309 { kKeyNone },
00310 { kKeyNone },
00311 { kKeyShift_R },
00312 { kKeyControl_R },
00313 { kKeyAlt_R },
00314 { kKeyNone },
00315 { kKeyNone },
00316 { kKeyNone },
00317 { kKeyNone },
00318 { kKeyNone },
00319 { kKeyNone },
00320 { kKeyNone },
00321 { kKeyNone },
00322 { kKeyNone },
00323 { kKeyNone },
00324 { kKeyNone },
00325 { kKeyNone },
00326 { kKeyNone },
00327 { kKeyNone },
00328 { kKeyPageUp },
00329 { kKeyPageDown },
00330 { kKeyEnd },
00331 { kKeyHome },
00332 { kKeyLeft },
00333 { kKeyUp },
00334 { kKeyRight },
00335 { kKeyDown },
00336 { kKeySelect },
00337 { kKeyNone },
00338 { kKeyExecute },
00339 { kKeyPrint },
00340 { kKeyInsert },
00341 { kKeyDelete },
00342 { kKeyHelp },
00343 { kKeyNone },
00344 { kKeyNone },
00345 { kKeyNone },
00346 { kKeyNone },
00347 { kKeyNone },
00348 { kKeyNone },
00349 { kKeyNone },
00350 { kKeyNone },
00351 { kKeyNone },
00352 { kKeyNone },
00353 { kKeyNone },
00354 { kKeyNone },
00355 { kKeyNone },
00356 { kKeyNone },
00357 { kKeyNone },
00358 { kKeyNone },
00359 { kKeyNone },
00360 { kKeyNone },
00361 { kKeyNone },
00362 { kKeyNone },
00363 { kKeyNone },
00364 { kKeyNone },
00365 { kKeyNone },
00366 { kKeyNone },
00367 { kKeyNone },
00368 { kKeyNone },
00369 { kKeyNone },
00370 { kKeyNone },
00371 { kKeyNone },
00372 { kKeyNone },
00373 { kKeyNone },
00374 { kKeyNone },
00375 { kKeyNone },
00376 { kKeyNone },
00377 { kKeyNone },
00378 { kKeyNone },
00379 { kKeyNone },
00380 { kKeyNone },
00381 { kKeyNone },
00382 { kKeyNone },
00383 { kKeyNone },
00384 { kKeyNone },
00385 { kKeyNone },
00386 { kKeySuper_L },
00387 { kKeySuper_R },
00388 { kKeyMenu },
00389 { kKeyNone },
00390 { kKeyNone },
00391 { kKeyNone },
00392 { kKeyNone },
00393 { kKeyNone },
00394 { kKeyNone },
00395 { kKeyNone },
00396 { kKeyNone },
00397 { kKeyNone },
00398 { kKeyNone },
00399 { kKeyNone },
00400 { kKeyNone },
00401 { kKeyNone },
00402 { kKeyNone },
00403 { kKeyKP_Separator },
00404 { kKeyNone },
00405 { kKeyNone },
00406 { kKeyKP_Divide },
00407 { kKeyNone },
00408 { kKeyNone },
00409 { kKeyNone },
00410 { kKeyNone },
00411 { kKeyNone },
00412 { kKeyNone },
00413 { kKeyNone },
00414 { kKeyNone },
00415 { kKeyNone },
00416 { kKeyNone },
00417 { kKeyNone },
00418 { kKeyNone },
00419 { kKeyF13 },
00420 { kKeyF14 },
00421 { kKeyF15 },
00422 { kKeyF16 },
00423 { kKeyF17 },
00424 { kKeyF18 },
00425 { kKeyF19 },
00426 { kKeyF20 },
00427 { kKeyF21 },
00428 { kKeyF22 },
00429 { kKeyF23 },
00430 { kKeyF24 },
00431 { kKeyNone },
00432 { kKeyNone },
00433 { kKeyNone },
00434 { kKeyNone },
00435 { kKeyNone },
00436 { kKeyNone },
00437 { kKeyNone },
00438 { kKeyNone },
00439 { kKeyNumLock },
00440 { kKeyNone },
00441 { kKeyNone },
00442 { kKeyNone },
00443 { kKeyNone },
00444 { kKeyNone },
00445 { kKeyNone },
00446 { kKeyNone },
00447 { kKeyNone },
00448 { kKeyNone },
00449 { kKeyNone },
00450 { kKeyNone },
00451 { kKeyNone },
00452 { kKeyNone },
00453 { kKeyNone },
00454 { kKeyNone },
00455 { kKeyShift_L },
00456 { kKeyShift_R },
00457 { kKeyControl_L },
00458 { kKeyControl_R },
00459 { kKeyAlt_L },
00460 { kKeyAlt_R },
00461 { kKeyWWWBack },
00462 { kKeyWWWForward },
00463 { kKeyWWWRefresh },
00464 { kKeyWWWStop },
00465 { kKeyWWWSearch },
00466 { kKeyWWWFavorites },
00467 { kKeyWWWHome },
00468 { kKeyAudioMute },
00469 { kKeyAudioDown },
00470 { kKeyAudioUp },
00471 { kKeyAudioNext },
00472 { kKeyAudioPrev },
00473 { kKeyAudioStop },
00474 { kKeyAudioPlay },
00475 { kKeyAppMail },
00476 { kKeyAppMedia },
00477 { kKeyAppUser1 },
00478 { kKeyAppUser2 },
00479 { kKeyNone },
00480 { kKeyNone },
00481 { kKeyNone },
00482 { kKeyNone },
00483 { kKeyNone },
00484 { kKeyNone },
00485 { kKeyNone },
00486 { kKeyNone },
00487 { kKeyNone },
00488 { kKeyNone },
00489 { kKeyNone },
00490 { kKeyNone },
00491 { kKeyNone },
00492 { kKeyNone },
00493 { kKeyNone },
00494 { kKeyNone },
00495 { kKeyNone },
00496 { kKeyNone },
00497 { kKeyNone },
00498 { kKeyNone },
00499 { kKeyNone },
00500 { kKeyNone },
00501 { kKeyNone },
00502 { kKeyNone },
00503 { kKeyNone },
00504 { kKeyNone },
00505 { kKeyNone },
00506 { kKeyNone },
00507 { kKeyNone },
00508 { kKeyNone },
00509 { kKeyNone },
00510 { kKeyNone },
00511 { kKeyNone },
00512 { kKeyNone },
00513 { kKeyNone },
00514 { kKeyNone },
00515 { kKeyNone },
00516 { kKeyNone },
00517 { kKeyNone },
00518 { kKeyNone },
00519 { kKeyNone },
00520 { kKeyNone },
00521 { kKeyNone },
00522 { kKeyNone },
00523 { kKeyNone },
00524 { kKeyNone },
00525 { kKeyNone },
00526 { kKeyNone },
00527 { kKeyNone },
00528 { kKeyNone },
00529 { kKeyNone },
00530 { kKeyNone },
00531 { kKeyNone },
00532 { kKeyNone },
00533 { kKeyNone },
00534 { kKeyNone },
00535 { kKeyNone },
00536 { kKeyNone },
00537 { kKeyNone },
00538 { kKeyNone },
00539 { kKeyNone },
00540 { kKeyNone },
00541 { kKeyNone },
00542 { kKeyNone },
00543 { kKeyNone },
00544 { kKeyNone },
00545 { kKeyNone },
00546 { kKeyNone },
00547 { kKeyNone },
00548 { kKeyNone },
00549 { kKeyNone },
00550 { kKeyNone }
00551 };
00552
00553 struct CWin32Modifiers {
00554 public:
00555 UINT m_vk;
00556 KeyModifierMask m_mask;
00557 };
00558
00559 static const CWin32Modifiers s_modifiers[] =
00560 {
00561 { VK_SHIFT, KeyModifierShift },
00562 { VK_LSHIFT, KeyModifierShift },
00563 { VK_RSHIFT, KeyModifierShift },
00564 { VK_CONTROL, KeyModifierControl },
00565 { VK_LCONTROL, KeyModifierControl },
00566 { VK_RCONTROL, KeyModifierControl },
00567 { VK_MENU, KeyModifierAlt },
00568 { VK_LMENU, KeyModifierAlt },
00569 { VK_RMENU, KeyModifierAlt },
00570 { VK_LWIN, KeyModifierSuper },
00571 { VK_RWIN, KeyModifierSuper }
00572 };
00573
00574 CMSWindowsKeyState::CMSWindowsKeyState(CMSWindowsDesks* desks,
00575 void* eventTarget) :
00576 m_is95Family(CArchMiscWindows::isWindows95Family()),
00577 m_eventTarget(eventTarget),
00578 m_desks(desks),
00579 m_keyLayout(GetKeyboardLayout(0)),
00580 m_fixTimer(NULL),
00581 m_lastDown(0),
00582 m_useSavedModifiers(false),
00583 m_savedModifiers(0),
00584 m_originalSavedModifiers(0)
00585 {
00586
00587 HMODULE userModule = GetModuleHandle("user32.dll");
00588 m_ToUnicodeEx = (ToUnicodeEx_t)GetProcAddress(userModule, "ToUnicodeEx");
00589 }
00590
00591 CMSWindowsKeyState::~CMSWindowsKeyState()
00592 {
00593 disable();
00594 }
00595
00596 void
00597 CMSWindowsKeyState::disable()
00598 {
00599 if (m_fixTimer != NULL) {
00600 EVENTQUEUE->removeHandler(CEvent::kTimer, m_fixTimer);
00601 EVENTQUEUE->deleteTimer(m_fixTimer);
00602 m_fixTimer = NULL;
00603 }
00604 m_lastDown = 0;
00605 }
00606
00607 KeyButton
00608 CMSWindowsKeyState::virtualKeyToButton(UINT virtualKey) const
00609 {
00610 return m_virtualKeyToButton[virtualKey & 0xffu];
00611 }
00612
00613 void
00614 CMSWindowsKeyState::setKeyLayout(HKL keyLayout)
00615 {
00616 m_keyLayout = keyLayout;
00617 }
00618
00619 bool
00620 CMSWindowsKeyState::testAutoRepeat(bool press, bool isRepeat, KeyButton button)
00621 {
00622 if (!isRepeat) {
00623 isRepeat = (press && m_lastDown != 0 && button == m_lastDown);
00624 }
00625 if (press) {
00626 m_lastDown = button;
00627 }
00628 else {
00629 m_lastDown = 0;
00630 }
00631 return isRepeat;
00632 }
00633
00634 void
00635 CMSWindowsKeyState::saveModifiers()
00636 {
00637 m_savedModifiers = getActiveModifiers();
00638 m_originalSavedModifiers = m_savedModifiers;
00639 }
00640
00641 void
00642 CMSWindowsKeyState::useSavedModifiers(bool enable)
00643 {
00644 if (enable != m_useSavedModifiers) {
00645 m_useSavedModifiers = enable;
00646 if (!m_useSavedModifiers) {
00647
00648 KeyModifierMask mask = m_originalSavedModifiers ^ m_savedModifiers;
00649 getActiveModifiersRValue() =
00650 (getActiveModifiers() & ~mask) | (m_savedModifiers & mask);
00651 }
00652 }
00653 }
00654
00655 KeyID
00656 CMSWindowsKeyState::mapKeyFromEvent(WPARAM charAndVirtKey,
00657 LPARAM info, KeyModifierMask* maskOut) const
00658 {
00659 static const KeyModifierMask s_controlAlt =
00660 KeyModifierControl | KeyModifierAlt;
00661
00662
00663 char c = (char)((charAndVirtKey & 0xff00u) >> 8);
00664 UINT vkCode = (charAndVirtKey & 0xffu);
00665 bool noAltGr = ((charAndVirtKey & 0xff0000u) != 0);
00666
00667
00668 KeyID id = getKeyID(vkCode, (KeyButton)((info >> 16) & 0x1ffu));
00669
00670
00671 if (id == kKeyNone && c != 0) {
00672 if ((c & 0x80u) == 0) {
00673
00674 id = static_cast<KeyID>(c) & 0xffu;
00675 }
00676 else {
00677
00678
00679
00680
00681 char src = c;
00682 wchar_t unicode;
00683 if (MultiByteToWideChar(CP_THREAD_ACP, MB_PRECOMPOSED,
00684 &src, 1, &unicode, 1) > 0) {
00685 id = static_cast<KeyID>(unicode);
00686 }
00687 else {
00688 id = static_cast<KeyID>(c) & 0xffu;
00689 }
00690 }
00691 }
00692
00693
00694 if (maskOut != NULL) {
00695 KeyModifierMask active = getActiveModifiers();
00696 if (!noAltGr && (active & s_controlAlt) == s_controlAlt) {
00697
00698
00699
00700
00701 active &= ~s_controlAlt;
00702 }
00703 *maskOut = active;
00704 }
00705
00706 return id;
00707 }
00708
00709 bool
00710 CMSWindowsKeyState::didGroupsChange() const
00711 {
00712 GroupList groups;
00713 return (getGroups(groups) && groups != m_groups);
00714 }
00715
00716 UINT
00717 CMSWindowsKeyState::mapKeyToVirtualKey(KeyID key) const
00718 {
00719 if (key == kKeyNone) {
00720 return 0;
00721 }
00722 KeyToVKMap::const_iterator i = m_keyToVKMap.find(key);
00723 if (i == m_keyToVKMap.end()) {
00724 return 0;
00725 }
00726 else {
00727 return i->second;
00728 }
00729 }
00730
00731 void
00732 CMSWindowsKeyState::onKey(KeyButton button, bool down, KeyModifierMask newState)
00733 {
00734
00735 fixKeys();
00736 CKeyState::onKey(button, down, newState);
00737 fixKeys();
00738 }
00739
00740 void
00741 CMSWindowsKeyState::sendKeyEvent(void* target,
00742 bool press, bool isAutoRepeat,
00743 KeyID key, KeyModifierMask mask,
00744 SInt32 count, KeyButton button)
00745 {
00746 if (press || isAutoRepeat) {
00747
00748 if (press && !isAutoRepeat) {
00749 CKeyState::sendKeyEvent(target, true, false,
00750 key, mask, 1, button);
00751 if (count > 0) {
00752 --count;
00753 }
00754 }
00755 if (count >= 1) {
00756 CKeyState::sendKeyEvent(target, true, true,
00757 key, mask, count, button);
00758 }
00759 }
00760 else {
00761
00762 CKeyState::sendKeyEvent(target, false, false, key, mask, 1, button);
00763 }
00764 }
00765
00766 void
00767 CMSWindowsKeyState::fakeKeyDown(KeyID id, KeyModifierMask mask,
00768 KeyButton button)
00769 {
00770 CKeyState::fakeKeyDown(id, mask, button);
00771 }
00772
00773 void
00774 CMSWindowsKeyState::fakeKeyRepeat(KeyID id, KeyModifierMask mask,
00775 SInt32 count, KeyButton button)
00776 {
00777 CKeyState::fakeKeyRepeat(id, mask, count, button);
00778 }
00779
00780 bool
00781 CMSWindowsKeyState::fakeCtrlAltDel()
00782 {
00783 if (!m_is95Family) {
00784
00785
00786
00787
00788
00789 CThread cad(new CFunctionJob(&CMSWindowsKeyState::ctrlAltDelThread));
00790 cad.wait();
00791 }
00792 else {
00793
00794 fakeKeyDown(kKeyDelete, KeyModifierControl | KeyModifierAlt,
00795 virtualKeyToButton(VK_DELETE));
00796 }
00797 return true;
00798 }
00799
00800 void
00801 CMSWindowsKeyState::ctrlAltDelThread(void*)
00802 {
00803
00804 HDESK desk = OpenDesktop("Winlogon", 0, FALSE, MAXIMUM_ALLOWED);
00805 if (desk != NULL) {
00806 if (SetThreadDesktop(desk)) {
00807 PostMessage(HWND_BROADCAST, WM_HOTKEY, 0,
00808 MAKELPARAM(MOD_CONTROL | MOD_ALT, VK_DELETE));
00809 }
00810 else {
00811 LOG((CLOG_DEBUG "can't switch to Winlogon desk: %d", GetLastError()));
00812 }
00813 CloseDesktop(desk);
00814 }
00815 else {
00816 LOG((CLOG_DEBUG "can't open Winlogon desk: %d", GetLastError()));
00817 }
00818 }
00819
00820 KeyModifierMask
00821 CMSWindowsKeyState::pollActiveModifiers() const
00822 {
00823 KeyModifierMask state = 0;
00824
00825
00826 for (size_t i = 0; i < sizeof(s_modifiers) / sizeof(s_modifiers[0]); ++i) {
00827 KeyButton button = virtualKeyToButton(s_modifiers[i].m_vk);
00828 if (button != 0 && isKeyDown(button)) {
00829 state |= s_modifiers[i].m_mask;
00830 }
00831 }
00832
00833
00834 if ((GetKeyState(VK_CAPITAL) & 0x01) != 0) {
00835 state |= KeyModifierCapsLock;
00836 }
00837 if ((GetKeyState(VK_NUMLOCK) & 0x01) != 0) {
00838 state |= KeyModifierNumLock;
00839 }
00840 if ((GetKeyState(VK_SCROLL) & 0x01) != 0) {
00841 state |= KeyModifierScrollLock;
00842 }
00843
00844 return state;
00845 }
00846
00847 SInt32
00848 CMSWindowsKeyState::pollActiveGroup() const
00849 {
00850
00851 HWND targetWindow = GetForegroundWindow();
00852 DWORD targetThread = GetWindowThreadProcessId(targetWindow, NULL);
00853
00854
00855 HKL hkl = GetKeyboardLayout(targetThread);
00856
00857
00858 GroupMap::const_iterator i = m_groupMap.find(hkl);
00859 if (i == m_groupMap.end()) {
00860 LOG((CLOG_DEBUG1 "can't find keyboard layout %08x", hkl));
00861 return 0;
00862 }
00863
00864 return i->second;
00865 }
00866
00867 void
00868 CMSWindowsKeyState::pollPressedKeys(KeyButtonSet& pressedKeys) const
00869 {
00870 BYTE keyState[256];
00871 GetKeyboardState(keyState);
00872 for (KeyButton i = 1; i < 256; ++i) {
00873 if ((keyState[i] & 0x80) != 0) {
00874 pressedKeys.insert(i);
00875 }
00876 }
00877 }
00878
00879 void
00880 CMSWindowsKeyState::getKeyMap(CKeyMap& keyMap)
00881 {
00882
00883 if (getGroups(m_groups)) {
00884 m_groupMap.clear();
00885 SInt32 numGroups = (SInt32)m_groups.size();
00886 for (SInt32 g = 0; g < numGroups; ++g) {
00887 m_groupMap[m_groups[g]] = g;
00888 }
00889 }
00890 HKL activeLayout = GetKeyboardLayout(0);
00891
00892
00893 memset(m_virtualKeyToButton, 0, sizeof(m_virtualKeyToButton));
00894 m_keyToVKMap.clear();
00895
00896 CKeyMap::KeyItem item;
00897 SInt32 numGroups = (SInt32)m_groups.size();
00898 for (SInt32 g = 0; g < numGroups; ++g) {
00899 item.m_group = g;
00900 ActivateKeyboardLayout(m_groups[g], 0);
00901
00902
00903 memset(m_buttonToVK, 0, sizeof(m_buttonToVK));
00904 memset(m_buttonToNumpadVK, 0, sizeof(m_buttonToNumpadVK));
00905
00906
00907 for (KeyButton i = 1; i < 256; ++i) {
00908 UINT vk = MapVirtualKey(i, 1);
00909 if (vk == 0) {
00910
00911 continue;
00912 }
00913
00914
00915 switch (vk) {
00916 case VK_SHIFT:
00917 if (MapVirtualKey(VK_RSHIFT, 0) == i) {
00918 vk = VK_RSHIFT;
00919 }
00920 else {
00921 vk = VK_LSHIFT;
00922 }
00923 break;
00924
00925 case VK_CONTROL:
00926 vk = VK_LCONTROL;
00927 break;
00928
00929 case VK_MENU:
00930 vk = VK_LMENU;
00931 break;
00932
00933 case VK_NUMLOCK:
00934 vk = VK_PAUSE;
00935 break;
00936
00937 case VK_NUMPAD0:
00938 case VK_NUMPAD1:
00939 case VK_NUMPAD2:
00940 case VK_NUMPAD3:
00941 case VK_NUMPAD4:
00942 case VK_NUMPAD5:
00943 case VK_NUMPAD6:
00944 case VK_NUMPAD7:
00945 case VK_NUMPAD8:
00946 case VK_NUMPAD9:
00947 case VK_DECIMAL:
00948
00949 m_buttonToNumpadVK[i] = vk;
00950 continue;
00951
00952 case VK_LWIN:
00953 case VK_RWIN:
00954
00955 if (m_is95Family) {
00956 m_buttonToVK[i | 0x100u] = vk;
00957 continue;
00958 }
00959 break;
00960
00961 case VK_RETURN:
00962 case VK_PRIOR:
00963 case VK_NEXT:
00964 case VK_END:
00965 case VK_HOME:
00966 case VK_LEFT:
00967 case VK_UP:
00968 case VK_RIGHT:
00969 case VK_DOWN:
00970 case VK_INSERT:
00971 case VK_DELETE:
00972
00973 m_buttonToVK[i | 0x100u] = vk;
00974 break;
00975 }
00976
00977 if (m_buttonToVK[i] == 0) {
00978 m_buttonToVK[i] = vk;
00979 }
00980 }
00981
00982
00983
00984
00985
00986
00987 for (UINT i = 1; i < 255; ++i) {
00988
00989 switch (i) {
00990 case VK_LBUTTON:
00991 case VK_RBUTTON:
00992 case VK_MBUTTON:
00993 case VK_XBUTTON1:
00994 case VK_XBUTTON2:
00995 case VK_SHIFT:
00996 case VK_CONTROL:
00997 case VK_MENU:
00998 continue;
00999 }
01000
01001
01002 KeyButton button = static_cast<KeyButton>(MapVirtualKey(i, 0));
01003 if (button == 0) {
01004 continue;
01005 }
01006
01007
01008 switch (i) {
01009 case VK_NUMPAD0:
01010 case VK_NUMPAD1:
01011 case VK_NUMPAD2:
01012 case VK_NUMPAD3:
01013 case VK_NUMPAD4:
01014 case VK_NUMPAD5:
01015 case VK_NUMPAD6:
01016 case VK_NUMPAD7:
01017 case VK_NUMPAD8:
01018 case VK_NUMPAD9:
01019 case VK_DECIMAL:
01020 m_buttonToNumpadVK[button] = i;
01021 break;
01022
01023 default:
01024
01025 if (m_buttonToVK[button] != i) {
01026 m_buttonToVK[button | 0x100u] = i;
01027 }
01028 break;
01029 }
01030 }
01031
01032
01033 if (m_buttonToVK[0x54u] == 0) {
01034 m_buttonToVK[0x54u] = VK_SNAPSHOT;
01035 }
01036
01037
01038 if (GetKeyboardLayout(0) == m_groups[g]) {
01039 for (KeyButton i = 0; i < 512; ++i) {
01040 if (m_buttonToVK[i] != 0) {
01041 if (m_virtualKeyToButton[m_buttonToVK[i]] == 0) {
01042 m_virtualKeyToButton[m_buttonToVK[i]] = i;
01043 }
01044 }
01045 if (m_buttonToNumpadVK[i] != 0) {
01046 if (m_virtualKeyToButton[m_buttonToNumpadVK[i]] == 0) {
01047 m_virtualKeyToButton[m_buttonToNumpadVK[i]] = i;
01048 }
01049 }
01050 }
01051 }
01052
01053
01054 for (KeyButton i = 0; i < 512; ++i) {
01055 if (m_buttonToNumpadVK[i] != 0) {
01056 item.m_id = getKeyID(m_buttonToNumpadVK[i], i);
01057 item.m_button = i;
01058 item.m_required = KeyModifierNumLock;
01059 item.m_sensitive = KeyModifierNumLock | KeyModifierShift;
01060 item.m_generates = 0;
01061 item.m_client = m_buttonToNumpadVK[i];
01062 addKeyEntry(keyMap, item);
01063 }
01064 }
01065
01066
01067 BYTE keys[256];
01068 memset(keys, 0, sizeof(keys));
01069 for (KeyButton i = 0; i < 512; ++i) {
01070 if (m_buttonToVK[i] != 0) {
01071
01072 item.m_id = getKeyID(m_buttonToVK[i], i);
01073 item.m_button = i;
01074 item.m_required = 0;
01075 item.m_sensitive = 0;
01076 item.m_client = m_buttonToVK[i];
01077
01078
01079 CKeyMap::initModifierKey(item);
01080
01081 if (item.m_id == 0) {
01082
01083
01084 struct Modifier {
01085 UINT m_vk1;
01086 UINT m_vk2;
01087 BYTE m_state;
01088 KeyModifierMask m_mask;
01089 };
01090 static const Modifier modifiers[] = {
01091 { VK_SHIFT, VK_SHIFT, 0x80u, KeyModifierShift },
01092 { VK_CAPITAL, VK_CAPITAL, 0x01u, KeyModifierCapsLock },
01093 { VK_CONTROL, VK_MENU, 0x80u, KeyModifierControl |
01094 KeyModifierAlt }
01095 };
01096 static const size_t s_numModifiers =
01097 sizeof(modifiers) / sizeof(modifiers[0]);
01098 static const size_t s_numCombinations = 1 << s_numModifiers;
01099 KeyID id[s_numCombinations];
01100
01101 bool anyFound = false;
01102 KeyButton button = static_cast<KeyButton>(i & 0xffu);
01103 for (size_t j = 0; j < s_numCombinations; ++j) {
01104 for (size_t k = 0; k < s_numModifiers; ++k) {
01105 if ((j & (1 << k)) != 0) {
01106 keys[modifiers[k].m_vk1] = modifiers[k].m_state;
01107 keys[modifiers[k].m_vk2] = modifiers[k].m_state;
01108 }
01109 else {
01110 keys[modifiers[k].m_vk1] = 0;
01111 keys[modifiers[k].m_vk2] = 0;
01112 }
01113 }
01114 id[j] = getIDForKey(item, button,
01115 m_buttonToVK[i], keys, m_groups[g]);
01116 if (id[j] != 0) {
01117 anyFound = true;
01118 }
01119 }
01120
01121 if (anyFound) {
01122
01123
01124
01125 item.m_sensitive = 0;
01126 for (size_t k = 0; k < s_numModifiers; ++k) {
01127 for (size_t j = 0; j < s_numCombinations; ++j) {
01128 if (id[j] != id[j ^ (1u << k)]) {
01129 item.m_sensitive |= modifiers[k].m_mask;
01130 break;
01131 }
01132 }
01133 }
01134
01135
01136
01137
01138 for (size_t j = 0; j < s_numCombinations; ++j) {
01139 item.m_id = id[j];
01140 item.m_required = 0;
01141 for (size_t k = 0; k < s_numModifiers; ++k) {
01142 if ((j & (1 << k)) != 0) {
01143 item.m_required |= modifiers[k].m_mask;
01144 }
01145 }
01146 addKeyEntry(keyMap, item);
01147 }
01148 }
01149 }
01150 else {
01151
01152 switch (m_buttonToVK[i]) {
01153 case VK_TAB:
01154
01155 item.m_id = kKeyLeftTab;
01156 item.m_required |= KeyModifierShift;
01157 item.m_sensitive |= KeyModifierShift;
01158 addKeyEntry(keyMap, item);
01159 item.m_id = kKeyTab;
01160 item.m_required &= ~KeyModifierShift;
01161 break;
01162
01163 case VK_CANCEL:
01164 item.m_required |= KeyModifierControl;
01165 item.m_sensitive |= KeyModifierControl;
01166 break;
01167
01168 case VK_SNAPSHOT:
01169 item.m_sensitive |= KeyModifierAlt;
01170 if ((i & 0x100u) == 0) {
01171
01172 item.m_required |= KeyModifierAlt;
01173 }
01174 break;
01175 }
01176 addKeyEntry(keyMap, item);
01177 }
01178 }
01179 }
01180 }
01181
01182
01183 ActivateKeyboardLayout(activeLayout, 0);
01184 }
01185
01186 void
01187 CMSWindowsKeyState::fakeKey(const Keystroke& keystroke)
01188 {
01189 switch (keystroke.m_type) {
01190 case Keystroke::kButton: {
01191 LOG((CLOG_DEBUG1 " %03x (%08x) %s", keystroke.m_data.m_button.m_button, keystroke.m_data.m_button.m_client, keystroke.m_data.m_button.m_press ? "down" : "up"));
01192 KeyButton button = keystroke.m_data.m_button.m_button;
01193
01194
01195 if (keystroke.m_data.m_button.m_repeat &&
01196 !keystroke.m_data.m_button.m_press) {
01197 LOG((CLOG_DEBUG1 " discard key repeat release"));
01198 break;
01199 }
01200
01201
01202 UINT vk = keystroke.m_data.m_button.m_client;
01203
01204
01205 if (vk == VK_SNAPSHOT) {
01206 if ((getActiveModifiers() & KeyModifierAlt) != 0) {
01207
01208 button = 1;
01209 }
01210 else {
01211
01212 button = 0;
01213 }
01214 }
01215
01216
01217 m_desks->fakeKeyEvent(button, vk,
01218 keystroke.m_data.m_button.m_press,
01219 keystroke.m_data.m_button.m_repeat);
01220 break;
01221 }
01222
01223 case Keystroke::kGroup:
01224
01225
01226
01227 if (!keystroke.m_data.m_group.m_restore) {
01228 if (keystroke.m_data.m_group.m_absolute) {
01229 LOG((CLOG_DEBUG1 " group %d", keystroke.m_data.m_group.m_group));
01230 setWindowGroup(keystroke.m_data.m_group.m_group);
01231 }
01232 else {
01233 LOG((CLOG_DEBUG1 " group %+d", keystroke.m_data.m_group.m_group));
01234 setWindowGroup(getEffectiveGroup(pollActiveGroup(),
01235 keystroke.m_data.m_group.m_group));
01236 }
01237 }
01238 break;
01239 }
01240 }
01241
01242 KeyModifierMask&
01243 CMSWindowsKeyState::getActiveModifiersRValue()
01244 {
01245 if (m_useSavedModifiers) {
01246 return m_savedModifiers;
01247 }
01248 else {
01249 return CKeyState::getActiveModifiersRValue();
01250 }
01251 }
01252
01253 bool
01254 CMSWindowsKeyState::getGroups(GroupList& groups) const
01255 {
01256
01257 UInt32 newNumLayouts = GetKeyboardLayoutList(0, NULL);
01258 if (newNumLayouts == 0) {
01259 LOG((CLOG_DEBUG1 "can't get keyboard layouts"));
01260 return false;
01261 }
01262 HKL* newLayouts = new HKL[newNumLayouts];
01263 newNumLayouts = GetKeyboardLayoutList(newNumLayouts, newLayouts);
01264 if (newNumLayouts == 0) {
01265 LOG((CLOG_DEBUG1 "can't get keyboard layouts"));
01266 delete[] newLayouts;
01267 return false;
01268 }
01269
01270 groups.clear();
01271 groups.insert(groups.end(), newLayouts, newLayouts + newNumLayouts);
01272 delete[] newLayouts;
01273 return true;
01274 }
01275
01276 void
01277 CMSWindowsKeyState::setWindowGroup(SInt32 group)
01278 {
01279 HWND targetWindow = GetForegroundWindow();
01280
01281 bool sysCharSet = true;
01282
01283
01284
01285 PostMessage(targetWindow, WM_INPUTLANGCHANGEREQUEST,
01286 sysCharSet ? 1 : 0, (LPARAM)m_groups[group]);
01287
01288
01289
01290
01291
01292 Sleep(100);
01293 }
01294
01295 void
01296 CMSWindowsKeyState::fixKeys()
01297 {
01298
01299
01300
01301
01302
01303
01304
01305
01306
01307
01308 if (!m_is95Family) {
01309 return;
01310 }
01311
01312 KeyButton leftButton = virtualKeyToButton(VK_LWIN);
01313 KeyButton rightButton = virtualKeyToButton(VK_RWIN);
01314 bool leftDown = isKeyDown(leftButton);
01315 bool rightDown = isKeyDown(rightButton);
01316 bool fix = (leftDown || rightDown);
01317 if (fix) {
01318
01319 bool leftAsyncDown = ((GetAsyncKeyState(VK_LWIN) & 0x8000) != 0);
01320 bool rightAsyncDown = ((GetAsyncKeyState(VK_RWIN) & 0x8000) != 0);
01321
01322 if (leftAsyncDown != leftDown || rightAsyncDown != rightDown) {
01323 KeyModifierMask state = getActiveModifiers();
01324 if (!leftAsyncDown && !rightAsyncDown) {
01325
01326 state &= ~KeyModifierSuper;
01327 }
01328
01329
01330 if (leftDown && !leftAsyncDown) {
01331 LOG((CLOG_DEBUG1 "event: fake key release left windows key (0x%03x)", leftButton));
01332 CKeyState::onKey(leftButton, false, state);
01333 CKeyState::sendKeyEvent(m_eventTarget, false, false,
01334 kKeySuper_L, state, 1, leftButton);
01335 }
01336 if (rightDown && !rightAsyncDown) {
01337 LOG((CLOG_DEBUG1 "event: fake key release right windows key (0x%03x)", rightButton));
01338 CKeyState::onKey(rightButton, false, state);
01339 CKeyState::sendKeyEvent(m_eventTarget, false, false,
01340 kKeySuper_R, state, 1, rightButton);
01341 }
01342 }
01343 }
01344
01345 if (fix && m_fixTimer == NULL) {
01346
01347 m_fixTimer = EVENTQUEUE->newTimer(0.1, NULL);
01348 EVENTQUEUE->adoptHandler(CEvent::kTimer, m_fixTimer,
01349 new TMethodEventJob<CMSWindowsKeyState>(
01350 this, &CMSWindowsKeyState::handleFixKeys));
01351 }
01352 else if (!fix && m_fixTimer != NULL) {
01353
01354 EVENTQUEUE->removeHandler(CEvent::kTimer, m_fixTimer);
01355 EVENTQUEUE->deleteTimer(m_fixTimer);
01356 m_fixTimer = NULL;
01357 }
01358 }
01359
01360 void
01361 CMSWindowsKeyState::handleFixKeys(const CEvent&, void*)
01362 {
01363 fixKeys();
01364 }
01365
01366 KeyID
01367 CMSWindowsKeyState::getKeyID(UINT virtualKey, KeyButton button)
01368 {
01369 if ((button & 0x100u) != 0) {
01370 virtualKey += 0x100u;
01371 }
01372 return s_virtualKey[virtualKey];
01373 }
01374
01375 KeyID
01376 CMSWindowsKeyState::getIDForKey(CKeyMap::KeyItem& item,
01377 KeyButton button, UINT virtualKey,
01378 PBYTE keyState, HKL hkl) const
01379 {
01380 int n;
01381 KeyID id;
01382 if (m_is95Family) {
01383
01384 WORD ascii;
01385 n = ToAsciiEx(virtualKey, button, keyState, &ascii, 0, hkl);
01386 id = static_cast<KeyID>(ascii & 0xffu);
01387 }
01388 else {
01389 WCHAR unicode[2];
01390 n = m_ToUnicodeEx(virtualKey, button, keyState,
01391 unicode, sizeof(unicode) / sizeof(unicode[0]),
01392 0, hkl);
01393 id = static_cast<KeyID>(unicode[0]);
01394 }
01395 switch (n) {
01396 case -1:
01397 return CKeyMap::getDeadKey(id);
01398
01399 default:
01400 case 0:
01401
01402 return kKeyNone;
01403
01404 case 1:
01405 return id;
01406
01407 case 2:
01408
01409 return getIDForKey(item, button, virtualKey, keyState, hkl);
01410 }
01411 }
01412
01413 void
01414 CMSWindowsKeyState::addKeyEntry(CKeyMap& keyMap, CKeyMap::KeyItem& item)
01415 {
01416 keyMap.addKeyEntry(item);
01417 if (item.m_group == 0) {
01418 m_keyToVKMap[item.m_id] = static_cast<UINT>(item.m_client);
01419 }
01420 }