2 * USER Input processing
4 * Copyright 1993 Bob Amstadt
5 * Copyright 1996 Albrecht Kleine
6 * Copyright 1997 David Faure
7 * Copyright 1998 Morten Welinder
8 * Copyright 1998 Ulrich Weigand
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31 #define NONAMELESSUNION
32 #define NONAMELESSSTRUCT
38 #include "wine/winbase16.h"
39 #include "wine/winuser16.h"
40 #include "wine/server.h"
44 #include "wine/debug.h"
47 WINE_DECLARE_DEBUG_CHANNEL(key
);
48 WINE_DECLARE_DEBUG_CHANNEL(keyboard
);
49 WINE_DECLARE_DEBUG_CHANNEL(win
);
50 WINE_DEFAULT_DEBUG_CHANNEL(event
);
52 static BOOL InputEnabled
= TRUE
;
53 static BOOL SwappedButtons
;
55 BYTE InputKeyStateTable
[256];
56 BYTE AsyncKeyStateTable
[256];
58 /* Storage for the USER-maintained mouse positions */
59 static DWORD PosX
, PosY
;
65 unsigned long count
: 16;
66 unsigned long code
: 8;
67 unsigned long extended
: 1;
68 unsigned long unused
: 2;
69 unsigned long win_internal
: 2;
70 unsigned long context
: 1;
71 unsigned long previous
: 1;
72 unsigned long transition
: 1;
78 /***********************************************************************
81 static WORD
get_key_state(void)
87 if (InputKeyStateTable
[VK_RBUTTON
] & 0x80) ret
|= MK_LBUTTON
;
88 if (InputKeyStateTable
[VK_LBUTTON
] & 0x80) ret
|= MK_RBUTTON
;
92 if (InputKeyStateTable
[VK_LBUTTON
] & 0x80) ret
|= MK_LBUTTON
;
93 if (InputKeyStateTable
[VK_RBUTTON
] & 0x80) ret
|= MK_RBUTTON
;
95 if (InputKeyStateTable
[VK_MBUTTON
] & 0x80) ret
|= MK_MBUTTON
;
96 if (InputKeyStateTable
[VK_SHIFT
] & 0x80) ret
|= MK_SHIFT
;
97 if (InputKeyStateTable
[VK_CONTROL
] & 0x80) ret
|= MK_CONTROL
;
98 if (InputKeyStateTable
[VK_XBUTTON1
] & 0x80) ret
|= MK_XBUTTON1
;
99 if (InputKeyStateTable
[VK_XBUTTON2
] & 0x80) ret
|= MK_XBUTTON2
;
104 /***********************************************************************
105 * queue_hardware_message
107 * Add a message to the hardware queue.
108 * Note: the position is relative to the desktop window.
110 static void queue_hardware_message( UINT message
, HWND hwnd
, WPARAM wParam
, LPARAM lParam
,
111 int xPos
, int yPos
, DWORD time
, ULONG_PTR extraInfo
)
113 SERVER_START_REQ( send_message
)
115 req
->id
= GetCurrentThreadId();
116 req
->type
= MSG_HARDWARE
;
119 req
->wparam
= wParam
;
120 req
->lparam
= lParam
;
124 req
->info
= extraInfo
;
126 wine_server_call( req
);
132 /***********************************************************************
135 * Put a keyboard event into a thread queue
137 static void queue_kbd_event( const KEYBDINPUT
*ki
, UINT injected_flags
)
141 KBDLLHOOKSTRUCT hook
;
145 keylp
.lp1
.code
= ki
->wScan
;
146 keylp
.lp1
.extended
= (ki
->dwFlags
& KEYEVENTF_EXTENDEDKEY
) != 0;
147 keylp
.lp1
.win_internal
= 0; /* this has something to do with dialogs,
148 * don't remember where I read it - AK */
149 /* it's '1' under windows, when a dialog box appears
150 * and you press one of the underlined keys - DF*/
152 if (ki
->dwFlags
& KEYEVENTF_KEYUP
)
154 BOOL sysKey
= (InputKeyStateTable
[VK_MENU
] & 0x80) &&
155 !(InputKeyStateTable
[VK_CONTROL
] & 0x80);
156 InputKeyStateTable
[ki
->wVk
] &= ~0x80;
157 keylp
.lp1
.previous
= 1;
158 keylp
.lp1
.transition
= 1;
159 message
= sysKey
? WM_SYSKEYUP
: WM_KEYUP
;
163 keylp
.lp1
.previous
= (InputKeyStateTable
[ki
->wVk
] & 0x80) != 0;
164 keylp
.lp1
.transition
= 0;
165 if (!(InputKeyStateTable
[ki
->wVk
] & 0x80)) InputKeyStateTable
[ki
->wVk
] ^= 0x01;
166 InputKeyStateTable
[ki
->wVk
] |= 0x80;
167 AsyncKeyStateTable
[ki
->wVk
] |= 0x80;
169 message
= (InputKeyStateTable
[VK_MENU
] & 0x80) && !(InputKeyStateTable
[VK_CONTROL
] & 0x80)
170 ? WM_SYSKEYDOWN
: WM_KEYDOWN
;
173 keylp
.lp1
.context
= (InputKeyStateTable
[VK_MENU
] & 0x80) != 0; /* 1 if alt */
175 TRACE_(key
)(" wParam=%04x, lParam=%08lx, InputKeyState=%x\n",
176 ki
->wVk
, keylp
.lp2
, InputKeyStateTable
[ki
->wVk
] );
178 hook
.vkCode
= ki
->wVk
;
179 hook
.scanCode
= ki
->wScan
;
180 hook
.flags
= (keylp
.lp2
>> 24) | injected_flags
;
181 hook
.time
= ki
->time
;
182 hook
.dwExtraInfo
= ki
->dwExtraInfo
;
183 if (!HOOK_CallHooks( WH_KEYBOARD_LL
, HC_ACTION
, message
, (LPARAM
)&hook
, TRUE
))
184 queue_hardware_message( message
, 0, ki
->wVk
, keylp
.lp2
,
185 PosX
, PosY
, ki
->time
, ki
->dwExtraInfo
);
189 /***********************************************************************
190 * queue_raw_mouse_message
192 static void queue_raw_mouse_message( UINT message
, UINT flags
, INT x
, INT y
, const MOUSEINPUT
*mi
)
198 hook
.mouseData
= MAKELONG( 0, mi
->mouseData
);
200 hook
.time
= mi
->time
;
201 hook
.dwExtraInfo
= mi
->dwExtraInfo
;
203 if (!HOOK_CallHooks( WH_MOUSE_LL
, HC_ACTION
, message
, (LPARAM
)&hook
, TRUE
))
204 queue_hardware_message( message
, (HWND
)mi
->dwExtraInfo
/*FIXME*/,
205 MAKEWPARAM( get_key_state(), mi
->mouseData
),
206 0, x
, y
, mi
->time
, mi
->dwExtraInfo
);
210 /***********************************************************************
213 static void queue_mouse_event( const MOUSEINPUT
*mi
, UINT flags
)
215 if (mi
->dwFlags
& MOUSEEVENTF_ABSOLUTE
)
217 PosX
= (mi
->dx
* GetSystemMetrics(SM_CXSCREEN
)) >> 16;
218 PosY
= (mi
->dy
* GetSystemMetrics(SM_CYSCREEN
)) >> 16;
220 else if (mi
->dwFlags
& MOUSEEVENTF_MOVE
)
222 int width
= GetSystemMetrics(SM_CXSCREEN
);
223 int height
= GetSystemMetrics(SM_CYSCREEN
);
224 long posX
= (long) PosX
, posY
= (long) PosY
;
228 /* dx and dy can be negative numbers for relative movements */
229 SystemParametersInfoA(SPI_GETMOUSE
, 0, accel
, 0);
232 if (mi
->dx
> accel
[0] && accel
[2] != 0)
235 if ((mi
->dx
> accel
[1]) && (accel
[2] == 2))
240 posX
+= (long)mi
->dx
* accelMult
;
243 if (mi
->dy
> accel
[0] && accel
[2] != 0)
246 if ((mi
->dy
> accel
[1]) && (accel
[2] == 2))
251 posY
+= (long)mi
->dy
* accelMult
;
253 /* Clip to the current screen size */
254 if (posX
< 0) PosX
= 0;
255 else if (posX
>= width
) PosX
= width
- 1;
258 if (posY
< 0) PosY
= 0;
259 else if (posY
>= height
) PosY
= height
- 1;
263 if (mi
->dwFlags
& MOUSEEVENTF_MOVE
)
265 queue_raw_mouse_message( WM_MOUSEMOVE
, flags
, PosX
, PosY
, mi
);
267 if (mi
->dwFlags
& MOUSEEVENTF_LEFTDOWN
)
269 InputKeyStateTable
[VK_LBUTTON
] |= 0x80;
270 AsyncKeyStateTable
[VK_LBUTTON
] |= 0x80;
271 queue_raw_mouse_message( SwappedButtons
? WM_RBUTTONDOWN
: WM_LBUTTONDOWN
,
272 flags
, PosX
, PosY
, mi
);
274 if (mi
->dwFlags
& MOUSEEVENTF_LEFTUP
)
276 InputKeyStateTable
[VK_LBUTTON
] &= ~0x80;
277 queue_raw_mouse_message( SwappedButtons
? WM_RBUTTONUP
: WM_LBUTTONUP
,
278 flags
, PosX
, PosY
, mi
);
280 if (mi
->dwFlags
& MOUSEEVENTF_RIGHTDOWN
)
282 InputKeyStateTable
[VK_RBUTTON
] |= 0x80;
283 AsyncKeyStateTable
[VK_RBUTTON
] |= 0x80;
284 queue_raw_mouse_message( SwappedButtons
? WM_LBUTTONDOWN
: WM_RBUTTONDOWN
,
285 flags
, PosX
, PosY
, mi
);
287 if (mi
->dwFlags
& MOUSEEVENTF_RIGHTUP
)
289 InputKeyStateTable
[VK_RBUTTON
] &= ~0x80;
290 queue_raw_mouse_message( SwappedButtons
? WM_LBUTTONUP
: WM_RBUTTONUP
,
291 flags
, PosX
, PosY
, mi
);
293 if (mi
->dwFlags
& MOUSEEVENTF_MIDDLEDOWN
)
295 InputKeyStateTable
[VK_MBUTTON
] |= 0x80;
296 AsyncKeyStateTable
[VK_MBUTTON
] |= 0x80;
297 queue_raw_mouse_message( WM_MBUTTONDOWN
, flags
, PosX
, PosY
, mi
);
299 if (mi
->dwFlags
& MOUSEEVENTF_MIDDLEUP
)
301 InputKeyStateTable
[VK_MBUTTON
] &= ~0x80;
302 queue_raw_mouse_message( WM_MBUTTONUP
, flags
, PosX
, PosY
, mi
);
304 if (mi
->dwFlags
& MOUSEEVENTF_WHEEL
)
306 queue_raw_mouse_message( WM_MOUSEWHEEL
, flags
, PosX
, PosY
, mi
);
308 if (flags
& LLMHF_INJECTED
) /* we have to actually move the cursor */
309 SetCursorPos( PosX
, PosY
);
313 /***********************************************************************
314 * SendInput (USER32.@)
316 UINT WINAPI
SendInput( UINT count
, LPINPUT inputs
, int size
)
320 if (!InputEnabled
) return 0;
322 for (i
= 0; i
< count
; i
++, inputs
++)
327 queue_mouse_event( &inputs
->u
.mi
, LLMHF_INJECTED
);
329 case WINE_INTERNAL_INPUT_MOUSE
:
330 queue_mouse_event( &inputs
->u
.mi
, 0 );
333 queue_kbd_event( &inputs
->u
.ki
, LLKHF_INJECTED
);
335 case WINE_INTERNAL_INPUT_KEYBOARD
:
336 queue_kbd_event( &inputs
->u
.ki
, 0 );
339 FIXME( "INPUT_HARDWARE not supported\n" );
347 /***********************************************************************
348 * keybd_event (USER32.@)
350 void WINAPI
keybd_event( BYTE bVk
, BYTE bScan
,
351 DWORD dwFlags
, ULONG_PTR dwExtraInfo
)
355 input
.type
= INPUT_KEYBOARD
;
356 input
.u
.ki
.wVk
= bVk
;
357 input
.u
.ki
.wScan
= bScan
;
358 input
.u
.ki
.dwFlags
= dwFlags
;
359 input
.u
.ki
.time
= GetTickCount();
360 input
.u
.ki
.dwExtraInfo
= dwExtraInfo
;
361 SendInput( 1, &input
, sizeof(input
) );
365 /***********************************************************************
366 * keybd_event (USER.289)
368 void WINAPI
keybd_event16( CONTEXT86
*context
)
372 if (HIBYTE(context
->Eax
) & 0x80) dwFlags
|= KEYEVENTF_KEYUP
;
373 if (HIBYTE(context
->Ebx
) & 0x01) dwFlags
|= KEYEVENTF_EXTENDEDKEY
;
375 keybd_event( LOBYTE(context
->Eax
), LOBYTE(context
->Ebx
),
376 dwFlags
, MAKELONG(LOWORD(context
->Esi
), LOWORD(context
->Edi
)) );
380 /***********************************************************************
381 * mouse_event (USER32.@)
383 void WINAPI
mouse_event( DWORD dwFlags
, DWORD dx
, DWORD dy
,
384 DWORD dwData
, ULONG_PTR dwExtraInfo
)
388 input
.type
= INPUT_MOUSE
;
391 input
.u
.mi
.mouseData
= dwData
;
392 input
.u
.mi
.dwFlags
= dwFlags
;
393 input
.u
.mi
.time
= GetCurrentTime();
394 input
.u
.mi
.dwExtraInfo
= dwExtraInfo
;
395 SendInput( 1, &input
, sizeof(input
) );
399 /***********************************************************************
400 * mouse_event (USER.299)
402 void WINAPI
mouse_event16( CONTEXT86
*context
)
404 mouse_event( LOWORD(context
->Eax
), LOWORD(context
->Ebx
), LOWORD(context
->Ecx
),
405 LOWORD(context
->Edx
), MAKELONG(context
->Esi
, context
->Edi
) );
408 /***********************************************************************
409 * GetMouseEventProc (USER.337)
411 FARPROC16 WINAPI
GetMouseEventProc16(void)
413 HMODULE16 hmodule
= GetModuleHandle16("USER");
414 return GetProcAddress16( hmodule
, "mouse_event" );
418 /**********************************************************************
419 * EnableHardwareInput (USER.331)
421 BOOL16 WINAPI
EnableHardwareInput16(BOOL16 bEnable
)
423 BOOL16 bOldState
= InputEnabled
;
424 FIXME_(event
)("(%d) - stub\n", bEnable
);
425 InputEnabled
= bEnable
;
430 /***********************************************************************
431 * SwapMouseButton (USER.186)
433 BOOL16 WINAPI
SwapMouseButton16( BOOL16 fSwap
)
435 BOOL16 ret
= SwappedButtons
;
436 SwappedButtons
= fSwap
;
441 /***********************************************************************
442 * SwapMouseButton (USER32.@)
444 BOOL WINAPI
SwapMouseButton( BOOL fSwap
)
446 BOOL ret
= SwappedButtons
;
447 SwappedButtons
= fSwap
;
452 /***********************************************************************
453 * GetCursorPos (USER.17)
455 BOOL16 WINAPI
GetCursorPos16( POINT16
*pt
)
466 /***********************************************************************
467 * GetCursorPos (USER32.@)
469 BOOL WINAPI
GetCursorPos( POINT
*pt
)
474 if (USER_Driver
.pGetCursorPos
) USER_Driver
.pGetCursorPos( pt
);
479 /***********************************************************************
480 * GetCursorInfo (USER32.@)
482 BOOL WINAPI
GetCursorInfo( PCURSORINFO pci
)
484 MESSAGEQUEUE
*queue
= QUEUE_Current();
487 if (queue
->cursor_count
>= 0) pci
->flags
= CURSOR_SHOWING
;
489 GetCursorPos(&pci
->ptScreenPos
);
494 /***********************************************************************
495 * SetCursorPos (USER.70)
497 void WINAPI
SetCursorPos16( INT16 x
, INT16 y
)
499 SetCursorPos( x
, y
);
503 /***********************************************************************
504 * SetCursorPos (USER32.@)
506 BOOL WINAPI
SetCursorPos( INT x
, INT y
)
508 if (USER_Driver
.pSetCursorPos
) USER_Driver
.pSetCursorPos( x
, y
);
515 /**********************************************************************
516 * SetCapture (USER32.@)
518 HWND WINAPI
SetCapture( HWND hwnd
)
522 SERVER_START_REQ( set_capture_window
)
526 if (!wine_server_call_err( req
))
528 previous
= reply
->previous
;
529 hwnd
= reply
->full_handle
;
534 if (previous
&& previous
!= hwnd
)
535 SendMessageW( previous
, WM_CAPTURECHANGED
, 0, (LPARAM
)hwnd
);
540 /**********************************************************************
541 * ReleaseCapture (USER32.@)
543 BOOL WINAPI
ReleaseCapture(void)
545 return (SetCapture(0) != 0);
549 /**********************************************************************
550 * GetCapture (USER32.@)
552 HWND WINAPI
GetCapture(void)
556 SERVER_START_REQ( get_thread_input
)
558 req
->tid
= GetCurrentThreadId();
559 if (!wine_server_call_err( req
)) ret
= reply
->capture
;
566 /**********************************************************************
567 * GetAsyncKeyState (USER32.@)
569 * Determine if a key is or was pressed. retval has high-order
570 * bit set to 1 if currently pressed, low-order bit set to 1 if key has
573 * This uses the variable AsyncMouseButtonsStates and
574 * AsyncKeyStateTable (set in event.c) which have the mouse button
575 * number or key number (whichever is applicable) set to true if the
576 * mouse or key had been depressed since the last call to
579 SHORT WINAPI
GetAsyncKeyState(INT nKey
)
581 SHORT retval
= ((AsyncKeyStateTable
[nKey
] & 0x80) ? 0x0001 : 0) |
582 ((InputKeyStateTable
[nKey
] & 0x80) ? 0x8000 : 0);
583 AsyncKeyStateTable
[nKey
] = 0;
584 TRACE_(key
)("(%x) -> %x\n", nKey
, retval
);
588 /**********************************************************************
589 * GetAsyncKeyState (USER.249)
591 INT16 WINAPI
GetAsyncKeyState16(INT16 nKey
)
593 return GetAsyncKeyState(nKey
);
596 /***********************************************************************
597 * IsUserIdle (USER.333)
599 BOOL16 WINAPI
IsUserIdle16(void)
601 if ( GetAsyncKeyState( VK_LBUTTON
) & 0x8000 )
604 if ( GetAsyncKeyState( VK_RBUTTON
) & 0x8000 )
607 if ( GetAsyncKeyState( VK_MBUTTON
) & 0x8000 )
610 /* Should check for screen saver activation here ... */
615 /**********************************************************************
616 * VkKeyScanA (USER32.@)
618 * VkKeyScan translates an ANSI character to a virtual-key and shift code
619 * for the current keyboard.
620 * high-order byte yields :
624 * 3-5 Shift-key combinations that are not used for characters
627 * I.e. : Shift = 1, Ctrl = 2, Alt = 4.
628 * FIXME : works ok except for dead chars :
629 * VkKeyScan '^'(0x5e, 94) ... got keycode 00 ... returning 00
630 * VkKeyScan '`'(0x60, 96) ... got keycode 00 ... returning 00
632 WORD WINAPI
VkKeyScanA(CHAR cChar
)
634 return USER_Driver
.pVkKeyScan( cChar
);
637 /******************************************************************************
638 * VkKeyScanW (USER32.@)
640 WORD WINAPI
VkKeyScanW(WCHAR cChar
)
642 return VkKeyScanA((CHAR
)cChar
); /* FIXME: check unicode */
645 /**********************************************************************
646 * VkKeyScanExA (USER32.@)
648 WORD WINAPI
VkKeyScanExA(CHAR cChar
, HKL dwhkl
)
650 /* FIXME: complete workaround this is */
651 return VkKeyScanA(cChar
);
654 /******************************************************************************
655 * VkKeyScanExW (USER32.@)
657 WORD WINAPI
VkKeyScanExW(WCHAR cChar
, HKL dwhkl
)
659 /* FIXME: complete workaround this is */
660 return VkKeyScanA((CHAR
)cChar
); /* FIXME: check unicode */
663 /******************************************************************************
664 * GetKeyboardType (USER32.@)
666 INT WINAPI
GetKeyboardType(INT nTypeFlag
)
668 TRACE_(keyboard
)("(%d)\n", nTypeFlag
);
671 case 0: /* Keyboard type */
672 return 4; /* AT-101 */
673 case 1: /* Keyboard Subtype */
674 return 0; /* There are no defined subtypes */
675 case 2: /* Number of F-keys */
676 return 12; /* We're doing an 101 for now, so return 12 F-keys */
678 WARN_(keyboard
)("Unknown type\n");
679 return 0; /* The book says 0 here, so 0 */
683 /******************************************************************************
684 * MapVirtualKeyA (USER32.@)
686 UINT WINAPI
MapVirtualKeyA(UINT code
, UINT maptype
)
688 return USER_Driver
.pMapVirtualKey( code
, maptype
);
691 /******************************************************************************
692 * MapVirtualKeyW (USER32.@)
694 UINT WINAPI
MapVirtualKeyW(UINT code
, UINT maptype
)
696 return MapVirtualKeyA(code
,maptype
);
699 /******************************************************************************
700 * MapVirtualKeyExA (USER32.@)
702 UINT WINAPI
MapVirtualKeyExA(UINT code
, UINT maptype
, HKL hkl
)
705 FIXME_(keyboard
)("(%d,%d,0x%08lx), hkl unhandled!\n",code
,maptype
,(DWORD
)hkl
);
706 return MapVirtualKeyA(code
,maptype
);
709 /******************************************************************************
710 * MapVirtualKeyExW (USER32.@)
712 UINT WINAPI
MapVirtualKeyExW(UINT code
, UINT maptype
, HKL hkl
)
715 FIXME_(keyboard
)("(%d,%d,0x%08lx), hkl unhandled!\n",code
,maptype
,(DWORD
)hkl
);
716 return MapVirtualKeyA(code
,maptype
);
719 /****************************************************************************
720 * GetKBCodePage (USER32.@)
722 UINT WINAPI
GetKBCodePage(void)
727 /****************************************************************************
728 * GetKeyboardLayoutName (USER.477)
730 INT16 WINAPI
GetKeyboardLayoutName16(LPSTR pwszKLID
)
732 return GetKeyboardLayoutNameA(pwszKLID
);
735 /***********************************************************************
736 * GetKeyboardLayout (USER32.@)
738 * FIXME: - device handle for keyboard layout defaulted to
739 * the language id. This is the way Windows default works.
740 * - the thread identifier (dwLayout) is also ignored.
742 HKL WINAPI
GetKeyboardLayout(DWORD dwLayout
)
745 layout
= GetSystemDefaultLCID(); /* FIXME */
746 layout
|= (layout
<<16); /* FIXME */
747 TRACE_(keyboard
)("returning %08x\n",layout
);
751 /****************************************************************************
752 * GetKeyboardLayoutNameA (USER32.@)
754 INT WINAPI
GetKeyboardLayoutNameA(LPSTR pwszKLID
)
756 sprintf(pwszKLID
, "%p",GetKeyboardLayout(0));
760 /****************************************************************************
761 * GetKeyboardLayoutNameW (USER32.@)
763 INT WINAPI
GetKeyboardLayoutNameW(LPWSTR pwszKLID
)
765 char buf
[KL_NAMELENGTH
];
766 int res
= GetKeyboardLayoutNameA(buf
);
767 MultiByteToWideChar( CP_ACP
, 0, buf
, -1, pwszKLID
, KL_NAMELENGTH
);
771 /****************************************************************************
772 * GetKeyNameTextA (USER32.@)
774 INT WINAPI
GetKeyNameTextA(LONG lParam
, LPSTR lpBuffer
, INT nSize
)
776 return USER_Driver
.pGetKeyNameText( lParam
, lpBuffer
, nSize
);
779 /****************************************************************************
780 * GetKeyNameTextW (USER32.@)
782 INT WINAPI
GetKeyNameTextW(LONG lParam
, LPWSTR lpBuffer
, INT nSize
)
785 LPSTR buf
= HeapAlloc( GetProcessHeap(), 0, nSize
);
786 if(buf
== NULL
) return 0; /* FIXME: is this the correct failure value?*/
787 res
= GetKeyNameTextA(lParam
,buf
,nSize
);
789 if (nSize
> 0 && !MultiByteToWideChar( CP_ACP
, 0, buf
, -1, lpBuffer
, nSize
))
790 lpBuffer
[nSize
-1] = 0;
791 HeapFree( GetProcessHeap(), 0, buf
);
795 /****************************************************************************
796 * ToUnicode (USER32.@)
798 INT WINAPI
ToUnicode(UINT virtKey
, UINT scanCode
, LPBYTE lpKeyState
,
799 LPWSTR lpwStr
, int size
, UINT flags
)
801 return USER_Driver
.pToUnicode(virtKey
, scanCode
, lpKeyState
, lpwStr
, size
, flags
);
804 /****************************************************************************
805 * ToUnicodeEx (USER32.@)
807 INT WINAPI
ToUnicodeEx(UINT virtKey
, UINT scanCode
, LPBYTE lpKeyState
,
808 LPWSTR lpwStr
, int size
, UINT flags
, HKL hkl
)
810 /* FIXME: need true implementation */
811 return ToUnicode(virtKey
, scanCode
, lpKeyState
, lpwStr
, size
, flags
);
814 /****************************************************************************
817 INT WINAPI
ToAscii( UINT virtKey
,UINT scanCode
,LPBYTE lpKeyState
,
818 LPWORD lpChar
,UINT flags
)
823 ret
= ToUnicode(virtKey
, scanCode
, lpKeyState
, uni_chars
, 2, flags
);
824 if(ret
< 0) n_ret
= 1; /* FIXME: make ToUnicode return 2 for dead chars */
826 WideCharToMultiByte(CP_ACP
, 0, uni_chars
, n_ret
, (LPSTR
)lpChar
, 2, NULL
, NULL
);
830 /****************************************************************************
831 * ToAsciiEx (USER32.@)
833 INT WINAPI
ToAsciiEx( UINT virtKey
, UINT scanCode
, LPBYTE lpKeyState
,
834 LPWORD lpChar
, UINT flags
, HKL dwhkl
)
836 /* FIXME: need true implementation */
837 return ToAscii(virtKey
, scanCode
, lpKeyState
, lpChar
, flags
);
840 /**********************************************************************
841 * ActivateKeyboardLayout (USER32.@)
843 * Call ignored. WINE supports only system default keyboard layout.
845 HKL WINAPI
ActivateKeyboardLayout(HKL hLayout
, UINT flags
)
847 TRACE_(keyboard
)("(%p, %d)\n", hLayout
, flags
);
848 ERR_(keyboard
)("Only default system keyboard layout supported. Call ignored.\n");
853 /***********************************************************************
854 * GetKeyboardLayoutList (USER32.@)
856 * FIXME: Supports only the system default language and layout and
857 * returns only 1 value.
859 * Return number of values available if either input parm is
860 * 0, per MS documentation.
863 INT WINAPI
GetKeyboardLayoutList(INT nBuff
,HKL
*layouts
)
865 TRACE_(keyboard
)("(%d,%p)\n",nBuff
,layouts
);
866 if (!nBuff
|| !layouts
)
869 layouts
[0] = GetKeyboardLayout(0);
874 /***********************************************************************
875 * RegisterHotKey (USER32.@)
877 BOOL WINAPI
RegisterHotKey(HWND hwnd
,INT id
,UINT modifiers
,UINT vk
) {
878 FIXME_(keyboard
)("(%p,%d,0x%08x,%d): stub\n",hwnd
,id
,modifiers
,vk
);
882 /***********************************************************************
883 * UnregisterHotKey (USER32.@)
885 BOOL WINAPI
UnregisterHotKey(HWND hwnd
,INT id
) {
886 FIXME_(keyboard
)("(%p,%d): stub\n",hwnd
,id
);
890 /***********************************************************************
891 * LoadKeyboardLayoutW (USER32.@)
892 * Call ignored. WINE supports only system default keyboard layout.
894 HKL WINAPI
LoadKeyboardLayoutW(LPCWSTR pwszKLID
, UINT Flags
)
896 TRACE_(keyboard
)("(%s, %d)\n", debugstr_w(pwszKLID
), Flags
);
897 ERR_(keyboard
)("Only default system keyboard layout supported. Call ignored.\n");
901 /***********************************************************************
902 * LoadKeyboardLayoutA (USER32.@)
904 HKL WINAPI
LoadKeyboardLayoutA(LPCSTR pwszKLID
, UINT Flags
)
907 UNICODE_STRING pwszKLIDW
;
909 if (pwszKLID
) RtlCreateUnicodeStringFromAsciiz(&pwszKLIDW
, pwszKLID
);
910 else pwszKLIDW
.Buffer
= NULL
;
912 ret
= LoadKeyboardLayoutW(pwszKLIDW
.Buffer
, Flags
);
913 RtlFreeUnicodeString(&pwszKLIDW
);
918 typedef struct __TRACKINGLIST
{
920 POINT pos
; /* center of hover rectangle */
921 INT iHoverTime
; /* elapsed time the cursor has been inside of the hover rect */
924 static _TRACKINGLIST TrackingList
[10];
925 static int iTrackMax
= 0;
926 static UINT_PTR timer
;
927 static const INT iTimerInterval
= 50; /* msec for timer interval */
929 /* FIXME: need to implement WM_NCMOUSELEAVE and WM_NCMOUSEHOVER for */
930 /* TrackMouseEventProc and _TrackMouseEvent */
931 static void CALLBACK
TrackMouseEventProc(HWND hwndUnused
, UINT uMsg
, UINT_PTR idEvent
,
938 INT hoverwidth
= 0, hoverheight
= 0;
941 hwnd
= WindowFromPoint(pos
);
943 SystemParametersInfoA(SPI_GETMOUSEHOVERWIDTH
, 0, &hoverwidth
, 0);
944 SystemParametersInfoA(SPI_GETMOUSEHOVERHEIGHT
, 0, &hoverheight
, 0);
946 /* loop through tracking events we are processing */
947 while (i
< iTrackMax
) {
948 /* see if this tracking event is looking for TME_LEAVE and that the */
949 /* mouse has left the window */
950 if ((TrackingList
[i
].tme
.dwFlags
& TME_LEAVE
) &&
951 (TrackingList
[i
].tme
.hwndTrack
!= hwnd
)) {
952 PostMessageA(TrackingList
[i
].tme
.hwndTrack
, WM_MOUSELEAVE
, 0, 0);
954 /* remove the TME_LEAVE flag */
955 TrackingList
[i
].tme
.dwFlags
^= TME_LEAVE
;
958 /* see if we are tracking hovering for this hwnd */
959 if(TrackingList
[i
].tme
.dwFlags
& TME_HOVER
) {
960 /* add the timer interval to the hovering time */
961 TrackingList
[i
].iHoverTime
+=iTimerInterval
;
963 /* has the cursor moved outside the rectangle centered around pos? */
964 if((abs(pos
.x
- TrackingList
[i
].pos
.x
) > (hoverwidth
/ 2.0))
965 || (abs(pos
.y
- TrackingList
[i
].pos
.y
) > (hoverheight
/ 2.0)))
967 /* record this new position as the current position and reset */
968 /* the iHoverTime variable to 0 */
969 TrackingList
[i
].pos
= pos
;
970 TrackingList
[i
].iHoverTime
= 0;
973 /* has the mouse hovered long enough? */
974 if(TrackingList
[i
].iHoverTime
<= TrackingList
[i
].tme
.dwHoverTime
)
978 ScreenToClient(hwnd
, &posClient
);
979 PostMessageW(TrackingList
[i
].tme
.hwndTrack
, WM_MOUSEHOVER
,
980 get_key_state(), MAKELPARAM( posClient
.x
, posClient
.y
));
982 /* stop tracking mouse hover */
983 TrackingList
[i
].tme
.dwFlags
^= TME_HOVER
;
987 /* see if we are still tracking TME_HOVER or TME_LEAVE for this entry */
988 if((TrackingList
[i
].tme
.dwFlags
& TME_HOVER
) ||
989 (TrackingList
[i
].tme
.dwFlags
& TME_LEAVE
)) {
991 } else { /* remove this entry from the tracking list */
992 TrackingList
[i
] = TrackingList
[--iTrackMax
];
996 /* stop the timer if the tracking list is empty */
1004 /***********************************************************************
1005 * TrackMouseEvent [USER32]
1007 * Requests notification of mouse events
1009 * During mouse tracking WM_MOUSEHOVER or WM_MOUSELEAVE events are posted
1010 * to the hwnd specified in the ptme structure. After the event message
1011 * is posted to the hwnd, the entry in the queue is removed.
1013 * If the current hwnd isn't ptme->hwndTrack the TME_HOVER flag is completely
1014 * ignored. The TME_LEAVE flag results in a WM_MOUSELEAVE message being posted
1015 * immediately and the TME_LEAVE flag being ignored.
1018 * ptme [I,O] pointer to TRACKMOUSEEVENT information structure.
1027 TrackMouseEvent (TRACKMOUSEEVENT
*ptme
)
1031 BOOL cancel
= 0, hover
= 0, leave
= 0, query
= 0;
1038 TRACE("%lx, %lx, %p, %lx\n", ptme
->cbSize
, ptme
->dwFlags
, ptme
->hwndTrack
, ptme
->dwHoverTime
);
1040 if (ptme
->cbSize
!= sizeof(TRACKMOUSEEVENT
)) {
1041 WARN("wrong TRACKMOUSEEVENT size from app\n");
1042 SetLastError(ERROR_INVALID_PARAMETER
); /* FIXME not sure if this is correct */
1046 flags
= ptme
->dwFlags
;
1048 /* if HOVER_DEFAULT was specified replace this with the systems current value */
1049 if(ptme
->dwHoverTime
== HOVER_DEFAULT
)
1050 SystemParametersInfoA(SPI_GETMOUSEHOVERTIME
, 0, &(ptme
->dwHoverTime
), 0);
1053 hwnd
= WindowFromPoint(pos
);
1055 if ( flags
& TME_CANCEL
) {
1056 flags
&= ~ TME_CANCEL
;
1060 if ( flags
& TME_HOVER
) {
1061 flags
&= ~ TME_HOVER
;
1065 if ( flags
& TME_LEAVE
) {
1066 flags
&= ~ TME_LEAVE
;
1070 /* fill the TRACKMOUSEEVENT struct with the current tracking for the given hwnd */
1071 if ( flags
& TME_QUERY
) {
1072 flags
&= ~ TME_QUERY
;
1076 /* Find the tracking list entry with the matching hwnd */
1077 while((i
< iTrackMax
) && (TrackingList
[i
].tme
.hwndTrack
!= ptme
->hwndTrack
)) {
1081 /* hwnd found, fill in the ptme struct */
1083 *ptme
= TrackingList
[i
].tme
;
1087 return TRUE
; /* return here, TME_QUERY is retrieving information */
1091 FIXME("Unknown flag(s) %08lx\n", flags
);
1094 /* find a matching hwnd if one exists */
1097 while((i
< iTrackMax
) && (TrackingList
[i
].tme
.hwndTrack
!= ptme
->hwndTrack
)) {
1102 TrackingList
[i
].tme
.dwFlags
&= ~(ptme
->dwFlags
& ~TME_CANCEL
);
1104 /* if we aren't tracking on hover or leave remove this entry */
1105 if(!((TrackingList
[i
].tme
.dwFlags
& TME_HOVER
) ||
1106 (TrackingList
[i
].tme
.dwFlags
& TME_LEAVE
)))
1108 TrackingList
[i
] = TrackingList
[--iTrackMax
];
1110 if(iTrackMax
== 0) {
1111 KillTimer(0, timer
);
1117 /* see if hwndTrack isn't the current window */
1118 if(ptme
->hwndTrack
!= hwnd
) {
1120 PostMessageA(ptme
->hwndTrack
, WM_MOUSELEAVE
, 0, 0);
1123 /* See if this hwnd is already being tracked and update the tracking flags */
1124 for(i
= 0; i
< iTrackMax
; i
++) {
1125 if(TrackingList
[i
].tme
.hwndTrack
== ptme
->hwndTrack
) {
1127 TrackingList
[i
].tme
.dwFlags
|= TME_HOVER
;
1128 TrackingList
[i
].tme
.dwHoverTime
= ptme
->dwHoverTime
;
1132 TrackingList
[i
].tme
.dwFlags
|= TME_LEAVE
;
1134 /* reset iHoverTime as per winapi specs */
1135 TrackingList
[i
].iHoverTime
= 0;
1141 /* if the tracking list is full return FALSE */
1142 if (iTrackMax
== sizeof (TrackingList
) / sizeof(*TrackingList
)) {
1146 /* Adding new mouse event to the tracking list */
1147 TrackingList
[iTrackMax
].tme
= *ptme
;
1149 /* Initialize HoverInfo variables even if not hover tracking */
1150 TrackingList
[iTrackMax
].iHoverTime
= 0;
1151 TrackingList
[iTrackMax
].pos
= pos
;
1156 timer
= SetTimer(0, 0, iTimerInterval
, TrackMouseEventProc
);