2 * Windows hook functions
4 * Copyright 2002 Alexandre Julliard
5 * Copyright 2005 Dmitry Timoshkov
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 * Status of the various hooks:
24 * WH_JOURNALRECORD Partially implemented
25 * WH_JOURNALPLAYBACK Partially implemented
27 * WH_GETMESSAGE OK (FIXME: A/W mapping?)
28 * WH_CALLWNDPROC OK (FIXME: A/W mapping?)
36 * HCBT_CLICKSKIPPED OK
42 * WH_HARDWARE Not supported in Win32
43 * WH_DEBUG Not implemented
45 * HSHELL_WINDOWCREATED OK
46 * HSHELL_WINDOWDESTROYED OK
47 * HSHELL_ACTIVATESHELLWINDOW Not implemented
48 * HSHELL_WINDOWACTIVATED Not implemented
49 * HSHELL_GETMINRECT Not implemented
50 * HSHELL_REDRAW Not implemented
51 * HSHELL_TASKMAN Not implemented
52 * HSHELL_LANGUAGE Not implemented
53 * HSHELL_SYSMENU Not implemented
54 * HSHELL_ENDTASK Not implemented
55 * HSHELL_ACCESSIBILITYSTATE Not implemented
56 * HSHELL_APPCOMMAND Not implemented
57 * HSHELL_WINDOWREPLACED Not implemented
58 * HSHELL_WINDOWREPLACING Not implemented
59 * WH_FOREGROUNDIDLE Not implemented
60 * WH_CALLWNDPROCRET OK (FIXME: A/W mapping?)
61 * WH_KEYBOARD_LL Implemented but should use SendMessage instead
62 * WH_MOUSE_LL Implemented but should use SendMessage instead
66 #include "wine/port.h"
76 #include "user_private.h"
77 #include "wine/server.h"
78 #include "wine/unicode.h"
79 #include "wine/debug.h"
82 WINE_DEFAULT_DEBUG_CHANNEL(hook
);
83 WINE_DECLARE_DEBUG_CHANNEL(relay
);
91 BOOL prev_unicode
, next_unicode
;
92 WCHAR module
[MAX_PATH
];
95 #define WH_WINEVENT (WH_MAXHOOK+1)
97 static const char * const hook_names
[WH_WINEVENT
- WH_MINHOOK
+ 1] =
101 "WH_JOURNALPLAYBACK",
119 /***********************************************************************
120 * get_ll_hook_timeout
123 static UINT
get_ll_hook_timeout(void)
125 /* FIXME: should retrieve LowLevelHooksTimeout in HKEY_CURRENT_USER\Control Panel\Desktop */
130 /***********************************************************************
133 * Implementation of SetWindowsHookExA and SetWindowsHookExW.
135 static HHOOK
set_windows_hook( INT id
, HOOKPROC proc
, HINSTANCE inst
, DWORD tid
, BOOL unicode
)
138 WCHAR module
[MAX_PATH
];
143 SetLastError( ERROR_INVALID_FILTER_PROC
);
147 /* FIXME: what if the tid belongs to another process? */
148 if (tid
) /* thread-local hook */
150 if (id
== WH_JOURNALRECORD
||
151 id
== WH_JOURNALPLAYBACK
||
152 id
== WH_KEYBOARD_LL
||
154 id
== WH_SYSMSGFILTER
)
156 /* these can only be global */
157 SetLastError( ERROR_INVALID_PARAMETER
);
162 else /* system-global hook */
164 if (id
== WH_KEYBOARD_LL
|| id
== WH_MOUSE_LL
) inst
= 0;
165 else if (!inst
|| !(len
= GetModuleFileNameW( inst
, module
, MAX_PATH
)) || len
>= MAX_PATH
)
167 SetLastError( ERROR_HOOK_NEEDS_HMOD
);
172 SERVER_START_REQ( set_hook
)
177 req
->event_min
= EVENT_MIN
;
178 req
->event_max
= EVENT_MAX
;
179 req
->flags
= WINEVENT_INCONTEXT
;
180 req
->unicode
= unicode
;
181 if (inst
) /* make proc relative to the module base */
183 req
->proc
= (void *)((char *)proc
- (char *)inst
);
184 wine_server_add_data( req
, module
, strlenW(module
) * sizeof(WCHAR
) );
186 else req
->proc
= proc
;
188 if (!wine_server_call_err( req
))
190 handle
= reply
->handle
;
191 get_user_thread_info()->active_hooks
= reply
->active_hooks
;
196 TRACE( "%s %p %x -> %p\n", hook_names
[id
-WH_MINHOOK
], proc
, tid
, handle
);
201 /***********************************************************************
204 static LRESULT
call_hook_AtoW( HOOKPROC proc
, INT id
, INT code
, WPARAM wparam
, LPARAM lparam
)
207 UNICODE_STRING usBuffer
;
208 if (id
!= WH_CBT
|| code
!= HCBT_CREATEWND
) ret
= proc( code
, wparam
, lparam
);
211 CBT_CREATEWNDA
*cbtcwA
= (CBT_CREATEWNDA
*)lparam
;
212 CBT_CREATEWNDW cbtcwW
;
216 cbtcwW
.hwndInsertAfter
= cbtcwA
->hwndInsertAfter
;
217 csW
= *(CREATESTRUCTW
*)cbtcwA
->lpcs
;
219 if (HIWORD(cbtcwA
->lpcs
->lpszName
))
221 RtlCreateUnicodeStringFromAsciiz(&usBuffer
,cbtcwA
->lpcs
->lpszName
);
222 csW
.lpszName
= usBuffer
.Buffer
;
224 if (HIWORD(cbtcwA
->lpcs
->lpszClass
))
226 RtlCreateUnicodeStringFromAsciiz(&usBuffer
,cbtcwA
->lpcs
->lpszClass
);
227 csW
.lpszClass
= usBuffer
.Buffer
;
229 ret
= proc( code
, wparam
, (LPARAM
)&cbtcwW
);
230 cbtcwA
->hwndInsertAfter
= cbtcwW
.hwndInsertAfter
;
231 if (HIWORD(csW
.lpszName
)) HeapFree( GetProcessHeap(), 0, (LPWSTR
)csW
.lpszName
);
232 if (HIWORD(csW
.lpszClass
)) HeapFree( GetProcessHeap(), 0, (LPWSTR
)csW
.lpszClass
);
238 /***********************************************************************
241 static LRESULT
call_hook_WtoA( HOOKPROC proc
, INT id
, INT code
, WPARAM wparam
, LPARAM lparam
)
245 if (id
!= WH_CBT
|| code
!= HCBT_CREATEWND
) ret
= proc( code
, wparam
, lparam
);
248 CBT_CREATEWNDW
*cbtcwW
= (CBT_CREATEWNDW
*)lparam
;
249 CBT_CREATEWNDA cbtcwA
;
254 cbtcwA
.hwndInsertAfter
= cbtcwW
->hwndInsertAfter
;
255 csA
= *(CREATESTRUCTA
*)cbtcwW
->lpcs
;
257 if (HIWORD(cbtcwW
->lpcs
->lpszName
)) {
258 len
= WideCharToMultiByte( CP_ACP
, 0, cbtcwW
->lpcs
->lpszName
, -1, NULL
, 0, NULL
, NULL
);
259 csA
.lpszName
= HeapAlloc( GetProcessHeap(), 0, len
*sizeof(CHAR
) );
260 WideCharToMultiByte( CP_ACP
, 0, cbtcwW
->lpcs
->lpszName
, -1, (LPSTR
)csA
.lpszName
, len
, NULL
, NULL
);
263 if (HIWORD(cbtcwW
->lpcs
->lpszClass
)) {
264 len
= WideCharToMultiByte( CP_ACP
, 0, cbtcwW
->lpcs
->lpszClass
, -1, NULL
, 0, NULL
, NULL
);
265 csA
.lpszClass
= HeapAlloc( GetProcessHeap(), 0, len
*sizeof(CHAR
) );
266 WideCharToMultiByte( CP_ACP
, 0, cbtcwW
->lpcs
->lpszClass
, -1, (LPSTR
)csA
.lpszClass
, len
, NULL
, NULL
);
269 ret
= proc( code
, wparam
, (LPARAM
)&cbtcwA
);
270 cbtcwW
->hwndInsertAfter
= cbtcwA
.hwndInsertAfter
;
271 if (HIWORD(csA
.lpszName
)) HeapFree( GetProcessHeap(), 0, (LPSTR
)csA
.lpszName
);
272 if (HIWORD(csA
.lpszClass
)) HeapFree( GetProcessHeap(), 0, (LPSTR
)csA
.lpszClass
);
278 /***********************************************************************
281 static LRESULT
call_hook_proc( HOOKPROC proc
, INT id
, INT code
, WPARAM wparam
, LPARAM lparam
,
282 BOOL prev_unicode
, BOOL next_unicode
)
287 DPRINTF( "%04x:Call hook proc %p (id=%s,code=%x,wp=%08x,lp=%08lx)\n",
288 GetCurrentThreadId(), proc
, hook_names
[id
-WH_MINHOOK
], code
, wparam
, lparam
);
290 if (!prev_unicode
== !next_unicode
) ret
= proc( code
, wparam
, lparam
);
291 else if (prev_unicode
) ret
= call_hook_WtoA( proc
, id
, code
, wparam
, lparam
);
292 else ret
= call_hook_AtoW( proc
, id
, code
, wparam
, lparam
);
295 DPRINTF( "%04x:Ret hook proc %p (id=%s,code=%x,wp=%08x,lp=%08lx) retval=%08lx\n",
296 GetCurrentThreadId(), proc
, hook_names
[id
-WH_MINHOOK
], code
, wparam
, lparam
, ret
);
302 /***********************************************************************
305 * Retrieve the hook procedure real value for a module-relative proc
307 static void *get_hook_proc( void *proc
, const WCHAR
*module
)
311 if (!(mod
= GetModuleHandleW(module
)))
313 TRACE( "loading %s\n", debugstr_w(module
) );
314 /* FIXME: the library will never be freed */
315 if (!(mod
= LoadLibraryW(module
))) return NULL
;
317 return (char *)mod
+ (ULONG_PTR
)proc
;
320 /***********************************************************************
323 * Call hook either in current thread or send message to the destination
326 static LRESULT
call_hook( struct hook_info
*info
, INT code
, WPARAM wparam
, LPARAM lparam
)
332 struct hook_extra_info h_extra
;
333 h_extra
.handle
= info
->handle
;
334 h_extra
.lparam
= lparam
;
336 TRACE( "calling hook in thread %04x %s code %x wp %x lp %lx\n",
337 info
->tid
, hook_names
[info
->id
-WH_MINHOOK
], code
, wparam
, lparam
);
342 MSG_SendInternalMessageTimeout( info
->pid
, info
->tid
, WM_WINE_KEYBOARD_LL_HOOK
,
343 wparam
, (LPARAM
)&h_extra
, SMTO_ABORTIFHUNG
,
344 get_ll_hook_timeout(), &ret
);
347 MSG_SendInternalMessageTimeout( info
->pid
, info
->tid
, WM_WINE_MOUSE_LL_HOOK
,
348 wparam
, (LPARAM
)&h_extra
, SMTO_ABORTIFHUNG
,
349 get_ll_hook_timeout(), &ret
);
352 ERR("Unknown hook id %d\n", info
->id
);
359 TRACE( "calling hook %p %s code %x wp %x lp %lx module %s\n",
360 info
->proc
, hook_names
[info
->id
-WH_MINHOOK
], code
, wparam
,
361 lparam
, debugstr_w(info
->module
) );
363 if (!info
->module
[0] ||
364 (info
->proc
= get_hook_proc( info
->proc
, info
->module
)) != NULL
)
366 struct user_thread_info
*thread_info
= get_user_thread_info();
367 HHOOK prev
= thread_info
->hook
;
368 BOOL prev_unicode
= thread_info
->hook_unicode
;
370 thread_info
->hook
= info
->handle
;
371 thread_info
->hook_unicode
= info
->next_unicode
;
372 ret
= call_hook_proc( (HOOKPROC
)info
->proc
, info
->id
, code
, wparam
, lparam
,
373 info
->prev_unicode
, info
->next_unicode
);
374 thread_info
->hook
= prev
;
375 thread_info
->hook_unicode
= prev_unicode
;
381 /***********************************************************************
384 LRESULT
HOOK_CallHooks( INT id
, INT code
, WPARAM wparam
, LPARAM lparam
, BOOL unicode
)
386 struct user_thread_info
*thread_info
= get_user_thread_info();
387 struct hook_info info
;
392 if (!HOOK_IsHooked( id
))
394 TRACE( "skipping hook %s mask %x\n", hook_names
[id
-WH_MINHOOK
], thread_info
->active_hooks
);
398 ZeroMemory( &info
, sizeof(info
) - sizeof(info
.module
) );
399 info
.prev_unicode
= unicode
;
402 SERVER_START_REQ( start_hook_chain
)
405 req
->event
= EVENT_MIN
;
406 wine_server_set_reply( req
, info
.module
, sizeof(info
.module
)-sizeof(WCHAR
) );
407 if (!wine_server_call( req
))
409 info
.module
[wine_server_reply_size(req
) / sizeof(WCHAR
)] = 0;
410 info
.handle
= reply
->handle
;
411 info
.pid
= reply
->pid
;
412 info
.tid
= reply
->tid
;
413 info
.proc
= reply
->proc
;
414 info
.next_unicode
= reply
->unicode
;
415 thread_info
->active_hooks
= reply
->active_hooks
;
420 if (!info
.tid
&& !info
.proc
) return 0;
421 ret
= call_hook( &info
, code
, wparam
, lparam
);
423 SERVER_START_REQ( finish_hook_chain
)
426 wine_server_call( req
);
433 /***********************************************************************
436 BOOL
HOOK_IsHooked( INT id
)
438 struct user_thread_info
*thread_info
= get_user_thread_info();
440 if (!thread_info
->active_hooks
) return TRUE
;
441 return (thread_info
->active_hooks
& (1 << (id
- WH_MINHOOK
))) != 0;
445 /***********************************************************************
446 * SetWindowsHookA (USER32.@)
448 HHOOK WINAPI
SetWindowsHookA( INT id
, HOOKPROC proc
)
450 return SetWindowsHookExA( id
, proc
, 0, GetCurrentThreadId() );
454 /***********************************************************************
455 * SetWindowsHookW (USER32.@)
457 HHOOK WINAPI
SetWindowsHookW( INT id
, HOOKPROC proc
)
459 return SetWindowsHookExW( id
, proc
, 0, GetCurrentThreadId() );
463 /***********************************************************************
464 * SetWindowsHookExA (USER32.@)
466 HHOOK WINAPI
SetWindowsHookExA( INT id
, HOOKPROC proc
, HINSTANCE inst
, DWORD tid
)
468 return set_windows_hook( id
, proc
, inst
, tid
, FALSE
);
471 /***********************************************************************
472 * SetWindowsHookExW (USER32.@)
474 HHOOK WINAPI
SetWindowsHookExW( INT id
, HOOKPROC proc
, HINSTANCE inst
, DWORD tid
)
476 return set_windows_hook( id
, proc
, inst
, tid
, TRUE
);
480 /***********************************************************************
481 * UnhookWindowsHook (USER32.@)
483 BOOL WINAPI
UnhookWindowsHook( INT id
, HOOKPROC proc
)
487 TRACE( "%s %p\n", hook_names
[id
-WH_MINHOOK
], proc
);
489 SERVER_START_REQ( remove_hook
)
494 ret
= !wine_server_call_err( req
);
495 if (ret
) get_user_thread_info()->active_hooks
= reply
->active_hooks
;
498 if (!ret
&& GetLastError() == ERROR_INVALID_HANDLE
) SetLastError( ERROR_INVALID_HOOK_HANDLE
);
504 /***********************************************************************
505 * UnhookWindowsHookEx (USER32.@)
507 BOOL WINAPI
UnhookWindowsHookEx( HHOOK hhook
)
511 TRACE( "%p\n", hhook
);
513 SERVER_START_REQ( remove_hook
)
517 ret
= !wine_server_call_err( req
);
518 if (ret
) get_user_thread_info()->active_hooks
= reply
->active_hooks
;
521 if (!ret
&& GetLastError() == ERROR_INVALID_HANDLE
) SetLastError( ERROR_INVALID_HOOK_HANDLE
);
526 /***********************************************************************
527 * CallNextHookEx (USER32.@)
529 LRESULT WINAPI
CallNextHookEx( HHOOK hhook
, INT code
, WPARAM wparam
, LPARAM lparam
)
531 struct user_thread_info
*thread_info
= get_user_thread_info();
532 struct hook_info info
;
534 ZeroMemory( &info
, sizeof(info
) - sizeof(info
.module
) );
536 SERVER_START_REQ( get_hook_info
)
538 req
->handle
= thread_info
->hook
;
540 req
->event
= EVENT_MIN
;
541 wine_server_set_reply( req
, info
.module
, sizeof(info
.module
)-sizeof(WCHAR
) );
542 if (!wine_server_call_err( req
))
544 info
.module
[wine_server_reply_size(req
) / sizeof(WCHAR
)] = 0;
545 info
.handle
= reply
->handle
;
547 info
.pid
= reply
->pid
;
548 info
.tid
= reply
->tid
;
549 info
.proc
= reply
->proc
;
550 info
.next_unicode
= reply
->unicode
;
555 info
.prev_unicode
= thread_info
->hook_unicode
;
556 return call_hook( &info
, code
, wparam
, lparam
);
560 LRESULT
call_current_hook( HHOOK hhook
, INT code
, WPARAM wparam
, LPARAM lparam
)
562 struct hook_info info
;
564 ZeroMemory( &info
, sizeof(info
) - sizeof(info
.module
) );
566 SERVER_START_REQ( get_hook_info
)
570 req
->event
= EVENT_MIN
;
571 wine_server_set_reply( req
, info
.module
, sizeof(info
.module
)-sizeof(WCHAR
) );
572 if (!wine_server_call_err( req
))
574 info
.module
[wine_server_reply_size(req
) / sizeof(WCHAR
)] = 0;
575 info
.handle
= reply
->handle
;
577 info
.pid
= reply
->pid
;
578 info
.tid
= reply
->tid
;
579 info
.proc
= reply
->proc
;
580 info
.next_unicode
= reply
->unicode
;
585 info
.prev_unicode
= TRUE
; /* assume Unicode for this function */
586 return call_hook( &info
, code
, wparam
, lparam
);
589 /***********************************************************************
590 * CallMsgFilterA (USER32.@)
592 BOOL WINAPI
CallMsgFilterA( LPMSG msg
, INT code
)
594 if (HOOK_CallHooks( WH_SYSMSGFILTER
, code
, 0, (LPARAM
)msg
, FALSE
)) return TRUE
;
595 return HOOK_CallHooks( WH_MSGFILTER
, code
, 0, (LPARAM
)msg
, FALSE
);
599 /***********************************************************************
600 * CallMsgFilterW (USER32.@)
602 BOOL WINAPI
CallMsgFilterW( LPMSG msg
, INT code
)
604 if (HOOK_CallHooks( WH_SYSMSGFILTER
, code
, 0, (LPARAM
)msg
, TRUE
)) return TRUE
;
605 return HOOK_CallHooks( WH_MSGFILTER
, code
, 0, (LPARAM
)msg
, TRUE
);
609 /***********************************************************************
610 * SetWinEventHook [USER32.@]
612 * Set up an event hook for a set of events.
615 * event_min [I] Lowest event handled by pfnProc
616 * event_max [I] Highest event handled by pfnProc
617 * inst [I] DLL containing pfnProc
618 * proc [I] Callback event hook function
619 * pid [I] Process to get events from, or 0 for all processes
620 * tid [I] Thread to get events from, or 0 for all threads
621 * flags [I] Flags indicating the status of pfnProc
624 * Success: A handle representing the hook.
625 * Failure: A NULL handle.
627 HWINEVENTHOOK WINAPI
SetWinEventHook(DWORD event_min
, DWORD event_max
,
628 HMODULE inst
, WINEVENTPROC proc
,
629 DWORD pid
, DWORD tid
, DWORD flags
)
631 HWINEVENTHOOK handle
= 0;
632 WCHAR module
[MAX_PATH
];
635 TRACE("%d,%d,%p,%p,%08x,%04x,%08x\n", event_min
, event_max
, inst
,
636 proc
, pid
, tid
, flags
);
640 if (!(len
= GetModuleFileNameW(inst
, module
, MAX_PATH
)) || len
>= MAX_PATH
)
644 if ((flags
& WINEVENT_INCONTEXT
) && !inst
)
646 SetLastError(ERROR_HOOK_NEEDS_HMOD
);
650 if (event_min
> event_max
)
652 SetLastError(ERROR_INVALID_HOOK_FILTER
);
656 /* FIXME: what if the tid or pid belongs to another process? */
657 if (tid
) /* thread-local hook */
660 SERVER_START_REQ( set_hook
)
662 req
->id
= WH_WINEVENT
;
665 req
->event_min
= event_min
;
666 req
->event_max
= event_max
;
669 if (inst
) /* make proc relative to the module base */
671 req
->proc
= (void *)((char *)proc
- (char *)inst
);
672 wine_server_add_data( req
, module
, strlenW(module
) * sizeof(WCHAR
) );
674 else req
->proc
= proc
;
676 if (!wine_server_call_err( req
))
678 handle
= reply
->handle
;
679 get_user_thread_info()->active_hooks
= reply
->active_hooks
;
684 TRACE("-> %p\n", handle
);
689 /***********************************************************************
690 * UnhookWinEvent [USER32.@]
692 * Remove an event hook for a set of events.
695 * hEventHook [I] Event hook to remove
698 * Success: TRUE. The event hook has been removed.
699 * Failure: FALSE, if hEventHook is invalid.
701 BOOL WINAPI
UnhookWinEvent(HWINEVENTHOOK hEventHook
)
705 TRACE( "%p\n", hEventHook
);
707 SERVER_START_REQ( remove_hook
)
709 req
->handle
= hEventHook
;
710 req
->id
= WH_WINEVENT
;
711 ret
= !wine_server_call_err( req
);
712 if (ret
) get_user_thread_info()->active_hooks
= reply
->active_hooks
;
718 inline static BOOL
find_first_hook(DWORD id
, DWORD event
, HWND hwnd
, LONG object_id
,
719 LONG child_id
, struct hook_info
*info
)
721 struct user_thread_info
*thread_info
= get_user_thread_info();
724 if (!HOOK_IsHooked( id
))
726 TRACE( "skipping hook %s mask %x\n", hook_names
[id
-WH_MINHOOK
], thread_info
->active_hooks
);
730 SERVER_START_REQ( start_hook_chain
)
735 req
->object_id
= object_id
;
736 req
->child_id
= child_id
;
737 wine_server_set_reply( req
, info
->module
, sizeof(info
->module
)-sizeof(WCHAR
) );
738 ret
= !wine_server_call( req
);
741 info
->module
[wine_server_reply_size(req
) / sizeof(WCHAR
)] = 0;
742 info
->handle
= reply
->handle
;
743 info
->proc
= reply
->proc
;
744 info
->tid
= reply
->tid
;
745 thread_info
->active_hooks
= reply
->active_hooks
;
749 return ret
&& (info
->tid
|| info
->proc
);
752 inline static BOOL
find_next_hook(DWORD event
, HWND hwnd
, LONG object_id
,
753 LONG child_id
, struct hook_info
*info
)
757 SERVER_START_REQ( get_hook_info
)
759 req
->handle
= info
->handle
;
763 req
->object_id
= object_id
;
764 req
->child_id
= child_id
;
765 wine_server_set_reply( req
, info
->module
, sizeof(info
->module
)-sizeof(WCHAR
) );
766 ret
= !wine_server_call( req
);
769 info
->module
[wine_server_reply_size(req
) / sizeof(WCHAR
)] = 0;
770 info
->handle
= reply
->handle
;
771 info
->proc
= reply
->proc
;
772 info
->tid
= reply
->tid
;
779 inline static void find_hook_close(DWORD id
)
781 SERVER_START_REQ( finish_hook_chain
)
784 wine_server_call( req
);
789 /***********************************************************************
790 * NotifyWinEvent [USER32.@]
792 * Inform the OS that an event has occurred.
795 * event [I] Id of the event
796 * hwnd [I] Window holding the object that created the event
797 * object_id [I] Type of object that created the event
798 * child_id [I] Child object of nId, or CHILDID_SELF.
803 void WINAPI
NotifyWinEvent(DWORD event
, HWND hwnd
, LONG object_id
, LONG child_id
)
805 struct hook_info info
;
807 TRACE("%04x,%p,%d,%d\n", event
, hwnd
, object_id
, child_id
);
811 SetLastError(ERROR_INVALID_WINDOW_HANDLE
);
818 if (event
& 0x80000000)
820 /* FIXME: on 64-bit platforms we need to invent some other way for
821 * passing parameters, nId and nChildId can't hold full [W|L]PARAM.
822 * struct call_hook *hook = (LRESULT *)hWnd;
823 * wparam = hook->wparam;
824 * lparam = hook->lparam;
826 LRESULT
*ret
= (LRESULT
*)hwnd
;
827 INT id
, code
, unicode
;
829 id
= (dwEvent
& 0x7fff0000) >> 16;
830 code
= event
& 0x7fff;
831 unicode
= event
& 0x8000;
832 *ret
= HOOK_CallHooks(id
, code
, object_id
, child_id
, unicode
);
837 if (!find_first_hook(WH_WINEVENT
, event
, hwnd
, object_id
, child_id
, &info
)) return;
843 TRACE( "calling WH_WINEVENT hook %p event %x hwnd %p %x %x module %s\n",
844 info
.proc
, event
, hwnd
, object_id
, child_id
, debugstr_w(info
.module
) );
846 if (!info
.module
[0] || (info
.proc
= get_hook_proc( info
.proc
, info
.module
)) != NULL
)
849 DPRINTF( "%04x:Call winevent hook proc %p (hhook=%p,event=%x,hwnd=%p,object_id=%x,child_id=%x,tid=%04x,time=%x)\n",
850 GetCurrentThreadId(), info
.proc
, info
.handle
, event
, hwnd
, object_id
,
851 child_id
, GetCurrentThreadId(), GetCurrentTime());
853 info
.proc(info
.handle
, event
, hwnd
, object_id
, child_id
,
854 GetCurrentThreadId(), GetCurrentTime());
857 DPRINTF( "%04x:Ret winevent hook proc %p (hhook=%p,event=%x,hwnd=%p,object_id=%x,child_id=%x,tid=%04x,time=%x)\n",
858 GetCurrentThreadId(), info
.proc
, info
.handle
, event
, hwnd
, object_id
,
859 child_id
, GetCurrentThreadId(), GetCurrentTime());
865 while (find_next_hook(event
, hwnd
, object_id
, child_id
, &info
));
867 find_hook_close(WH_WINEVENT
);
871 /***********************************************************************
872 * IsWinEventHookInstalled [USER32.@]
874 * Determine if an event hook is installed for an event.
877 * dwEvent [I] Id of the event
880 * TRUE, If there are any hooks installed for the event.
886 BOOL WINAPI
IsWinEventHookInstalled(DWORD dwEvent
)
888 FIXME("(%d)-stub!\n", dwEvent
);