git.oblomov.eu Git - wine/blob - dlls/user/hook.c

   1 /*
   2  * Windows hook functions
   3  *
   4  * Copyright 2002 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * NOTES:
  21  *   Status of the various hooks:
  22  *     WH_MSGFILTER                 OK
  23  *     WH_JOURNALRECORD             Partially implemented
  24  *     WH_JOURNALPLAYBACK           Partially implemented
  25  *     WH_KEYBOARD                  OK
  26  *     WH_GETMESSAGE                OK (FIXME: A/W mapping?)
  27  *     WH_CALLWNDPROC               OK (FIXME: A/W mapping?)
  28  *     WH_CBT
  29  *       HCBT_MOVESIZE              OK
  30  *       HCBT_MINMAX                OK
  31  *       HCBT_QS                    OK
  32  *       HCBT_CREATEWND             OK
  33  *       HCBT_DESTROYWND            OK
  34  *       HCBT_ACTIVATE              OK
  35  *       HCBT_CLICKSKIPPED          OK
  36  *       HCBT_KEYSKIPPED            OK
  37  *       HCBT_SYSCOMMAND            OK
  38  *       HCBT_SETFOCUS              OK
  39  *     WH_SYSMSGFILTER              OK
  40  *     WH_MOUSE                     OK
  41  *     WH_HARDWARE                  Not supported in Win32
  42  *     WH_DEBUG                     Not implemented
  43  *     WH_SHELL
  44  *       HSHELL_WINDOWCREATED       OK
  45  *       HSHELL_WINDOWDESTROYED     OK
  46  *       HSHELL_ACTIVATESHELLWINDOW Not implemented
  47  *       HSHELL_WINDOWACTIVATED     Not implemented
  48  *       HSHELL_GETMINRECT          Not implemented
  49  *       HSHELL_REDRAW              Not implemented
  50  *       HSHELL_TASKMAN             Not implemented
  51  *       HSHELL_LANGUAGE            Not implemented
  52  *       HSHELL_SYSMENU             Not implemented
  53  *       HSHELL_ENDTASK             Not implemented
  54  *       HSHELL_ACCESSIBILITYSTATE  Not implemented
  55  *       HSHELL_APPCOMMAND          Not implemented
  56  *       HSHELL_WINDOWREPLACED      Not implemented
  57  *       HSHELL_WINDOWREPLACING     Not implemented
  58  *     WH_FOREGROUNDIDLE            Not implemented
  59  *     WH_CALLWNDPROCRET            OK (FIXME: A/W mapping?)
  60  *     WH_KEYBOARD_LL               Implemented but should use SendMessage instead
  61  *     WH_MOUSE_LL                  Implemented but should use SendMessage instead
  62  */
  63
  64 #include "config.h"
  65 #include "wine/port.h"
  66
  67 #include <stdarg.h>
  68
  69 #include "windef.h"
  70 #include "winbase.h"
  71 #include "winuser.h"
  72 #include "winerror.h"
  73 #include "message.h"
  74 #include "win.h"
  75 #include "user_private.h"
  76 #include "wine/server.h"
  77 #include "wine/unicode.h"
  78 #include "wine/debug.h"
  79 #include "winternl.h"
  80
  81 WINE_DEFAULT_DEBUG_CHANNEL(hook);
  82 WINE_DECLARE_DEBUG_CHANNEL(relay);
  83
  84 static const char * const hook_names[WH_MAXHOOK - WH_MINHOOK + 1] =
  85 {
  86     "WH_MSGFILTER",
  87     "WH_JOURNALRECORD",
  88     "WH_JOURNALPLAYBACK",
  89     "WH_KEYBOARD",
  90     "WH_GETMESSAGE",
  91     "WH_CALLWNDPROC",
  92     "WH_CBT",
  93     "WH_SYSMSGFILTER",
  94     "WH_MOUSE",
  95     "WH_HARDWARE",
  96     "WH_DEBUG",
  97     "WH_SHELL",
  98     "WH_FOREGROUNDIDLE",
  99     "WH_CALLWNDPROCRET",
 100     "WH_KEYBOARD_LL",
 101     "WH_MOUSE_LL"
 102 };
 103
 104
 105 /***********************************************************************
 106  *              get_ll_hook_timeout
 107  *
 108  */
 109 static UINT get_ll_hook_timeout(void)
 110 {
 111     /* FIXME: should retrieve LowLevelHooksTimeout in HKEY_CURRENT_USER\Control Panel\Desktop */
 112     return 2000;
 113 }
 114
 115
 116 /***********************************************************************
 117  *              set_windows_hook
 118  *
 119  * Implementation of SetWindowsHookExA and SetWindowsHookExW.
 120  */
 121 static HHOOK set_windows_hook( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid, BOOL unicode )
 122 {
 123     HHOOK handle = 0;
 124     WCHAR module[MAX_PATH];
 125     DWORD len;
 126
 127     if (tid)  /* thread-local hook */
 128     {
 129         if (id == WH_JOURNALRECORD ||
 130             id == WH_JOURNALPLAYBACK ||
 131             id == WH_KEYBOARD_LL ||
 132             id == WH_MOUSE_LL ||
 133             id == WH_SYSMSGFILTER)
 134         {
 135             /* these can only be global */
 136             SetLastError( ERROR_INVALID_PARAMETER );
 137             return 0;
 138         }
 139         inst = 0;
 140     }
 141     else  /* system-global hook */
 142     {
 143         if (id == WH_KEYBOARD_LL || id == WH_MOUSE_LL) inst = 0;
 144         else if (!inst || !(len = GetModuleFileNameW( inst, module, MAX_PATH )) || len >= MAX_PATH)
 145         {
 146             SetLastError( ERROR_INVALID_PARAMETER );
 147             return 0;
 148         }
 149     }
 150
 151     SERVER_START_REQ( set_hook )
 152     {
 153         req->id      = id;
 154         req->tid     = tid;
 155         req->unicode = unicode;
 156         if (inst) /* make proc relative to the module base */
 157         {
 158             req->proc = (void *)((char *)proc - (char *)inst);
 159             wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
 160         }
 161         else req->proc = proc;
 162
 163         if (!wine_server_call_err( req )) handle = reply->handle;
 164     }
 165     SERVER_END_REQ;
 166
 167     TRACE( "%s %p %lx -> %p\n", hook_names[id-WH_MINHOOK], proc, tid, handle );
 168     return handle;
 169 }
 170
 171
 172 /***********************************************************************
 173  *              call_hook_AtoW
 174  */
 175 static LRESULT call_hook_AtoW( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
 176 {
 177     LRESULT ret;
 178     UNICODE_STRING usBuffer;
 179     if (id != WH_CBT || code != HCBT_CREATEWND) ret = proc( code, wparam, lparam );
 180     else
 181     {
 182         CBT_CREATEWNDA *cbtcwA = (CBT_CREATEWNDA *)lparam;
 183         CBT_CREATEWNDW cbtcwW;
 184         CREATESTRUCTW csW;
 185
 186         cbtcwW.lpcs = &csW;
 187         cbtcwW.hwndInsertAfter = cbtcwA->hwndInsertAfter;
 188         csW = *(CREATESTRUCTW *)cbtcwA->lpcs;
 189
 190         if (HIWORD(cbtcwA->lpcs->lpszName))
 191         {
 192             RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszName);
 193             csW.lpszName = usBuffer.Buffer;
 194         }
 195         if (HIWORD(cbtcwA->lpcs->lpszClass))
 196         {
 197             RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszClass);
 198             csW.lpszClass = usBuffer.Buffer;
 199         }
 200         ret = proc( code, wparam, (LPARAM)&cbtcwW );
 201         cbtcwA->hwndInsertAfter = cbtcwW.hwndInsertAfter;
 202         if (HIWORD(csW.lpszName)) HeapFree( GetProcessHeap(), 0, (LPWSTR)csW.lpszName );
 203         if (HIWORD(csW.lpszClass)) HeapFree( GetProcessHeap(), 0, (LPWSTR)csW.lpszClass );
 204     }
 205     return ret;
 206 }
 207
 208
 209 /***********************************************************************
 210  *              call_hook_WtoA
 211  */
 212 static LRESULT call_hook_WtoA( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
 213 {
 214     LRESULT ret;
 215
 216     if (id != WH_CBT || code != HCBT_CREATEWND) ret = proc( code, wparam, lparam );
 217     else
 218     {
 219         CBT_CREATEWNDW *cbtcwW = (CBT_CREATEWNDW *)lparam;
 220         CBT_CREATEWNDA cbtcwA;
 221         CREATESTRUCTA csA;
 222         int len;
 223
 224         cbtcwA.lpcs = &csA;
 225         cbtcwA.hwndInsertAfter = cbtcwW->hwndInsertAfter;
 226         csA = *(CREATESTRUCTA *)cbtcwW->lpcs;
 227
 228         if (HIWORD(cbtcwW->lpcs->lpszName)) {
 229             len = WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszName, -1, NULL, 0, NULL, NULL );
 230             csA.lpszName = HeapAlloc( GetProcessHeap(), 0, len*sizeof(CHAR) );
 231             WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszName, -1, (LPSTR)csA.lpszName, len, NULL, NULL );
 232         }
 233
 234         if (HIWORD(cbtcwW->lpcs->lpszClass)) {
 235             len = WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszClass, -1, NULL, 0, NULL, NULL );
 236             csA.lpszClass = HeapAlloc( GetProcessHeap(), 0, len*sizeof(CHAR) );
 237             WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszClass, -1, (LPSTR)csA.lpszClass, len, NULL, NULL );
 238         }
 239
 240         ret = proc( code, wparam, (LPARAM)&cbtcwA );
 241         cbtcwW->hwndInsertAfter = cbtcwA.hwndInsertAfter;
 242         if (HIWORD(csA.lpszName)) HeapFree( GetProcessHeap(), 0, (LPSTR)csA.lpszName );
 243         if (HIWORD(csA.lpszClass)) HeapFree( GetProcessHeap(), 0, (LPSTR)csA.lpszClass );
 244     }
 245     return ret;
 246 }
 247
 248
 249 /***********************************************************************
 250  *              call_hook
 251  */
 252 static LRESULT call_hook( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam,
 253                           BOOL prev_unicode, BOOL next_unicode )
 254 {
 255     LRESULT ret;
 256
 257     if (TRACE_ON(relay))
 258         DPRINTF( "%04lx:Call hook proc %p (id=%s,code=%x,wp=%08x,lp=%08lx)\n",
 259                  GetCurrentThreadId(), proc, hook_names[id-WH_MINHOOK], code, wparam, lparam );
 260
 261     if (!prev_unicode == !next_unicode) ret = proc( code, wparam, lparam );
 262     else if (prev_unicode) ret = call_hook_WtoA( proc, id, code, wparam, lparam );
 263     else ret = call_hook_AtoW( proc, id, code, wparam, lparam );
 264
 265     if (TRACE_ON(relay))
 266         DPRINTF( "%04lx:Ret  hook proc %p (id=%s,code=%x,wp=%08x,lp=%08lx) retval=%08lx\n",
 267                  GetCurrentThreadId(), proc, hook_names[id-WH_MINHOOK], code, wparam, lparam, ret );
 268
 269     return ret;
 270 }
 271
 272
 273 /***********************************************************************
 274  *              get_hook_proc
 275  *
 276  * Retrieve the hook procedure real value for a module-relative proc
 277  */
 278 static HOOKPROC get_hook_proc( HOOKPROC proc, const WCHAR *module )
 279 {
 280     HMODULE mod;
 281
 282     if (!(mod = GetModuleHandleW(module)))
 283     {
 284         TRACE( "loading %s\n", debugstr_w(module) );
 285         /* FIXME: the library will never be freed */
 286         if (!(mod = LoadLibraryW(module))) return NULL;
 287     }
 288     return (HOOKPROC)((char *)mod + (ULONG_PTR)proc);
 289 }
 290
 291
 292 /***********************************************************************
 293  *              HOOK_CallHooks
 294  */
 295 LRESULT HOOK_CallHooks( INT id, INT code, WPARAM wparam, LPARAM lparam, BOOL unicode )
 296 {
 297     MESSAGEQUEUE *queue = QUEUE_Current();
 298     HOOKPROC proc = NULL;
 299     HHOOK handle = 0;
 300     DWORD pid = 0, tid = 0;
 301     WCHAR module[MAX_PATH];
 302     BOOL unicode_hook = FALSE;
 303     LRESULT ret = 0;
 304
 305     if (!queue) return 0;
 306     SERVER_START_REQ( start_hook_chain )
 307     {
 308         req->id = id;
 309         wine_server_set_reply( req, module, sizeof(module)-sizeof(WCHAR) );
 310         if (!wine_server_call( req ))
 311         {
 312             module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
 313             handle       = reply->handle;
 314             proc         = reply->proc;
 315             pid          = reply->pid;
 316             tid          = reply->tid;
 317             unicode_hook = reply->unicode;
 318         }
 319     }
 320     SERVER_END_REQ;
 321
 322     if (tid)
 323     {
 324         TRACE( "calling hook in thread %04lx %s code %x wp %x lp %lx\n",
 325                tid, hook_names[id-WH_MINHOOK], code, wparam, lparam );
 326
 327         switch(id)
 328         {
 329         case WH_KEYBOARD_LL:
 330             MSG_SendInternalMessageTimeout( pid, tid, WM_WINE_KEYBOARD_LL_HOOK, wparam, lparam,
 331                                             SMTO_ABORTIFHUNG, get_ll_hook_timeout(), &ret );
 332             break;
 333         case WH_MOUSE_LL:
 334             MSG_SendInternalMessageTimeout( pid, tid, WM_WINE_MOUSE_LL_HOOK, wparam, lparam,
 335                                             SMTO_ABORTIFHUNG, get_ll_hook_timeout(), &ret );
 336             break;
 337         }
 338     }
 339     else if (proc)
 340     {
 341         TRACE( "calling hook %p %s code %x wp %x lp %lx module %s\n",
 342                proc, hook_names[id-WH_MINHOOK], code, wparam, lparam, debugstr_w(module) );
 343
 344         if (!module[0] || (proc = get_hook_proc( proc, module )) != NULL)
 345         {
 346             int locks = WIN_SuspendWndsLock();
 347             HHOOK prev = queue->hook;
 348             queue->hook = handle;
 349             ret = call_hook( proc, id, code, wparam, lparam, unicode, unicode_hook );
 350             queue->hook = prev;
 351             WIN_RestoreWndsLock( locks );
 352         }
 353
 354     }
 355     else return 0;
 356
 357     SERVER_START_REQ( finish_hook_chain )
 358     {
 359         req->id = id;
 360         wine_server_call( req );
 361     }
 362     SERVER_END_REQ;
 363     return ret;
 364 }
 365
 366
 367 /***********************************************************************
 368  *           HOOK_IsHooked
 369  */
 370 BOOL HOOK_IsHooked( INT id )
 371 {
 372     return TRUE;  /* FIXME */
 373 }
 374
 375
 376 /***********************************************************************
 377  *              SetWindowsHookA (USER32.@)
 378  */
 379 HHOOK WINAPI SetWindowsHookA( INT id, HOOKPROC proc )
 380 {
 381     return SetWindowsHookExA( id, proc, 0, GetCurrentThreadId() );
 382 }
 383
 384
 385 /***********************************************************************
 386  *              SetWindowsHookW (USER32.@)
 387  */
 388 HHOOK WINAPI SetWindowsHookW( INT id, HOOKPROC proc )
 389 {
 390     return SetWindowsHookExW( id, proc, 0, GetCurrentThreadId() );
 391 }
 392
 393
 394 /***********************************************************************
 395  *              SetWindowsHookExA (USER32.@)
 396  */
 397 HHOOK WINAPI SetWindowsHookExA( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
 398 {
 399     return set_windows_hook( id, proc, inst, tid, FALSE );
 400 }
 401
 402 /***********************************************************************
 403  *              SetWindowsHookExW (USER32.@)
 404  */
 405 HHOOK WINAPI SetWindowsHookExW( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
 406 {
 407     return set_windows_hook( id, proc, inst, tid, TRUE );
 408 }
 409
 410
 411 /***********************************************************************
 412  *              UnhookWindowsHook (USER32.@)
 413  */
 414 BOOL WINAPI UnhookWindowsHook( INT id, HOOKPROC proc )
 415 {
 416     BOOL ret;
 417
 418     TRACE( "%s %p\n", hook_names[id-WH_MINHOOK], proc );
 419
 420     SERVER_START_REQ( remove_hook )
 421     {
 422         req->handle = 0;
 423         req->id   = id;
 424         req->proc = proc;
 425         ret = !wine_server_call_err( req );
 426     }
 427     SERVER_END_REQ;
 428     return ret;
 429 }
 430
 431
 432
 433 /***********************************************************************
 434  *              UnhookWindowsHookEx (USER32.@)
 435  */
 436 BOOL WINAPI UnhookWindowsHookEx( HHOOK hhook )
 437 {
 438     BOOL ret;
 439
 440     TRACE( "%p\n", hhook );
 441
 442     SERVER_START_REQ( remove_hook )
 443     {
 444         req->handle = hhook;
 445         ret = !wine_server_call_err( req );
 446     }
 447     SERVER_END_REQ;
 448     return ret;
 449 }
 450
 451
 452 /***********************************************************************
 453  *              CallNextHookEx (USER32.@)
 454  */
 455 LRESULT WINAPI CallNextHookEx( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
 456 {
 457     MESSAGEQUEUE *queue = QUEUE_Current();
 458     HOOKPROC proc = NULL;
 459     WCHAR module[MAX_PATH];
 460     HHOOK handle = 0;
 461     DWORD pid = 0, tid = 0;
 462     INT id = 0;
 463     BOOL prev_unicode = FALSE, next_unicode = FALSE;
 464     LRESULT ret = 0;
 465
 466     if (!queue) return 0;
 467
 468     SERVER_START_REQ( get_next_hook )
 469     {
 470         req->handle = queue->hook;
 471         wine_server_set_reply( req, module, sizeof(module)-sizeof(WCHAR) );
 472         if (!wine_server_call_err( req ))
 473         {
 474             module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
 475             handle       = reply->next;
 476             id           = reply->id;
 477             pid          = reply->pid;
 478             tid          = reply->tid;
 479             proc         = reply->proc;
 480             prev_unicode = reply->prev_unicode;
 481             next_unicode = reply->next_unicode;
 482         }
 483     }
 484     SERVER_END_REQ;
 485
 486     if (tid)
 487     {
 488         TRACE( "calling hook in thread %04lx %s code %x wp %x lp %lx\n",
 489                tid, hook_names[id-WH_MINHOOK], code, wparam, lparam );
 490
 491         switch(id)
 492         {
 493         case WH_KEYBOARD_LL:
 494             MSG_SendInternalMessageTimeout( pid, tid, WM_WINE_KEYBOARD_LL_HOOK, wparam, lparam,
 495                                             SMTO_ABORTIFHUNG, get_ll_hook_timeout(), &ret );
 496             break;
 497         case WH_MOUSE_LL:
 498             MSG_SendInternalMessageTimeout( pid, tid, WM_WINE_MOUSE_LL_HOOK, wparam, lparam,
 499                                             SMTO_ABORTIFHUNG, get_ll_hook_timeout(), &ret );
 500             break;
 501         }
 502     }
 503     else if (proc)
 504     {
 505         TRACE( "calling hook %p %s code %x wp %x lp %lx module %s\n",
 506                proc, hook_names[id-WH_MINHOOK], code, wparam, lparam, debugstr_w(module) );
 507
 508         if (!module[0] || (proc = get_hook_proc( proc, module )) != NULL)
 509         {
 510             HHOOK prev = queue->hook;
 511             queue->hook = handle;
 512             ret = call_hook( proc, id, code, wparam, lparam, prev_unicode, next_unicode );
 513             queue->hook = prev;
 514         }
 515     }
 516     return ret;
 517 }
 518
 519
 520 /***********************************************************************
 521  *              CallMsgFilterA (USER32.@)
 522  */
 523 BOOL WINAPI CallMsgFilterA( LPMSG msg, INT code )
 524 {
 525     if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, FALSE )) return TRUE;
 526     return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, FALSE );
 527 }
 528
 529
 530 /***********************************************************************
 531  *              CallMsgFilterW (USER32.@)
 532  */
 533 BOOL WINAPI CallMsgFilterW( LPMSG msg, INT code )
 534 {
 535     if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, TRUE )) return TRUE;
 536     return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, TRUE );
 537 }
 538
 539
 540 /***********************************************************************
 541  *           SetWinEventHook                            [USER32.@]
 542  *
 543  * Set up an event hook for a set of events.
 544  *
 545  * PARAMS
 546  *  dwMin     [I] Lowest event handled by pfnProc
 547  *  dwMax     [I] Highest event handled by pfnProc
 548  *  hModule   [I] DLL containing pfnProc
 549  *  pfnProc   [I] Callback event hook function
 550  *  dwProcess [I] Process to get events from, or 0 for all processes
 551  *  dwThread  [I] Thread to get events from, or 0 for all threads
 552  *  dwFlags   [I] Flags indicating the status of pfnProc
 553  *
 554  * RETURNS
 555  *  Success: A handle representing the hook.
 556  *  Failure: A NULL handle.
 557  *
 558  * BUGS
 559  *  Not implemented.
 560  */
 561 HWINEVENTHOOK WINAPI SetWinEventHook(DWORD dwMin, DWORD dwMax, HMODULE hModule,
 562                                      WINEVENTPROC pfnProc, DWORD dwProcess,
 563                                      DWORD dwThread, DWORD dwFlags)
 564 {
 565     FIXME("(%ld,%ld,%p,%p,%ld,%ld,0x%08lx)-stub!\n", dwMin, dwMax, hModule,
 566           pfnProc, dwProcess, dwThread, dwFlags);
 567     return 0;
 568 }
 569
 570
 571 /***********************************************************************
 572  *           UnhookWinEvent                             [USER32.@]
 573  *
 574  * Remove an event hook for a set of events.
 575  *
 576  * PARAMS
 577  *  hEventHook [I] Event hook to remove
 578  *
 579  * RETURNS
 580  *  Success: TRUE. The event hook has been removed.
 581  *  Failure: FALSE, if hEventHook is invalid.
 582  *
 583  * BUGS
 584  *  Not implemented.
 585  */
 586 BOOL WINAPI UnhookWinEvent(HWINEVENTHOOK hEventHook)
 587 {
 588     FIXME("(%p)-stub!\n", hEventHook);
 589
 590     return (hEventHook != 0);
 591 }
 592
 593
 594 /***********************************************************************
 595  *           NotifyWinEvent                             [USER32.@]
 596  *
 597  * Inform the OS that an event has occurred.
 598  *
 599  * PARAMS
 600  *  dwEvent  [I] Id of the event
 601  *  hWnd     [I] Window holding the object that created the event
 602  *  nId      [I] Type of object that created the event
 603  *  nChildId [I] Child object of nId, or CHILDID_SELF.
 604  *
 605  * RETURNS
 606  *  Nothing.
 607  *
 608  * BUGS
 609  *  Not implemented.
 610  */
 611 void WINAPI NotifyWinEvent(DWORD dwEvent, HWND hWnd, LONG nId, LONG nChildId)
 612 {
 613     FIXME("(%ld,%p,%ld,%ld)-stub!\n", dwEvent, hWnd, nId, nChildId);
 614 }
 615
 616
 617 /***********************************************************************
 618  *           IsWinEventHookInstalled                       [USER32.@]
 619  *
 620  * Determine if an event hook is installed for an event.
 621  *
 622  * PARAMS
 623  *  dwEvent  [I] Id of the event
 624  *
 625  * RETURNS
 626  *  TRUE,  If there are any hooks installed for the event.
 627  *  FALSE, Otherwise.
 628  *
 629  * BUGS
 630  *  Not implemented.
 631  */
 632 BOOL WINAPI IsWinEventHookInstalled(DWORD dwEvent)
 633 {
 634     FIXME("(%ld)-stub!\n", dwEvent);
 635     return TRUE;
 636 }