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
26 #include "wine/port.h"
35 #define NONAMELESSUNION
36 #define NONAMELESSSTRUCT
42 #include "wine/server.h"
43 #include "user_private.h"
45 #include "wine/debug.h"
48 WINE_DEFAULT_DEBUG_CHANNEL(key
);
49 WINE_DECLARE_DEBUG_CHANNEL(keyboard
);
52 /***********************************************************************
55 static WORD
get_key_state(void)
59 if (GetSystemMetrics( SM_SWAPBUTTON
))
61 if (GetAsyncKeyState(VK_RBUTTON
) & 0x80) ret
|= MK_LBUTTON
;
62 if (GetAsyncKeyState(VK_LBUTTON
) & 0x80) ret
|= MK_RBUTTON
;
66 if (GetAsyncKeyState(VK_LBUTTON
) & 0x80) ret
|= MK_LBUTTON
;
67 if (GetAsyncKeyState(VK_RBUTTON
) & 0x80) ret
|= MK_RBUTTON
;
69 if (GetAsyncKeyState(VK_MBUTTON
) & 0x80) ret
|= MK_MBUTTON
;
70 if (GetAsyncKeyState(VK_SHIFT
) & 0x80) ret
|= MK_SHIFT
;
71 if (GetAsyncKeyState(VK_CONTROL
) & 0x80) ret
|= MK_CONTROL
;
72 if (GetAsyncKeyState(VK_XBUTTON1
) & 0x80) ret
|= MK_XBUTTON1
;
73 if (GetAsyncKeyState(VK_XBUTTON2
) & 0x80) ret
|= MK_XBUTTON2
;
78 /***********************************************************************
79 * SendInput (USER32.@)
81 UINT WINAPI
SendInput( UINT count
, LPINPUT inputs
, int size
)
83 return USER_Driver
->pSendInput( count
, inputs
, size
);
87 /***********************************************************************
88 * keybd_event (USER32.@)
90 void WINAPI
keybd_event( BYTE bVk
, BYTE bScan
,
91 DWORD dwFlags
, ULONG_PTR dwExtraInfo
)
95 input
.type
= INPUT_KEYBOARD
;
97 input
.u
.ki
.wScan
= bScan
;
98 input
.u
.ki
.dwFlags
= dwFlags
;
99 input
.u
.ki
.time
= GetTickCount();
100 input
.u
.ki
.dwExtraInfo
= dwExtraInfo
;
101 SendInput( 1, &input
, sizeof(input
) );
105 /***********************************************************************
106 * mouse_event (USER32.@)
108 void WINAPI
mouse_event( DWORD dwFlags
, DWORD dx
, DWORD dy
,
109 DWORD dwData
, ULONG_PTR dwExtraInfo
)
113 input
.type
= INPUT_MOUSE
;
116 input
.u
.mi
.mouseData
= dwData
;
117 input
.u
.mi
.dwFlags
= dwFlags
;
118 input
.u
.mi
.time
= GetCurrentTime();
119 input
.u
.mi
.dwExtraInfo
= dwExtraInfo
;
120 SendInput( 1, &input
, sizeof(input
) );
124 /***********************************************************************
125 * GetCursorPos (USER32.@)
127 BOOL WINAPI
GetCursorPos( POINT
*pt
)
129 if (!pt
) return FALSE
;
130 return USER_Driver
->pGetCursorPos( pt
);
134 /***********************************************************************
135 * GetCursorInfo (USER32.@)
137 BOOL WINAPI
GetCursorInfo( PCURSORINFO pci
)
140 if (get_user_thread_info()->cursor_count
>= 0) pci
->flags
= CURSOR_SHOWING
;
142 GetCursorPos(&pci
->ptScreenPos
);
147 /***********************************************************************
148 * SetCursorPos (USER32.@)
150 BOOL WINAPI
SetCursorPos( INT x
, INT y
)
152 return USER_Driver
->pSetCursorPos( x
, y
);
156 /**********************************************************************
157 * SetCapture (USER32.@)
159 HWND WINAPI
SetCapture( HWND hwnd
)
163 SERVER_START_REQ( set_capture_window
)
167 if (!wine_server_call_err( req
))
169 previous
= reply
->previous
;
170 hwnd
= reply
->full_handle
;
175 if (previous
&& previous
!= hwnd
)
176 SendMessageW( previous
, WM_CAPTURECHANGED
, 0, (LPARAM
)hwnd
);
181 /**********************************************************************
182 * ReleaseCapture (USER32.@)
184 BOOL WINAPI
ReleaseCapture(void)
189 SERVER_START_REQ( set_capture_window
)
193 if ((ret
= !wine_server_call_err( req
))) previous
= reply
->previous
;
197 if (previous
) SendMessageW( previous
, WM_CAPTURECHANGED
, 0, 0 );
199 /* Somebody may have missed some mouse movements */
200 mouse_event( MOUSEEVENTF_MOVE
, 0, 0, 0, 0 );
206 /**********************************************************************
207 * GetCapture (USER32.@)
209 HWND WINAPI
GetCapture(void)
213 SERVER_START_REQ( get_thread_input
)
215 req
->tid
= GetCurrentThreadId();
216 if (!wine_server_call_err( req
)) ret
= reply
->capture
;
223 /**********************************************************************
224 * GetAsyncKeyState (USER32.@)
226 * Determine if a key is or was pressed. retval has high-order
227 * bit set to 1 if currently pressed, low-order bit set to 1 if key has
230 SHORT WINAPI
GetAsyncKeyState(INT nKey
)
232 return USER_Driver
->pGetAsyncKeyState( nKey
);
236 /***********************************************************************
237 * GetQueueStatus (USER32.@)
239 DWORD WINAPI
GetQueueStatus( UINT flags
)
243 if (flags
& ~(QS_ALLINPUT
| QS_ALLPOSTMESSAGE
| QS_SMRESULT
))
245 SetLastError( ERROR_INVALID_FLAGS
);
249 /* check for pending X events */
250 USER_Driver
->pMsgWaitForMultipleObjectsEx( 0, NULL
, 0, flags
, 0 );
252 SERVER_START_REQ( get_queue_status
)
255 wine_server_call( req
);
256 ret
= MAKELONG( reply
->changed_bits
& flags
, reply
->wake_bits
& flags
);
263 /***********************************************************************
264 * GetInputState (USER32.@)
266 BOOL WINAPI
GetInputState(void)
270 /* check for pending X events */
271 USER_Driver
->pMsgWaitForMultipleObjectsEx( 0, NULL
, 0, QS_INPUT
, 0 );
273 SERVER_START_REQ( get_queue_status
)
276 wine_server_call( req
);
277 ret
= reply
->wake_bits
& (QS_KEY
| QS_MOUSEBUTTON
);
284 /******************************************************************
285 * GetLastInputInfo (USER32.@)
287 BOOL WINAPI
GetLastInputInfo(PLASTINPUTINFO plii
)
293 if (plii
->cbSize
!= sizeof (*plii
) )
295 SetLastError(ERROR_INVALID_PARAMETER
);
299 SERVER_START_REQ( get_last_input_time
)
301 ret
= !wine_server_call_err( req
);
303 plii
->dwTime
= reply
->time
;
310 /**********************************************************************
311 * AttachThreadInput (USER32.@)
313 * Attaches the input processing mechanism of one thread to that of
316 BOOL WINAPI
AttachThreadInput( DWORD from
, DWORD to
, BOOL attach
)
320 SERVER_START_REQ( attach_thread_input
)
322 req
->tid_from
= from
;
324 req
->attach
= attach
;
325 ret
= !wine_server_call_err( req
);
332 /**********************************************************************
333 * GetKeyState (USER32.@)
335 * An application calls the GetKeyState function in response to a
336 * keyboard-input message. This function retrieves the state of the key
337 * at the time the input message was generated.
339 SHORT WINAPI
GetKeyState(INT vkey
)
343 SERVER_START_REQ( get_key_state
)
345 req
->tid
= GetCurrentThreadId();
347 if (!wine_server_call( req
)) retval
= (signed char)reply
->state
;
350 TRACE("key (0x%x) -> %x\n", vkey
, retval
);
355 /**********************************************************************
356 * GetKeyboardState (USER32.@)
358 BOOL WINAPI
GetKeyboardState( LPBYTE state
)
362 TRACE("(%p)\n", state
);
364 memset( state
, 0, 256 );
365 SERVER_START_REQ( get_key_state
)
367 req
->tid
= GetCurrentThreadId();
369 wine_server_set_reply( req
, state
, 256 );
370 ret
= !wine_server_call_err( req
);
377 /**********************************************************************
378 * SetKeyboardState (USER32.@)
380 BOOL WINAPI
SetKeyboardState( LPBYTE state
)
384 TRACE("(%p)\n", state
);
386 SERVER_START_REQ( set_key_state
)
388 req
->tid
= GetCurrentThreadId();
389 wine_server_add_data( req
, state
, 256 );
390 ret
= !wine_server_call_err( req
);
397 /**********************************************************************
398 * VkKeyScanA (USER32.@)
400 * VkKeyScan translates an ANSI character to a virtual-key and shift code
401 * for the current keyboard.
402 * high-order byte yields :
406 * 3-5 Shift-key combinations that are not used for characters
409 * I.e. : Shift = 1, Ctrl = 2, Alt = 4.
410 * FIXME : works ok except for dead chars :
411 * VkKeyScan '^'(0x5e, 94) ... got keycode 00 ... returning 00
412 * VkKeyScan '`'(0x60, 96) ... got keycode 00 ... returning 00
414 SHORT WINAPI
VkKeyScanA(CHAR cChar
)
418 if (IsDBCSLeadByte(cChar
)) return -1;
420 MultiByteToWideChar(CP_ACP
, 0, &cChar
, 1, &wChar
, 1);
421 return VkKeyScanW(wChar
);
424 /******************************************************************************
425 * VkKeyScanW (USER32.@)
427 SHORT WINAPI
VkKeyScanW(WCHAR cChar
)
429 return VkKeyScanExW(cChar
, GetKeyboardLayout(0));
432 /**********************************************************************
433 * VkKeyScanExA (USER32.@)
435 WORD WINAPI
VkKeyScanExA(CHAR cChar
, HKL dwhkl
)
439 if (IsDBCSLeadByte(cChar
)) return -1;
441 MultiByteToWideChar(CP_ACP
, 0, &cChar
, 1, &wChar
, 1);
442 return VkKeyScanExW(wChar
, dwhkl
);
445 /******************************************************************************
446 * VkKeyScanExW (USER32.@)
448 WORD WINAPI
VkKeyScanExW(WCHAR cChar
, HKL dwhkl
)
450 return USER_Driver
->pVkKeyScanEx(cChar
, dwhkl
);
453 /**********************************************************************
454 * OemKeyScan (USER32.@)
456 DWORD WINAPI
OemKeyScan(WORD wOemChar
)
458 TRACE("(%d)\n", wOemChar
);
462 /******************************************************************************
463 * GetKeyboardType (USER32.@)
465 INT WINAPI
GetKeyboardType(INT nTypeFlag
)
467 TRACE_(keyboard
)("(%d)\n", nTypeFlag
);
470 case 0: /* Keyboard type */
471 return 4; /* AT-101 */
472 case 1: /* Keyboard Subtype */
473 return 0; /* There are no defined subtypes */
474 case 2: /* Number of F-keys */
475 return 12; /* We're doing an 101 for now, so return 12 F-keys */
477 WARN_(keyboard
)("Unknown type\n");
478 return 0; /* The book says 0 here, so 0 */
482 /******************************************************************************
483 * MapVirtualKeyA (USER32.@)
485 UINT WINAPI
MapVirtualKeyA(UINT code
, UINT maptype
)
487 return MapVirtualKeyExA( code
, maptype
, GetKeyboardLayout(0) );
490 /******************************************************************************
491 * MapVirtualKeyW (USER32.@)
493 UINT WINAPI
MapVirtualKeyW(UINT code
, UINT maptype
)
495 return MapVirtualKeyExW(code
, maptype
, GetKeyboardLayout(0));
498 /******************************************************************************
499 * MapVirtualKeyExA (USER32.@)
501 UINT WINAPI
MapVirtualKeyExA(UINT code
, UINT maptype
, HKL hkl
)
503 return MapVirtualKeyExW(code
, maptype
, hkl
);
506 /******************************************************************************
507 * MapVirtualKeyExW (USER32.@)
509 UINT WINAPI
MapVirtualKeyExW(UINT code
, UINT maptype
, HKL hkl
)
511 TRACE_(keyboard
)("(%d, %d, %p)\n", code
, maptype
, hkl
);
513 return USER_Driver
->pMapVirtualKeyEx(code
, maptype
, hkl
);
516 /****************************************************************************
517 * GetKBCodePage (USER32.@)
519 UINT WINAPI
GetKBCodePage(void)
524 /***********************************************************************
525 * GetKeyboardLayout (USER32.@)
527 * - device handle for keyboard layout defaulted to
528 * the language id. This is the way Windows default works.
529 * - the thread identifier (dwLayout) is also ignored.
531 HKL WINAPI
GetKeyboardLayout(DWORD dwLayout
)
533 return USER_Driver
->pGetKeyboardLayout(dwLayout
);
536 /****************************************************************************
537 * GetKeyboardLayoutNameA (USER32.@)
539 BOOL WINAPI
GetKeyboardLayoutNameA(LPSTR pszKLID
)
541 WCHAR buf
[KL_NAMELENGTH
];
543 if (GetKeyboardLayoutNameW(buf
))
544 return WideCharToMultiByte( CP_ACP
, 0, buf
, -1, pszKLID
, KL_NAMELENGTH
, NULL
, NULL
) != 0;
548 /****************************************************************************
549 * GetKeyboardLayoutNameW (USER32.@)
551 BOOL WINAPI
GetKeyboardLayoutNameW(LPWSTR pwszKLID
)
553 return USER_Driver
->pGetKeyboardLayoutName(pwszKLID
);
556 /****************************************************************************
557 * GetKeyNameTextA (USER32.@)
559 INT WINAPI
GetKeyNameTextA(LONG lParam
, LPSTR lpBuffer
, INT nSize
)
564 if (!GetKeyNameTextW(lParam
, buf
, 256))
566 ret
= WideCharToMultiByte(CP_ACP
, 0, buf
, -1, lpBuffer
, nSize
, NULL
, NULL
);
575 /****************************************************************************
576 * GetKeyNameTextW (USER32.@)
578 INT WINAPI
GetKeyNameTextW(LONG lParam
, LPWSTR lpBuffer
, INT nSize
)
580 return USER_Driver
->pGetKeyNameText( lParam
, lpBuffer
, nSize
);
583 /****************************************************************************
584 * ToUnicode (USER32.@)
586 INT WINAPI
ToUnicode(UINT virtKey
, UINT scanCode
, LPBYTE lpKeyState
,
587 LPWSTR lpwStr
, int size
, UINT flags
)
589 return ToUnicodeEx(virtKey
, scanCode
, lpKeyState
, lpwStr
, size
, flags
, GetKeyboardLayout(0));
592 /****************************************************************************
593 * ToUnicodeEx (USER32.@)
595 INT WINAPI
ToUnicodeEx(UINT virtKey
, UINT scanCode
, LPBYTE lpKeyState
,
596 LPWSTR lpwStr
, int size
, UINT flags
, HKL hkl
)
598 return USER_Driver
->pToUnicodeEx(virtKey
, scanCode
, lpKeyState
, lpwStr
, size
, flags
, hkl
);
601 /****************************************************************************
604 INT WINAPI
ToAscii( UINT virtKey
, UINT scanCode
, LPBYTE lpKeyState
,
605 LPWORD lpChar
, UINT flags
)
607 return ToAsciiEx(virtKey
, scanCode
, lpKeyState
, lpChar
, flags
, GetKeyboardLayout(0));
610 /****************************************************************************
611 * ToAsciiEx (USER32.@)
613 INT WINAPI
ToAsciiEx( UINT virtKey
, UINT scanCode
, LPBYTE lpKeyState
,
614 LPWORD lpChar
, UINT flags
, HKL dwhkl
)
619 ret
= ToUnicodeEx(virtKey
, scanCode
, lpKeyState
, uni_chars
, 2, flags
, dwhkl
);
620 if (ret
< 0) n_ret
= 1; /* FIXME: make ToUnicode return 2 for dead chars */
622 WideCharToMultiByte(CP_ACP
, 0, uni_chars
, n_ret
, (LPSTR
)lpChar
, 2, NULL
, NULL
);
626 /**********************************************************************
627 * ActivateKeyboardLayout (USER32.@)
629 HKL WINAPI
ActivateKeyboardLayout(HKL hLayout
, UINT flags
)
631 TRACE_(keyboard
)("(%p, %d)\n", hLayout
, flags
);
633 return USER_Driver
->pActivateKeyboardLayout(hLayout
, flags
);
637 /***********************************************************************
638 * GetKeyboardLayoutList (USER32.@)
640 * Return number of values available if either input parm is
641 * 0, per MS documentation.
643 UINT WINAPI
GetKeyboardLayoutList(INT nBuff
, HKL
*layouts
)
645 TRACE_(keyboard
)("(%d,%p)\n",nBuff
,layouts
);
647 return USER_Driver
->pGetKeyboardLayoutList(nBuff
, layouts
);
651 /***********************************************************************
652 * RegisterHotKey (USER32.@)
654 BOOL WINAPI
RegisterHotKey(HWND hwnd
,INT id
,UINT modifiers
,UINT vk
)
656 FIXME_(keyboard
)("(%p,%d,0x%08x,%d): stub\n",hwnd
,id
,modifiers
,vk
);
660 /***********************************************************************
661 * UnregisterHotKey (USER32.@)
663 BOOL WINAPI
UnregisterHotKey(HWND hwnd
,INT id
)
665 FIXME_(keyboard
)("(%p,%d): stub\n",hwnd
,id
);
669 /***********************************************************************
670 * LoadKeyboardLayoutW (USER32.@)
672 HKL WINAPI
LoadKeyboardLayoutW(LPCWSTR pwszKLID
, UINT Flags
)
674 TRACE_(keyboard
)("(%s, %d)\n", debugstr_w(pwszKLID
), Flags
);
676 return USER_Driver
->pLoadKeyboardLayout(pwszKLID
, Flags
);
679 /***********************************************************************
680 * LoadKeyboardLayoutA (USER32.@)
682 HKL WINAPI
LoadKeyboardLayoutA(LPCSTR pwszKLID
, UINT Flags
)
685 UNICODE_STRING pwszKLIDW
;
687 if (pwszKLID
) RtlCreateUnicodeStringFromAsciiz(&pwszKLIDW
, pwszKLID
);
688 else pwszKLIDW
.Buffer
= NULL
;
690 ret
= LoadKeyboardLayoutW(pwszKLIDW
.Buffer
, Flags
);
691 RtlFreeUnicodeString(&pwszKLIDW
);
696 /***********************************************************************
697 * UnloadKeyboardLayout (USER32.@)
699 BOOL WINAPI
UnloadKeyboardLayout(HKL hkl
)
701 TRACE_(keyboard
)("(%p)\n", hkl
);
703 return USER_Driver
->pUnloadKeyboardLayout(hkl
);
706 typedef struct __TRACKINGLIST
{
708 POINT pos
; /* center of hover rectangle */
709 INT iHoverTime
; /* elapsed time the cursor has been inside of the hover rect */
712 static _TRACKINGLIST TrackingList
[10];
713 static int iTrackMax
= 0;
714 static UINT_PTR timer
;
715 static const INT iTimerInterval
= 50; /* msec for timer interval */
717 static void CALLBACK
TrackMouseEventProc(HWND hwndUnused
, UINT uMsg
, UINT_PTR idEvent
,
725 INT hoverwidth
= 0, hoverheight
= 0;
729 hwnd
= WindowFromPoint(pos
);
731 SystemParametersInfoA(SPI_GETMOUSEHOVERWIDTH
, 0, &hoverwidth
, 0);
732 SystemParametersInfoA(SPI_GETMOUSEHOVERHEIGHT
, 0, &hoverheight
, 0);
734 /* loop through tracking events we are processing */
735 while (i
< iTrackMax
) {
736 if (TrackingList
[i
].tme
.dwFlags
& TME_NONCLIENT
) {
743 /* see if this tracking event is looking for TME_LEAVE and that the */
744 /* mouse has left the window */
745 if (TrackingList
[i
].tme
.dwFlags
& TME_LEAVE
) {
746 if (TrackingList
[i
].tme
.hwndTrack
!= hwnd
) {
748 PostMessageA(TrackingList
[i
].tme
.hwndTrack
, WM_NCMOUSELEAVE
, 0, 0);
751 PostMessageA(TrackingList
[i
].tme
.hwndTrack
, WM_MOUSELEAVE
, 0, 0);
754 /* remove the TME_LEAVE flag */
755 TrackingList
[i
].tme
.dwFlags
^= TME_LEAVE
;
758 GetClientRect(hwnd
, &client
);
759 MapWindowPoints(hwnd
, NULL
, (LPPOINT
)&client
, 2);
760 if(PtInRect(&client
, pos
)) {
762 PostMessageA(TrackingList
[i
].tme
.hwndTrack
, WM_NCMOUSELEAVE
, 0, 0);
763 /* remove the TME_LEAVE flag */
764 TrackingList
[i
].tme
.dwFlags
^= TME_LEAVE
;
769 PostMessageA(TrackingList
[i
].tme
.hwndTrack
, WM_MOUSELEAVE
, 0, 0);
770 /* remove the TME_LEAVE flag */
771 TrackingList
[i
].tme
.dwFlags
^= TME_LEAVE
;
777 /* see if we are tracking hovering for this hwnd */
778 if(TrackingList
[i
].tme
.dwFlags
& TME_HOVER
) {
779 /* add the timer interval to the hovering time */
780 TrackingList
[i
].iHoverTime
+=iTimerInterval
;
782 /* has the cursor moved outside the rectangle centered around pos? */
783 if((abs(pos
.x
- TrackingList
[i
].pos
.x
) > (hoverwidth
/ 2.0))
784 || (abs(pos
.y
- TrackingList
[i
].pos
.y
) > (hoverheight
/ 2.0)))
786 /* record this new position as the current position and reset */
787 /* the iHoverTime variable to 0 */
788 TrackingList
[i
].pos
= pos
;
789 TrackingList
[i
].iHoverTime
= 0;
792 /* has the mouse hovered long enough? */
793 if(TrackingList
[i
].iHoverTime
<= TrackingList
[i
].tme
.dwHoverTime
)
797 ScreenToClient(hwnd
, &posClient
);
799 PostMessageW(TrackingList
[i
].tme
.hwndTrack
, WM_NCMOUSEHOVER
,
800 get_key_state(), MAKELPARAM( posClient
.x
, posClient
.y
));
803 PostMessageW(TrackingList
[i
].tme
.hwndTrack
, WM_MOUSEHOVER
,
804 get_key_state(), MAKELPARAM( posClient
.x
, posClient
.y
));
807 /* stop tracking mouse hover */
808 TrackingList
[i
].tme
.dwFlags
^= TME_HOVER
;
812 /* see if we are still tracking TME_HOVER or TME_LEAVE for this entry */
813 if((TrackingList
[i
].tme
.dwFlags
& TME_HOVER
) ||
814 (TrackingList
[i
].tme
.dwFlags
& TME_LEAVE
)) {
816 } else { /* remove this entry from the tracking list */
817 TrackingList
[i
] = TrackingList
[--iTrackMax
];
821 /* stop the timer if the tracking list is empty */
829 /***********************************************************************
830 * TrackMouseEvent [USER32]
832 * Requests notification of mouse events
834 * During mouse tracking WM_MOUSEHOVER or WM_MOUSELEAVE events are posted
835 * to the hwnd specified in the ptme structure. After the event message
836 * is posted to the hwnd, the entry in the queue is removed.
838 * If the current hwnd isn't ptme->hwndTrack the TME_HOVER flag is completely
839 * ignored. The TME_LEAVE flag results in a WM_MOUSELEAVE message being posted
840 * immediately and the TME_LEAVE flag being ignored.
843 * ptme [I,O] pointer to TRACKMOUSEEVENT information structure.
852 TrackMouseEvent (TRACKMOUSEEVENT
*ptme
)
856 BOOL cancel
= 0, hover
= 0, leave
= 0, query
= 0, nonclient
= 0, inclient
= 0;
864 SetRectEmpty(&client
);
866 TRACE("%lx, %lx, %p, %lx\n", ptme
->cbSize
, ptme
->dwFlags
, ptme
->hwndTrack
, ptme
->dwHoverTime
);
868 if (ptme
->cbSize
!= sizeof(TRACKMOUSEEVENT
)) {
869 WARN("wrong TRACKMOUSEEVENT size from app\n");
870 SetLastError(ERROR_INVALID_PARAMETER
); /* FIXME not sure if this is correct */
874 flags
= ptme
->dwFlags
;
876 /* if HOVER_DEFAULT was specified replace this with the systems current value */
877 if(ptme
->dwHoverTime
== HOVER_DEFAULT
)
878 SystemParametersInfoA(SPI_GETMOUSEHOVERTIME
, 0, &(ptme
->dwHoverTime
), 0);
881 hwnd
= WindowFromPoint(pos
);
883 if ( flags
& TME_CANCEL
) {
884 flags
&= ~ TME_CANCEL
;
888 if ( flags
& TME_HOVER
) {
889 flags
&= ~ TME_HOVER
;
893 if ( flags
& TME_LEAVE
) {
894 flags
&= ~ TME_LEAVE
;
898 if ( flags
& TME_NONCLIENT
) {
899 flags
&= ~ TME_NONCLIENT
;
903 /* fill the TRACKMOUSEEVENT struct with the current tracking for the given hwnd */
904 if ( flags
& TME_QUERY
) {
905 flags
&= ~ TME_QUERY
;
909 /* Find the tracking list entry with the matching hwnd */
910 while((i
< iTrackMax
) && (TrackingList
[i
].tme
.hwndTrack
!= ptme
->hwndTrack
)) {
914 /* hwnd found, fill in the ptme struct */
916 *ptme
= TrackingList
[i
].tme
;
920 return TRUE
; /* return here, TME_QUERY is retrieving information */
924 FIXME("Unknown flag(s) %08lx\n", flags
);
927 /* find a matching hwnd if one exists */
930 while((i
< iTrackMax
) && (TrackingList
[i
].tme
.hwndTrack
!= ptme
->hwndTrack
)) {
935 TrackingList
[i
].tme
.dwFlags
&= ~(ptme
->dwFlags
& ~TME_CANCEL
);
937 /* if we aren't tracking on hover or leave remove this entry */
938 if(!((TrackingList
[i
].tme
.dwFlags
& TME_HOVER
) ||
939 (TrackingList
[i
].tme
.dwFlags
& TME_LEAVE
)))
941 TrackingList
[i
] = TrackingList
[--iTrackMax
];
950 /* see if hwndTrack isn't the current window */
951 if(ptme
->hwndTrack
!= hwnd
) {
954 PostMessageA(ptme
->hwndTrack
, WM_NCMOUSELEAVE
, 0, 0);
957 PostMessageA(ptme
->hwndTrack
, WM_MOUSELEAVE
, 0, 0);
961 GetClientRect(ptme
->hwndTrack
, &client
);
962 MapWindowPoints(ptme
->hwndTrack
, NULL
, (LPPOINT
)&client
, 2);
963 if(PtInRect(&client
, pos
)) {
966 if(nonclient
&& inclient
) {
967 PostMessageA(ptme
->hwndTrack
, WM_NCMOUSELEAVE
, 0, 0);
970 else if(!nonclient
&& !inclient
) {
971 PostMessageA(ptme
->hwndTrack
, WM_MOUSELEAVE
, 0, 0);
975 /* See if this hwnd is already being tracked and update the tracking flags */
976 for(i
= 0; i
< iTrackMax
; i
++) {
977 if(TrackingList
[i
].tme
.hwndTrack
== ptme
->hwndTrack
) {
978 TrackingList
[i
].tme
.dwFlags
= 0;
981 TrackingList
[i
].tme
.dwFlags
|= TME_HOVER
;
982 TrackingList
[i
].tme
.dwHoverTime
= ptme
->dwHoverTime
;
986 TrackingList
[i
].tme
.dwFlags
|= TME_LEAVE
;
989 TrackingList
[i
].tme
.dwFlags
|= TME_NONCLIENT
;
991 /* reset iHoverTime as per winapi specs */
992 TrackingList
[i
].iHoverTime
= 0;
998 /* if the tracking list is full return FALSE */
999 if (iTrackMax
== sizeof (TrackingList
) / sizeof(*TrackingList
)) {
1003 /* Adding new mouse event to the tracking list */
1004 TrackingList
[iTrackMax
].tme
= *ptme
;
1006 /* Initialize HoverInfo variables even if not hover tracking */
1007 TrackingList
[iTrackMax
].iHoverTime
= 0;
1008 TrackingList
[iTrackMax
].pos
= pos
;
1013 timer
= SetTimer(0, 0, iTimerInterval
, TrackMouseEventProc
);