00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
#include "precomp.h"
00014
#pragma hdrstop
00015
#include <ntddmou.h>
00016
00017
00018 PKWAIT_BLOCK gWaitBlockArray;
00019
00020 KEYBOARD_UNIT_ID_PARAMETER
kuid;
00021 MOUSE_UNIT_ID_PARAMETER
muid;
00022
00023 #define UPDATE_KBD_TYPEMATIC 1
00024 #define UPDATE_KBD_LEDS 2
00025
00026
void ProcessQueuedMouseEvents(
void);
00027
VOID RawInputThread(PVOID pVoid);
00028 LONG
DoMouseAccel(LONG delta);
00029
VOID GetMouseCoord(LONG dx, LONG dy, DWORD dwFlags, LONG time, ULONG_PTR ExtraInfo, PPOINT ppt);
00030
VOID xxxMoveEventAbsolute(LONG x, LONG y, ULONG_PTR dwExtraInfo, DWORD time,
00031 BOOL bInjected);
00032 INT idxRemainder,
idyRemainder ;
00033
00034
00035
00036
00037
#ifdef DIAGNOSE_IO
00038 ULONG
gMouseProcessMiceInputTime = 0;
00039 ULONG
gMouseQueueMouseEventTime = 0;
00040 ULONG
gMouseUnqueueMouseEventTime = 0;
00041
00042
00043
00044
00045
00046
00047
00048 ULONG
MonotonicTick()
00049 {
00050
static ULONG lasttick = 0;
00051 ULONG newtick;
00052
00053 newtick =
NtGetTickCount();
00054
if (newtick > lasttick) {
00055 lasttick = newtick;
00056 }
else {
00057 lasttick++;
00058 }
00059
return lasttick;
00060 }
00061
00062
#endif
00063
00064
00065
00066
00067 #define MOUSE_BUTTON_LEFT 0x0001
00068 #define MOUSE_BUTTON_RIGHT 0x0002
00069 #define MOUSE_BUTTON_MIDDLE 0x0004
00070 #define MOUSE_BUTTON_X1 0x0008
00071 #define MOUSE_BUTTON_X2 0x0010
00072
00073 #define ID_INPUT 0
00074 #define ID_MOUSE 1
00075
00076 #define ID_TIMER 2
00077 #define ID_HIDCHANGE 3
00078 #define ID_NUMBER_NON_HYDRA_HANDLES 4
00079
00080 #define ID_SHUTDOWN 4
00081 #define ID_WDTIMER 5
00082 PKTIMER gptmrWD;
00083
00084 PVOID *
apObjects;
00085
00086 typedef struct _RIT_INIT {
00087 PTERMINAL pTerm;
00088 PKEVENT pRitReadyEvent;
00089 }
RIT_INIT, *
PRIT_INIT;
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100 #define fAbsoluteMouse( pmei ) \
00101
(((pmei)->Flags & MOUSE_MOVE_ABSOLUTE) != 0)
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
#if ((MOUSEEVENTF_ABSOLUTE >> 15) ^ MOUSE_MOVE_ABSOLUTE) || \
00114
((MOUSEEVENTF_VIRTUALDESK >> 13) ^ MOUSE_VIRTUAL_DESKTOP)
00115
# error("Bit mapping broken: fix ConvertToMouseDriverFlags")
00116
#endif
00117
00118 #define ConvertToMouseDriverFlags( Flags ) \
00119
(((Flags) & MOUSEEVENTF_ABSOLUTE) >> 15 | \
00120
((Flags) & MOUSEEVENTF_VIRTUALDESK) >> 13)
00121
00122 #define VKTOMODIFIERS(Vk) ((((Vk) >= VK_SHIFT) && ((Vk) <= VK_MENU)) ? \
00123
(MOD_SHIFT >> ((Vk) - VK_SHIFT)) : \
00124
0)
00125
#if (VKTOMODIFIERS(VK_SHIFT) != MOD_SHIFT) || \
00126
(VKTOMODIFIERS(VK_CONTROL) != MOD_CONTROL) || \
00127
(VKTOMODIFIERS(VK_MENU) != MOD_ALT)
00128
# error("VKTOMODIFIERS broken")
00129
#endif
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140 BOOL xxxInitInput(
00141
PTERMINAL pTerm)
00142 {
00143
NTSTATUS Status;
00144 HANDLE hThreadRawInput;
00145
RIT_INIT initData;
00146 UserAssert(pTerm !=
NULL);
00147
00148
#ifdef MOUSE_LOCK_CODE
00149
00150
00151
00152 LockMouseInputCodePages();
00153
#endif
00154
00155 initData.
pTerm = pTerm;
00156 initData.
pRitReadyEvent =
CreateKernelEvent(SynchronizationEvent,
FALSE);
00157
if (initData.
pRitReadyEvent ==
NULL) {
00158
return FALSE;
00159 }
00160
00161
00162
00163
LeaveCrit();
00164
Status =
CreateSystemThread((
PKSTART_ROUTINE)
RawInputThread, &initData,
00165 &hThreadRawInput);
00166
if (!
NT_SUCCESS(
Status)) {
00167
goto Exit;
00168 }
00169 ZwClose(hThreadRawInput);
00170
00171
KeWaitForSingleObject(initData.
pRitReadyEvent,
WrUserRequest,
00172
KernelMode,
FALSE,
NULL);
00173 Exit:
00174
FreeKernelEvent(&initData.
pRitReadyEvent);
00175
EnterCrit();
00176
00177
return (
gptiRit !=
NULL);
00178 }
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
PSCANCODEMAP
00194 InitScancodeMap()
00195 {
00196 LPBYTE pb =
NULL;
00197
DWORD dwBytes;
00198
00199
00200
00201
00202 dwBytes =
FastGetProfileValue(
NULL,
PMAP_KBDLAYOUT,
L"Scancode Map",
NULL,
NULL, 0);
00203
00204
00205
00206
00207
if (dwBytes >
sizeof(
SCANCODEMAP)) {
00208
if ((pb = UserAllocPoolZInit(dwBytes, TAG_SCANCODEMAP)) != 0) {
00209 dwBytes =
FastGetProfileValue(
NULL,
PMAP_KBDLAYOUT,
L"Scancode Map",
00210
NULL, pb, dwBytes);
00211 }
00212 }
00213
00214
#ifdef LATER
00215
00216
00217
00218
00219
00220
00221
00222
if (
gbRemoteSession && dwBytes) {
00223
00224 ZwDeviceIoControlFile(
ghRemoteKeyboardChannel,
NULL,
NULL,
NULL,
00225 &
giosbKbdControl, IOCTL_KEYBOARD_ICA_SCANMAP, pb, dwBytes,
00226
NULL, 0);
00227
00228 }
00229
#endif // LATER
00230
00231
return (
PSCANCODEMAP)pb;
00232 }
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
BOOL
00256 MapScancode(
00257 PBYTE pbScanCode,
00258 PBYTE pbPrefix
00259 )
00260 {
00261
DWORD *pdw;
00262 WORD wT = MAKEWORD(*pbScanCode, *pbPrefix);
00263
00264
CheckCritIn();
00265 UserAssert(
gpScancodeMap !=
NULL);
00266
00267
for (pdw = &(
gpScancodeMap->dwMap[0]); *pdw; pdw++) {
00268
if (HIWORD(*pdw) == wT) {
00269 wT = LOWORD(*pdw);
00270 *pbScanCode =
LOBYTE(wT);
00271 *pbPrefix =
HIBYTE(wT);
00272
return TRUE;
00273 }
00274 }
00275
return FALSE;
00276 }
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289 VOID InitMice()
00290 {
00291
CLEAR_ACCF(
ACCF_MKVIRTUALMOUSE);
00292
CLEAR_GTERMF(
GTERMF_MOUSE);
00293
SYSMET(MOUSEPRESENT) =
FALSE;
00294
SYSMET(CMOUSEBUTTONS) = 0;
00295
SYSMET(MOUSEWHEELPRESENT) =
FALSE;
00296 }
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313 PDEVICEINFO FreeDeviceInfo(
PDEVICEINFO pDeviceInfo)
00314 {
00315
PDEVICEINFO *ppDeviceInfo;
00316
00317
CheckDeviceInfoListCritIn();
00318
00319 TAGMSG1(DBGTAG_PNP,
"FreeDeviceInfo(%#p)", pDeviceInfo);
00320
00321
00322
00323
00324
00325
00326
00327
if (pDeviceInfo->bFlags &
GDIF_READING) {
00328
#if DIAGNOSE_IO
00329
pDeviceInfo->bFlags |=
GDIF_READERMUSTFREE;
00330
#endif
00331
TAGMSG1(DBGTAG_PNP,
"** FreeDeviceInfo(%#p) DEFERRED : reader must free", pDeviceInfo);
00332 pDeviceInfo->usActions |=
GDIAF_FREEME;
00333
return pDeviceInfo->pNext;
00334 }
00335
00336
00337
00338
00339
00340
00341
if (pDeviceInfo->usActions &
GDIAF_PNPWAITING) {
00342
#if DIAGNOSE_IO
00343
pDeviceInfo->bFlags |=
GDIF_PNPMUSTFREE;
00344
#endif
00345
TAGMSG1(DBGTAG_PNP,
"** FreeDeviceInfo(%#p) DEFERRED : PnP must free", pDeviceInfo);
00346 pDeviceInfo->usActions |=
GDIAF_FREEME;
00347
KeSetEvent(pDeviceInfo->pkeHidChangeCompleted,
EVENT_INCREMENT,
FALSE);
00348
return pDeviceInfo->pNext;
00349 }
00350
00351 ppDeviceInfo = &
gpDeviceInfoList;
00352
00353
while (*ppDeviceInfo) {
00354
if (*ppDeviceInfo == pDeviceInfo) {
00355
00356
00357
00358
if (pDeviceInfo->pkeHidChangeCompleted !=
NULL) {
00359
FreeKernelEvent(&pDeviceInfo->pkeHidChangeCompleted);
00360 }
00361
if (pDeviceInfo->ustrName.Buffer !=
NULL) {
00362 UserFreePool(pDeviceInfo->ustrName.Buffer);
00363 }
00364 *ppDeviceInfo = pDeviceInfo->pNext;
00365 UserFreePool(pDeviceInfo);
00366
00367
return *ppDeviceInfo;
00368 }
00369 ppDeviceInfo = &(*ppDeviceInfo)->pNext;
00370 }
00371 RIPMSG1(RIP_ERROR,
"pDeviceInfo %#p not found in gpDeviceInfoList", pDeviceInfo);
00372
00373
return NULL;
00374 }
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385 void UpdateMouseInfo(
void)
00386 {
00387
DEVICEINFO *pDeviceInfo;
00388
CheckCritIn();
00389
00390 UserAssert(
gbRemoteSession);
00391
00392
if (
ghRemoteMouseChannel ==
NULL) {
00393
return;
00394 }
00395
00396 UserAssert(
gnMice == 1);
00397
00398
00399
00400
00401
EnterDeviceInfoListCrit();
00402
for (pDeviceInfo =
gpDeviceInfoList; pDeviceInfo; pDeviceInfo = pDeviceInfo->pNext) {
00403
if (pDeviceInfo->type ==
DEVICE_TYPE_MOUSE) {
00404 TAGMSG1(DBGTAG_PNP,
"UpdateMouseInfo(): pDeviceInfo %#p ARRIVED", pDeviceInfo);
00405
RequestDeviceChange(pDeviceInfo,
GDIAF_ARRIVED |
GDIAF_RECONNECT,
TRUE);
00406 }
00407 }
00408
LeaveDeviceInfoListCrit();
00409 }
00410
00411
00412
NTSTATUS DeviceNotify(IN PPLUGPLAY_NOTIFY_HDR, IN
PDEVICEINFO);
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
00426
00427
00428 VOID InitKeyboard(VOID)
00429 {
00430
if (!
gbRemoteSession) {
00431
00432
00433
00434
gpScancodeMap =
InitScancodeMap();
00435 }
00436 }
00437
00438
00439 HKL
GetActiveHKL()
00440 {
00441
CheckCritIn();
00442
if (
gpqForeground &&
gpqForeground->
spwndActive) {
00443
PTHREADINFO ptiForeground =
GETPTI(
gpqForeground->
spwndActive);
00444
if (ptiForeground && ptiForeground->
spklActive) {
00445
return ptiForeground->
spklActive->
hkl;
00446 }
00447 }
00448
return _GetKeyboardLayout(0
L);
00449 }
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472 VOID xxxButtonEvent(
00473 DWORD ButtonNumber,
00474 POINT ptPointer,
00475 BOOL fBreak,
00476 DWORD time,
00477 ULONG_PTR ExtraInfo,
00478 BOOL bInjected,
00479 BOOL fDblClk)
00480 {
00481
UINT message, usVK, usOtherVK, wHardwareButton;
00482
PWND pwnd;
00483 LPARAM lParam;
00484 WPARAM wParam;
00485
int xbutton;
00486
TL tlpwnd;
00487
PHOOK pHook;
00488
00489
#ifdef REDIRECTION
00490
PWND pwndStart;
00491
#endif // REDIRECTION
00492
00493
CheckCritIn();
00494
00495
00496
00497
00498
00499
if (
gspwndAltTab !=
NULL) {
00500
xxxCancelCoolSwitch();
00501 }
00502
00503
00504
00505
00506
00507
00508 wHardwareButton = (
UINT)ButtonNumber;
00509
00510
00511
00512
00513
00514
if (ButtonNumber & (
MOUSE_BUTTON_LEFT |
MOUSE_BUTTON_RIGHT)) {
00515
00516
00517
00518
if (
SYSMET(SWAPBUTTON)) {
00519 ButtonNumber ^= (
MOUSE_BUTTON_LEFT |
MOUSE_BUTTON_RIGHT);
00520 }
00521
00522
00523
00524
00525
if (ButtonNumber ==
MOUSE_BUTTON_RIGHT) {
00526 usVK = VK_RBUTTON;
00527 usOtherVK = VK_LBUTTON;
00528 }
else if (ButtonNumber ==
MOUSE_BUTTON_LEFT) {
00529 usVK = VK_LBUTTON;
00530 usOtherVK = VK_RBUTTON;
00531 }
else {
00532 RIPMSG1(RIP_ERROR,
"Unexpected Button number %d", ButtonNumber);
00533 }
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
if (
gbMouseButtonsRecentlySwapped) {
00550
if ((!fBreak == !!
TestAsyncKeyStateDown(usVK)) &&
00551 (fBreak == !!
TestAsyncKeyStateDown(usOtherVK))) {
00552 RIPMSG4(RIP_WARNING,
"Correct %s %s to %s %s",
00553 ButtonNumber ==
MOUSE_BUTTON_LEFT ?
"Left" :
"Right",
00554 fBreak ?
"Up" :
"Down",
00555 ButtonNumber ==
MOUSE_BUTTON_LEFT ?
"Right" :
"Left",
00556 fBreak ?
"Up" :
"Down");
00557 ButtonNumber ^= (
MOUSE_BUTTON_LEFT |
MOUSE_BUTTON_RIGHT);
00558 usVK = usOtherVK;
00559 }
00560
gbMouseButtonsRecentlySwapped =
FALSE;
00561 }
00562 }
00563
00564 xbutton = 0;
00565
switch (ButtonNumber) {
00566
case MOUSE_BUTTON_RIGHT:
00567
if (fBreak) {
00568 message = WM_RBUTTONUP;
00569 }
else {
00570
if (
ISTS() && fDblClk)
00571 message = WM_RBUTTONDBLCLK;
00572
else
00573 message = WM_RBUTTONDOWN;
00574 }
00575
break;
00576
00577
case MOUSE_BUTTON_LEFT:
00578
if (fBreak) {
00579 message = WM_LBUTTONUP;
00580 }
else {
00581
if (
ISTS() && fDblClk)
00582 message = WM_LBUTTONDBLCLK;
00583
else
00584 message = WM_LBUTTONDOWN;
00585 }
00586
break;
00587
00588
case MOUSE_BUTTON_MIDDLE:
00589
if (fBreak) {
00590 message = WM_MBUTTONUP;
00591 }
else {
00592
if (
ISTS() && fDblClk)
00593 message = WM_MBUTTONDBLCLK;
00594
else
00595 message = WM_MBUTTONDOWN;
00596 }
00597 usVK = VK_MBUTTON;
00598
break;
00599
00600
case MOUSE_BUTTON_X1:
00601
case MOUSE_BUTTON_X2:
00602
if (fBreak) {
00603 message = WM_XBUTTONUP;
00604 }
else {
00605
if (
ISTS() && fDblClk)
00606 message = WM_XBUTTONDBLCLK;
00607
else
00608 message = WM_XBUTTONDOWN;
00609 }
00610
00611
if (ButtonNumber ==
MOUSE_BUTTON_X1) {
00612 usVK = VK_XBUTTON1;
00613 xbutton = XBUTTON1;
00614 }
else {
00615 usVK = VK_XBUTTON2;
00616 xbutton = XBUTTON2;
00617 }
00618
break;
00619
00620
default:
00621
00622
00623
00624
00625
return;
00626 }
00627 UserAssert(usVK != 0);
00628
00629 wParam = MAKEWPARAM(0, xbutton);
00630
00631
00632
00633
00634
00635
if ((pHook =
PhkFirstValid(
PtiCurrent(), WH_MOUSE_LL)) !=
NULL) {
00636 MSLLHOOKSTRUCT mslls;
00637
BOOL bAnsiHook;
00638
00639 mslls.pt = ptPointer;
00640 mslls.mouseData = (LONG)wParam;
00641 mslls.flags = bInjected;
00642 mslls.time = time;
00643 mslls.dwExtraInfo = ExtraInfo;
00644
00645
if (
xxxCallHook2(pHook, HC_ACTION, (
DWORD)message, (LPARAM)&mslls, &bAnsiHook)) {
00646
return;
00647 }
00648 }
00649
00650
00651
00652
00653 UserAssert(
grpdeskRitInput !=
NULL);
00654
00655
#ifdef REDIRECTION
00656
00657
00658
00659 pwndStart = xxxCallSpeedHitTestHook(&ptPointer);
00660
if (pwndStart ==
NULL) {
00661 pwndStart =
grpdeskRitInput->
pDeskInfo->
spwnd;
00662 }
00663
00664 pwnd =
SpeedHitTest(pwndStart, ptPointer);
00665
#else
00666
pwnd =
SpeedHitTest(
grpdeskRitInput->
pDeskInfo->
spwnd, ptPointer);
00667
#endif // REDIRECTION
00668
00669
00670
00671
00672
if (pwnd ==
NULL)
00673
return;
00674
00675
00676
00677
00678 lParam = MAKELONG((
SHORT)ptPointer.x, (
SHORT)ptPointer.y);
00679
00680
00681
00682
00683
00684
00685
if (
IS_IME_ENABLED() &&
00686 !fBreak &&
00687 KOREAN_KBD_LAYOUT(
GetActiveHKL()) &&
00688 !
TestCF(pwnd,
CFIME) &&
00689
gpqForeground !=
NULL) {
00690
00691
PTHREADINFO ptiWnd =
GETPTI(pwnd);
00692
00693
00694
00695
00696
00697
if (
gpqForeground->
spwndCapture ==
NULL &&
00698
00699
00700
00701 (
GetAppImeCompatFlags(ptiWnd) & IMECOMPAT_NOFINALIZECOMPSTR) == 0) {
00702
00703
if (ptiWnd->
dwExpWinVer >
VER40) {
00704
PWND pwndIme = ptiWnd->
spwndDefaultIme;
00705
00706
if (pwndIme && !
TestWF(pwndIme,
WFINDESTROY)) {
00707
00708
00709
00710
00711
_PostMessage(pwndIme, WM_IME_SYSTEM, IMS_FINALIZE_COMPSTR, 0);
00712 }
00713 }
else {
00714
00715
00716
00717
00718
PostInputMessage(
gpqForeground,
NULL, WM_KEYUP, VK_PROCESSKEY, 0, 0, 0);
00719 }
00720 }
00721 }
00722
00723
00724
00725
00726
if (
gspwndScreenCapture !=
NULL)
00727 pwnd =
gspwndScreenCapture;
00728
00729
00730
00731
00732
00733
if (
gspwndMouseOwner ==
NULL) {
00734
if (!fBreak) {
00735
PWND pwndCapture;
00736
00737
00738
00739
00740
00741
00742
00743
if (pwndCapture =
PwndForegroundCapture()) {
00744
00745
if (
GETPTI(pwnd)->pq !=
GETPTI(pwndCapture)->pq) {
00746
PQ pqCapture;
00747
00748 pqCapture =
GETPTI(pwndCapture)->pq;
00749
PostInputMessage(pqCapture, pwndCapture, message,
00750 0, lParam, 0, 0);
00751
PostInputMessage(pqCapture, pwndCapture, message + 1,
00752 0, lParam, 0, 0);
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
if ((
GETPTI(pwndCapture)->pmsd !=
NULL) &&
00764 !
IsMenuStarted(
GETPTI(pwndCapture))) {
00765
return;
00766 }
00767 }
00768 }
00769
00770
Lock(&(
gspwndMouseOwner), pwnd);
00771
gwMouseOwnerButton |= wHardwareButton;
00772
glinp.
ptLastClick =
gpsi->ptCursor;
00773 }
else {
00774
00775
00776
00777
00778
00779
gwMouseOwnerButton &= ~wHardwareButton;
00780 }
00781
00782 }
else {
00783
00784
00785
00786
00787
00788
if (
gspwndScreenCapture ==
NULL) {
00789
00790
00791
00792
00793
00794
if (fBreak && (
GETPTI(pwnd) !=
GETPTI(
gspwndMouseOwner))) {
00795
glinp.
ptiLastWoken =
GETPTI(pwnd);
00796 TAGMSG1(DBGTAG_FOREGROUND,
"xxxButtonEvent. ptiLastWoken %#p",
glinp.
ptiLastWoken);
00797 }
00798 pwnd =
gspwndMouseOwner;
00799 }
00800
00801
00802
00803
00804
00805
if (fBreak) {
00806
gwMouseOwnerButton &= ~wHardwareButton;
00807
if (!
gwMouseOwnerButton)
00808
Unlock(&
gspwndMouseOwner);
00809 }
else {
00810
gwMouseOwnerButton |= wHardwareButton;
00811 }
00812 }
00813
00814
00815
00816
00817
00818
00819 UserAssert(usVK != 0);
00820
UpdateAsyncKeyState(
GETPTI(pwnd)->pq, usVK, fBreak);
00821
00822
00823
00824
00825
00826
if (!fBreak &&
GETPTI(pwnd)->pq !=
gpqForeground) {
00827
00828
00829
00830
00831
00832
if ((
gpqForeground !=
NULL) && (pwnd ==
grpdeskRitInput->
pDeskInfo->
spwnd) &&
00833 ((
gwMouseOwnerButton & wHardwareButton) ||
00834 (
gwMouseOwnerButton == 0))) {
00835
PostEventMessage(
gpqForeground->
ptiMouse,
00836
gpqForeground,
QEVENT_CANCELMODE,
NULL, 0, 0, 0);
00837
00838 }
else if ((
gwMouseOwnerButton & wHardwareButton) ||
00839 (
gwMouseOwnerButton == 0)) {
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
PWND pwndTopLevel =
GetTopLevelWindow(pwnd);
00854
if (!
TestWF(pwndTopLevel,
WEFNOACTIVATE)) {
00855
ThreadLockAlways(pwnd, &tlpwnd);
00856
xxxSetForegroundWindow2(pwnd,
NULL, 0);
00857
00858
00859
00860
00861
ThreadUnlock(&tlpwnd);
00862
00863 }
00864 }
00865 }
00866
00867
if (
GETPTI(pwnd)->pq->QF_flags &
QF_MOUSEMOVED) {
00868
PostMove(
GETPTI(pwnd)->pq);
00869 }
00870
00871
PostInputMessage(
GETPTI(pwnd)->pq, pwnd, message, wParam, lParam, time, ExtraInfo);
00872
00873
00874
00875
00876
00877
if (fBreak && (
TEST_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON) ||
00878
TEST_ACCESSFLAG(
MouseKeys, MKF_MOUSEKEYSON))) {
00879
xxxHardwareMouseKeyUp(ButtonNumber);
00880 }
00881
00882
if (message == WM_LBUTTONDOWN) {
00883
PDESKTOP pdesk =
GETPTI(pwnd)->rpdesk;
00884
if (pdesk !=
NULL && pdesk->
rpwinstaParent !=
NULL) {
00885
00886 UserAssert(!(pdesk->
rpwinstaParent->
dwWSF_Flags &
WSF_NOIO));
00887
00888
#ifdef HUNGAPP_GHOSTING
00889
if (
FHungApp(
GETPTI(pwnd),
CMSHUNGAPPTIMEOUT)) {
00890 SignalGhost(pwnd);
00891 }
00892
#else // HUNGAPP_GHOSTING
00893
KeSetEvent(
gpEventHungThread,
EVENT_INCREMENT,
FALSE);
00894
#endif // HUNGAPP_GHOSTING
00895
}
00896 }
00897 }
00898
00899
00900
00901
00902
00903
00904
#ifdef LOCK_MOUSE_CODE
00905
#pragma alloc_text(MOUSE, QueueMouseEvent)
00906
#endif
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921
00922
00923
00924
00925 VOID QueueMouseEvent(
00926 USHORT ButtonFlags,
00927 USHORT ButtonData,
00928 ULONG_PTR ExtraInfo,
00929 POINT ptMouse,
00930 LONG time,
00931 BOOL bInjected,
00932 BOOL bWakeRIT
00933 )
00934 {
00935
CheckCritOut();
00936
00937
EnterMouseCrit();
00938
00939
LOGTIME(
gMouseQueueMouseEventTime);
00940
00941
00942
00943
00944 UserAssert(ButtonData == 0 || ButtonFlags != 0);
00945
00946
00947
00948
00949
00950
00951
if ((
gdwMouseEvents == 0) ||
00952 (ButtonFlags != 0) ||
00953 (
gMouseEventQueue[
gdwMouseQueueHead].
ButtonFlags != 0)) {
00954
00955
00956
00957
if (
gdwMouseEvents >=
NELEM_BUTTONQUEUE) {
00958
00959
00960
00961
LeaveMouseCrit();
00962
UserBeep(440, 125);
00963
return;
00964 }
00965
00966
gdwMouseQueueHead = (
gdwMouseQueueHead + 1) %
NELEM_BUTTONQUEUE;
00967
gMouseEventQueue[
gdwMouseQueueHead].
ButtonFlags = ButtonFlags;
00968
gMouseEventQueue[
gdwMouseQueueHead].
ButtonData = ButtonData;
00969
gdwMouseEvents++;
00970 }
00971
00972
gMouseEventQueue[
gdwMouseQueueHead].
ExtraInfo = ExtraInfo;
00973
gMouseEventQueue[
gdwMouseQueueHead].
ptPointer = ptMouse;
00974
gMouseEventQueue[
gdwMouseQueueHead].
time = time;
00975
gMouseEventQueue[
gdwMouseQueueHead].
bInjected = bInjected;
00976
00977
LeaveMouseCrit();
00978
00979
if (bWakeRIT) {
00980
00981
00982
00983
KeSetEvent(
gpkeMouseData,
EVENT_INCREMENT,
FALSE);
00984 }
00985 }
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997 BOOL UnqueueMouseEvent(
00998
PMOUSEEVENT pme
00999 )
01000 {
01001
DWORD dwTail;
01002
01003
EnterMouseCrit();
01004
01005
LOGTIME(
gMouseUnqueueMouseEventTime);
01006
01007
if (
gdwMouseEvents == 0) {
01008
LeaveMouseCrit();
01009
return FALSE;
01010 }
else {
01011 dwTail = (
gdwMouseQueueHead -
gdwMouseEvents + 1) %
NELEM_BUTTONQUEUE;
01012 *pme =
gMouseEventQueue[dwTail];
01013
gdwMouseEvents--;
01014 }
01015
01016
LeaveMouseCrit();
01017
return TRUE;
01018 }
01019
01020 VOID xxxDoButtonEvent(
PMOUSEEVENT pme)
01021 {
01022 ULONG dwButtonMask;
01023 ULONG dwButtonState;
01024 LPARAM lParam;
01025
BOOL fWheel;
01026
PHOOK pHook;
01027 ULONG dwButtonData = (ULONG) pme->
ButtonData;
01028
01029
CheckCritIn();
01030
01031 dwButtonState = (ULONG) pme->
ButtonFlags;
01032 fWheel = dwButtonState & MOUSE_WHEEL;
01033 dwButtonState &= ~MOUSE_WHEEL;
01034
01035
for( dwButtonMask = 1;
01036 dwButtonState != 0;
01037 dwButtonData >>= 2, dwButtonState >>= 2, dwButtonMask <<= 1) {
01038
01039
if (dwButtonState & 1) {
01040
xxxButtonEvent(dwButtonMask, pme->
ptPointer,
FALSE,
01041 pme->
time, pme->
ExtraInfo, pme->
bInjected,
01042
gbClientDoubleClickSupport && (dwButtonData & 1));
01043 }
01044
01045
if (dwButtonState & 2) {
01046
xxxButtonEvent(dwButtonMask, pme->
ptPointer,
TRUE,
01047 pme->
time, pme->
ExtraInfo, pme->
bInjected ,
FALSE);
01048 }
01049 }
01050
01051
01052
01053
01054
if (fWheel && pme->
ButtonData != 0 &&
gpqForeground) {
01055
01056 lParam = MAKELONG((
SHORT)pme->
ptPointer.x, (
SHORT)pme->
ptPointer.y);
01057
01058
01059
01060
01061
01062
if ((pHook =
PhkFirstValid(
PtiCurrent(), WH_MOUSE_LL)) !=
NULL) {
01063 MSLLHOOKSTRUCT mslls;
01064
BOOL bAnsiHook;
01065
01066 mslls.pt = pme->
ptPointer;
01067 mslls.mouseData = MAKELONG(0, pme->
ButtonData);
01068 mslls.flags = pme->
bInjected;
01069 mslls.time = pme->
time;
01070 mslls.dwExtraInfo = pme->
ExtraInfo;
01071
01072
if (
xxxCallHook2(pHook, HC_ACTION, (
DWORD)WM_MOUSEWHEEL,
01073 (LPARAM)&mslls, &bAnsiHook)) {
01074
return;
01075 }
01076 }
01077
01078
PostInputMessage(
01079
gpqForeground,
01080
NULL,
01081 WM_MOUSEWHEEL,
01082 MAKELONG(0, pme->
ButtonData),
01083 lParam, pme->
time,
01084 pme->
ExtraInfo);
01085
01086
return;
01087 }
01088 }
01089
01090 VOID NTAPI
InputApc(
01091 IN PVOID ApcContext,
01092 IN PIO_STATUS_BLOCK IoStatusBlock,
01093 IN ULONG Reserved
01094 )
01095 {
01096
PDEVICEINFO pDeviceInfo = (
PDEVICEINFO)ApcContext;
01097 UNREFERENCED_PARAMETER(Reserved);
01098
01099
#ifdef DIAGNOSE_IO
01100
pDeviceInfo->nReadsOutstanding--;
01101
#endif
01102
01103
01104
01105
01106
01107
if (pDeviceInfo->usActions &
GDIAF_FREEME) {
01108
EnterDeviceInfoListCrit();
01109 pDeviceInfo->bFlags &= ~
GDIF_READING;
01110
FreeDeviceInfo(pDeviceInfo);
01111
LeaveDeviceInfoListCrit();
01112
return;
01113 }
01114
01115
if (
NT_SUCCESS(IoStatusBlock->Status)) {
01116
PDEVICE_TEMPLATE pDevTpl = &
aDeviceTemplate[pDeviceInfo->type];
01117 pDevTpl->
DeviceRead(pDeviceInfo);
01118 }
01119
StartDeviceRead(pDeviceInfo);
01120 }
01121
01122
01123
01124
01125
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137 VOID ProcessMouseInput(
01138
PDEVICEINFO pMouseInfo)
01139 {
01140 PMOUSE_INPUT_DATA pmei, pmeiNext;
01141 LONG time;
01142 POINT ptLastMove;
01143
01144
01145
01146
01147
01148
01149
CheckCritOut();
01150
CheckDeviceInfoListCritOut();
01151
01152 UserAssert(pMouseInfo);
01153 UserAssert((
PtiCurrentShared() ==
gTermIO.
ptiDesktop) ||
01154 (
PtiCurrentShared() ==
gTermNOIO.
ptiDesktop));
01155
01156
LOGTIME(
gMouseProcessMiceInputTime);
01157
01158
if (
gptiBlockInput !=
NULL) {
01159
return;
01160 }
01161
01162
if (
TEST_ACCF(
ACCF_ACCESSENABLED)) {
01163
01164
01165
01166
01167
01168
gStickyKeysLeftShiftCount = 0;
01169
gStickyKeysRightShiftCount = 0;
01170
01171
01172
01173
01174
01175
if (
gtmridFKActivation != 0) {
01176
EnterCrit();
01177
KILLRITTIMER(
NULL,
gtmridFKActivation);
01178
gtmridFKActivation = 0;
01179
gFilterKeysState =
FKMOUSEMOVE;
01180
LeaveCrit();
01181
return;
01182 }
01183 }
01184
01185
if (!
NT_SUCCESS(pMouseInfo->iosb.Status)) {
01186
01187
01188
01189
if (!
gbRemoteSession)
01190
if (pMouseInfo->iosb.Status != STATUS_DELETE_PENDING) {
01191 RIPMSG3(RIP_ERROR,
"iosb.Status %lx for mouse %#p (id %x) tell IanJa x63321",
01192 pMouseInfo->iosb.Status,
01193 pMouseInfo, pMouseInfo->
mouse.
Attr.MouseIdentifier);
01194 }
01195
return;
01196 }
01197
01198
01199
01200
01201 ptLastMove =
gptCursorAsync;
01202
01203 pmei = pMouseInfo->
mouse.
Data;
01204
while (pmei !=
NULL) {
01205
01206 time =
NtGetTickCount();
01207
01208
01209
01210
01211 pmeiNext = pmei + 1;
01212
if ((PUCHAR)pmeiNext >=
01213 (PUCHAR)(((PUCHAR)pMouseInfo->
mouse.
Data) + pMouseInfo->iosb.Information)) {
01214
01215
01216
01217
01218
01219 pmeiNext =
NULL;
01220 }
01221
01222
01223
01224
01225
01226
if (pmei->Flags & MOUSE_ATTRIBUTES_CHANGED) {
01227
RequestDeviceChange(pMouseInfo,
GDIAF_REFRESH_MOUSE,
FALSE);
01228
goto NextMouseInputRecord;
01229 }
01230
01231
01232
01233
01234
01235
01236
01237
if (pmei->LastX || pmei->LastY) {
01238
01239
01240
01241
01242
GetMouseCoord(pmei->LastX,
01243 pmei->LastY,
01244 pmei->Flags,
01245 time,
01246 pmei->ExtraInformation,
01247 &ptLastMove);
01248
01249
01250
01251
01252
01253
if ( (pmeiNext !=
NULL) &&
01254 (pmei->ButtonFlags == 0) &&
01255 (pmeiNext->ButtonFlags == 0) &&
01256 (
fAbsoluteMouse(pmei) ==
fAbsoluteMouse(pmeiNext))) {
01257
01258 pmei = pmeiNext;
01259
01260
continue;
01261 }
01262
01263
01264
01265
01266
01267
01268
xxxMoveEventAbsolute(
01269 ptLastMove.x,
01270 ptLastMove.y,
01271 pmei->ExtraInformation,
01272 time,
01273
FALSE
01274 );
01275
01276
01277
01278
01279
01280 ptLastMove =
gptCursorAsync;
01281 }
01282
01283
01284
01285
01286
01287
01288
QueueMouseEvent(
01289 pmei->ButtonFlags,
01290 pmei->ButtonData,
01291 pmei->ExtraInformation,
01292
gptCursorAsync,
01293 time,
01294
FALSE,
01295 (pmeiNext ==
NULL));
01296
01297 NextMouseInputRecord:
01298 pmei = pmeiNext;
01299 }
01300
01301
return;
01302 }
01303
01304
01305
01306
01307
01308
01309
01310
01311 __inline
IsHexNumpadKeys(BYTE Vk, WORD wScanCode)
01312 {
01313
return (wScanCode >= SCANCODE_NUMPAD_FIRST && wScanCode <= SCANCODE_NUMPAD_LAST &&
aVkNumpad[wScanCode - SCANCODE_NUMPAD_FIRST] != 0xff) ||
01314 (Vk >=
L'A' && Vk <=
L'F') ||
01315 (Vk >=
L'0' && Vk <=
L'9');
01316 }
01317
01318
01319
01320
01321
01322
01323
01324
01325
01326
01327
01328
01329
01330
01331
01332
01333
01334
01335
01336
01337
01338 VOID xxxKeyEvent(
01339 USHORT usFlaggedVk,
01340 WORD wScanCode,
01341 DWORD time,
01342 ULONG_PTR ExtraInfo,
01343 BOOL bInjected)
01344 {
01345
USHORT message, usExtraStuff;
01346
BOOL fBreak;
01347
BYTE VkHanded;
01348
BYTE Vk;
01349
TL tlpwndActivate;
01350
DWORD fsReserveKeys;
01351
static BOOL fMakeAltUpASysKey;
01352
PHOOK pHook;
01353
PTHREADINFO ptiCurrent =
PtiCurrent();
01354
01355
CheckCritIn();
01356
01357 fBreak = usFlaggedVk & KBDBREAK;
01358
gpsi->bLastRITWasKeyboard =
TRUE;
01359
01360
01361
01362
01363 message = fBreak ? WM_KEYUP : WM_KEYDOWN;
01364
01365 VkHanded = (
BYTE)usFlaggedVk;
01366 usExtraStuff = usFlaggedVk & KBDEXT;
01367
01368
01369
01370
01371
01372
01373
if ((VkHanded >= VK_LSHIFT) && (VkHanded <= VK_RMENU)) {
01374
BYTE VkOtherHand = VkHanded ^ 1;
01375
01376 Vk = (
BYTE)((VkHanded - VK_LSHIFT) / 2 + VK_SHIFT);
01377
if (!fBreak || !
TestAsyncKeyStateDown(VkOtherHand)) {
01378
if ((
gptiBlockInput ==
NULL) || (
gptiBlockInput != ptiCurrent)) {
01379
UpdateAsyncKeyState(
gpqForeground, Vk, fBreak);
01380 }
01381 }
01382 }
else {
01383 Vk = VkHanded;
01384 }
01385
01386
01387
01388
01389
01390
if (!bInjected && ((wScanCode & SCANCODE_SIMULATED) == 0)) {
01391
if (fBreak) {
01392
gfsSASModifiersDown &= ~
VKTOMODIFIERS(Vk);
01393 }
else {
01394
gfsSASModifiersDown |=
VKTOMODIFIERS(Vk);
01395 }
01396 }
01397
01398
01399
01400
01401
01402
if ((pHook =
PhkFirstValid(ptiCurrent, WH_KEYBOARD_LL)) !=
NULL) {
01403 KBDLLHOOKSTRUCT kbds;
01404
BOOL bAnsiHook;
01405
USHORT msg = message;
01406
01407
01408
01409
01410
if (
TestRawKeyDown(VK_MENU) &&
01411 !
TestRawKeyDown(VK_CONTROL)) {
01412
01413
msg += (WM_SYSKEYDOWN - WM_KEYDOWN);
01414 usExtraStuff |= 0x2000;
01415 }
01416 kbds.vkCode = (
DWORD)VkHanded;
01417 kbds.scanCode = (
DWORD)wScanCode;
01418 kbds.flags =
HIBYTE(usExtraStuff | (bInjected ? (LLKHF_INJECTED << 8) : 0));
01419 kbds.flags |= (fBreak ? (KBDBREAK >> 8) : 0);
01420 kbds.time = time;
01421 kbds.dwExtraInfo = ExtraInfo;
01422
01423
if (
xxxCallHook2(pHook, HC_ACTION, (
DWORD)
msg, (LPARAM)&kbds, &bAnsiHook)) {
01424
01425
UINT fsModifiers;
01426
01427
01428
01429
01430
01431
if (
IsSAS(VkHanded, &fsModifiers)) {
01432 RIPMSG0(RIP_WARNING,
"xxxKeyEvent: SAS ignore bad response from low level hook");
01433 }
else {
01434
return;
01435 }
01436 }
01437 }
01438
01439
01440
01441
01442
if (
gptiBlockInput && (
gptiBlockInput != ptiCurrent)) {
01443
UINT fsModifiers;
01444
if (
IsSAS(VkHanded, &fsModifiers)) {
01445 RIPMSG0(RIP_WARNING,
"xxxKeyEvent: SAS unblocks BlockInput");
01446
gptiBlockInput =
NULL;
01447 }
else {
01448
return;
01449 }
01450 }
01451
01452
UpdateAsyncKeyState(
gpqForeground, VkHanded, fBreak);
01453
01454
01455
01456
01457
if (
gfEnableHexNumpad) {
01458
if (!
TestAsyncKeyStateDown(VK_MENU)) {
01459
if (
gfInNumpadHexInput &
NUMPAD_HEXMODE_LL) {
01460
gfInNumpadHexInput &= ~
NUMPAD_HEXMODE_LL;
01461 }
01462 }
else {
01463
if (!fBreak) {
01464
if ((
gfInNumpadHexInput &
NUMPAD_HEXMODE_LL) ||
01465 wScanCode ==
SCANCODE_NUMPAD_PLUS || wScanCode ==
SCANCODE_NUMPAD_DOT) {
01466
if ((usExtraStuff & KBDEXT) == 0) {
01467
01468
01469
01470
01471
01472
01473
01474 WORD wModBits = 0;
01475
01476 wModBits |=
TestAsyncKeyStateDown(VK_MENU) ? KBDALT : 0;
01477 wModBits |=
TestAsyncKeyStateDown(VK_SHIFT) ? KBDSHIFT : 0;
01478 wModBits |=
TestAsyncKeyStateDown(VK_KANA) ? KBDKANA : 0;
01479
01480
if (
MODIFIER_FOR_ALT_NUMPAD(wModBits)) {
01481
if ((
gfInNumpadHexInput &
NUMPAD_HEXMODE_LL) == 0) {
01482
01483
01484
01485
UINT wHotKeyMod = 0;
01486
01487 wHotKeyMod |= (wModBits & KBDSHIFT) ? MOD_SHIFT : 0;
01488 wHotKeyMod |=
TestAsyncKeyStateDown(VK_CONTROL) ? MOD_CONTROL : 0;
01489 UserAssert(wModBits & KBDALT);
01490 wHotKeyMod |= MOD_ALT;
01491 wHotKeyMod |=
TestAsyncKeyStateDown(VK_LWIN) ||
TestAsyncKeyStateDown(VK_RWIN) ?
01492 MOD_WIN : 0;
01493
01494
if (
IsHotKey(wHotKeyMod, Vk) ==
NULL) {
01495 UserAssert(wScanCode ==
SCANCODE_NUMPAD_PLUS || wScanCode ==
SCANCODE_NUMPAD_DOT);
01496
gfInNumpadHexInput |=
NUMPAD_HEXMODE_LL;
01497 }
01498 }
else if (!
IsHexNumpadKeys(Vk, wScanCode)) {
01499
gfInNumpadHexInput &= ~
NUMPAD_HEXMODE_LL;
01500 }
01501 }
else {
01502
gfInNumpadHexInput &= ~
NUMPAD_HEXMODE_LL;
01503 }
01504 }
else {
01505
gfInNumpadHexInput &= ~
NUMPAD_HEXMODE_LL;
01506 }
01507 }
else {
01508 UserAssert((
gfInNumpadHexInput &
NUMPAD_HEXMODE_LL) == 0);
01509 }
01510 }
01511 }
01512 }
01513
01514
01515
01516
01517
01518
01519
if (!fBreak &&
01520 ((Vk == VK_CAPITAL) || (Vk == VK_NUMLOCK) || (Vk == VK_SCROLL) ||
01521 (Vk == VK_KANA && JAPANESE_KBD_LAYOUT(
GetActiveHKL())))) {
01522
01523
01524
01525
01526
01527
01528
01529
01530
01531
01532
UpdateKeyLights(bInjected);
01533 }
01534
01535
01536
01537
01538 fsReserveKeys = 0;
01539
if (
gptiForeground !=
NULL)
01540 fsReserveKeys =
gptiForeground->
fsReserveKeys;
01541
01542
01543
01544
01545
01546
if (
gspwndAltTab !=
NULL && (!fBreak) &&
01547 Vk != VK_TAB && Vk != VK_SHIFT && Vk != VK_MENU) {
01548
01549
01550
01551
01552
xxxCancelCoolSwitch();
01553
01554
01555
01556
01557
if ((Vk == VK_ESCAPE) && !(fsReserveKeys & CONSOLE_ALTESC)) {
01558
return;
01559 }
01560 }
01561
01562
01563
01564
01565
if (
xxxDoHotKeyStuff(Vk, fBreak, fsReserveKeys)) {
01566
01567
01568
01569
01570
return;
01571 }
01572
01573
01574
01575
01576
01577
if (
TestAsyncKeyStateDown(VK_MENU) && !
TestAsyncKeyStateDown(VK_CONTROL) && Vk != VK_JUNJA) {
01578
01579
01580 message += (WM_SYSKEYDOWN - WM_KEYDOWN);
01581 usExtraStuff |= 0x2000;
01582
01583
01584
01585
01586
01587
01588
if (Vk == VK_MENU) {
01589 fMakeAltUpASysKey =
TRUE;
01590
01591
01592
01593
if (!fBreak) {
01594
gppiLockSFW =
NULL;
01595 }
01596 }
else {
01597 fMakeAltUpASysKey =
FALSE;
01598 }
01599
01600 }
else if (Vk == VK_MENU) {
01601
if (fBreak) {
01602
01603
01604
01605
if (fMakeAltUpASysKey) {
01606
01607
01608
01609
01610
01611
01612
01613
01614
01615 message += (WM_SYSKEYDOWN - WM_KEYDOWN);
01616 }
01617
01618
if (
gspwndAltTab !=
NULL) {
01619
01620
01621
01622
01623
if (
gpqForeground !=
NULL) {
01624
01625
01626
01627
01628
01629
01630
01631
gpqForeground->
QF_flags |=
QF_TABSWITCHING;
01632
01633
PostInputMessage(
gpqForeground,
NULL, message, (
DWORD)Vk,
01634 MAKELONG(1, (wScanCode | usExtraStuff)),
01635 time, ExtraInfo);
01636 }
01637
01638
01639
01640
01641
xxxCancelCoolSwitch();
01642
01643
if (
gspwndActivate !=
NULL) {
01644
01645
01646
01647
01648
01649
01650
01651
01652
01653
if (
gpqForeground ==
GETPTI(
gspwndActivate)->pq) {
01654
gpqForeground =
NULL;
01655 }
01656
01657
01658
01659
01660
01661
glinp.
ptiLastWoken =
GETPTI(
gspwndActivate);
01662
01663
01664
ThreadLockAlways(
gspwndActivate, &tlpwndActivate);
01665
xxxSetForegroundWindow2(
gspwndActivate,
NULL,
01666
SFW_SWITCH |
SFW_ACTIVATERESTORE);
01667
01668
01669
01670
01671
01672
01673
01674
01675
01676
01677
01678
01679
01680
01681
if (
TestWF(
gspwndActivate,
WFCHILD)) {
01682
xxxSetWindowPos(
gspwndActivate, (
PWND)HWND_TOP, 0, 0, 0, 0,
01683 SWP_NOSIZE | SWP_NOMOVE | SWP_ASYNCWINDOWPOS);
01684 }
01685
ThreadUnlock(&tlpwndActivate);
01686
01687
Unlock(&
gspwndActivate);
01688 }
01689
return;
01690 }
01691 }
else {
01692
01693
01694
01695
gppiLockSFW =
NULL;
01696 }
01697 }
01698
01699
01700
01701
01702
if (!
FJOURNALPLAYBACK() && !
FJOURNALRECORD() && (!fBreak) &&
01703 (
TestAsyncKeyStateDown(VK_MENU)) &&
01704 (!
TestAsyncKeyStateDown(VK_CONTROL)) &&
01705 (((Vk == VK_TAB) && !(fsReserveKeys & CONSOLE_ALTTAB)) ||
01706 ((Vk == VK_ESCAPE) && !(fsReserveKeys & CONSOLE_ALTESC)))) {
01707
01708
xxxNextWindow(
gpqForeground ?
gpqForeground :
gptiRit->
pq, Vk);
01709
01710 }
else if (
gpqForeground !=
NULL) {
01711
PQMSG pqmsgPrev =
gpqForeground->
mlInput.
pqmsgWriteLast;
01712
DWORD wParam = (
DWORD)Vk;
01713 LONG lParam;
01714
01715
01716
01717
01718
01719
if ((Vk == VK_PACKET) && (usFlaggedVk & KBDUNICODE)) {
01720 wParam |= (wScanCode << 16);
01721 wScanCode = 0;
01722 }
01723 lParam = MAKELONG(1, (wScanCode | usExtraStuff));
01724
01725
01726
01727
01728
01729
if (pqmsgPrev !=
NULL &&
01730 pqmsgPrev->
msg.message == message &&
01731 (message == WM_KEYDOWN || message == WM_SYSKEYDOWN) &&
01732 pqmsgPrev->
msg.wParam == wParam &&
01733 HIWORD(pqmsgPrev->
msg.lParam) == HIWORD(lParam)) {
01734
01735
01736
01737
01738
01739
01740 pqmsgPrev->
msg.lParam = MAKELONG(LOWORD(pqmsgPrev->
msg.lParam) + 1,
01741 HIWORD(lParam));
01742
01743
WakeSomeone(
gpqForeground, message, pqmsgPrev);
01744
01745 }
else {
01746
01747
01748
01749
01750
01751
01752
01753
01754
01755
01756
if (VK_APPCOMMAND_FIRST <= Vk && Vk <= VK_APPCOMMAND_LAST) {
01757
01758
01759
01760
01761
if (!fBreak &&
gpqForeground) {
01762
01763
01764
01765
01766
PostEventMessage(
gpqForeground->
ptiKeyboard,
gpqForeground,
QEVENT_APPCOMMAND,
01767
NULL, 0, (WPARAM)0, Vk);
01768 }
01769 }
01770
01771
01772
01773
01774
01775
if (
gpqForeground->
QF_flags &
QF_MOUSEMOVED) {
01776
PostMove(
gpqForeground);
01777 }
01778
01779
PostInputMessage(
gpqForeground,
NULL, message, wParam,
01780 lParam, time, ExtraInfo);
01781 }
01782 }
01783 }
01784
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794 VOID GetMouseCoord(
01795 LONG dx,
01796 LONG dy,
01797 DWORD dwFlags,
01798 LONG time,
01799 ULONG_PTR ExtraInfo,
01800 PPOINT ppt)
01801 {
01802
if (
dwFlags & MOUSE_MOVE_ABSOLUTE) {
01803
01804 LONG cxMetric, cyMetric;
01805
01806
01807
01808
01809
if (
dwFlags & MOUSE_VIRTUAL_DESKTOP) {
01810 cxMetric =
SYSMET(CXVIRTUALSCREEN);
01811 cyMetric =
SYSMET(CYVIRTUALSCREEN);
01812 }
else {
01813 cxMetric =
SYSMET(CXSCREEN);
01814 cyMetric =
SYSMET(CYSCREEN);
01815 }
01816
01817
01818
01819
01820
01821
01822
01823
01824
01825
01826
01827
01828
01829
01830
01831
01832
01833
01834
01835
01836 ppt->x = dx * cxMetric;
01837
if (ppt->x >= 0) {
01838 ppt->x = HIWORD(ppt->x);
01839 }
else {
01840 ppt->x = - (
long) HIWORD(-ppt->x);
01841 }
01842
01843 ppt->y = dy * cyMetric;
01844
if (ppt->y >= 0) {
01845 ppt->y = HIWORD(ppt->y);
01846 }
else {
01847 ppt->y = - (
long) HIWORD(-ppt->y);
01848 }
01849
01850
01851
01852
01853
if (
dwFlags & MOUSE_VIRTUAL_DESKTOP) {
01854 ppt->x +=
SYSMET(XVIRTUALSCREEN);
01855 ppt->y +=
SYSMET(YVIRTUALSCREEN);
01856 }
01857
01858
01859
01860
01861
idxRemainder =
idyRemainder = 0;
01862
01863
01864
01865
01866
01867
SAVEPOINT(dx, dy, 0xFFFF, 0xFFFF, time, ExtraInfo);
01868 }
else {
01869
01870
01871
01872
if (
gMouseSpeed != 0) {
01873 dx =
DoMouseAccel(dx);
01874 dy =
DoMouseAccel(dy);
01875 }
01876
01877
01878
01879
01880
if (
gMouseSensitivity !=
MOUSE_SENSITIVITY_DEFAULT) {
01881
int iNumerator;
01882
01883
if (dx) {
01884 iNumerator = dx *
gMouseSensitivityFactor +
idxRemainder;
01885 dx = iNumerator / 256 ;
01886
idxRemainder = iNumerator % 256 ;
01887
if ((iNumerator < 0) && (idxRemainder > 0)) {
01888 dx++ ;
01889
idxRemainder -= 256 ;
01890 }
01891 }
01892
if (dy) {
01893 iNumerator = dy *
gMouseSensitivityFactor +
idyRemainder ;
01894 dy = iNumerator / 256 ;
01895
idyRemainder = iNumerator % 256 ;
01896
if ((iNumerator < 0) && (idyRemainder > 0)) {
01897 dy++ ;
01898
idyRemainder -= 256 ;
01899 }
01900 }
01901 }
01902
01903 ppt->x += dx;
01904 ppt->y += dy;
01905
01906
01907
01908
01909
01910
SAVEPOINT(ppt->x, ppt->y,
01911
SYSMET(CXVIRTUALSCREEN) - 1,
SYSMET(CYVIRTUALSCREEN) - 1,
01912 time, ExtraInfo);
01913 }
01914 }
01915
01916
01917
01918
01919
01920
01921
01922
01923
01924
01925
01926
01927
01928
01929
01930
01931
01932
#ifdef LOCK_MOUSE_CODE
01933
#pragma alloc_text(MOUSE, xxxMoveEventAbsolute)
01934
#endif
01935
01936 VOID xxxMoveEventAbsolute(
01937 LONG x,
01938 LONG y,
01939 ULONG_PTR dwExtraInfo,
01940 DWORD time,
01941 BOOL bInjected
01942 )
01943 {
01944
CheckCritOut();
01945
01946
if (
IsHooked(
gptiRit,
WHF_FROM_WH(WH_MOUSE_LL))) {
01947 MSLLHOOKSTRUCT mslls;
01948
BOOL bEatEvent =
FALSE;
01949
BOOL bAnsiHook;
01950
PHOOK pHook;
01951
01952 mslls.pt.x = x;
01953 mslls.pt.y = y;
01954 mslls.mouseData = 0;
01955 mslls.flags = bInjected;
01956 mslls.time = time;
01957 mslls.dwExtraInfo = dwExtraInfo;
01958
01959
01960
01961
01962
01963
01964
EnterCrit();
01965
01966
01967
01968
01969
if ((pHook =
PhkFirstValid(
gptiRit, WH_MOUSE_LL)) !=
NULL) {
01970 bEatEvent = (
xxxCallHook2(pHook, HC_ACTION, WM_MOUSEMOVE, (LPARAM)&mslls, &bAnsiHook) != 0);
01971 }
01972
01973
LeaveCrit();
01974
01975
if (bEatEvent) {
01976
return;
01977 }
01978 }
01979
01980
01981
01982
01983
01984
01985
01986
if (
IsGlobalHooked(
gptiRit,
WHF_FROM_WH(WH_JOURNALPLAYBACK))) {
01987
return;
01988 }
01989
01990
gptCursorAsync.x = x;
01991
gptCursorAsync.y = y;
01992
01993
BoundCursor(&
gptCursorAsync);
01994
01995
01996
01997
01998 GreMovePointer(
gpDispInfo->
hDev,
gptCursorAsync.x,
gptCursorAsync.y);
01999
02000
02001
02002
02003
gdwMouseMoveTimeStamp = time;
02004 }
02005
02006
02007
02008
02009
02010
02011
02012
02013
02014
02015
02016
#ifdef LOCK_MOUSE_CODE
02017
#pragma alloc_text(MOUSE, xxxMoveEvent)
02018
#endif
02019
02020 VOID xxxMoveEvent(
02021 LONG dx,
02022 LONG dy,
02023 DWORD dwFlags,
02024 ULONG_PTR dwExtraInfo,
02025 DWORD time,
02026 BOOL bInjected)
02027 {
02028 POINT ptLastMove =
gptCursorAsync;
02029
02030
CheckCritOut();
02031
02032
02033
02034
02035
GetMouseCoord(dx, dy,
ConvertToMouseDriverFlags(
dwFlags),
02036 time, dwExtraInfo, &ptLastMove);
02037
02038
02039
02040
02041
xxxMoveEventAbsolute(
02042 ptLastMove.x,
02043 ptLastMove.y,
02044 dwExtraInfo,
02045 time,
02046 bInjected);
02047 }
02048
02049
02050
02051
02052
02053
02054
02055
02056
02057
02058
02059
02060
02061 void UpdateRawKeyState(
02062 BYTE Vk,
02063 BOOL fBreak)
02064 {
02065
CheckCritIn();
02066
02067
if (fBreak) {
02068
ClearRawKeyDown(Vk);
02069 }
else {
02070
02071
02072
02073
02074
02075
if (!
TestRawKeyDown(Vk)) {
02076
ToggleRawKeyToggle(Vk);
02077 }
02078
02079
02080
02081
02082
SetRawKeyDown(Vk);
02083 }
02084 }
02085
02086
02087 VOID CleanupResources(
02088 VOID)
02089 {
02090
PPCLS ppcls;
02091
PTHREADINFO pti;
02092
02093 UserAssert(!
gbCleanedUpResources);
02094
02095
gbCleanedUpResources =
TRUE;
02096
02097
HYDRA_HINT(
HH_CLEANUPRESOURCES);
02098
02099
02100
02101
02102
CleanupPowerRequestList();
02103
02104
02105
02106
02107 ppcls = &
gpclsList;
02108
while (*ppcls !=
NULL) {
02109
DestroyClass(ppcls);
02110 }
02111
02112
02113
02114
02115
02116
02117
02118
02119 pti =
PpiCurrent()->ptiList;
02120
02121
while (pti !=
NULL) {
02122
02123
if (pti->
pq !=
NULL) {
02124
LockQCursor(pti->
pq,
NULL);
02125 }
02126 pti = pti->
ptiSibling;
02127 }
02128
02129
UnloadCursorsAndIcons();
02130
02131
02132
02133
02134
CleanupGDI();
02135 }
02136
02137
02138
02139
02140
02141
02142
02143
02144
02145
02146 BOOL InitiateWin32kCleanup(
02147 VOID)
02148 {
02149
PTHREADINFO ptiCurrent;
02150
PWINDOWSTATION pwinsta;
02151 BOOLEAN fWait =
TRUE;
02152
PDESKTOP pdesk;
02153 UNICODE_STRING ustrName;
02154 WCHAR
szName[
MAX_SESSION_PATH];
02155 HANDLE hevtRitExited;
02156 OBJECT_ATTRIBUTES obja;
02157
NTSTATUS Status;
02158 LARGE_INTEGER timeout;
02159
NTSTATUS Reason;
02160
BOOL fFirstTimeout =
TRUE;
02161
02162
if (!
gbRemoteSession) {
02163
return FALSE;
02164 }
02165
02166
TRACE_HYDAPI((
"InitiateWin32kCleanup\n"));
02167
02168
TRACE_RIT((
"Exiting Win32k ...\n"));
02169
02170
02171
02172
02173
CleanupPowerRequestList();
02174
02175
EnterCrit();
02176
02177
HYDRA_HINT(
HH_INITIATEWIN32KCLEANUP);
02178
02179 ptiCurrent =
PtiCurrent();
02180
02181 UserAssert(ptiCurrent !=
NULL);
02182
02183 pwinsta = ptiCurrent->
pwinsta;
02184
02185
02186
02187
02188 timeout.QuadPart = Int32x32To64(-10000, 300000);
02189
02190
02191
02192
02193
while (fWait) {
02194
02195
02196
02197
02198
02199
02200 pdesk = pwinsta->
rpdeskList;
02201
02202
if (pdesk ==
NULL) {
02203
break;
02204 }
02205
02206 fWait = pdesk !=
gspdeskDisconnect
02207 || pdesk->
rpdeskNext !=
NULL
02208 || pwinsta->
pTerm->
rpdeskDestroy !=
NULL;
02209
02210
if (fWait) {
02211
02212
LeaveCrit();
02213
02214 Reason =
KeWaitForSingleObject(
gpevtDesktopDestroyed,
WrUserRequest,
02215
KernelMode,
FALSE, &timeout);
02216
02217
if (Reason == STATUS_TIMEOUT) {
02218
02219
02220
02221
02222
02223
02224
02225
02226
02227
02228
02229
02230
if (fFirstTimeout) {
02231
02232 HANDLE hevtRitStuck;
02233
02234 RIPMSG0(RIP_WARNING,
02235
"Timeout in RIT waiting for gpevtDesktopDestroyed. Signal EventRitStuck...");
02236
02237 swprintf(
szName,
L"\\Sessions\\%ld\\BaseNamedObjects\\EventRitStuck",
02238
gSessionId);
02239
02240
RtlInitUnicodeString(&ustrName,
szName);
02241
02242 InitializeObjectAttributes(&obja,
02243 &ustrName,
02244 OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
02245
NULL,
02246
NULL);
02247
02248
Status = ZwCreateEvent(&hevtRitStuck,
02249 EVENT_ALL_ACCESS,
02250 &obja,
02251 SynchronizationEvent,
02252
FALSE);
02253
02254 UserAssert(
NT_SUCCESS(
Status));
02255
02256
if (
NT_SUCCESS(
Status)) {
02257 ZwSetEvent(hevtRitStuck,
NULL);
02258 ZwClose(hevtRitStuck);
02259
02260 fFirstTimeout =
FALSE;
02261 }
02262
02263 }
else {
02264 RIPMSG0(RIP_ERROR,
02265
"Timeout in RIT waiting for gpevtDesktopDestroyed.\n"
02266
"There are still GUI threads (assigned to a desktop) running !");
02267 }
02268 }
02269
02270
EnterCrit();
02271 }
02272 }
02273
TRACE_RIT((
"All other desktops exited...\n"));
02274
02275
Unlock(&
gspwndLogonNotify);
02276
02277
gbExitInProgress =
TRUE;
02278
02279
TRACE_RIT((
"Shutting down ptiCurrent %lx cWindows %d\n",
02280 ptiCurrent, ptiCurrent->
cWindows));
02281
02282
02283
02284
02285 UserAssert(
gspwndScreenCapture ==
NULL);
02286 UserAssert(
gspwndMouseOwner ==
NULL);
02287 UserAssert(
gspwndInternalCapture ==
NULL);
02288
02289
02290
02291
02292
02293
if (
gpDispInfo)
02294
FreeAllSpbs();
02295
02296
02297
02298
02299
if (
ghDisconnectWinSta) {
02300 UserVerify(
NT_SUCCESS(ZwClose(
ghDisconnectWinSta)));
02301
ghDisconnectWinSta =
NULL;
02302 }
02303
02304
if (
ghDisconnectDesk) {
02305
CloseProtectedHandle(
ghDisconnectDesk);
02306
ghDisconnectDesk =
NULL;
02307 }
02308
02309 UserAssert(pwinsta->
rpdeskList ==
NULL);
02310
02311
02312
02313
02314
UnlockDesktop(&
grpdeskLogon, LDU_DESKLOGON, 0);
02315
02316
02317
02318
02319
02320
02321
02322
02323
UnlockDesktop(&
gspdeskDisconnect, LDU_DESKDISCONNECT, 0);
02324
02325
02326
02327
02328
02329
02330 {
02331
PSMS psms =
gpsmsList;
02332
02333
while (psms !=
NULL) {
02334
if (psms->spwnd !=
NULL) {
02335 UserAssert(psms->message == WM_CLIENTSHUTDOWN);
02336
02337 RIPMSG1(RIP_WARNING,
"Window %x locked in the SMS list",
02338 psms->spwnd);
02339
02340
Unlock(&psms->spwnd);
02341 }
02342 psms = psms->psmsNext;
02343 }
02344 }
02345
02346
TRACE_RIT((
"posting WM_QUIT to the IO DT\n"));
02347
02348 UserAssert(pwinsta->
pTerm->
ptiDesktop !=
NULL);
02349
02350 UserVerify(
_PostThreadMessage(pwinsta->
pTerm->
ptiDesktop, WM_QUIT, 0, 0));
02351
02352
HYDRA_HINT(
HH_DTQUITPOSTED);
02353
02354
02355
02356
02357
02358
02359
02360
02361 {
02362 PVOID aDT[2];
02363 ULONG objects = 1;
02364
02365 aDT[0] =
gTermIO.
ptiDesktop->pEThread;
02366
02367
ObReferenceObject(aDT[0]);
02368
02369
if (
gTermNOIO.
ptiDesktop !=
NULL) {
02370 aDT[1] =
gTermNOIO.
ptiDesktop->pEThread;
02371
ObReferenceObject(aDT[1]);
02372 objects++;
02373 }
02374
02375
TRACE_RIT((
"waiting on desktop thread(s) destruction ...\n"));
02376
02377
LeaveCrit();
02378
02379
02380
02381
02382 timeout.QuadPart = Int32x32To64(-10000, 300000);
02383 WaitAgain:
02384
02385 Reason =
02386
02387
KeWaitForMultipleObjects(objects,
02388 aDT,
02389 WaitAll,
02390
WrUserRequest,
02391
KernelMode,
02392
TRUE,
02393 &timeout,
02394
NULL);
02395
02396
if (Reason == STATUS_TIMEOUT) {
02397 RIPMSG0(RIP_ERROR,
02398
"Timeout in RIT waiting for desktop threads to go away.");
02399
goto WaitAgain;
02400 }
02401
02402
TRACE_RIT((
"desktop thread(s) destroyed\n"));
02403
02404
ObDereferenceObject(aDT[0]);
02405
02406
if (objects > 1) {
02407
ObDereferenceObject(aDT[1]);
02408 }
02409
02410
EnterCrit();
02411 }
02412
02413
HYDRA_HINT(
HH_ALLDTGONE);
02414
02415
02416
02417
02418
if (
gbConnected) {
02419 bDrvDisconnect(
gpDispInfo->
hDev,
ghRemoteThinwireChannel,
02420
gThinwireFileObject);
02421 }
02422
02423
UnlockDesktop(&
grpdeskRitInput, LDU_DESKRITINPUT, 0);
02424
UnlockDesktop(&
gspdeskShouldBeForeground, LDU_DESKSHOULDBEFOREGROUND, 0);
02425
02426
02427
02428
02429
while (
gptmrFirst !=
NULL) {
02430
FreeTimer(
gptmrFirst);
02431 }
02432
02433
02434
02435
02436
if (
CsrApiPort !=
NULL) {
02437
ObDereferenceObject(
CsrApiPort);
02438
CsrApiPort =
NULL;
02439 }
02440
02441
Unlock(&
gspwndCursor);
02442
02443
02444
02445
02446
gptiRit =
NULL;
02447
02448
TRACE_RIT((
"TERMINATING !!!\n"));
02449
02450
#if DBG
02451
{
02452
PPROCESSINFO ppi =
gppiList;
02453
02454 KdPrint((
"Processes still running:\n"));
02455 KdPrint((
"-------------------------\n"));
02456
02457
while (ppi) {
02458
02459
PTHREADINFO pti;
02460
02461 KdPrint((
"ppi '%s' 0x%x threads: %d\n",
02462 ppi->Process->ImageFileName,
02463 ppi,
02464 ppi->
cThreads));
02465
02466 KdPrint((
"\tGUI threads\n"));
02467
02468 pti = ppi->
ptiList;
02469
02470
while (pti) {
02471 KdPrint((
"\t%#p\n", pti));
02472 pti = pti->
ptiSibling;
02473 }
02474
02475 ppi = ppi->
ppiNextRunning;
02476 }
02477 KdPrint((
"-------------------------\n"));
02478 }
02479
#endif // DBG
02480
02481
LeaveCrit();
02482
02483 swprintf(
szName,
L"\\Sessions\\%ld\\BaseNamedObjects\\EventRitExited",
02484
gSessionId);
02485
02486
RtlInitUnicodeString(&ustrName,
szName);
02487
02488 InitializeObjectAttributes(&obja,
02489 &ustrName,
02490 OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
02491
NULL,
02492
NULL);
02493
02494
Status = ZwCreateEvent(&hevtRitExited,
02495 EVENT_ALL_ACCESS,
02496 &obja,
02497 SynchronizationEvent,
02498
FALSE);
02499
02500 UserAssert(
NT_SUCCESS(
Status));
02501
02502 ZwSetEvent(hevtRitExited,
NULL);
02503
02504 ZwClose(hevtRitExited);
02505
02506
02507
02508
02509 ptiCurrent->
TIF_flags &= ~
TIF_PALETTEAWARE;
02510
02511
HYDRA_HINT(
HH_RITGONE);
02512
02513
return TRUE;
02514 }
02515
02516
02517
02518
02519
02520
02521
02522
02523
02524
02525
02526
02527 void RemoteSyncToggleKeys(ULONG toggleKeys)
02528 {
02529 KE ke;
02530
02531
CheckCritIn();
02532
gSetLedReceived = toggleKeys | KEYBOARD_LED_INJECTED;
02533
02534
02535
if (
gpqForeground !=
NULL) {
02536
02537
if (((
gSetLedReceived & KEYBOARD_CAPS_LOCK_ON) &&
02538 !
TestRawKeyToggle(VK_CAPITAL)) ||
02539 (!(
gSetLedReceived & KEYBOARD_CAPS_LOCK_ON) &&
02540
TestRawKeyToggle(VK_CAPITAL))) {
02541
02542 ke.bScanCode = (
BYTE)(0x3a);
02543 ke.usFlaggedVk = VK_CAPITAL;
02544
xxxProcessKeyEvent(&ke, 0,
FALSE);
02545
02546 ke.bScanCode = (
BYTE)(0xba);
02547 ke.usFlaggedVk = VK_CAPITAL | KBDBREAK;
02548
xxxProcessKeyEvent(&ke, 0,
FALSE);
02549 }
02550
02551
if (((
gSetLedReceived & KEYBOARD_NUM_LOCK_ON) &&
02552 !
TestRawKeyToggle(VK_NUMLOCK)) ||
02553 (!(
gSetLedReceived & KEYBOARD_NUM_LOCK_ON) &&
02554
TestRawKeyToggle(VK_NUMLOCK))) {
02555
02556 ke.bScanCode = (
BYTE)(0x45);
02557 ke.usFlaggedVk = VK_NUMLOCK;
02558
xxxProcessKeyEvent(&ke, 0,
FALSE);
02559
02560 ke.bScanCode = (
BYTE)(0xc5);
02561 ke.usFlaggedVk = VK_NUMLOCK | KBDBREAK;
02562
xxxProcessKeyEvent(&ke, 0,
FALSE);
02563 }
02564
02565
if (((
gSetLedReceived & KEYBOARD_SCROLL_LOCK_ON) &&
02566 !
TestRawKeyToggle(VK_SCROLL)) ||
02567 (!(
gSetLedReceived & KEYBOARD_SCROLL_LOCK_ON) &&
02568
TestRawKeyToggle(VK_SCROLL))) {
02569
02570 ke.bScanCode = (
BYTE)(0x46);
02571 ke.usFlaggedVk = VK_SCROLL;
02572
xxxProcessKeyEvent(&ke, 0,
FALSE);
02573
02574 ke.bScanCode = (
BYTE)(0xc6);
02575 ke.usFlaggedVk = VK_SCROLL | KBDBREAK;
02576
xxxProcessKeyEvent(&ke, 0,
FALSE);
02577 }
02578
02579
if (JAPANESE_KBD_LAYOUT(
GetActiveHKL())) {
02580
if (((
gSetLedReceived & KEYBOARD_KANA_LOCK_ON) &&
02581 !
TestRawKeyToggle(VK_KANA)) ||
02582 (!(
gSetLedReceived & KEYBOARD_KANA_LOCK_ON) &&
02583
TestRawKeyToggle(VK_KANA))) {
02584
02585 ke.bScanCode = (
BYTE)(0x70);
02586 ke.usFlaggedVk = VK_KANA;
02587
xxxProcessKeyEvent(&ke, 0,
FALSE);
02588
02589 ke.bScanCode = (
BYTE)(0xf0);
02590 ke.usFlaggedVk = VK_KANA | KBDBREAK;
02591
xxxProcessKeyEvent(&ke, 0,
FALSE);
02592 }
02593 }
02594
02595
gSetLedReceived = 0;
02596 }
02597 }
02598
02599
02600
02601
02602
02603
02604
02605
02606
02607
02608
02609
02610
02611
02612
02613
02614
02615 VOID ProcessKeyboardInput(
PDEVICEINFO pDeviceInfo)
02616 {
02617
BYTE Vk;
02618
BYTE bPrefix;
02619 KE ke;
02620 PKEYBOARD_INPUT_DATA pkei;
02621 PKEYBOARD_INPUT_DATA pkeiStart, pkeiEnd;
02622
02623
EnterCrit();
02624 UserAssert(pDeviceInfo->type ==
DEVICE_TYPE_KEYBOARD);
02625
02626 pkeiStart = pDeviceInfo->
keyboard.
Data;
02627 pkeiEnd = (PKEYBOARD_INPUT_DATA)((
PBYTE)pkeiStart + pDeviceInfo->iosb.Information);
02628
for (pkei = pkeiStart; pkei < pkeiEnd; pkei++) {
02629
02630
02631
02632
02633
02634
02635
02636
if (!(pkei->Flags & KEY_TERMSRV_SET_LED)) {
02637
02638
02639
if (!(
gSetLedReceived & KEYBOARD_LED_INJECTED))
02640
goto ProcessKeys;
02641
else
02642
RemoteSyncToggleKeys(
gSetLedReceived);
02643
02644 ProcessKeys:
02645
if (pkei->Flags & KEY_E0) {
02646 bPrefix = 0xE0;
02647 }
else if (pkei->Flags & KEY_E1) {
02648 bPrefix = 0xE1;
02649 }
else {
02650 bPrefix = 0;
02651 }
02652
02653
if (pkei->MakeCode == 0xFF) {
02654
02655
02656
02657
02658
02659
LeaveCrit();
02660
UserBeep(440, 125);
02661
EnterCrit();
02662
continue;
02663 }
02664
02665 ke.bScanCode = (
BYTE)(pkei->MakeCode & 0x7F);
02666
if (
gpScancodeMap) {
02667
MapScancode(&ke.bScanCode, &bPrefix);
02668 }
02669
02670 Vk =
VKFromVSC(&ke, bPrefix,
gafRawKeyState);
02671
02672
if (Vk == 0) {
02673
continue;
02674 }
02675
02676
if (pkei->Flags & KEY_BREAK) {
02677 ke.usFlaggedVk |= KBDBREAK;
02678 }
02679
02680
02681
02682
02683
02684
02685
02686
02687
02688
02689
02690
02691
02692
02693
02694
02695
if (
gbRemoteSession) {
02696
BYTE CheckVk = (
BYTE)ke.usFlaggedVk;
02697
02698
if (CheckVk == VK_LWIN || CheckVk == VK_RWIN)
02699
if ( !
gfEnableWindowsKey )
02700
continue;
02701 }
02702
02703
02704
02705
02706
02707
02708
02709
02710
02711
02712
02713
02714
02715
02716
02717
02718
02719
switch (Vk) {
02720
case VK_LSHIFT:
02721
case VK_RSHIFT:
02722
case VK_LCONTROL:
02723
case VK_RCONTROL:
02724
case VK_LMENU:
02725
case VK_RMENU:
02726
gCurrentModifierBit = 1 << (Vk & 0xf);
02727
break;
02728
case VK_LWIN:
02729
gCurrentModifierBit = 0x40;
02730
break;
02731
case VK_RWIN:
02732
gCurrentModifierBit = 0x80;
02733
break;
02734
default:
02735
gCurrentModifierBit = 0;
02736 }
02737
if (
gCurrentModifierBit) {
02738
02739
02740
02741
02742
if (pkei->Flags & KEY_BREAK) {
02743
gPhysModifierState &= ~
gCurrentModifierBit;
02744 }
else {
02745
gPhysModifierState |=
gCurrentModifierBit;
02746 }
02747 }
02748
02749
if (!
TEST_ACCF(
ACCF_ACCESSENABLED)) {
02750
xxxProcessKeyEvent(&ke, (ULONG_PTR)pkei->ExtraInformation,
FALSE);
02751 }
else {
02752
if ((
gtmridAccessTimeOut != 0) &&
TEST_ACCESSFLAG(AccessTimeOut, ATF_TIMEOUTON)) {
02753
gtmridAccessTimeOut =
InternalSetTimer(
02754
NULL,
02755
gtmridAccessTimeOut,
02756 (
UINT)
gAccessTimeOut.iTimeOutMSec,
02757
xxxAccessTimeOutTimer,
02758 TMRF_RIT | TMRF_ONESHOT
02759 );
02760 }
02761
if (
AccessProceduresStream(&ke, pkei->ExtraInformation, 0)) {
02762
xxxProcessKeyEvent(&ke, (ULONG_PTR)pkei->ExtraInformation,
FALSE);
02763 }
02764 }
02765 }
02766
02767
02768
else {
02769
RemoteSyncToggleKeys(pkei->ExtraInformation);
02770 }
02771 }
02772
02773
LeaveCrit();
02774 }
02775
02776
02777
02778
02779
02780
02781
02782
02783
02784
02785
02786
02787
02788
02789
02790
02791 VOID xxxProcessKeyEvent(
02792 PKE pke,
02793 ULONG_PTR ExtraInformation,
02794 BOOL bInjected)
02795 {
02796
BYTE Vk;
02797
02798
CheckCritIn();
02799
02800 Vk = (
BYTE)pke->usFlaggedVk;
02801
02802
02803
02804
02805
02806
02807
02808
02809
02810
02811
02812
02813
02814
02815
02816
02817
02818
if (KOREAN_KBD_LAYOUT(
GetActiveHKL())) {
02819
if ((pke->usFlaggedVk & KBDBREAK) &&
02820 !(pke->usFlaggedVk & KBDUNICODE) &&
02821 (pke->bScanCode == 0xF1 || pke->bScanCode == 0xF2) &&
02822 !
TestRawKeyDown(Vk)) {
02823
02824
02825
02826
02827
02828
02829 pke->usFlaggedVk &= ~KBDBREAK;
02830 }
else {
02831
UpdateRawKeyState(Vk, pke->usFlaggedVk & KBDBREAK);
02832 }
02833 }
else {
02834
UpdateRawKeyState(Vk, pke->usFlaggedVk & KBDBREAK);
02835 }
02836
02837
02838
02839
02840
02841
if ((Vk >= VK_LSHIFT) && (Vk <= VK_RMENU)) {
02842 Vk = (
BYTE)((Vk - VK_LSHIFT) / 2 + VK_SHIFT);
02843
UpdateRawKeyState(Vk, pke->usFlaggedVk & KBDBREAK);
02844 }
02845
02846
02847
02848
02849
if (
glinp.
dwFlags &
LINP_POWERTIMEOUTS) {
02850
02851
02852
02853 KdPrint((
"Exit video power down mode\n"));
02854 DrvSetMonitorPowerState(
gpDispInfo->
pmdev, PowerDeviceD0);
02855 }
02856
glinp.
dwFlags = (
glinp.
dwFlags & ~
LINP_INPUTTIMEOUTS) |
LINP_KEYBOARD;
02857
glinp.
timeLastInputMessage =
gpsi->dwLastRITEventTickCount =
NtGetTickCount();
02858
if (!bInjected || (pke->dwTime == 0)) {
02859 pke->dwTime =
glinp.
timeLastInputMessage;
02860 }
02861
02862
02863
02864
02865
02866
02867
if (pke->usFlaggedVk & KBDUNICODE) {
02868
xxxKeyEvent(pke->usFlaggedVk, pke->wchInjected,
02869 pke->dwTime, ExtraInformation, bInjected);
02870 }
else {
02871
if (
KEOEMProcs(pke) &&
xxxKELocaleProcs(pke) &&
xxxKENLSProcs(pke,ExtraInformation)) {
02872
xxxKeyEvent(pke->usFlaggedVk, pke->bScanCode,
02873 pke->dwTime, ExtraInformation, bInjected);
02874 }
02875 }
02876 }
02877
02878
02879
02880
02881
02882
02883
02884
#ifdef LOCK_MOUSE_CODE
02885
#pragma alloc_text(MOUSE, DoMouseAccel)
02886
#endif
02887
02888 LONG
DoMouseAccel(
02889 LONG Delta)
02890 {
02891 LONG newDelta = Delta;
02892
02893
if (
abs(Delta) >
gMouseThresh1) {
02894 newDelta *= 2;
02895
02896
if ((
abs(Delta) >
gMouseThresh2) && (
gMouseSpeed == 2)) {
02897 newDelta *= 2;
02898 }
02899 }
02900
02901
return newDelta;
02902 }
02903
02904
02905
02906
02907
02908
02909
02910
02911
02912 PWND PwndForegroundCapture(VOID)
02913 {
02914
if (
gpqForeground !=
NULL) {
02915
return gpqForeground->
spwndCapture;
02916 }
02917
02918
return NULL;
02919 }
02920
02921
02922
02923
02924
02925
02926
02927
02928
02929
02930
02931
02932 VOID SetKeyboardRate(
02933 UINT nKeySpeedAndDelay
02934 )
02935 {
02936
UINT nKeyDelay;
02937
UINT nKeySpeed;
02938
02939 nKeyDelay = (nKeySpeedAndDelay &
KDELAY_MASK) >>
KDELAY_SHIFT;
02940
02941 nKeySpeed =
KSPEED_MASK & nKeySpeedAndDelay;
02942
02943
gktp.Rate = (
USHORT)( (
gKeyboardInfo.KeyRepeatMaximum.Rate -
02944
gKeyboardInfo.KeyRepeatMinimum.Rate
02945 ) * nKeySpeed /
KSPEED_MASK
02946 ) +
02947
gKeyboardInfo.KeyRepeatMinimum.Rate;
02948
02949
gktp.Delay = (
USHORT)( (
gKeyboardInfo.KeyRepeatMaximum.Delay -
02950
gKeyboardInfo.KeyRepeatMinimum.Delay
02951 ) * nKeyDelay / (
KDELAY_MASK >>
KDELAY_SHIFT)
02952 ) +
02953
gKeyboardInfo.KeyRepeatMinimum.Delay;
02954
02955
02956
02957
02958
02959
gdwUpdateKeyboard |=
UPDATE_KBD_TYPEMATIC;
02960 }
02961
02962
02963
02964
02965
02966
02967
02968
02969
02970
02971
02972
02973
02974
02975
02976
02977
02978
02979
02980
02981
02982
02983
02984
02985 VOID UpdateKeyLights(BOOL bInjected)
02986 {
02987
02988
02989
02990
CheckCritIn();
02991
02992
02993
02994
02995
02996
gklp.LedFlags = 0;
02997
if (
TestAsyncKeyStateToggle(VK_CAPITAL)) {
02998
gklp.LedFlags |= KEYBOARD_CAPS_LOCK_ON;
02999
SetRawKeyToggle(VK_CAPITAL);
03000 }
else {
03001
ClearRawKeyToggle(VK_CAPITAL);
03002 }
03003
03004
if (
TestAsyncKeyStateToggle(VK_NUMLOCK)) {
03005
gklp.LedFlags |= KEYBOARD_NUM_LOCK_ON;
03006
SetRawKeyToggle(VK_NUMLOCK);
03007 }
else {
03008
ClearRawKeyToggle(VK_NUMLOCK);
03009 }
03010
03011
if (
TestAsyncKeyStateToggle(VK_SCROLL)) {
03012
gklp.LedFlags |= KEYBOARD_SCROLL_LOCK_ON;
03013
SetRawKeyToggle(VK_SCROLL);
03014 }
else {
03015
ClearRawKeyToggle(VK_SCROLL);
03016 }
03017
03018
03019
03020
03021
03022
if (JAPANESE_KEYBOARD(
gKeyboardInfo.KeyboardIdentifier)) {
03023
if (
TestAsyncKeyStateToggle(VK_KANA)) {
03024
gklp.LedFlags |= KEYBOARD_KANA_LOCK_ON;
03025
SetRawKeyToggle(VK_KANA);
03026 }
else {
03027
ClearRawKeyToggle(VK_KANA);
03028 }
03029 }
03030
03031
03032
03033
03034
03035
if (
gbRemoteSession) {
03036
if (bInjected)
03037
gklp.LedFlags |= KEYBOARD_LED_INJECTED;
03038
else
03039
gklp.LedFlags &= ~KEYBOARD_LED_INJECTED;
03040 }
03041
03042
03043
if (
PtiCurrent() !=
gptiRit) {
03044
03045
03046
03047
03048
03049
gdwUpdateKeyboard |=
UPDATE_KBD_LEDS;
03050 }
else {
03051
03052
03053
03054
03055
PDEVICEINFO pDeviceInfo;
03056
03057
EnterDeviceInfoListCrit();
03058
for (pDeviceInfo =
gpDeviceInfoList; pDeviceInfo; pDeviceInfo = pDeviceInfo->pNext) {
03059
if ((pDeviceInfo->type ==
DEVICE_TYPE_KEYBOARD) && (pDeviceInfo->handle)) {
03060 ZwDeviceIoControlFile(pDeviceInfo->handle,
NULL,
NULL,
NULL,
03061 &
giosbKbdControl, IOCTL_KEYBOARD_SET_INDICATORS,
03062 (PVOID)&
gklp,
sizeof(
gklp),
NULL, 0);
03063 }
03064 }
03065
LeaveDeviceInfoListCrit();
03066 }
03067 }
03068
03069
03070 int _GetKeyboardType(
int nTypeFlag)
03071 {
03072
03073
switch (nTypeFlag) {
03074
case 0:
03075
return gKeyboardInfo.KeyboardIdentifier.Type;
03076
03077
case 1:
03078
03079 {
03080
int OEMId = 0;
03081
03082
03083
03084
03085
03086
03087
if (
gpKbdNlsTbl !=
NULL) {
03088
if (
gpKbdNlsTbl->LayoutInformation & NLSKBD_INFO_EMURATE_101_KEYBOARD) {
03089
return (MICROSOFT_KBD_101_TYPE);
03090 }
03091
if (
gpKbdNlsTbl->LayoutInformation & NLSKBD_INFO_EMURATE_106_KEYBOARD) {
03092
return (MICROSOFT_KBD_106_TYPE);
03093 }
03094 }
03095
03096
03097
03098
03099
03100
03101
03102
03103
03104
03105
03106
03107
03108
03109
03110
03111
03112
03113
03114
03115
03116
03117
03118
03119
03120
03121
03122
03123
03124
03125
03126
03127
03128
03129
03130
03131
03132
03133
03134
03135
03136
03137
03138
03139
03140
03141
03142
03143
03144
03145
03146
03147
03148
03149
03150
03151
03152
03153
03154
if (
gpKbdNlsTbl !=
NULL) {
03155
03156
03157
03158 OEMId = ((
int)
gpKbdNlsTbl->OEMIdentifier) << 8;
03159 }
03160
03161
03162
03163
03164
03165
03166
03167
03168
03169
03170
03171
03172
03173
03174
03175
03176
03177
03178
03179
03180
03181
03182
03183
03184
03185
return (
int)(OEMId | (
gKeyboardInfo.KeyboardIdentifier.Subtype & 0x0F));
03186 }
03187
03188
case 2:
03189
return gKeyboardInfo.NumberOfFunctionKeys;
03190 }
03191
return 0;
03192 }
03193
03194
03195
03196
03197
03198
03199
03200
03201
03202
03203
03204
03205
03206
03207
03208
03209
03210
03211
03212
03213 VOID xxxMouseEventDirect(
03214 DWORD dx,
03215 DWORD dy,
03216 DWORD mouseData,
03217 DWORD dwMEFlags,
03218 DWORD dwTime,
03219 ULONG_PTR dwExtraInfo)
03220 {
03221
DWORD dwDriverMouseFlags;
03222
DWORD dwDriverMouseData;
03223
03224
PTHREADINFO pti =
PtiCurrent();
03225
if (dwTime == 0) {
03226 dwTime =
NtGetTickCount();
03227 }
03228
03229
03230
03231
03232
03233
if (pti->
rpdesk ==
grpdeskRitInput) {
03234 UserAssert(!(pti->
rpdesk->
rpwinstaParent->
dwWSF_Flags &
WSF_NOIO));
03235
if (!
CheckGrantedAccess(pti->
amdesk, DESKTOP_JOURNALPLAYBACK)) {
03236 RIPMSG0(RIP_ERROR,
"mouse_event(): No DESKTOP_JOURNALPLAYBACK access to input desktop." );
03237
return;
03238 }
03239 }
else {
03240
03241
03242
03243
if (pti->
dwExpWinVer >=
VER40) {
03244 RIPMSG0(RIP_VERBOSE,
"mouse_event(): Calls not forwarded for 4.0 or greater apps.");
03245
return;
03246 }
else {
03247
BOOL fAccessToDesktop;
03248
03249
03250
03251
03252
03253
03254
03255
03256
03257
03258
03259 UserAssert(
grpdeskRitInput !=
NULL);
03260
03261 UserAssert(!(
grpdeskRitInput->
rpwinstaParent->
dwWSF_Flags &
WSF_NOIO));
03262 fAccessToDesktop =
AccessCheckObject(
grpdeskRitInput,
03263 DESKTOP_READOBJECTS | DESKTOP_WRITEOBJECTS | DESKTOP_JOURNALPLAYBACK,
03264
KernelMode,
03265 &
DesktopMapping);
03266
if (!fAccessToDesktop) {
03267 RIPMSG0(RIP_VERBOSE,
"mouse_event(): Call NOT forwarded to input desktop" );
03268
return;
03269 }
03270
03271
03272
03273
03274
03275 RIPMSG0( RIP_VERBOSE,
"mouse_event(): Call forwarded to input desktop" );
03276 }
03277 }
03278
03279
03280
03281
03282
03283
gppiInputProvider = pti->
ppi;
03284
03285
LeaveCrit();
03286
03287
03288
03289
03290
03291
if (dwMEFlags & MOUSEEVENTF_MOVE) {
03292
xxxMoveEvent(dx, dy, dwMEFlags, dwExtraInfo, dwTime,
TRUE);
03293 }
03294
03295
03296
03297
03298
03299
03300
03301
#if MOUSEEVENTF_MOVE != 1
03302
# error("MOUSEEVENTF_MOVE != 1")
03303
#endif
03304
#if MOUSEEVENTF_LEFTDOWN != MOUSE_LEFT_BUTTON_DOWN * 2
03305
# error("MOUSEEVENTF_LEFTDOWN != MOUSE_LEFT_BUTTON_DOWN * 2")
03306
#endif
03307
#if MOUSEEVENTF_LEFTUP != MOUSE_LEFT_BUTTON_UP * 2
03308
# error("MOUSEEVENTF_LEFTUP != MOUSE_LEFT_BUTTON_UP * 2")
03309
#endif
03310
#if MOUSEEVENTF_RIGHTDOWN != MOUSE_RIGHT_BUTTON_DOWN * 2
03311
# error("MOUSEEVENTF_RIGHTDOWN != MOUSE_RIGHT_BUTTON_DOWN * 2")
03312
#endif
03313
#if MOUSEEVENTF_RIGHTUP != MOUSE_RIGHT_BUTTON_UP * 2
03314
# error("MOUSEEVENTF_RIGHTUP != MOUSE_RIGHT_BUTTON_UP * 2")
03315
#endif
03316
#if MOUSEEVENTF_MIDDLEDOWN != MOUSE_MIDDLE_BUTTON_DOWN * 2
03317
# error("MOUSEEVENTF_MIDDLEDOWN != MOUSE_MIDDLE_BUTTON_DOWN * 2")
03318
#endif
03319
#if MOUSEEVENTF_MIDDLEUP != MOUSE_MIDDLE_BUTTON_UP * 2
03320
# error("MOUSEEVENTF_MIDDLEUP != MOUSE_MIDDLE_BUTTON_UP * 2")
03321
#endif
03322
#if MOUSEEVENTF_WHEEL != MOUSE_WHEEL * 2
03323
# error("MOUSEEVENTF_WHEEL != MOUSE_WHEEL * 2")
03324
#endif
03325
03326
03327 dwDriverMouseFlags = dwMEFlags & MOUSEEVENTF_BUTTONMASK;
03328
03329
03330
03331 dwDriverMouseFlags &= ~(MOUSEEVENTF_XDOWN | MOUSEEVENTF_XUP);
03332
03333 dwDriverMouseData = 0;
03334
03335
03336
03337
03338
03339
03340
03341
if ( ((dwMEFlags & (MOUSEEVENTF_XDOWN | MOUSEEVENTF_WHEEL)) == (MOUSEEVENTF_XDOWN | MOUSEEVENTF_WHEEL)) ||
03342 ((dwMEFlags & (MOUSEEVENTF_XUP | MOUSEEVENTF_WHEEL)) == (MOUSEEVENTF_XUP | MOUSEEVENTF_WHEEL))) {
03343
03344 RIPMSG1(RIP_WARNING,
"Can't specify both MOUSEEVENTF_XDOWN/UP and MOUSEEVENTF_WHEEL in call to SendInput, dwFlags=0x%.8X", dwMEFlags);
03345 dwDriverMouseFlags &= ~(MOUSEEVENTF_XDOWN | MOUSEEVENTF_XUP | MOUSEEVENTF_WHEEL);
03346 }
else if (dwMEFlags & MOUSEEVENTF_WHEEL) {
03347
03348
03349
03350
03351 dwDriverMouseData =
min(
max(SHRT_MIN, (LONG)mouseData), SHRT_MAX);
03352 }
else {
03353
03354
if (~XBUTTON_MASK & mouseData) {
03355 RIPMSG1(RIP_WARNING,
"Invalid xbutton specified in SendInput, mouseData=0x%.8X", mouseData);
03356 }
else {
03357
if (dwMEFlags & MOUSEEVENTF_XDOWN) {
03358
if (mouseData & XBUTTON1) {
03359 dwDriverMouseFlags |= MOUSEEVENTF_DRIVER_X1DOWN;
03360 }
03361
if (mouseData & XBUTTON2) {
03362 dwDriverMouseFlags |= MOUSEEVENTF_DRIVER_X2DOWN;
03363 }
03364 }
03365
if (dwMEFlags & MOUSEEVENTF_XUP) {
03366
if (mouseData & XBUTTON1) {
03367 dwDriverMouseFlags |= MOUSEEVENTF_DRIVER_X1UP;
03368 }
03369
if (mouseData & XBUTTON2) {
03370 dwDriverMouseFlags |= MOUSEEVENTF_DRIVER_X2UP;
03371 }
03372 }
03373 }
03374 }
03375
03376
03377 dwDriverMouseFlags >>= 1;
03378
03379
QueueMouseEvent(
03380 (
USHORT) dwDriverMouseFlags,
03381 (
USHORT) dwDriverMouseData,
03382 dwExtraInfo,
03383
gptCursorAsync,
03384 dwTime,
03385
TRUE,
03386
FALSE
03387 );
03388
03389
ProcessQueuedMouseEvents();
03390
03391
EnterCrit();
03392 }
03393
03394
03395
03396
03397
03398
03399
03400
03401
03402
03403 VOID xxxInternalKeyEventDirect(
03404 BYTE bVk,
03405 WORD wScan,
03406 DWORD dwFlags,
03407 DWORD dwTime,
03408 ULONG_PTR dwExtraInfo)
03409 {
03410
PTHREADINFO pti =
PtiCurrent();
03411 KE KeyEvent;
03412
03413
03414
03415
03416
03417
if (pti->
rpdesk !=
grpdeskRitInput ||
03418 !
RtlAreAllAccessesGranted(pti->
amdesk, DESKTOP_JOURNALPLAYBACK)) {
03419
03420 RIPNTERR0(STATUS_ACCESS_DENIED, RIP_WARNING,
03421
"Injecting key failed: Non active desktop or access denied");
03422
03423
return;
03424 }
03425 UserAssert(!(pti->
rpdesk->
rpwinstaParent->
dwWSF_Flags &
WSF_NOIO));
03426
03427 KeyEvent.bScanCode = (
BYTE)wScan;
03428
if (
dwFlags & KEYEVENTF_SCANCODE) {
03429 bVk =
VKFromVSC(&KeyEvent,
03430 (
BYTE)(
dwFlags & KEYEVENTF_EXTENDEDKEY ? 0xE0 : 0),
03431
gafRawKeyState);
03432 KeyEvent.usFlaggedVk = (
USHORT)bVk;
03433 }
else {
03434 KeyEvent.usFlaggedVk = bVk | KBDINJECTEDVK;
03435 }
03436
03437
if (
dwFlags & KEYEVENTF_KEYUP)
03438 KeyEvent.usFlaggedVk |= KBDBREAK;
03439
03440
if (
dwFlags & KEYEVENTF_UNICODE) {
03441 KeyEvent.usFlaggedVk |= KBDUNICODE;
03442 KeyEvent.wchInjected = wScan;
03443 }
else if (
dwFlags & KEYEVENTF_EXTENDEDKEY) {
03444 KeyEvent.usFlaggedVk |= KBDEXT;
03445 }
else {
03446
03447
if (((bVk >= VK_NUMPAD0) && (bVk <= VK_NUMPAD9)) || (bVk == VK_DECIMAL)) {
03448 KeyEvent.usFlaggedVk |= KBDNUMPAD;
03449 }
else {
03450
int i;
03451
for (i = 0;
ausNumPadCvt[i] != 0; i++) {
03452
if (bVk ==
LOBYTE(
ausNumPadCvt[i])) {
03453 KeyEvent.usFlaggedVk |= KBDNUMPAD;
03454
break;
03455 }
03456 }
03457 }
03458 }
03459
03460
03461
03462
03463
03464
gppiInputProvider = pti->
ppi;
03465
03466 KeyEvent.dwTime = dwTime;
03467
xxxProcessKeyEvent(&KeyEvent, dwExtraInfo,
TRUE);
03468 }
03469
03470
03471
03472
03473
03474
03475
03476
03477
03478
03479
03480
03481
03482
03483
03484
03485
03486
03487
03488
03489
03490
03491
03492
03493
03494
03495
03496
03497
BOOL
03498 _BlockInput(BOOL fBlockIt)
03499 {
03500
PTHREADINFO ptiCurrent;
03501
03502 ptiCurrent =
PtiCurrent();
03503
03504
03505
03506
03507
03508
03509
if (fBlockIt &&
03510 (ptiCurrent->
rpdesk !=
grpdeskRitInput ||
03511 !
RtlAreAllAccessesGranted(ptiCurrent->
amdesk, DESKTOP_JOURNALPLAYBACK))) {
03512
03513 RIPNTERR0(STATUS_ACCESS_DENIED, RIP_WARNING,
03514
"BlockInput failed: Non active desktop or access denied");
03515
return FALSE;
03516 }
03517 UserAssert(!(ptiCurrent->
rpdesk->
rpwinstaParent->
dwWSF_Flags &
WSF_NOIO));
03518
03519
03520
03521
03522
03523
03524
03525
03526
03527
03528
03529
if (fBlockIt) {
03530
03531
03532
03533
if (
gptiBlockInput !=
NULL) {
03534
return FALSE;
03535 }
03536
03537
03538
03539
03540
03541
if (ptiCurrent->
TIF_flags &
TIF_INCLEANUP) {
03542
return FALSE;
03543 }
03544
03545
03546
03547
03548
gptiBlockInput = ptiCurrent;
03549 }
else {
03550
03551
03552
03553
if (
gptiBlockInput != ptiCurrent) {
03554
return FALSE;
03555 }
03556
03557
03558
03559
03560
gptiBlockInput =
NULL;
03561 }
03562
03563
return TRUE;
03564 }
03565
03566
03567
03568
03569
03570
03571
03572
03573
03574
03575 UINT xxxSendInput(
03576 UINT nInputs,
03577 LPINPUT pInputs)
03578 {
03579
UINT nEv;
03580 LPINPUT pEvent;
03581
DWORD dwExpWinVer =
PtiCurrent()->dwExpWinVer;
03582
03583
for (nEv = 0, pEvent = pInputs; nEv < nInputs; nEv++) {
03584
03585
switch (pEvent->type) {
03586
case INPUT_MOUSE:
03587
xxxMouseEventDirect(
03588 pEvent->mi.dx,
03589 pEvent->mi.dy,
03590 pEvent->mi.mouseData,
03591 pEvent->mi.dwFlags,
03592 pEvent->mi.time,
03593 pEvent->mi.dwExtraInfo);
03594
break;
03595
03596
case INPUT_KEYBOARD:
03597
if ((pEvent->ki.dwFlags & KEYEVENTF_UNICODE) &&
03598 (pEvent->ki.wVk == 0) &&
03599 ((pEvent->ki.dwFlags & ~(KEYEVENTF_KEYUP | KEYEVENTF_UNICODE)) == 0)) {
03600
xxxInternalKeyEventDirect(
03601 VK_PACKET,
03602 pEvent->ki.wScan,
03603 pEvent->ki.dwFlags,
03604 pEvent->ki.time,
03605 pEvent->ki.dwExtraInfo);
03606 }
else {
03607
xxxInternalKeyEventDirect(
03608
LOBYTE(pEvent->ki.wVk),
03609
LOBYTE(pEvent->ki.wScan),
03610 pEvent->ki.dwFlags,
03611 pEvent->ki.time,
03612 pEvent->ki.dwExtraInfo);
03613 }
03614
break;
03615
03616
case INPUT_HARDWARE:
03617
break;
03618 }
03619
03620 pEvent++;
03621 }
03622
return nInputs;
03623 }
03624
03625
03626
03627
03628
03629
03630
03631
03632
03633
03634 BOOL _SetConsoleReserveKeys(
03635
PWND pwnd,
03636 DWORD fsReserveKeys)
03637 {
03638
GETPTI(pwnd)->fsReserveKeys = fsReserveKeys;
03639
return TRUE;
03640 }
03641
03642
03643
03644
03645
03646
03647
03648
03649
03650
03651
03652 int _GetMouseMovePointsEx(
03653 CONST MOUSEMOVEPOINT* ppt,
03654 MOUSEMOVEPOINT* ccxpptBuf,
03655 UINT nPoints,
03656 DWORD resolution)
03657 {
03658
UINT uInd, uStart, nPointsRetrieved, i;
03659
BOOL bFound =
FALSE;
03660
int x, y;
03661
DWORD resX, resY;
03662
03663 uStart =
PREVPOINT(
gptInd);
03664
03665
03666
03667
03668 uInd = uStart;
03669
03670
do {
03671
03672
03673
03674
if (HIWORD(
gaptMouse[uInd].x) == 0 || HIWORD(
gaptMouse[uInd].y) == 0) {
03675
break;
03676 }
03677
03678 resX = (
DWORD)HIWORD(
gaptMouse[uInd].x) + 1;
03679 resY = (
DWORD)HIWORD(
gaptMouse[uInd].y) + 1;
03680
03681
if ((
int)resX !=
SYSMET(CXVIRTUALSCREEN)) {
03682 UserAssert(resX == 0x10000);
03683 x = (LOWORD(
gaptMouse[uInd].x) *
SYSMET(CXVIRTUALSCREEN)) / resX;
03684 }
else {
03685 x = LOWORD(
gaptMouse[uInd].x);
03686 }
03687
03688
if ((
int)resY !=
SYSMET(CYVIRTUALSCREEN)) {
03689 UserAssert(resY == 0x10000);
03690 y = (LOWORD(
gaptMouse[uInd].y) *
SYSMET(CYVIRTUALSCREEN)) / resY;
03691 }
else {
03692 y = LOWORD(
gaptMouse[uInd].y);
03693 }
03694
03695
if (x == ppt->x && y == ppt->y) {
03696
03697
03698
03699
03700
03701
if (ppt->time != 0 && ppt->time !=
gaptMouse[uInd].time) {
03702 uInd =
PREVPOINT(uInd);
03703 RIPMSG4(RIP_VERBOSE,
03704
"GetMouseMovePointsEx: Found point (%x, %y) but timestamp %x diff from %x",
03705 x, y, ppt->time,
gaptMouse[uInd].time);
03706
continue;
03707 }
03708
03709 bFound =
TRUE;
03710
break;
03711 }
03712 uInd =
PREVPOINT(uInd);
03713
03714 }
while (uInd != uStart);
03715
03716
03717
03718
03719
if (!bFound) {
03720 RIPERR2(ERROR_POINT_NOT_FOUND, RIP_VERBOSE,
03721
"GetMouseMovePointsEx: point not found (%x, %y)", ppt->x, ppt->y);
03722
return -1;
03723 }
03724
03725
03726
03727
03728 nPointsRetrieved = (uInd <= uStart ? uInd +
MAX_MOUSEPOINTS - uStart : uInd - uStart);
03729
03730 nPointsRetrieved =
min(nPointsRetrieved, nPoints);
03731
03732
03733
03734
03735
try {
03736
for (i = 0; i < nPointsRetrieved; i++) {
03737
03738 resX = (
DWORD)HIWORD(
gaptMouse[uInd].x) + 1;
03739 resY = (
DWORD)HIWORD(
gaptMouse[uInd].y) + 1;
03740
03741
03742
03743
03744
if (HIWORD(
gaptMouse[uInd].x) == 0 || HIWORD(
gaptMouse[uInd].y) == 0) {
03745
break;
03746 }
03747
03748
03749
03750
03751
03752
if (resolution == GMMP_USE_HIGH_RESOLUTION_POINTS) {
03753 ccxpptBuf[i].x = ((
DWORD)LOWORD(
gaptMouse[uInd].x) * 0xFFFF) / (resX - 1);
03754
03755 ccxpptBuf[i].y = ((
DWORD)LOWORD(
gaptMouse[uInd].y) * 0xFFFF) / (resY - 1);
03756
03757 }
else {
03758 UserAssert(resolution == GMMP_USE_DISPLAY_POINTS);
03759
03760 ccxpptBuf[i].x = (LOWORD(
gaptMouse[uInd].x) *
SYSMET(CXVIRTUALSCREEN)) / resX;
03761
03762 ccxpptBuf[i].y = (LOWORD(
gaptMouse[uInd].y) *
SYSMET(CYVIRTUALSCREEN)) / resY;
03763 }
03764 ccxpptBuf[i].time =
gaptMouse[uInd].time;
03765 ccxpptBuf[i].dwExtraInfo =
gaptMouse[uInd].dwExtraInfo;
03766
03767
03768 uInd =
PREVPOINT(uInd);
03769 }
03770 } except(W32ExceptionHandler(
FALSE, RIP_WARNING)) {
03771 }
03772
return i;
03773 }
03774
03775
03776
03777
03778
03779
03780
03781
03782
03783
03784 void ProcessQueuedMouseEvents(
03785
void)
03786 {
03787
MOUSEEVENT MouseEvent;
03788
static POINT ptCursorLast = {0,0};
03789
03790
while (
UnqueueMouseEvent(&MouseEvent)) {
03791
03792
EnterCrit();
03793
03794
03795
if (
glinp.
dwFlags &
LINP_POWERTIMEOUTS) {
03796
03797 KdPrint((
"Exit video power down mode\n"));
03798 DrvSetMonitorPowerState(
gpDispInfo->
pmdev, PowerDeviceD0);
03799 }
03800
glinp.
dwFlags &= ~(
LINP_INPUTTIMEOUTS |
LINP_KEYBOARD);
03801
glinp.
timeLastInputMessage =
gpsi->dwLastRITEventTickCount = MouseEvent.
time;
03802
gpsi->bLastRITWasKeyboard =
FALSE;
03803
03804
gpsi->ptCursor = MouseEvent.
ptPointer;
03805
03806
if ((ptCursorLast.x !=
gpsi->ptCursor.x) ||
03807 (ptCursorLast.y !=
gpsi->ptCursor.y)) {
03808
03809
03810
03811
03812
03813
03814
03815
gdwMouseMoveExtraInfo = MouseEvent.
ExtraInfo;
03816
03817 ptCursorLast =
gpsi->ptCursor;
03818
03819
03820
03821
03822
03823
zzzSetFMouseMoved();
03824
03825
gdwMouseMoveExtraInfo = MouseEvent.
ExtraInfo;
03826 }
03827
03828
if (MouseEvent.
ButtonFlags != 0) {
03829
xxxDoButtonEvent(&MouseEvent);
03830 }
03831
03832
LeaveCrit();
03833 }
03834 }
03835
03836
03837
03838
03839
03840
03841
03842
03843
03844
03845
03846
03847
03848
03849
03850
03851
03852
03853
#if DBG
03854
DWORD gBlockDelay = 0;
03855
DWORD gBlockSleep = 0;
03856
#endif
03857
03858 VOID RawInputThread(
03859 PRIT_INIT pInitData)
03860 {
03861 KPRIORITY Priority;
03862
NTSTATUS Status;
03863 UNICODE_STRING strRIT;
03864
PKEVENT pEvent;
03865
UINT NumberOfHandles =
ID_NUMBER_NON_HYDRA_HANDLES;
03866
PTERMINAL pTerm;
03867
PMONITOR pMonitorPrimary;
03868 HANDLE hevtShutDown;
03869
static DWORD nLastRetryReadInput = 0;
03870
03871
if (
gbRemoteSession) {
03872 NumberOfHandles += 2;
03873 }
03874
03875 pTerm = pInitData->
pTerm;
03876
03877
03878
03879
03880
apObjects = UserAllocPoolNonPaged(NumberOfHandles *
sizeof(PVOID), TAG_SYSTEM);
03881
03882
gWaitBlockArray = UserAllocPoolNonPaged(NumberOfHandles *
sizeof(
KWAIT_BLOCK),
03883 TAG_SYSTEM);
03884
03885
if (
apObjects ==
NULL ||
gWaitBlockArray ==
NULL) {
03886 RIPMSG0(RIP_WARNING,
"RIT failed to allocate memory");
03887
goto Exit;
03888 }
03889
03890
03891
03892
03893 Priority = LOW_REALTIME_PRIORITY + 3;
03894
03895 ZwSetInformationThread(NtCurrentThread(),
03896 ThreadPriority,
03897 &Priority,
03898
sizeof(KPRIORITY));
03899
03900
RtlInitUnicodeString(&strRIT,
L"WinSta0_RIT");
03901
03902
03903
03904
03905
03906
aDeviceTemplate[
DEVICE_TYPE_KEYBOARD].
pkeHidChange =
03907
apObjects[
ID_HIDCHANGE] =
03908
CreateKernelEvent(SynchronizationEvent,
FALSE);
03909
aDeviceTemplate[
DEVICE_TYPE_MOUSE].
pkeHidChange =
03910
CreateKernelEvent(SynchronizationEvent,
FALSE);
03911
03912
03913
03914
03915
apObjects[
ID_MOUSE] =
CreateKernelEvent(SynchronizationEvent,
FALSE);
03916
gpkeMouseData =
apObjects[
ID_MOUSE];
03917
03918
if (
aDeviceTemplate[
DEVICE_TYPE_MOUSE].
pkeHidChange ==
NULL ||
03919
apObjects[
ID_HIDCHANGE] ==
NULL ||
03920
gpkeMouseData ==
NULL) {
03921 RIPMSG0(RIP_WARNING,
"RIT failed to create a required input event");
03922
goto Exit;
03923 }
03924
03925
03926
03927
03928
EnterCrit();
03929
InitKeyboard();
03930
InitMice();
03931
LeaveCrit();
03932
03933
Status =
InitSystemThread(&strRIT);
03934
03935
if (!
NT_SUCCESS(
Status)) {
03936 RIPMSG0(RIP_WARNING,
"RIT failed InitSystemThread");
03937
goto Exit;
03938 }
03939
03940 UserAssert(
gpepCSRSS !=
NULL);
03941
03942
03943
03944
03945 ((PW32PROCESS)
gpepCSRSS->
Win32Process)->W32PF_Flags |= (W32PF_READSCREENACCESSGRANTED|W32PF_IOWINSTA);
03946
03947
03948
03949
03950 UserAssert(
gpDispInfo !=
NULL);
03951
grcCursorClip =
gpDispInfo->
rcScreen;
03952
03953
03954
03955
03956 pMonitorPrimary =
GetPrimaryMonitor();
03957
03958 UserAssert(
gpsi !=
NULL);
03959
03960
gpsi->ptCursor.x = pMonitorPrimary->
rcMonitor.right / 2;
03961
gpsi->ptCursor.y = pMonitorPrimary->
rcMonitor.bottom / 2;
03962
gptCursorAsync =
gpsi->ptCursor;
03963
03964
03965
03966
03967
03968
03969 UserAssert(
gpvwplHungRedraw ==
NULL);
03970
03971
03972
03973
03974
EnterCrit();
03975
_RegisterHotKey(
PWND_INPUTOWNER,
IDHOT_WINDOWS, MOD_WIN, VK_NONE);
03976
SetDebugHotKeys();
03977
LeaveCrit();
03978
03979
03980
03981
03982
gptmrMaster = UserAllocPoolNonPaged(
sizeof(
KTIMER),
03983 TAG_SYSTEM);
03984
if (
gptmrMaster ==
NULL) {
03985 RIPMSG0(RIP_WARNING,
"RIT failed to create gptmrMaster");
03986
goto Exit;
03987 }
03988
03989
KeInitializeTimer(
gptmrMaster);
03990
apObjects[
ID_TIMER] =
gptmrMaster;
03991
03992
03993
03994
03995
03996
03997 UserAssert(
gpDeviceInfoList ==
NULL);
03998
03999
if (
gbRemoteSession) {
04000
04001 OBJECT_ATTRIBUTES obja;
04002 UNICODE_STRING ustrName;
04003
BOOL fSuccess =
TRUE;
04004 WCHAR
szName[
MAX_SESSION_PATH];
04005
04006
04007
04008
04009
04010
04011
04012
04013
04014
gptmrWD = UserAllocPoolNonPaged(
sizeof(
KTIMER), TAG_SYSTEM);
04015
04016
if (
gptmrWD ==
NULL) {
04017 RIPMSG0(RIP_WARNING,
"RIT failed to create gptmrWD");
04018
goto Exit;
04019 }
04020
04021
KeInitializeTimerEx(
gptmrWD, SynchronizationTimer);
04022
apObjects[
ID_WDTIMER] =
gptmrWD;
04023
04024
RtlInitUnicodeString(&ustrName,
NULL);
04025
04026
04027
04028
04029
EnterCrit();
04030 fSuccess &= !!HDXDrvEscape(
gpDispInfo->
hDev,
04031 ESC_SET_WD_TIMEROBJ,
04032 (PVOID)
gptmrWD,
04033
sizeof(
gptmrWD));
04034
04035 fSuccess &= !!
CreateDeviceInfo(
DEVICE_TYPE_MOUSE, &ustrName, 0);
04036 fSuccess &= !!
CreateDeviceInfo(
DEVICE_TYPE_KEYBOARD, &ustrName, 0);
04037
04038
LeaveCrit();
04039
04040
if (!fSuccess) {
04041 RIPMSG0(RIP_WARNING,
04042
"RIT failed HDXDrvEscape or the creation of input devices");
04043
goto Exit;
04044 }
04045
04046
04047
04048
04049
04050
04051
04052 swprintf(
szName,
L"\\Sessions\\%ld\\BaseNamedObjects\\EventShutDownCSRSS",
04053
gSessionId);
04054
RtlInitUnicodeString(&ustrName,
szName);
04055
04056 InitializeObjectAttributes(&obja,
04057 &ustrName,
04058 OBJ_CASE_INSENSITIVE,
04059
NULL,
04060
NULL);
04061
04062
Status = ZwCreateEvent(&hevtShutDown,
04063 EVENT_ALL_ACCESS,
04064 &obja,
04065 SynchronizationEvent,
04066
FALSE);
04067
04068
if (!
NT_SUCCESS(
Status)) {
04069 RIPMSG0(RIP_WARNING,
"RIT failed to create EventShutDownCSRSS");
04070
goto Exit;
04071 }
04072
04073
ObReferenceObjectByHandle(hevtShutDown,
04074 EVENT_ALL_ACCESS,
04075 *
ExEventObjectType,
04076
KernelMode,
04077 &
apObjects[
ID_SHUTDOWN],
04078
NULL);
04079 }
else {
04080
EnterCrit();
04081
04082
04083
04084
04085
04086
04087
xxxRegisterForDeviceClassNotifications();
04088
04089
LeaveCrit();
04090 }
04091
04092
04093
04094
04095
gptiRit =
PtiCurrentShared();
04096
04097
HYDRA_HINT(
HH_RITCREATED);
04098
04099
04100
04101
04102
gptiRit->
TIF_flags |=
TIF_DONTJOURNALATTACH;
04103
04104
04105
04106
04107
04108
apObjects[
ID_INPUT] =
gptiRit->
pEventQueueServer;
04109
04110
04111
04112
04113
KeSetEvent(pInitData->
pRitReadyEvent,
EVENT_INCREMENT,
FALSE);
04114
04115
04116
04117
04118
04119
04120
04121
04122
04123
gptiRit->
pwinsta =
NULL;
04124
04125 pEvent = pTerm->
pEventInputReady;
04126
04127
04128
04129
04130
ObReferenceObjectByPointer(pEvent,
04131 EVENT_ALL_ACCESS,
04132 *
ExEventObjectType,
04133
KernelMode);
04134
04135
KeWaitForSingleObject(pEvent,
WrUserRequest,
KernelMode,
FALSE,
NULL);
04136
ObDereferenceObject(pEvent);
04137
04138
04139
04140
04141
04142
EnterCrit();
04143
04144
if (
gptiRit->
rpdesk ==
NULL) {
04145 UserVerify(
xxxSwitchDesktop(
gptiRit->
pwinsta,
gptiRit->
pwinsta->
rpdeskList,
FALSE));
04146 }
04147
04148
04149
04150
04151
StartTimers();
04152
04153
LeaveCrit();
04154
04155
04156
04157
04158
04159
while (
TRUE) {
04160
04161
CheckCritOut();
04162
04163
Status =
KeWaitForMultipleObjects(NumberOfHandles,
04164
apObjects,
04165 WaitAny,
04166
WrUserRequest,
04167
KernelMode,
04168
TRUE,
04169
NULL,
04170
gWaitBlockArray);
04171
04172 UserAssert(
NT_SUCCESS(
Status));
04173
04174
if (
gdwUpdateKeyboard != 0) {
04175
04176
04177
04178
04179
04180
04181
04182
04183
PDEVICEINFO pDeviceInfo;
04184
EnterDeviceInfoListCrit();
04185
for (pDeviceInfo =
gpDeviceInfoList; pDeviceInfo; pDeviceInfo = pDeviceInfo->pNext) {
04186
if ((pDeviceInfo->type ==
DEVICE_TYPE_KEYBOARD) && (pDeviceInfo->handle)) {
04187
if (
gdwUpdateKeyboard &
UPDATE_KBD_TYPEMATIC) {
04188 ZwDeviceIoControlFile(pDeviceInfo->handle,
NULL,
NULL,
NULL,
04189 &
giosbKbdControl, IOCTL_KEYBOARD_SET_TYPEMATIC,
04190 (PVOID)&
gktp,
sizeof(
gktp),
NULL, 0);
04191 }
04192
if (
gdwUpdateKeyboard &
UPDATE_KBD_LEDS) {
04193 ZwDeviceIoControlFile(pDeviceInfo->handle,
NULL,
NULL,
NULL,
04194 &
giosbKbdControl, IOCTL_KEYBOARD_SET_INDICATORS,
04195 (PVOID)&
gklp,
sizeof(
gklp),
NULL, 0);
04196 }
04197 }
04198 }
04199
LeaveDeviceInfoListCrit();
04200
gdwUpdateKeyboard &= ~(
UPDATE_KBD_TYPEMATIC |
UPDATE_KBD_LEDS);
04201 }
04202
04203
if (
Status ==
ID_MOUSE) {
04204
04205
04206
04207
ProcessQueuedMouseEvents();
04208
04209 }
else if (
Status ==
ID_HIDCHANGE) {
04210 TAGMSG0(DBGTAG_PNP | RIP_THERESMORE,
"RIT wakes for HID Change");
04211
EnterCrit();
04212
ProcessDeviceChanges(
DEVICE_TYPE_KEYBOARD);
04213
LeaveCrit();
04214 }
else if (
Status ==
ID_SHUTDOWN) {
04215
04216
InitiateWin32kCleanup();
04217
04218 ZwClose(hevtShutDown);
04219
04220
break;
04221
04222 }
else if (
Status ==
ID_WDTIMER) {
04223
04224
04225
EnterCrit();
04226
04227 UserAssert(
gbRemoteSession);
04228
04229
04230
04231
04232
04233
if (!HDXDrvEscape(
gpDispInfo->
hDev, ESC_TIMEROBJ_SIGNALED,
NULL, 0)) {
04234 UserAssert(
FALSE);
04235 }
04236
LeaveCrit();
04237
04238 }
else {
04239
04240
04241
04242
04243
04244
if (
Status ==
ID_TIMER) {
04245
TimersProc();
04246
04247
04248
04249
04250
04251
if (
gnRetryReadInput != nLastRetryReadInput) {
04252 nLastRetryReadInput =
gnRetryReadInput;
04253
KeSetEvent(
aDeviceTemplate[
DEVICE_TYPE_MOUSE].pkeHidChange,
EVENT_INCREMENT,
FALSE);
04254
KeSetEvent(
aDeviceTemplate[
DEVICE_TYPE_KEYBOARD].pkeHidChange,
EVENT_INCREMENT,
FALSE);
04255 }
04256 }
04257
04258
#if DBG
04259
04260
04261
04262
04263
04264
if (gBlockDelay) {
04265 gBlockDelay--;
04266 }
else if ((gBlockDelay == 0) && (gBlockSleep != 0)) {
04267
UserSleep(gBlockSleep);
04268 gBlockDelay = 100 * gBlockSleep;
04269 }
04270
#endif
04271
04272
04273
04274
04275
04276
if (
gspwndAltTab !=
NULL) {
04277
EnterCrit();
04278
xxxReceiveMessages(
gptiRit);
04279
LeaveCrit();
04280 }
04281 }
04282 }
04283
04284
return;
04285
04286 Exit:
04287
04288 UserAssert(
gptiRit ==
NULL);
04289
04290
04291
04292
04293
KeSetEvent(pInitData->
pRitReadyEvent,
EVENT_INCREMENT,
FALSE);
04294
04295 RIPMSG0(RIP_WARNING,
"RIT initialization failure");
04296
return;
04297 }