f8550fc79d6a535982e3e8b7a4e23881315b91fd
[reactos.git] / reactos / subsystems / win32 / win32k / ntuser / input.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: Window classes
5 * FILE: subsystems/win32/win32k/ntuser/input.c
6 * PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * REVISION HISTORY:
8 * 06-06-2001 CSH Created
9 */
10
11 /* INCLUDES ******************************************************************/
12
13 #include <win32k.h>
14 #include <ntddkbd.h>
15
16 #define NDEBUG
17 #include <debug.h>
18
19 extern BYTE gQueueKeyStateTable[];
20 extern NTSTATUS Win32kInitWin32Thread(PETHREAD Thread);
21
22 /* GLOBALS *******************************************************************/
23
24 PTHREADINFO ptiRawInput;
25 PTHREADINFO ptiKeyboard;
26 PTHREADINFO ptiMouse;
27 PKTIMER MasterTimer = NULL;
28 PATTACHINFO gpai = NULL;
29
30 static HANDLE MouseDeviceHandle;
31 static HANDLE MouseThreadHandle;
32 static CLIENT_ID MouseThreadId;
33 static HANDLE KeyboardThreadHandle;
34 static CLIENT_ID KeyboardThreadId;
35 static HANDLE KeyboardDeviceHandle;
36 static HANDLE RawInputThreadHandle;
37 static CLIENT_ID RawInputThreadId;
38 static KEVENT InputThreadsStart;
39 static BOOLEAN InputThreadsRunning = FALSE;
40 static BYTE TrackSysKey = 0; /* determine whether ALT key up will cause a WM_SYSKEYUP
41 or a WM_KEYUP message */
42
43 /* FUNCTIONS *****************************************************************/
44 DWORD IntLastInputTick(BOOL LastInputTickSetGet);
45
46 #define ClearMouseInput(mi) \
47 mi.dx = 0; \
48 mi.dy = 0; \
49 mi.mouseData = 0; \
50 mi.dwFlags = 0;
51
52 #define SendMouseEvent(mi) \
53 if(mi.dx != 0 || mi.dy != 0) \
54 mi.dwFlags |= MOUSEEVENTF_MOVE; \
55 if(mi.dwFlags) \
56 IntMouseInput(&mi); \
57 ClearMouseInput(mi);
58
59
60 DWORD IntLastInputTick(BOOL LastInputTickSetGet)
61 {
62 static DWORD LastInputTick = 0;
63 if (LastInputTickSetGet == TRUE)
64 {
65 LARGE_INTEGER TickCount;
66 KeQueryTickCount(&TickCount);
67 LastInputTick = TickCount.u.LowPart * (KeQueryTimeIncrement() / 10000);
68 }
69 return LastInputTick;
70 }
71
72 BOOL
73 APIENTRY
74 NtUserGetLastInputInfo(PLASTINPUTINFO plii)
75 {
76 BOOL ret = TRUE;
77
78 UserEnterShared();
79
80 _SEH2_TRY
81 {
82 if (ProbeForReadUint(&plii->cbSize) != sizeof(LASTINPUTINFO))
83 {
84 EngSetLastError(ERROR_INVALID_PARAMETER);
85 ret = FALSE;
86 _SEH2_LEAVE;
87 }
88
89 ProbeForWrite(plii, sizeof(LASTINPUTINFO), sizeof(DWORD));
90
91 plii->dwTime = IntLastInputTick(FALSE);
92 }
93 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
94 {
95 SetLastNtError(_SEH2_GetExceptionCode());
96 ret = FALSE;
97 }
98 _SEH2_END;
99
100 UserLeave();
101
102 return ret;
103 }
104
105
106 VOID FASTCALL
107 ProcessMouseInputData(PMOUSE_INPUT_DATA Data, ULONG InputCount)
108 {
109 PMOUSE_INPUT_DATA mid;
110 MOUSEINPUT mi;
111 ULONG i;
112
113 ClearMouseInput(mi);
114 mi.time = 0;
115 mi.dwExtraInfo = 0;
116 for(i = 0; i < InputCount; i++)
117 {
118 mid = (Data + i);
119 mi.dx += mid->LastX;
120 mi.dy += mid->LastY;
121
122 /* Check if the mouse move is absolute */
123 if (mid->Flags == MOUSE_MOVE_ABSOLUTE)
124 {
125 /* Set flag to convert to screen location */
126 mi.dwFlags |= MOUSEEVENTF_ABSOLUTE;
127 }
128
129 if(mid->ButtonFlags)
130 {
131 if(mid->ButtonFlags & MOUSE_LEFT_BUTTON_DOWN)
132 {
133 mi.dwFlags |= MOUSEEVENTF_LEFTDOWN;
134 SendMouseEvent(mi);
135 }
136 if(mid->ButtonFlags & MOUSE_LEFT_BUTTON_UP)
137 {
138 mi.dwFlags |= MOUSEEVENTF_LEFTUP;
139 SendMouseEvent(mi);
140 }
141 if(mid->ButtonFlags & MOUSE_MIDDLE_BUTTON_DOWN)
142 {
143 mi.dwFlags |= MOUSEEVENTF_MIDDLEDOWN;
144 SendMouseEvent(mi);
145 }
146 if(mid->ButtonFlags & MOUSE_MIDDLE_BUTTON_UP)
147 {
148 mi.dwFlags |= MOUSEEVENTF_MIDDLEUP;
149 SendMouseEvent(mi);
150 }
151 if(mid->ButtonFlags & MOUSE_RIGHT_BUTTON_DOWN)
152 {
153 mi.dwFlags |= MOUSEEVENTF_RIGHTDOWN;
154 SendMouseEvent(mi);
155 }
156 if(mid->ButtonFlags & MOUSE_RIGHT_BUTTON_UP)
157 {
158 mi.dwFlags |= MOUSEEVENTF_RIGHTUP;
159 SendMouseEvent(mi);
160 }
161 if(mid->ButtonFlags & MOUSE_BUTTON_4_DOWN)
162 {
163 mi.mouseData |= XBUTTON1;
164 mi.dwFlags |= MOUSEEVENTF_XDOWN;
165 SendMouseEvent(mi);
166 }
167 if(mid->ButtonFlags & MOUSE_BUTTON_4_UP)
168 {
169 mi.mouseData |= XBUTTON1;
170 mi.dwFlags |= MOUSEEVENTF_XUP;
171 SendMouseEvent(mi);
172 }
173 if(mid->ButtonFlags & MOUSE_BUTTON_5_DOWN)
174 {
175 mi.mouseData |= XBUTTON2;
176 mi.dwFlags |= MOUSEEVENTF_XDOWN;
177 SendMouseEvent(mi);
178 }
179 if(mid->ButtonFlags & MOUSE_BUTTON_5_UP)
180 {
181 mi.mouseData |= XBUTTON2;
182 mi.dwFlags |= MOUSEEVENTF_XUP;
183 SendMouseEvent(mi);
184 }
185 if(mid->ButtonFlags & MOUSE_WHEEL)
186 {
187 mi.mouseData = mid->ButtonData;
188 mi.dwFlags |= MOUSEEVENTF_WHEEL;
189 SendMouseEvent(mi);
190 }
191 }
192 }
193
194 SendMouseEvent(mi);
195 }
196
197
198
199
200 VOID APIENTRY
201 MouseThreadMain(PVOID StartContext)
202 {
203 UNICODE_STRING MouseDeviceName = RTL_CONSTANT_STRING(L"\\Device\\PointerClass0");
204 OBJECT_ATTRIBUTES MouseObjectAttributes;
205 IO_STATUS_BLOCK Iosb;
206 NTSTATUS Status;
207 MOUSE_ATTRIBUTES MouseAttr;
208
209 KeSetPriorityThread(&PsGetCurrentThread()->Tcb,
210 LOW_REALTIME_PRIORITY + 3);
211
212 InitializeObjectAttributes(&MouseObjectAttributes,
213 &MouseDeviceName,
214 0,
215 NULL,
216 NULL);
217 do
218 {
219 LARGE_INTEGER DueTime;
220 KEVENT Event;
221 DueTime.QuadPart = (LONGLONG)(-10000000);
222 KeInitializeEvent(&Event, NotificationEvent, FALSE);
223 Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, &DueTime);
224 Status = NtOpenFile(&MouseDeviceHandle,
225 FILE_ALL_ACCESS,
226 &MouseObjectAttributes,
227 &Iosb,
228 0,
229 FILE_SYNCHRONOUS_IO_ALERT);
230 } while (!NT_SUCCESS(Status));
231
232 /* Need to setup basic win32k for this thread to process WH_MOUSE_LL messages. */
233 Status = Win32kInitWin32Thread(PsGetCurrentThread());
234 if (!NT_SUCCESS(Status))
235 {
236 DPRINT1("Win32K: Failed making mouse thread a win32 thread.\n");
237 return; //(Status);
238 }
239
240 ptiMouse = PsGetCurrentThreadWin32Thread();
241 ptiMouse->TIF_flags |= TIF_SYSTEMTHREAD;
242 DPRINT("Mouse Thread 0x%x \n", ptiMouse);
243
244 KeSetPriorityThread(&PsGetCurrentThread()->Tcb,
245 LOW_REALTIME_PRIORITY + 3);
246
247 for(;;)
248 {
249 /*
250 * Wait to start input.
251 */
252 DPRINT("Mouse Input Thread Waiting for start event\n");
253 Status = KeWaitForSingleObject(&InputThreadsStart,
254 0,
255 KernelMode,
256 TRUE,
257 NULL);
258 DPRINT("Mouse Input Thread Starting...\n");
259
260 /*FIXME: Does mouse attributes need to be used for anything */
261 Status = NtDeviceIoControlFile(MouseDeviceHandle,
262 NULL,
263 NULL,
264 NULL,
265 &Iosb,
266 IOCTL_MOUSE_QUERY_ATTRIBUTES,
267 &MouseAttr, sizeof(MOUSE_ATTRIBUTES),
268 NULL, 0);
269 if(!NT_SUCCESS(Status))
270 {
271 DPRINT("Failed to get mouse attributes\n");
272 }
273
274 /*
275 * Receive and process mouse input.
276 */
277 while(InputThreadsRunning)
278 {
279 MOUSE_INPUT_DATA MouseInput;
280 Status = NtReadFile(MouseDeviceHandle,
281 NULL,
282 NULL,
283 NULL,
284 &Iosb,
285 &MouseInput,
286 sizeof(MOUSE_INPUT_DATA),
287 NULL,
288 NULL);
289 if(Status == STATUS_ALERTED && !InputThreadsRunning)
290 {
291 break;
292 }
293 if(Status == STATUS_PENDING)
294 {
295 NtWaitForSingleObject(MouseDeviceHandle, FALSE, NULL);
296 Status = Iosb.Status;
297 }
298 if(!NT_SUCCESS(Status))
299 {
300 DPRINT1("Win32K: Failed to read from mouse.\n");
301 return; //(Status);
302 }
303 DPRINT("MouseEvent\n");
304 IntLastInputTick(TRUE);
305
306 UserEnterExclusive();
307
308 ProcessMouseInputData(&MouseInput, Iosb.Information / sizeof(MOUSE_INPUT_DATA));
309
310 UserLeave();
311 }
312 DPRINT("Mouse Input Thread Stopped...\n");
313 }
314 }
315
316 /* Returns a value that indicates if the key is a modifier key, and
317 * which one.
318 */
319 static UINT APIENTRY
320 IntKeyboardGetModifiers(KEYBOARD_INPUT_DATA *InputData)
321 {
322 if (InputData->Flags & KEY_E1)
323 return 0;
324
325 if (!(InputData->Flags & KEY_E0))
326 {
327 switch (InputData->MakeCode)
328 {
329 case 0x2a: /* left shift */
330 case 0x36: /* right shift */
331 return MOD_SHIFT;
332
333 case 0x1d: /* left control */
334 return MOD_CONTROL;
335
336 case 0x38: /* left alt */
337 return MOD_ALT;
338
339 default:
340 return 0;
341 }
342 }
343 else
344 {
345 switch (InputData->MakeCode)
346 {
347 case 0x1d: /* right control */
348 return MOD_CONTROL;
349
350 case 0x38: /* right alt */
351 return MOD_ALT;
352
353 case 0x5b: /* left gui (windows) */
354 case 0x5c: /* right gui (windows) */
355 return MOD_WIN;
356
357 default:
358 return 0;
359 }
360 }
361 }
362
363 /* Asks the keyboard driver to send a small table that shows which
364 * lights should connect with which scancodes
365 */
366 static NTSTATUS APIENTRY
367 IntKeyboardGetIndicatorTrans(HANDLE KeyboardDeviceHandle,
368 PKEYBOARD_INDICATOR_TRANSLATION *IndicatorTrans)
369 {
370 NTSTATUS Status;
371 DWORD Size = 0;
372 IO_STATUS_BLOCK Block;
373 PKEYBOARD_INDICATOR_TRANSLATION Ret;
374
375 Size = sizeof(KEYBOARD_INDICATOR_TRANSLATION);
376
377 Ret = ExAllocatePoolWithTag(PagedPool,
378 Size,
379 USERTAG_KBDTABLE);
380
381 while (Ret)
382 {
383 Status = NtDeviceIoControlFile(KeyboardDeviceHandle,
384 NULL,
385 NULL,
386 NULL,
387 &Block,
388 IOCTL_KEYBOARD_QUERY_INDICATOR_TRANSLATION,
389 NULL, 0,
390 Ret, Size);
391
392 if (Status != STATUS_BUFFER_TOO_SMALL)
393 break;
394
395 ExFreePoolWithTag(Ret, USERTAG_KBDTABLE);
396
397 Size += sizeof(KEYBOARD_INDICATOR_TRANSLATION);
398
399 Ret = ExAllocatePoolWithTag(PagedPool,
400 Size,
401 USERTAG_KBDTABLE);
402 }
403
404 if (!Ret)
405 return STATUS_INSUFFICIENT_RESOURCES;
406
407 if (Status != STATUS_SUCCESS)
408 {
409 ExFreePoolWithTag(Ret, USERTAG_KBDTABLE);
410 return Status;
411 }
412
413 *IndicatorTrans = Ret;
414 return Status;
415 }
416
417 /* Sends the keyboard commands to turn on/off the lights.
418 */
419 static NTSTATUS APIENTRY
420 IntKeyboardUpdateLeds(HANDLE KeyboardDeviceHandle,
421 PKEYBOARD_INPUT_DATA KeyInput,
422 PKEYBOARD_INDICATOR_TRANSLATION IndicatorTrans)
423 {
424 NTSTATUS Status;
425 UINT Count;
426 static KEYBOARD_INDICATOR_PARAMETERS Indicators;
427 IO_STATUS_BLOCK Block;
428
429 if (!IndicatorTrans)
430 return STATUS_NOT_SUPPORTED;
431
432 if (KeyInput->Flags & (KEY_E0 | KEY_E1 | KEY_BREAK))
433 return STATUS_SUCCESS;
434
435 for (Count = 0; Count < IndicatorTrans->NumberOfIndicatorKeys; Count++)
436 {
437 if (KeyInput->MakeCode == IndicatorTrans->IndicatorList[Count].MakeCode)
438 {
439 Indicators.LedFlags ^=
440 IndicatorTrans->IndicatorList[Count].IndicatorFlags;
441
442 /* Update the lights on the hardware */
443
444 Status = NtDeviceIoControlFile(KeyboardDeviceHandle,
445 NULL,
446 NULL,
447 NULL,
448 &Block,
449 IOCTL_KEYBOARD_SET_INDICATORS,
450 &Indicators, sizeof(Indicators),
451 NULL, 0);
452
453 return Status;
454 }
455 }
456
457 return STATUS_SUCCESS;
458 }
459
460 static VOID APIENTRY
461 IntKeyboardSendWinKeyMsg()
462 {
463 PWND Window;
464 MSG Mesg;
465
466 if (!(Window = UserGetWindowObject(InputWindowStation->ShellWindow)))
467 {
468 DPRINT1("Couldn't find window to send Windows key message!\n");
469 return;
470 }
471
472 Mesg.hwnd = InputWindowStation->ShellWindow;
473 Mesg.message = WM_SYSCOMMAND;
474 Mesg.wParam = SC_TASKLIST;
475 Mesg.lParam = 0;
476
477 /* The QS_HOTKEY is just a guess */
478 MsqPostMessage(Window->head.pti->MessageQueue, &Mesg, FALSE, QS_HOTKEY);
479 }
480
481 static VOID APIENTRY
482 co_IntKeyboardSendAltKeyMsg()
483 {
484 co_MsqPostKeyboardMessage(WM_SYSCOMMAND,SC_KEYMENU,0);
485 }
486
487 static VOID APIENTRY
488 KeyboardThreadMain(PVOID StartContext)
489 {
490 UNICODE_STRING KeyboardDeviceName = RTL_CONSTANT_STRING(L"\\Device\\KeyboardClass0");
491 OBJECT_ATTRIBUTES KeyboardObjectAttributes;
492 IO_STATUS_BLOCK Iosb;
493 NTSTATUS Status;
494 MSG msg;
495 PUSER_MESSAGE_QUEUE FocusQueue;
496 struct _ETHREAD *FocusThread;
497
498 PKEYBOARD_INDICATOR_TRANSLATION IndicatorTrans = NULL;
499 UINT ModifierState = 0;
500 USHORT LastMakeCode = 0;
501 USHORT LastFlags = 0;
502 UINT RepeatCount = 0;
503
504 InitializeObjectAttributes(&KeyboardObjectAttributes,
505 &KeyboardDeviceName,
506 0,
507 NULL,
508 NULL);
509 do
510 {
511 LARGE_INTEGER DueTime;
512 KEVENT Event;
513 DueTime.QuadPart = (LONGLONG)(-10000000);
514 KeInitializeEvent(&Event, NotificationEvent, FALSE);
515 Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, &DueTime);
516 Status = NtOpenFile(&KeyboardDeviceHandle,
517 FILE_ALL_ACCESS,
518 &KeyboardObjectAttributes,
519 &Iosb,
520 0,
521 FILE_SYNCHRONOUS_IO_ALERT);
522 } while (!NT_SUCCESS(Status));
523
524 /* Not sure if converting this thread to a win32 thread is such
525 a great idea. Since we're posting keyboard messages to the focus
526 window message queue, we'll be (indirectly) doing sendmessage
527 stuff from this thread (for WH_KEYBOARD_LL processing), which
528 means we need our own message queue. If keyboard messages were
529 instead queued to the system message queue, the thread removing
530 the message from the system message queue would be responsible
531 for WH_KEYBOARD_LL processing and we wouldn't need this thread
532 to be a win32 thread. */
533 Status = Win32kInitWin32Thread(PsGetCurrentThread());
534 if (!NT_SUCCESS(Status))
535 {
536 DPRINT1("Win32K: Failed making keyboard thread a win32 thread.\n");
537 return; //(Status);
538 }
539
540 ptiKeyboard = PsGetCurrentThreadWin32Thread();
541 ptiKeyboard->TIF_flags |= TIF_SYSTEMTHREAD;
542 DPRINT("Keyboard Thread 0x%x \n", ptiKeyboard);
543
544 KeSetPriorityThread(&PsGetCurrentThread()->Tcb,
545 LOW_REALTIME_PRIORITY + 3);
546
547 IntKeyboardGetIndicatorTrans(KeyboardDeviceHandle,
548 &IndicatorTrans);
549
550 for (;;)
551 {
552 /*
553 * Wait to start input.
554 */
555 DPRINT( "Keyboard Input Thread Waiting for start event\n" );
556 Status = KeWaitForSingleObject(&InputThreadsStart,
557 0,
558 KernelMode,
559 TRUE,
560 NULL);
561
562 DPRINT( "Keyboard Input Thread Starting...\n" );
563 /*
564 * Receive and process keyboard input.
565 */
566 while (InputThreadsRunning)
567 {
568 BOOLEAN NumKeys = 1;
569 BOOLEAN bLeftAlt;
570 KEYBOARD_INPUT_DATA KeyInput;
571 KEYBOARD_INPUT_DATA NextKeyInput;
572 LPARAM lParam = 0;
573 UINT fsModifiers, fsNextModifiers;
574 struct _ETHREAD *Thread;
575 HWND hWnd;
576 int id;
577
578 DPRINT("KeyInput @ %08x\n", &KeyInput);
579
580 Status = NtReadFile (KeyboardDeviceHandle,
581 NULL,
582 NULL,
583 NULL,
584 &Iosb,
585 &KeyInput,
586 sizeof(KEYBOARD_INPUT_DATA),
587 NULL,
588 NULL);
589
590 if(Status == STATUS_ALERTED && !InputThreadsRunning)
591 {
592 break;
593 }
594 if(Status == STATUS_PENDING)
595 {
596 NtWaitForSingleObject(KeyboardDeviceHandle, FALSE, NULL);
597 Status = Iosb.Status;
598 }
599 if(!NT_SUCCESS(Status))
600 {
601 DPRINT1("Win32K: Failed to read from mouse.\n");
602 return; //(Status);
603 }
604
605 DPRINT("KeyRaw: %s %04x\n",
606 (KeyInput.Flags & KEY_BREAK) ? "up" : "down",
607 KeyInput.MakeCode );
608
609 if (Status == STATUS_ALERTED && !InputThreadsRunning)
610 break;
611
612 if (!NT_SUCCESS(Status))
613 {
614 DPRINT1("Win32K: Failed to read from keyboard.\n");
615 return; //(Status);
616 }
617
618 /* Set LastInputTick */
619 IntLastInputTick(TRUE);
620
621 /* Update modifier state */
622 fsModifiers = IntKeyboardGetModifiers(&KeyInput);
623
624 if (fsModifiers)
625 {
626 if (KeyInput.Flags & KEY_BREAK)
627 {
628 ModifierState &= ~fsModifiers;
629 if(fsModifiers == MOD_ALT)
630 {
631 if(KeyInput.Flags & KEY_E0)
632 {
633 gQueueKeyStateTable[VK_RMENU] = 0;
634 }
635 else
636 {
637 gQueueKeyStateTable[VK_LMENU] = 0;
638 }
639 if (gQueueKeyStateTable[VK_RMENU] == 0 &&
640 gQueueKeyStateTable[VK_LMENU] == 0)
641 {
642 gQueueKeyStateTable[VK_MENU] = 0;
643 }
644 }
645 }
646 else
647 {
648 ModifierState |= fsModifiers;
649
650 if (ModifierState == fsModifiers &&
651 (fsModifiers == MOD_ALT || fsModifiers == MOD_WIN))
652 {
653 /* First send out special notifications
654 * (For alt, the message that turns on accelerator
655 * display, not sure what for win. Both TODO though.)
656 */
657 bLeftAlt = FALSE;
658 if(fsModifiers == MOD_ALT)
659 {
660 if(KeyInput.Flags & KEY_E0)
661 {
662 gQueueKeyStateTable[VK_RMENU] = 0x80;
663 }
664 else
665 {
666 gQueueKeyStateTable[VK_LMENU] = 0x80;
667 bLeftAlt = TRUE;
668 }
669
670 gQueueKeyStateTable[VK_MENU] = 0x80;
671 }
672
673 /* Read the next key before sending this one */
674 do
675 {
676 Status = NtReadFile (KeyboardDeviceHandle,
677 NULL,
678 NULL,
679 NULL,
680 &Iosb,
681 &NextKeyInput,
682 sizeof(KEYBOARD_INPUT_DATA),
683 NULL,
684 NULL);
685 DPRINT("KeyRaw: %s %04x\n",
686 (NextKeyInput.Flags & KEY_BREAK) ? "up":"down",
687 NextKeyInput.MakeCode );
688
689 if (Status == STATUS_ALERTED && !InputThreadsRunning)
690 goto KeyboardEscape;
691
692 }
693 while ((!(NextKeyInput.Flags & KEY_BREAK)) &&
694 NextKeyInput.MakeCode == KeyInput.MakeCode);
695 /* ^ Ignore repeats, they'll be KEY_MAKE and the same
696 * code. I'm not caring about the counting, not sure
697 * if that matters. I think not.
698 */
699
700 /* If the ModifierState is now empty again, send a
701 * special notification and eat both keypresses
702 */
703
704 fsNextModifiers = IntKeyboardGetModifiers(&NextKeyInput);
705
706 if (fsNextModifiers)
707 ModifierState ^= fsNextModifiers;
708
709 if (ModifierState == 0)
710 {
711 UserEnterExclusive();
712 if (fsModifiers == MOD_WIN)
713 IntKeyboardSendWinKeyMsg();
714 else if (fsModifiers == MOD_ALT)
715 {
716 gQueueKeyStateTable[VK_MENU] = 0;
717 if(bLeftAlt)
718 {
719 gQueueKeyStateTable[VK_LMENU] = 0;
720 }
721 else
722 {
723 gQueueKeyStateTable[VK_RMENU] = 0;
724 }
725 co_IntKeyboardSendAltKeyMsg();
726 }
727 UserLeave();
728 continue;
729 }
730
731 NumKeys = 2;
732 }
733 }
734 }
735
736 UserEnterExclusive();
737
738 for (;NumKeys;memcpy(&KeyInput, &NextKeyInput, sizeof(KeyInput)),
739 NumKeys--)
740 {
741 PKBL keyboardLayout = NULL;
742 lParam = 0;
743
744 IntKeyboardUpdateLeds(KeyboardDeviceHandle,
745 &KeyInput,
746 IndicatorTrans);
747
748 /* While we are working, we set up lParam. The format is:
749 * 0-15: The number of times this key has autorepeated
750 * 16-23: The keyboard scancode
751 * 24: Set if it's and extended key (I assume KEY_E0 | KEY_E1)
752 * Note that E1 is only used for PAUSE (E1-1D-45) and
753 * E0-45 happens not to be anything.
754 * 29: Alt is pressed ('Context code')
755 * 30: Previous state, if the key was down before this message
756 * This is a cheap way to ignore autorepeat keys
757 * 31: 1 if the key is being pressed
758 */
759
760 /* If it's a KEY_MAKE (which is 0, so test using !KEY_BREAK)
761 * and it's the same key as the last one, increase the repeat
762 * count.
763 */
764
765 if (!(KeyInput.Flags & KEY_BREAK))
766 {
767 if (((KeyInput.Flags & (KEY_E0 | KEY_E1)) == LastFlags) &&
768 (KeyInput.MakeCode == LastMakeCode))
769 {
770 RepeatCount++;
771 lParam |= (1 << 30);
772 }
773 else
774 {
775 RepeatCount = 1;
776 LastFlags = KeyInput.Flags & (KEY_E0 | KEY_E1);
777 LastMakeCode = KeyInput.MakeCode;
778 }
779 }
780 else
781 {
782 LastFlags = 0;
783 LastMakeCode = 0; /* Should never match */
784 lParam |= (1 << 30) | (1 << 31);
785 }
786
787 lParam |= RepeatCount;
788
789 lParam |= (KeyInput.MakeCode & 0xff) << 16;
790
791 if (KeyInput.Flags & KEY_E0)
792 lParam |= (1 << 24);
793
794 if (ModifierState & MOD_ALT)
795 {
796 lParam |= (1 << 29);
797
798 if (!(KeyInput.Flags & KEY_BREAK))
799 msg.message = WM_SYSKEYDOWN;
800 else
801 msg.message = WM_SYSKEYUP;
802 }
803 else
804 {
805 if (!(KeyInput.Flags & KEY_BREAK))
806 msg.message = WM_KEYDOWN;
807 else
808 msg.message = WM_KEYUP;
809 }
810
811 /* Find the target thread whose locale is in effect */
812 FocusQueue = IntGetFocusMessageQueue();
813
814 if (FocusQueue)
815 {
816 msg.hwnd = FocusQueue->FocusWindow;
817
818 FocusThread = FocusQueue->Thread;
819 if (FocusThread && FocusThread->Tcb.Win32Thread)
820 {
821 keyboardLayout = ((PTHREADINFO)FocusThread->Tcb.Win32Thread)->KeyboardLayout;
822 }
823 }
824 if (!keyboardLayout)
825 {
826 keyboardLayout = W32kGetDefaultKeyLayout();
827 }
828
829 msg.lParam = lParam;
830
831 /* This function uses lParam to fill wParam according to the
832 * keyboard layout in use.
833 */
834 W32kKeyProcessMessage(&msg,
835 keyboardLayout->KBTables,
836 KeyInput.Flags & KEY_E0 ? 0xE0 :
837 (KeyInput.Flags & KEY_E1 ? 0xE1 : 0));
838
839 if (GetHotKey(ModifierState,
840 msg.wParam,
841 &Thread,
842 &hWnd,
843 &id))
844 {
845 if (!(KeyInput.Flags & KEY_BREAK))
846 {
847 DPRINT("Hot key pressed (hWnd %lx, id %d)\n", hWnd, id);
848 MsqPostHotKeyMessage (Thread,
849 hWnd,
850 (WPARAM)id,
851 MAKELPARAM((WORD)ModifierState,
852 (WORD)msg.wParam));
853 }
854 continue; /* Eat key up motion too */
855 }
856
857 if (!FocusQueue)
858 {
859 /* There is no focused window to receive a keyboard message */
860 continue;
861 }
862 /*
863 * Post a keyboard message.
864 */
865 co_MsqPostKeyboardMessage(msg.message,msg.wParam,msg.lParam);
866 }
867
868 UserLeave();
869 }
870
871 KeyboardEscape:
872 DPRINT( "KeyboardInput Thread Stopped...\n" );
873 }
874 }
875
876
877 static PVOID Objects[2];
878 /*
879 Raw Input Thread.
880 Since this relies on InputThreadsStart, just fake it.
881 */
882 static VOID APIENTRY
883 RawInputThreadMain(PVOID StartContext)
884 {
885 NTSTATUS Status;
886 LARGE_INTEGER DueTime;
887
888 DueTime.QuadPart = (LONGLONG)(-10000000);
889
890 do
891 {
892 KEVENT Event;
893 KeInitializeEvent(&Event, NotificationEvent, FALSE);
894 Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, &DueTime);
895 } while (!NT_SUCCESS(Status));
896
897
898 Objects[0] = &InputThreadsStart;
899 Objects[1] = MasterTimer;
900
901 // This thread requires win32k!
902 Status = Win32kInitWin32Thread(PsGetCurrentThread());
903 if (!NT_SUCCESS(Status))
904 {
905 DPRINT1("Win32K: Failed making Raw Input thread a win32 thread.\n");
906 return; //(Status);
907 }
908
909 ptiRawInput = PsGetCurrentThreadWin32Thread();
910 ptiRawInput->TIF_flags |= TIF_SYSTEMTHREAD;
911 DPRINT("Raw Input Thread 0x%x \n", ptiRawInput);
912
913 KeSetPriorityThread(&PsGetCurrentThread()->Tcb,
914 LOW_REALTIME_PRIORITY + 3);
915
916 UserEnterExclusive();
917 StartTheTimers();
918 UserLeave();
919
920 //
921 // ATM, we just have one job to handle, merge the other two later.
922 //
923 for(;;)
924 {
925 DPRINT( "Raw Input Thread Waiting for start event\n" );
926
927 Status = KeWaitForMultipleObjects( 2,
928 Objects,
929 WaitAll, //WaitAny,
930 WrUserRequest,
931 KernelMode,
932 TRUE,
933 NULL,
934 NULL);
935 DPRINT( "Raw Input Thread Starting...\n" );
936
937 ProcessTimers();
938 }
939 DPRINT1("Raw Input Thread Exit!\n");
940 }
941
942 INIT_FUNCTION
943 NTSTATUS
944 NTAPI
945 InitInputImpl(VOID)
946 {
947 NTSTATUS Status;
948
949 KeInitializeEvent(&InputThreadsStart, NotificationEvent, FALSE);
950
951 MasterTimer = ExAllocatePoolWithTag(NonPagedPool, sizeof(KTIMER), USERTAG_SYSTEM);
952 if (!MasterTimer)
953 {
954 DPRINT1("Win32K: Failed making Raw Input thread a win32 thread.\n");
955 ASSERT(FALSE);
956 return STATUS_UNSUCCESSFUL;
957 }
958 KeInitializeTimer(MasterTimer);
959
960 /* Initialize the default keyboard layout */
961 if(!UserInitDefaultKeyboardLayout())
962 {
963 DPRINT1("Failed to initialize default keyboard layout!\n");
964 }
965
966 Status = PsCreateSystemThread(&RawInputThreadHandle,
967 THREAD_ALL_ACCESS,
968 NULL,
969 NULL,
970 &RawInputThreadId,
971 RawInputThreadMain,
972 NULL);
973 if (!NT_SUCCESS(Status))
974 {
975 DPRINT1("Win32K: Failed to create raw thread.\n");
976 }
977
978 Status = PsCreateSystemThread(&KeyboardThreadHandle,
979 THREAD_ALL_ACCESS,
980 NULL,
981 NULL,
982 &KeyboardThreadId,
983 KeyboardThreadMain,
984 NULL);
985 if (!NT_SUCCESS(Status))
986 {
987 DPRINT1("Win32K: Failed to create keyboard thread.\n");
988 }
989
990 Status = PsCreateSystemThread(&MouseThreadHandle,
991 THREAD_ALL_ACCESS,
992 NULL,
993 NULL,
994 &MouseThreadId,
995 MouseThreadMain,
996 NULL);
997 if (!NT_SUCCESS(Status))
998 {
999 DPRINT1("Win32K: Failed to create mouse thread.\n");
1000 }
1001
1002 InputThreadsRunning = TRUE;
1003 KeSetEvent(&InputThreadsStart, IO_NO_INCREMENT, FALSE);
1004
1005 return STATUS_SUCCESS;
1006 }
1007
1008 NTSTATUS FASTCALL
1009 CleanupInputImp(VOID)
1010 {
1011 return(STATUS_SUCCESS);
1012 }
1013
1014 BOOL FASTCALL
1015 IntBlockInput(PTHREADINFO W32Thread, BOOL BlockIt)
1016 {
1017 PTHREADINFO OldBlock;
1018 ASSERT(W32Thread);
1019
1020 if(!W32Thread->rpdesk || ((W32Thread->TIF_flags & TIF_INCLEANUP) && BlockIt))
1021 {
1022 /*
1023 * fail blocking if exiting the thread
1024 */
1025
1026 return FALSE;
1027 }
1028
1029 /*
1030 * FIXME - check access rights of the window station
1031 * e.g. services running in the service window station cannot block input
1032 */
1033 if(!ThreadHasInputAccess(W32Thread) ||
1034 !IntIsActiveDesktop(W32Thread->rpdesk))
1035 {
1036 EngSetLastError(ERROR_ACCESS_DENIED);
1037 return FALSE;
1038 }
1039
1040 ASSERT(W32Thread->rpdesk);
1041 OldBlock = W32Thread->rpdesk->BlockInputThread;
1042 if(OldBlock)
1043 {
1044 if(OldBlock != W32Thread)
1045 {
1046 EngSetLastError(ERROR_ACCESS_DENIED);
1047 return FALSE;
1048 }
1049 W32Thread->rpdesk->BlockInputThread = (BlockIt ? W32Thread : NULL);
1050 return OldBlock == NULL;
1051 }
1052
1053 W32Thread->rpdesk->BlockInputThread = (BlockIt ? W32Thread : NULL);
1054 return OldBlock == NULL;
1055 }
1056
1057 BOOL
1058 APIENTRY
1059 NtUserBlockInput(
1060 BOOL BlockIt)
1061 {
1062 DECLARE_RETURN(BOOLEAN);
1063
1064 DPRINT("Enter NtUserBlockInput\n");
1065 UserEnterExclusive();
1066
1067 RETURN( IntBlockInput(PsGetCurrentThreadWin32Thread(), BlockIt));
1068
1069 CLEANUP:
1070 DPRINT("Leave NtUserBlockInput, ret=%i\n",_ret_);
1071 UserLeave();
1072 END_CLEANUP;
1073 }
1074
1075 BOOL FASTCALL
1076 IntMouseInput(MOUSEINPUT *mi)
1077 {
1078 const UINT SwapBtnMsg[2][2] =
1079 {
1080 {WM_LBUTTONDOWN, WM_RBUTTONDOWN},
1081 {WM_LBUTTONUP, WM_RBUTTONUP}
1082 };
1083 const WPARAM SwapBtn[2] =
1084 {
1085 MK_LBUTTON, MK_RBUTTON
1086 };
1087 POINT MousePos;
1088 PSYSTEM_CURSORINFO CurInfo;
1089 BOOL SwapButtons;
1090 MSG Msg;
1091
1092 ASSERT(mi);
1093
1094 CurInfo = IntGetSysCursorInfo();
1095
1096 if(!mi->time)
1097 {
1098 LARGE_INTEGER LargeTickCount;
1099 KeQueryTickCount(&LargeTickCount);
1100 mi->time = MsqCalculateMessageTime(&LargeTickCount);
1101 }
1102
1103 SwapButtons = gspv.bMouseBtnSwap;
1104
1105 MousePos = gpsi->ptCursor;
1106
1107 if(mi->dwFlags & MOUSEEVENTF_MOVE)
1108 {
1109 if(mi->dwFlags & MOUSEEVENTF_ABSOLUTE)
1110 {
1111 MousePos.x = mi->dx * UserGetSystemMetrics(SM_CXVIRTUALSCREEN) >> 16;
1112 MousePos.y = mi->dy * UserGetSystemMetrics(SM_CYVIRTUALSCREEN) >> 16;
1113 }
1114 else
1115 {
1116 MousePos.x += mi->dx;
1117 MousePos.y += mi->dy;
1118 }
1119 }
1120
1121 /*
1122 * Insert the messages into the system queue
1123 */
1124 Msg.wParam = 0;
1125 Msg.lParam = MAKELPARAM(MousePos.x, MousePos.y);
1126 Msg.pt = MousePos;
1127
1128 if (gQueueKeyStateTable[VK_SHIFT] & 0xc0)
1129 {
1130 Msg.wParam |= MK_SHIFT;
1131 }
1132
1133 if (gQueueKeyStateTable[VK_CONTROL] & 0xc0)
1134 {
1135 Msg.wParam |= MK_CONTROL;
1136 }
1137
1138 if(mi->dwFlags & MOUSEEVENTF_MOVE)
1139 {
1140 UserSetCursorPos(MousePos.x, MousePos.y, TRUE);
1141 }
1142 if(mi->dwFlags & MOUSEEVENTF_LEFTDOWN)
1143 {
1144 gQueueKeyStateTable[VK_LBUTTON] |= 0xc0;
1145 Msg.message = SwapBtnMsg[0][SwapButtons];
1146 CurInfo->ButtonsDown |= SwapBtn[SwapButtons];
1147 Msg.wParam |= CurInfo->ButtonsDown;
1148 co_MsqInsertMouseMessage(&Msg);
1149 }
1150 else if(mi->dwFlags & MOUSEEVENTF_LEFTUP)
1151 {
1152 gQueueKeyStateTable[VK_LBUTTON] &= ~0x80;
1153 Msg.message = SwapBtnMsg[1][SwapButtons];
1154 CurInfo->ButtonsDown &= ~SwapBtn[SwapButtons];
1155 Msg.wParam |= CurInfo->ButtonsDown;
1156 co_MsqInsertMouseMessage(&Msg);
1157 }
1158 if(mi->dwFlags & MOUSEEVENTF_MIDDLEDOWN)
1159 {
1160 gQueueKeyStateTable[VK_MBUTTON] |= 0xc0;
1161 Msg.message = WM_MBUTTONDOWN;
1162 CurInfo->ButtonsDown |= MK_MBUTTON;
1163 Msg.wParam |= CurInfo->ButtonsDown;
1164 co_MsqInsertMouseMessage(&Msg);
1165 }
1166 else if(mi->dwFlags & MOUSEEVENTF_MIDDLEUP)
1167 {
1168 gQueueKeyStateTable[VK_MBUTTON] &= ~0x80;
1169 Msg.message = WM_MBUTTONUP;
1170 CurInfo->ButtonsDown &= ~MK_MBUTTON;
1171 Msg.wParam |= CurInfo->ButtonsDown;
1172 co_MsqInsertMouseMessage(&Msg);
1173 }
1174 if(mi->dwFlags & MOUSEEVENTF_RIGHTDOWN)
1175 {
1176 gQueueKeyStateTable[VK_RBUTTON] |= 0xc0;
1177 Msg.message = SwapBtnMsg[0][!SwapButtons];
1178 CurInfo->ButtonsDown |= SwapBtn[!SwapButtons];
1179 Msg.wParam |= CurInfo->ButtonsDown;
1180 co_MsqInsertMouseMessage(&Msg);
1181 }
1182 else if(mi->dwFlags & MOUSEEVENTF_RIGHTUP)
1183 {
1184 gQueueKeyStateTable[VK_RBUTTON] &= ~0x80;
1185 Msg.message = SwapBtnMsg[1][!SwapButtons];
1186 CurInfo->ButtonsDown &= ~SwapBtn[!SwapButtons];
1187 Msg.wParam |= CurInfo->ButtonsDown;
1188 co_MsqInsertMouseMessage(&Msg);
1189 }
1190
1191 if((mi->dwFlags & (MOUSEEVENTF_XDOWN | MOUSEEVENTF_XUP)) &&
1192 (mi->dwFlags & MOUSEEVENTF_WHEEL))
1193 {
1194 /* fail because both types of events use the mouseData field */
1195 return FALSE;
1196 }
1197
1198 if(mi->dwFlags & MOUSEEVENTF_XDOWN)
1199 {
1200 Msg.message = WM_XBUTTONDOWN;
1201 if(mi->mouseData & XBUTTON1)
1202 {
1203 gQueueKeyStateTable[VK_XBUTTON1] |= 0xc0;
1204 CurInfo->ButtonsDown |= MK_XBUTTON1;
1205 Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON1);
1206 co_MsqInsertMouseMessage(&Msg);
1207 }
1208 if(mi->mouseData & XBUTTON2)
1209 {
1210 gQueueKeyStateTable[VK_XBUTTON2] |= 0xc0;
1211 CurInfo->ButtonsDown |= MK_XBUTTON2;
1212 Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON2);
1213 co_MsqInsertMouseMessage(&Msg);
1214 }
1215 }
1216 else if(mi->dwFlags & MOUSEEVENTF_XUP)
1217 {
1218 Msg.message = WM_XBUTTONUP;
1219 if(mi->mouseData & XBUTTON1)
1220 {
1221 gQueueKeyStateTable[VK_XBUTTON1] &= ~0x80;
1222 CurInfo->ButtonsDown &= ~MK_XBUTTON1;
1223 Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON1);
1224 co_MsqInsertMouseMessage(&Msg);
1225 }
1226 if(mi->mouseData & XBUTTON2)
1227 {
1228 gQueueKeyStateTable[VK_XBUTTON2] &= ~0x80;
1229 CurInfo->ButtonsDown &= ~MK_XBUTTON2;
1230 Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, XBUTTON2);
1231 co_MsqInsertMouseMessage(&Msg);
1232 }
1233 }
1234 if(mi->dwFlags & MOUSEEVENTF_WHEEL)
1235 {
1236 Msg.message = WM_MOUSEWHEEL;
1237 Msg.wParam = MAKEWPARAM(CurInfo->ButtonsDown, mi->mouseData);
1238 co_MsqInsertMouseMessage(&Msg);
1239 }
1240
1241 return TRUE;
1242 }
1243
1244 BOOL FASTCALL
1245 IntKeyboardInput(KEYBDINPUT *ki)
1246 {
1247 PUSER_MESSAGE_QUEUE FocusMessageQueue;
1248 MSG Msg;
1249 LARGE_INTEGER LargeTickCount;
1250 KBDLLHOOKSTRUCT KbdHookData;
1251 WORD flags, wVkStripped, wVkL, wVkR, wVk = ki->wVk, vk_hook = ki->wVk;
1252
1253 Msg.lParam = 0;
1254
1255 // Condition may arise when calling MsqPostMessage and waiting for an event.
1256 ASSERT (UserIsEntered());
1257
1258 wVk = LOBYTE(wVk);
1259 Msg.wParam = wVk;
1260 flags = LOBYTE(ki->wScan);
1261
1262 if (ki->dwFlags & KEYEVENTF_EXTENDEDKEY) flags |= KF_EXTENDED;
1263 /* FIXME: set KF_DLGMODE and KF_MENUMODE when needed */
1264
1265 /* strip left/right for menu, control, shift */
1266 switch (wVk)
1267 {
1268 case VK_MENU:
1269 case VK_LMENU:
1270 case VK_RMENU:
1271 wVk = (ki->dwFlags & KEYEVENTF_EXTENDEDKEY) ? VK_RMENU : VK_LMENU;
1272 wVkStripped = VK_MENU;
1273 wVkL = VK_LMENU;
1274 wVkR = VK_RMENU;
1275 break;
1276 case VK_CONTROL:
1277 case VK_LCONTROL:
1278 case VK_RCONTROL:
1279 wVk = (ki->dwFlags & KEYEVENTF_EXTENDEDKEY) ? VK_RCONTROL : VK_LCONTROL;
1280 wVkStripped = VK_CONTROL;
1281 wVkL = VK_LCONTROL;
1282 wVkR = VK_RCONTROL;
1283 break;
1284 case VK_SHIFT:
1285 case VK_LSHIFT:
1286 case VK_RSHIFT:
1287 wVk = (ki->dwFlags & KEYEVENTF_EXTENDEDKEY) ? VK_RSHIFT : VK_LSHIFT;
1288 wVkStripped = VK_SHIFT;
1289 wVkL = VK_LSHIFT;
1290 wVkR = VK_RSHIFT;
1291 break;
1292 default:
1293 wVkStripped = wVkL = wVkR = wVk;
1294 }
1295
1296 if (ki->dwFlags & KEYEVENTF_KEYUP)
1297 {
1298 Msg.message = WM_KEYUP;
1299 if ((gQueueKeyStateTable[VK_MENU] & 0x80) &&
1300 ((wVkStripped == VK_MENU) || (wVkStripped == VK_CONTROL)
1301 || !(gQueueKeyStateTable[VK_CONTROL] & 0x80)))
1302 {
1303 if( TrackSysKey == VK_MENU || /* <ALT>-down/<ALT>-up sequence */
1304 (wVkStripped != VK_MENU)) /* <ALT>-down...<something else>-up */
1305 Msg.message = WM_SYSKEYUP;
1306 TrackSysKey = 0;
1307 }
1308 flags |= KF_REPEAT | KF_UP;
1309 }
1310 else
1311 {
1312 Msg.message = WM_KEYDOWN;
1313 if ((gQueueKeyStateTable[VK_MENU] & 0x80 || wVkStripped == VK_MENU) &&
1314 !(gQueueKeyStateTable[VK_CONTROL] & 0x80 || wVkStripped == VK_CONTROL))
1315 {
1316 Msg.message = WM_SYSKEYDOWN;
1317 TrackSysKey = wVkStripped;
1318 }
1319 if (!(ki->dwFlags & KEYEVENTF_UNICODE) && gQueueKeyStateTable[wVk] & 0x80) flags |= KF_REPEAT;
1320 }
1321
1322 if (ki->dwFlags & KEYEVENTF_UNICODE)
1323 {
1324 vk_hook = Msg.wParam = wVk = VK_PACKET;
1325 Msg.lParam = MAKELPARAM(1 /* repeat count */, ki->wScan);
1326 }
1327
1328 FocusMessageQueue = IntGetFocusMessageQueue();
1329
1330 Msg.hwnd = 0;
1331
1332 if (FocusMessageQueue && (FocusMessageQueue->FocusWindow != (HWND)0))
1333 Msg.hwnd = FocusMessageQueue->FocusWindow;
1334
1335 if (!ki->time)
1336 {
1337 KeQueryTickCount(&LargeTickCount);
1338 Msg.time = MsqCalculateMessageTime(&LargeTickCount);
1339 }
1340 else
1341 Msg.time = ki->time;
1342
1343 /* All messages have to contain the cursor point. */
1344 Msg.pt = gpsi->ptCursor;
1345
1346 KbdHookData.vkCode = vk_hook;
1347 KbdHookData.scanCode = ki->wScan;
1348 KbdHookData.flags = flags >> 8;
1349 KbdHookData.time = Msg.time;
1350 KbdHookData.dwExtraInfo = ki->dwExtraInfo;
1351 if (co_HOOK_CallHooks(WH_KEYBOARD_LL, HC_ACTION, Msg.message, (LPARAM) &KbdHookData))
1352 {
1353 DPRINT1("Kbd msg %d wParam %d lParam 0x%08x dropped by WH_KEYBOARD_LL hook\n",
1354 Msg.message, vk_hook, Msg.lParam);
1355
1356 return FALSE;
1357 }
1358
1359 if (!(ki->dwFlags & KEYEVENTF_UNICODE))
1360 {
1361 if (ki->dwFlags & KEYEVENTF_KEYUP)
1362 {
1363 gQueueKeyStateTable[wVk] &= ~0x80;
1364 gQueueKeyStateTable[wVkStripped] = gQueueKeyStateTable[wVkL] | gQueueKeyStateTable[wVkR];
1365 }
1366 else
1367 {
1368 if (!(gQueueKeyStateTable[wVk] & 0x80)) gQueueKeyStateTable[wVk] ^= 0x01;
1369 gQueueKeyStateTable[wVk] |= 0xc0;
1370 gQueueKeyStateTable[wVkStripped] = gQueueKeyStateTable[wVkL] | gQueueKeyStateTable[wVkR];
1371 }
1372
1373 if (gQueueKeyStateTable[VK_MENU] & 0x80) flags |= KF_ALTDOWN;
1374
1375 if (wVkStripped == VK_SHIFT) flags &= ~KF_EXTENDED;
1376
1377 Msg.lParam = MAKELPARAM(1 /* repeat count */, flags);
1378 }
1379
1380 if (FocusMessageQueue == NULL)
1381 {
1382 DPRINT("No focus message queue\n");
1383
1384 return FALSE;
1385 }
1386
1387 if (FocusMessageQueue->FocusWindow != (HWND)0)
1388 {
1389 Msg.hwnd = FocusMessageQueue->FocusWindow;
1390 DPRINT("Msg.hwnd = %x\n", Msg.hwnd);
1391
1392 FocusMessageQueue->Desktop->pDeskInfo->LastInputWasKbd = TRUE;
1393
1394 Msg.pt = gpsi->ptCursor;
1395 // Post to hardware queue, based on the first part of wine "some GetMessage tests"
1396 // in test_PeekMessage()
1397 MsqPostMessage(FocusMessageQueue, &Msg, TRUE, QS_KEY);
1398 }
1399 else
1400 {
1401 DPRINT("Invalid focus window handle\n");
1402 }
1403
1404 return TRUE;
1405 }
1406
1407 BOOL FASTCALL
1408 UserAttachThreadInput( PTHREADINFO pti, PTHREADINFO ptiTo, BOOL fAttach)
1409 {
1410 PATTACHINFO pai;
1411
1412 /* Can not be the same thread.*/
1413 if (pti == ptiTo) return FALSE;
1414
1415 /* Do not attach to system threads or between different desktops. */
1416 if ( pti->TIF_flags & TIF_DONTATTACHQUEUE ||
1417 ptiTo->TIF_flags & TIF_DONTATTACHQUEUE ||
1418 pti->rpdesk != ptiTo->rpdesk )
1419 return FALSE;
1420
1421 /* If Attach set, allocate and link. */
1422 if ( fAttach )
1423 {
1424 pai = ExAllocatePoolWithTag(PagedPool, sizeof(ATTACHINFO), USERTAG_ATTACHINFO);
1425 if ( !pai ) return FALSE;
1426
1427 pai->paiNext = gpai;
1428 pai->pti1 = pti;
1429 pai->pti2 = ptiTo;
1430 gpai = pai;
1431 }
1432 else /* If clear, unlink and free it. */
1433 {
1434 PATTACHINFO paiprev = NULL;
1435
1436 if ( !gpai ) return FALSE;
1437
1438 pai = gpai;
1439
1440 /* Search list and free if found or return false. */
1441 do
1442 {
1443 if ( pai->pti2 == ptiTo && pai->pti1 == pti ) break;
1444 paiprev = pai;
1445 pai = pai->paiNext;
1446 } while (pai);
1447
1448 if ( !pai ) return FALSE;
1449
1450 if (paiprev) paiprev->paiNext = pai->paiNext;
1451
1452 ExFreePoolWithTag(pai, USERTAG_ATTACHINFO);
1453 }
1454
1455 return TRUE;
1456 }
1457
1458 UINT
1459 APIENTRY
1460 NtUserSendInput(
1461 UINT nInputs,
1462 LPINPUT pInput,
1463 INT cbSize)
1464 {
1465 PTHREADINFO W32Thread;
1466 UINT cnt;
1467 DECLARE_RETURN(UINT);
1468
1469 DPRINT("Enter NtUserSendInput\n");
1470 UserEnterExclusive();
1471
1472 W32Thread = PsGetCurrentThreadWin32Thread();
1473 ASSERT(W32Thread);
1474
1475 if(!W32Thread->rpdesk)
1476 {
1477 RETURN( 0);
1478 }
1479
1480 if(!nInputs || !pInput || (cbSize != sizeof(INPUT)))
1481 {
1482 EngSetLastError(ERROR_INVALID_PARAMETER);
1483 RETURN( 0);
1484 }
1485
1486 /*
1487 * FIXME - check access rights of the window station
1488 * e.g. services running in the service window station cannot block input
1489 */
1490 if(!ThreadHasInputAccess(W32Thread) ||
1491 !IntIsActiveDesktop(W32Thread->rpdesk))
1492 {
1493 EngSetLastError(ERROR_ACCESS_DENIED);
1494 RETURN( 0);
1495 }
1496
1497 cnt = 0;
1498 while(nInputs--)
1499 {
1500 INPUT SafeInput;
1501 NTSTATUS Status;
1502
1503 Status = MmCopyFromCaller(&SafeInput, pInput++, sizeof(INPUT));
1504 if(!NT_SUCCESS(Status))
1505 {
1506 SetLastNtError(Status);
1507 RETURN( cnt);
1508 }
1509
1510 switch(SafeInput.type)
1511 {
1512 case INPUT_MOUSE:
1513 if(IntMouseInput(&SafeInput.mi))
1514 {
1515 cnt++;
1516 }
1517 break;
1518 case INPUT_KEYBOARD:
1519 if(IntKeyboardInput(&SafeInput.ki))
1520 {
1521 cnt++;
1522 }
1523 break;
1524 case INPUT_HARDWARE:
1525 break;
1526 #ifndef NDEBUG
1527
1528 default:
1529 DPRINT1("SendInput(): Invalid input type: 0x%x\n", SafeInput.type);
1530 break;
1531 #endif
1532
1533 }
1534 }
1535
1536 RETURN( cnt);
1537
1538 CLEANUP:
1539 DPRINT("Leave NtUserSendInput, ret=%i\n",_ret_);
1540 UserLeave();
1541 END_CLEANUP;
1542 }
1543
1544 /* EOF */