mirror of
git://source.winehq.org/git/wine.git
synced 2024-08-31 13:14:31 +00:00
1241 lines
37 KiB
C
1241 lines
37 KiB
C
/*
|
|
* Windows hook functions
|
|
*
|
|
* Copyright 1994, 1995 Alexandre Julliard
|
|
* 1996 Andrew Lewycky
|
|
*
|
|
* Based on investigations by Alex Korobka
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
/*
|
|
* Warning!
|
|
* A HHOOK is a 32-bit handle for compatibility with Windows 3.0 where it was
|
|
* a pointer to the next function. Now it is in fact composed of a USER heap
|
|
* handle in the low 16 bits and of a HOOK_MAGIC value in the high 16 bits.
|
|
*/
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "wingdi.h"
|
|
#include "winuser.h"
|
|
#include "wine/winuser16.h"
|
|
#include "wine/winbase16.h"
|
|
#include "hook.h"
|
|
#include "win.h"
|
|
#include "queue.h"
|
|
#include "user.h"
|
|
#include "heap.h"
|
|
#include "struct32.h"
|
|
#include "winproc.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(hook);
|
|
|
|
#include "pshpack1.h"
|
|
|
|
/* Hook data (pointed to by a HHOOK) */
|
|
typedef struct
|
|
{
|
|
HANDLE16 next; /* 00 Next hook in chain */
|
|
HOOKPROC proc; /* 02 Hook procedure (original) */
|
|
INT16 id; /* 06 Hook id (WH_xxx) */
|
|
HQUEUE16 ownerQueue; /* 08 Owner queue (0 for system hook) */
|
|
HMODULE16 ownerModule; /* 0a Owner module */
|
|
WORD flags; /* 0c flags */
|
|
} HOOKDATA;
|
|
|
|
#include "poppack.h"
|
|
|
|
#define HOOK_MAGIC ((int)'H' | (int)'K' << 8) /* 'HK' */
|
|
#define HHOOK_32(h) ((HHOOK)(h ? MAKELONG(h, HOOK_MAGIC) : 0))
|
|
#define HHOOK_16(h) ((HANDLE16)((HIWORD(h) == HOOK_MAGIC) ? LOWORD(h) : 0))
|
|
|
|
/* This should probably reside in USER heap */
|
|
static HANDLE16 HOOK_systemHooks[WH_NB_HOOKS] = { 0, };
|
|
|
|
/* ### start build ### */
|
|
extern LONG CALLBACK HOOK_CallTo16_long_wwl(HOOKPROC16,WORD,WORD,LONG);
|
|
/* ### stop build ### */
|
|
|
|
|
|
/***********************************************************************
|
|
* call_hook_16
|
|
*/
|
|
inline static LRESULT call_hook_16( HOOKPROC16 proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
|
|
{
|
|
LRESULT ret = HOOK_CallTo16_long_wwl( proc, code, wparam, lparam );
|
|
/* Grrr. While the hook procedure is supposed to have an LRESULT return
|
|
value even in Win16, it seems that for those hook types where the
|
|
return value is interpreted as BOOL, Windows doesn't actually check
|
|
the HIWORD ... Some buggy Win16 programs, notably WINFILE, rely on
|
|
that, because they neglect to clear DX ... */
|
|
if (id != WH_JOURNALPLAYBACK) ret = LOWORD( ret );
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* call_hook_16_to_32
|
|
*
|
|
* Convert hook params to 32-bit and call 32-bit hook procedure
|
|
*/
|
|
static LRESULT call_hook_16_to_32( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam,
|
|
BOOL unicode )
|
|
{
|
|
LRESULT ret = 0;
|
|
|
|
switch( id )
|
|
{
|
|
case WH_MSGFILTER:
|
|
case WH_SYSMSGFILTER:
|
|
case WH_JOURNALRECORD:
|
|
{
|
|
MSG16 *msg16 = MapSL(lparam);
|
|
MSG msg32;
|
|
|
|
STRUCT32_MSG16to32( msg16, &msg32 );
|
|
ret = proc( code, wparam, (LPARAM)&msg32 );
|
|
break;
|
|
}
|
|
|
|
case WH_GETMESSAGE:
|
|
{
|
|
MSG16 *msg16 = MapSL(lparam);
|
|
MSG msg32;
|
|
|
|
STRUCT32_MSG16to32( msg16, &msg32 );
|
|
ret = proc( code, wparam, (LPARAM)&msg32 );
|
|
STRUCT32_MSG32to16( &msg32, msg16 );
|
|
break;
|
|
}
|
|
|
|
case WH_JOURNALPLAYBACK:
|
|
{
|
|
EVENTMSG16 *em16 = MapSL(lparam);
|
|
EVENTMSG em32;
|
|
|
|
em32.message = em16->message;
|
|
em32.paramL = em16->paramL;
|
|
em32.paramH = em16->paramH;
|
|
em32.time = em16->time;
|
|
em32.hwnd = 0; /* FIXME */
|
|
ret = proc( code, wparam, (LPARAM)&em32 );
|
|
break;
|
|
}
|
|
|
|
case WH_CALLWNDPROC:
|
|
{
|
|
CWPSTRUCT16 *cwp16 = MapSL(lparam);
|
|
CWPSTRUCT cwp32;
|
|
|
|
cwp32.hwnd = WIN_Handle32(cwp16->hwnd);
|
|
cwp32.lParam = cwp16->lParam;
|
|
|
|
if (unicode)
|
|
WINPROC_MapMsg16To32W( cwp32.hwnd, cwp16->message, cwp16->wParam,
|
|
&cwp32.message, &cwp32.wParam, &cwp32.lParam );
|
|
else
|
|
WINPROC_MapMsg16To32A( cwp32.hwnd, cwp16->message, cwp16->wParam,
|
|
&cwp32.message, &cwp32.wParam, &cwp32.lParam );
|
|
|
|
ret = proc( code, wparam, (LPARAM)&cwp32 );
|
|
|
|
if (unicode)
|
|
WINPROC_UnmapMsg16To32W( cwp32.hwnd, cwp32.message, cwp32.wParam, cwp32.lParam, 0 );
|
|
else
|
|
WINPROC_UnmapMsg16To32A( cwp32.hwnd, cwp32.message, cwp32.wParam, cwp32.lParam, 0 );
|
|
break;
|
|
}
|
|
|
|
case WH_CBT:
|
|
switch (code)
|
|
{
|
|
case HCBT_CREATEWND:
|
|
{
|
|
CBT_CREATEWNDA cbtcw32;
|
|
CREATESTRUCTA cs32;
|
|
CBT_CREATEWND16 *cbtcw16 = MapSL(lparam);
|
|
CREATESTRUCT16 *cs16 = MapSL( (SEGPTR)cbtcw16->lpcs );
|
|
|
|
cbtcw32.lpcs = &cs32;
|
|
cbtcw32.hwndInsertAfter = WIN_Handle32( cbtcw16->hwndInsertAfter );
|
|
STRUCT32_CREATESTRUCT16to32A( cs16, &cs32 );
|
|
|
|
if (unicode)
|
|
{
|
|
cs32.lpszName = (LPSTR)map_str_16_to_32W( cs16->lpszName );
|
|
cs32.lpszClass = (LPSTR)map_str_16_to_32W( cs16->lpszClass );
|
|
ret = proc( code, wparam, (LPARAM)&cbtcw32 );
|
|
unmap_str_16_to_32W( (LPWSTR)cs32.lpszName );
|
|
unmap_str_16_to_32W( (LPWSTR)cs32.lpszClass );
|
|
}
|
|
else
|
|
{
|
|
cs32.lpszName = MapSL( cs16->lpszName );
|
|
cs32.lpszClass = MapSL( cs16->lpszClass );
|
|
ret = proc( code, wparam, (LPARAM)&cbtcw32 );
|
|
}
|
|
cbtcw16->hwndInsertAfter = HWND_16( cbtcw32.hwndInsertAfter );
|
|
break;
|
|
}
|
|
case HCBT_ACTIVATE:
|
|
{
|
|
CBTACTIVATESTRUCT16 *cas16 = MapSL(lparam);
|
|
CBTACTIVATESTRUCT cas32;
|
|
cas32.fMouse = cas16->fMouse;
|
|
cas32.hWndActive = WIN_Handle32(cas16->hWndActive);
|
|
ret = proc( code, wparam, (LPARAM)&cas32 );
|
|
break;
|
|
}
|
|
case HCBT_CLICKSKIPPED:
|
|
{
|
|
MOUSEHOOKSTRUCT16 *ms16 = MapSL(lparam);
|
|
MOUSEHOOKSTRUCT ms32;
|
|
|
|
ms32.pt.x = ms16->pt.x;
|
|
ms32.pt.y = ms16->pt.y;
|
|
/* wHitTestCode may be negative, so convince compiler to do
|
|
correct sign extension. Yay. :| */
|
|
ms32.wHitTestCode = (INT)(INT16)ms16->wHitTestCode;
|
|
ms32.dwExtraInfo = ms16->dwExtraInfo;
|
|
ms32.hwnd = WIN_Handle32( ms16->hwnd );
|
|
ret = proc( code, wparam, (LPARAM)&ms32 );
|
|
break;
|
|
}
|
|
case HCBT_MOVESIZE:
|
|
{
|
|
RECT16 *rect16 = MapSL(lparam);
|
|
RECT rect32;
|
|
|
|
CONV_RECT16TO32( rect16, &rect32 );
|
|
ret = proc( code, wparam, (LPARAM)&rect32 );
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WH_MOUSE:
|
|
{
|
|
MOUSEHOOKSTRUCT16 *ms16 = MapSL(lparam);
|
|
MOUSEHOOKSTRUCT ms32;
|
|
|
|
ms32.pt.x = ms16->pt.x;
|
|
ms32.pt.y = ms16->pt.y;
|
|
/* wHitTestCode may be negative, so convince compiler to do
|
|
correct sign extension. Yay. :| */
|
|
ms32.wHitTestCode = (INT)((INT16)ms16->wHitTestCode);
|
|
ms32.dwExtraInfo = ms16->dwExtraInfo;
|
|
ms32.hwnd = WIN_Handle32(ms16->hwnd);
|
|
ret = proc( code, wparam, (LPARAM)&ms32 );
|
|
break;
|
|
}
|
|
|
|
case WH_DEBUG:
|
|
{
|
|
DEBUGHOOKINFO16 *dh16 = MapSL(lparam);
|
|
DEBUGHOOKINFO dh32;
|
|
|
|
dh32.idThread = 0; /* FIXME */
|
|
dh32.idThreadInstaller = 0; /* FIXME */
|
|
dh32.lParam = dh16->lParam; /* FIXME Check for sign ext */
|
|
dh32.wParam = dh16->wParam;
|
|
dh32.code = dh16->code;
|
|
|
|
/* do sign extension if it was WH_MSGFILTER */
|
|
if (wparam == 0xffff) wparam = WH_MSGFILTER;
|
|
ret = proc( code, wparam, (LPARAM)&dh32 );
|
|
break;
|
|
}
|
|
|
|
case WH_SHELL:
|
|
case WH_KEYBOARD:
|
|
ret = proc( code, wparam, lparam );
|
|
break;
|
|
|
|
case WH_HARDWARE:
|
|
case WH_FOREGROUNDIDLE:
|
|
case WH_CALLWNDPROCRET:
|
|
default:
|
|
FIXME("\t[%i] 16to32 translation unimplemented\n", id);
|
|
ret = proc( code, wparam, lparam );
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* call_hook_32_to_16
|
|
*
|
|
* Convert hook params to 16-bit and call 16-bit hook procedure
|
|
*/
|
|
static LRESULT call_hook_32_to_16( HOOKPROC16 proc, INT id, INT code, WPARAM wparam, LPARAM lparam,
|
|
BOOL unicode )
|
|
{
|
|
LRESULT ret = 0;
|
|
|
|
switch (id)
|
|
{
|
|
case WH_MSGFILTER:
|
|
case WH_SYSMSGFILTER:
|
|
case WH_JOURNALRECORD:
|
|
{
|
|
MSG *msg32 = (MSG *)lparam;
|
|
MSG16 msg16;
|
|
|
|
STRUCT32_MSG32to16( msg32, &msg16 );
|
|
lparam = MapLS( &msg16 );
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
UnMapLS( lparam );
|
|
break;
|
|
}
|
|
|
|
case WH_GETMESSAGE:
|
|
{
|
|
MSG *msg32 = (MSG *)lparam;
|
|
MSG16 msg16;
|
|
|
|
STRUCT32_MSG32to16( msg32, &msg16 );
|
|
lparam = MapLS( &msg16 );
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
UnMapLS( lparam );
|
|
STRUCT32_MSG16to32( &msg16, msg32 );
|
|
break;
|
|
}
|
|
|
|
case WH_JOURNALPLAYBACK:
|
|
{
|
|
EVENTMSG *em32 = (EVENTMSG *)lparam;
|
|
EVENTMSG16 em16;
|
|
|
|
em16.message = em32->message;
|
|
em16.paramL = em32->paramL;
|
|
em16.paramH = em32->paramH;
|
|
em16.time = em32->time;
|
|
lparam = MapLS( &em16 );
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
UnMapLS( lparam );
|
|
break;
|
|
}
|
|
|
|
case WH_CALLWNDPROC:
|
|
{
|
|
CWPSTRUCT *cwp32 = (CWPSTRUCT *)lparam;
|
|
CWPSTRUCT16 cwp16;
|
|
MSGPARAM16 mp16;
|
|
|
|
cwp16.hwnd = HWND_16(cwp32->hwnd);
|
|
cwp16.lParam = cwp32->lParam;
|
|
|
|
if (unicode)
|
|
WINPROC_MapMsg32WTo16( cwp32->hwnd, cwp32->message, cwp32->wParam,
|
|
&cwp16.message, &cwp16.wParam, &cwp16.lParam );
|
|
else
|
|
WINPROC_MapMsg32ATo16( cwp32->hwnd, cwp32->message, cwp32->wParam,
|
|
&cwp16.message, &cwp16.wParam, &cwp16.lParam );
|
|
|
|
lparam = MapLS( &cwp16 );
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
UnMapLS( lparam );
|
|
|
|
mp16.wParam = cwp16.wParam;
|
|
mp16.lParam = cwp16.lParam;
|
|
mp16.lResult = 0;
|
|
if (unicode)
|
|
WINPROC_UnmapMsg32WTo16( cwp32->hwnd, cwp32->message, cwp32->wParam,
|
|
cwp32->lParam, &mp16 );
|
|
else
|
|
WINPROC_UnmapMsg32ATo16( cwp32->hwnd, cwp32->message, cwp32->wParam,
|
|
cwp32->lParam, &mp16 );
|
|
break;
|
|
}
|
|
|
|
case WH_CBT:
|
|
switch (code)
|
|
{
|
|
case HCBT_CREATEWND:
|
|
{
|
|
CBT_CREATEWNDA *cbtcw32 = (CBT_CREATEWNDA *)lparam;
|
|
CBT_CREATEWND16 cbtcw16;
|
|
CREATESTRUCT16 cs16;
|
|
|
|
STRUCT32_CREATESTRUCT32Ato16( cbtcw32->lpcs, &cs16 );
|
|
cbtcw16.lpcs = (CREATESTRUCT16 *)MapLS( &cs16 );
|
|
cbtcw16.hwndInsertAfter = HWND_16( cbtcw32->hwndInsertAfter );
|
|
lparam = MapLS( &cbtcw16 );
|
|
|
|
if (unicode)
|
|
{
|
|
cs16.lpszName = map_str_32W_to_16( (LPWSTR)cbtcw32->lpcs->lpszName );
|
|
cs16.lpszClass = map_str_32W_to_16( (LPWSTR)cbtcw32->lpcs->lpszClass );
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
unmap_str_32W_to_16( cs16.lpszName );
|
|
unmap_str_32W_to_16( cs16.lpszClass );
|
|
}
|
|
else
|
|
{
|
|
cs16.lpszName = MapLS( cbtcw32->lpcs->lpszName );
|
|
cs16.lpszClass = MapLS( cbtcw32->lpcs->lpszClass );
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
UnMapLS( cs16.lpszName );
|
|
UnMapLS( cs16.lpszClass );
|
|
}
|
|
cbtcw32->hwndInsertAfter = WIN_Handle32( cbtcw16.hwndInsertAfter );
|
|
UnMapLS( (SEGPTR)cbtcw16.lpcs );
|
|
UnMapLS( lparam );
|
|
break;
|
|
}
|
|
|
|
case HCBT_ACTIVATE:
|
|
{
|
|
CBTACTIVATESTRUCT *cas32 = (CBTACTIVATESTRUCT *)lparam;
|
|
CBTACTIVATESTRUCT16 cas16;
|
|
|
|
cas16.fMouse = cas32->fMouse;
|
|
cas16.hWndActive = HWND_16( cas32->hWndActive );
|
|
|
|
lparam = MapLS( &cas16 );
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
UnMapLS( lparam );
|
|
break;
|
|
}
|
|
case HCBT_CLICKSKIPPED:
|
|
{
|
|
MOUSEHOOKSTRUCT *ms32 = (MOUSEHOOKSTRUCT *)lparam;
|
|
MOUSEHOOKSTRUCT16 ms16;
|
|
|
|
ms16.pt.x = ms32->pt.x;
|
|
ms16.pt.y = ms32->pt.y;
|
|
ms16.hwnd = HWND_16( ms32->hwnd );
|
|
ms16.wHitTestCode = ms32->wHitTestCode;
|
|
ms16.dwExtraInfo = ms32->dwExtraInfo;
|
|
|
|
lparam = MapLS( &ms16 );
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
UnMapLS( lparam );
|
|
break;
|
|
}
|
|
case HCBT_MOVESIZE:
|
|
{
|
|
RECT *rect32 = (RECT *)lparam;
|
|
RECT16 rect16;
|
|
|
|
CONV_RECT32TO16( rect32, &rect16 );
|
|
lparam = MapLS( &rect16 );
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
UnMapLS( lparam );
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WH_MOUSE:
|
|
{
|
|
MOUSEHOOKSTRUCT *ms32 = (MOUSEHOOKSTRUCT *)lparam;
|
|
MOUSEHOOKSTRUCT16 ms16;
|
|
|
|
ms16.pt.x = ms32->pt.x;
|
|
ms16.pt.y = ms32->pt.y;
|
|
ms16.hwnd = HWND_16( ms32->hwnd );
|
|
ms16.wHitTestCode = ms32->wHitTestCode;
|
|
ms16.dwExtraInfo = ms32->dwExtraInfo;
|
|
|
|
lparam = MapLS( &ms16 );
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
UnMapLS( lparam );
|
|
break;
|
|
}
|
|
|
|
case WH_DEBUG:
|
|
{
|
|
DEBUGHOOKINFO *dh32 = (DEBUGHOOKINFO *)lparam;
|
|
DEBUGHOOKINFO16 dh16;
|
|
|
|
dh16.hModuleHook = 0; /* FIXME */
|
|
dh16.reserved = 0;
|
|
dh16.lParam = dh32->lParam;
|
|
dh16.wParam = dh32->wParam;
|
|
dh16.code = dh32->code;
|
|
|
|
lparam = MapLS( &dh16 );
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
UnMapLS( lparam );
|
|
break;
|
|
}
|
|
|
|
case WH_SHELL:
|
|
case WH_KEYBOARD:
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
break;
|
|
|
|
case WH_HARDWARE:
|
|
case WH_FOREGROUNDIDLE:
|
|
case WH_CALLWNDPROCRET:
|
|
default:
|
|
FIXME("\t[%i] 32to16 translation unimplemented\n", id);
|
|
ret = call_hook_16( proc, id, code, wparam, lparam );
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* call_hook_32_to_32
|
|
*
|
|
* Convert hook params to/from Unicode and call hook procedure
|
|
*/
|
|
static LRESULT call_hook_32_to_32( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam,
|
|
BOOL to_unicode )
|
|
{
|
|
if (id != WH_CBT || code != HCBT_CREATEWND) return proc( code, wparam, lparam );
|
|
|
|
if (to_unicode) /* ASCII to Unicode */
|
|
{
|
|
CBT_CREATEWNDA *cbtcwA = (CBT_CREATEWNDA *)lparam;
|
|
CBT_CREATEWNDW cbtcwW;
|
|
CREATESTRUCTW csW;
|
|
LRESULT ret;
|
|
|
|
cbtcwW.lpcs = &csW;
|
|
cbtcwW.hwndInsertAfter = cbtcwA->hwndInsertAfter;
|
|
csW = *(CREATESTRUCTW *)cbtcwA->lpcs;
|
|
|
|
if (HIWORD(cbtcwA->lpcs->lpszName))
|
|
csW.lpszName = HEAP_strdupAtoW( GetProcessHeap(), 0, cbtcwA->lpcs->lpszName );
|
|
if (HIWORD(cbtcwA->lpcs->lpszClass))
|
|
csW.lpszClass = HEAP_strdupAtoW( GetProcessHeap(), 0, cbtcwA->lpcs->lpszClass );
|
|
ret = proc( code, wparam, (LPARAM)&cbtcwW );
|
|
cbtcwA->hwndInsertAfter = cbtcwW.hwndInsertAfter;
|
|
if (HIWORD(csW.lpszName)) HeapFree( GetProcessHeap(), 0, (LPWSTR)csW.lpszName );
|
|
if (HIWORD(csW.lpszClass)) HeapFree( GetProcessHeap(), 0, (LPWSTR)csW.lpszClass );
|
|
return ret;
|
|
}
|
|
else /* Unicode to ASCII */
|
|
{
|
|
CBT_CREATEWNDW *cbtcwW = (CBT_CREATEWNDW *)lparam;
|
|
CBT_CREATEWNDA cbtcwA;
|
|
CREATESTRUCTA csA;
|
|
LRESULT ret;
|
|
|
|
cbtcwA.lpcs = &csA;
|
|
cbtcwA.hwndInsertAfter = cbtcwW->hwndInsertAfter;
|
|
csA = *(CREATESTRUCTA *)cbtcwW->lpcs;
|
|
|
|
if (HIWORD(cbtcwW->lpcs->lpszName))
|
|
csA.lpszName = HEAP_strdupWtoA( GetProcessHeap(), 0, cbtcwW->lpcs->lpszName );
|
|
if (HIWORD(cbtcwW->lpcs->lpszClass))
|
|
csA.lpszClass = HEAP_strdupWtoA( GetProcessHeap(), 0, cbtcwW->lpcs->lpszClass );
|
|
ret = proc( code, wparam, (LPARAM)&cbtcwA );
|
|
cbtcwW->hwndInsertAfter = cbtcwA.hwndInsertAfter;
|
|
if (HIWORD(csA.lpszName)) HeapFree( GetProcessHeap(), 0, (LPSTR)csA.lpszName );
|
|
if (HIWORD(csA.lpszClass)) HeapFree( GetProcessHeap(), 0, (LPSTR)csA.lpszClass );
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* call_hook
|
|
*
|
|
* Call a hook procedure.
|
|
*/
|
|
inline static LRESULT call_hook( HOOKDATA *data, INT fromtype, INT code,
|
|
WPARAM wparam, LPARAM lparam )
|
|
{
|
|
INT type = (data->flags & HOOK_MAPTYPE);
|
|
LRESULT ret;
|
|
|
|
/* Suspend window structure locks before calling user code */
|
|
int iWndsLocks = WIN_SuspendWndsLock();
|
|
|
|
if (type == HOOK_WIN16)
|
|
{
|
|
if (fromtype == HOOK_WIN16) /* 16->16 */
|
|
ret = call_hook_16( (HOOKPROC16)data->proc, data->id, code, wparam, lparam );
|
|
else /* 32->16 */
|
|
ret = call_hook_32_to_16( (HOOKPROC16)data->proc, data->id, code, wparam,
|
|
lparam, (type == HOOK_WIN32W) );
|
|
}
|
|
else if (fromtype == HOOK_WIN16) /* 16->32 */
|
|
ret = call_hook_16_to_32( data->proc, data->id, code, wparam,
|
|
lparam, (type == HOOK_WIN32W) );
|
|
else /* 32->32, check unicode */
|
|
{
|
|
if (type == fromtype)
|
|
ret = data->proc( code, wparam, lparam );
|
|
else
|
|
ret = call_hook_32_to_32( data->proc, data->id, code, wparam,
|
|
lparam, (type == HOOK_WIN32W) );
|
|
}
|
|
WIN_RestoreWndsLock(iWndsLocks);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HOOK_GetNextHook
|
|
*
|
|
* Get the next hook of a given hook.
|
|
*/
|
|
static HHOOK HOOK_GetNextHook( HHOOK hook )
|
|
{
|
|
HOOKDATA *data = (HOOKDATA *)USER_HEAP_LIN_ADDR(HHOOK_16(hook));
|
|
|
|
if (!data || !hook) return 0;
|
|
if (data->next) return HHOOK_32(data->next);
|
|
if (!data->ownerQueue) return 0; /* Already system hook */
|
|
|
|
/* Now start enumerating the system hooks */
|
|
return HHOOK_32(HOOK_systemHooks[data->id - WH_MINHOOK]);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HOOK_GetHook
|
|
*
|
|
* Get the first hook for a given type.
|
|
*/
|
|
static HHOOK HOOK_GetHook( INT16 id )
|
|
{
|
|
MESSAGEQUEUE *queue;
|
|
HANDLE16 handle = 0;
|
|
|
|
if ((queue = QUEUE_Current()) != NULL)
|
|
handle = queue->hooks[id - WH_MINHOOK];
|
|
if (!handle) handle = HOOK_systemHooks[id - WH_MINHOOK];
|
|
return HHOOK_32(handle);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HOOK_SetHook
|
|
*
|
|
* Install a given hook.
|
|
*/
|
|
static HHOOK HOOK_SetHook( INT16 id, LPVOID proc, INT type,
|
|
HMODULE16 hModule, DWORD dwThreadId )
|
|
{
|
|
HOOKDATA *data;
|
|
HANDLE16 handle;
|
|
HQUEUE16 hQueue = 0;
|
|
|
|
if ((id < WH_MINHOOK) || (id > WH_MAXHOOK)) return 0;
|
|
|
|
TRACE("Setting hook %d: %08x %04x %08lx\n",
|
|
id, (UINT)proc, hModule, dwThreadId );
|
|
|
|
/* Create task queue if none present */
|
|
InitThreadInput16( 0, 0 );
|
|
|
|
if (id == WH_JOURNALPLAYBACK) EnableHardwareInput16(FALSE);
|
|
|
|
if (dwThreadId) /* Task-specific hook */
|
|
{
|
|
if ((id == WH_JOURNALRECORD) || (id == WH_JOURNALPLAYBACK) ||
|
|
(id == WH_SYSMSGFILTER)) return 0; /* System-only hooks */
|
|
if (!(hQueue = GetThreadQueue16( dwThreadId )))
|
|
return 0;
|
|
}
|
|
|
|
/* Create the hook structure */
|
|
|
|
if (!(handle = USER_HEAP_ALLOC( sizeof(HOOKDATA) ))) return 0;
|
|
data = (HOOKDATA *) USER_HEAP_LIN_ADDR( handle );
|
|
data->proc = proc;
|
|
data->id = id;
|
|
data->ownerQueue = hQueue;
|
|
data->ownerModule = hModule;
|
|
data->flags = type;
|
|
|
|
/* Insert it in the correct linked list */
|
|
|
|
if (hQueue)
|
|
{
|
|
MESSAGEQUEUE *queue = (MESSAGEQUEUE *)QUEUE_Lock( hQueue );
|
|
data->next = queue->hooks[id - WH_MINHOOK];
|
|
queue->hooks[id - WH_MINHOOK] = handle;
|
|
QUEUE_Unlock( queue );
|
|
}
|
|
else
|
|
{
|
|
data->next = HOOK_systemHooks[id - WH_MINHOOK];
|
|
HOOK_systemHooks[id - WH_MINHOOK] = handle;
|
|
}
|
|
TRACE("Setting hook %d: ret=%04x [next=%04x]\n",
|
|
id, handle, data->next );
|
|
|
|
return HHOOK_32(handle);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HOOK_RemoveHook
|
|
*
|
|
* Remove a hook from the list.
|
|
*/
|
|
static BOOL HOOK_RemoveHook( HHOOK hook )
|
|
{
|
|
HOOKDATA *data;
|
|
HANDLE16 *prevHandle;
|
|
|
|
TRACE("Removing hook %04x\n", hook );
|
|
|
|
if (!(data = (HOOKDATA *)USER_HEAP_LIN_ADDR(HHOOK_16(hook)))) return FALSE;
|
|
if (data->flags & HOOK_INUSE)
|
|
{
|
|
/* Mark it for deletion later on */
|
|
WARN("Hook still running, deletion delayed\n" );
|
|
data->proc = (HOOKPROC)0;
|
|
return TRUE;
|
|
}
|
|
|
|
if (data->id == WH_JOURNALPLAYBACK) EnableHardwareInput16(TRUE);
|
|
|
|
/* Remove it from the linked list */
|
|
|
|
if (data->ownerQueue)
|
|
{
|
|
MESSAGEQUEUE *queue = (MESSAGEQUEUE *)QUEUE_Lock( data->ownerQueue );
|
|
if (!queue) return FALSE;
|
|
prevHandle = &queue->hooks[data->id - WH_MINHOOK];
|
|
QUEUE_Unlock( queue );
|
|
}
|
|
else prevHandle = &HOOK_systemHooks[data->id - WH_MINHOOK];
|
|
|
|
while (*prevHandle && *prevHandle != HHOOK_16(hook))
|
|
prevHandle = &((HOOKDATA *)USER_HEAP_LIN_ADDR(*prevHandle))->next;
|
|
|
|
if (!*prevHandle) return FALSE;
|
|
*prevHandle = data->next;
|
|
|
|
USER_HEAP_FREE(HHOOK_16(hook));
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HOOK_FindValidHook
|
|
*/
|
|
static HHOOK HOOK_FindValidHook( HHOOK hook )
|
|
{
|
|
HOOKDATA *data;
|
|
|
|
for (;;)
|
|
{
|
|
if (!(data = (HOOKDATA *)USER_HEAP_LIN_ADDR(HHOOK_16(hook)))) return 0;
|
|
if (data->proc) return hook;
|
|
hook = HHOOK_32(data->next);
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* HOOK_CallHook
|
|
*
|
|
* Call a hook procedure.
|
|
*/
|
|
static LRESULT HOOK_CallHook( HHOOK hook, INT fromtype, INT code,
|
|
WPARAM wParam, LPARAM lParam )
|
|
{
|
|
MESSAGEQUEUE *queue;
|
|
HANDLE16 prevHandle;
|
|
HOOKDATA *data = (HOOKDATA *)USER_HEAP_LIN_ADDR(HHOOK_16(hook));
|
|
LRESULT ret;
|
|
|
|
if (!(queue = QUEUE_Current())) return 0;
|
|
prevHandle = queue->hCurHook;
|
|
queue->hCurHook = HHOOK_16(hook);
|
|
|
|
TRACE("Calling hook %04x: %d %08x %08lx\n", hook, code, wParam, lParam );
|
|
|
|
data->flags |= HOOK_INUSE;
|
|
ret = call_hook( data, fromtype, code, wParam, lParam );
|
|
data->flags &= ~HOOK_INUSE;
|
|
|
|
TRACE("Ret hook %04x = %08lx\n", hook, ret );
|
|
|
|
queue->hCurHook = prevHandle;
|
|
if (!data->proc) HOOK_RemoveHook( hook );
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* Exported Functions & APIs
|
|
*/
|
|
|
|
/***********************************************************************
|
|
* HOOK_IsHooked
|
|
*
|
|
* Replacement for calling HOOK_GetHook from other modules.
|
|
*/
|
|
BOOL HOOK_IsHooked( INT16 id )
|
|
{
|
|
return HOOK_GetHook( id ) != 0;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HOOK_CallHooks16
|
|
*
|
|
* Call a hook chain.
|
|
*/
|
|
LRESULT HOOK_CallHooks16( INT16 id, INT16 code, WPARAM16 wParam,
|
|
LPARAM lParam )
|
|
{
|
|
HHOOK hook;
|
|
|
|
if (!(hook = HOOK_GetHook( id ))) return 0;
|
|
if (!(hook = HOOK_FindValidHook(hook))) return 0;
|
|
return HOOK_CallHook( hook, HOOK_WIN16, code, wParam, lParam );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* HOOK_CallHooksA
|
|
*
|
|
* Call a hook chain.
|
|
*/
|
|
LRESULT HOOK_CallHooksA( INT id, INT code, WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
HHOOK hook;
|
|
|
|
if (!(hook = HOOK_GetHook( id ))) return 0;
|
|
if (!(hook = HOOK_FindValidHook(hook))) return 0;
|
|
return HOOK_CallHook( hook, HOOK_WIN32A, code, wParam, lParam );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* HOOK_CallHooksW
|
|
*
|
|
* Call a hook chain.
|
|
*/
|
|
LRESULT HOOK_CallHooksW( INT id, INT code, WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
HHOOK hook;
|
|
|
|
if (!(hook = HOOK_GetHook( id ))) return 0;
|
|
if (!(hook = HOOK_FindValidHook(hook))) return 0;
|
|
return HOOK_CallHook( hook, HOOK_WIN32W, code, wParam,
|
|
lParam );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HOOK_FreeModuleHooks
|
|
*/
|
|
void HOOK_FreeModuleHooks( HMODULE16 hModule )
|
|
{
|
|
/* remove all system hooks registered by this module */
|
|
|
|
HOOKDATA* hptr;
|
|
HANDLE16 handle, next;
|
|
int id;
|
|
|
|
for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
|
|
{
|
|
handle = HOOK_systemHooks[id - WH_MINHOOK];
|
|
while( handle )
|
|
if( (hptr = (HOOKDATA *)USER_HEAP_LIN_ADDR(handle)) )
|
|
{
|
|
next = hptr->next;
|
|
if( hptr->ownerModule == hModule )
|
|
{
|
|
hptr->flags &= HOOK_MAPTYPE;
|
|
HOOK_RemoveHook(HHOOK_32(handle));
|
|
}
|
|
handle = next;
|
|
}
|
|
else handle = 0;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* HOOK_FreeQueueHooks
|
|
*/
|
|
void HOOK_FreeQueueHooks(void)
|
|
{
|
|
/* remove all hooks registered by the current queue */
|
|
|
|
HOOKDATA* hptr = NULL;
|
|
HHOOK hook, next;
|
|
int id;
|
|
|
|
for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
|
|
{
|
|
hook = HOOK_GetHook( id );
|
|
while( hook )
|
|
{
|
|
next = HOOK_GetNextHook(hook);
|
|
|
|
hptr = (HOOKDATA *)USER_HEAP_LIN_ADDR(HHOOK_16(hook));
|
|
if( hptr && hptr->ownerQueue )
|
|
{
|
|
hptr->flags &= HOOK_MAPTYPE;
|
|
HOOK_RemoveHook(hook);
|
|
}
|
|
hook = next;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetWindowsHook (USER.121)
|
|
*/
|
|
FARPROC16 WINAPI SetWindowsHook16( INT16 id, HOOKPROC16 proc )
|
|
{
|
|
HINSTANCE16 hInst = FarGetOwner16( HIWORD(proc) );
|
|
|
|
/* WH_MSGFILTER is the only task-specific hook for SetWindowsHook() */
|
|
HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
|
|
|
|
return (FARPROC16)SetWindowsHookEx16( id, proc, hInst, hTask );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* SetWindowsHookA (USER32.@)
|
|
*/
|
|
HHOOK WINAPI SetWindowsHookA( INT id, HOOKPROC proc )
|
|
{
|
|
return SetWindowsHookExA( id, proc, 0, GetCurrentThreadId() );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* SetWindowsHookW (USER32.@)
|
|
*/
|
|
HHOOK WINAPI SetWindowsHookW( INT id, HOOKPROC proc )
|
|
{
|
|
return SetWindowsHookExW( id, proc, 0, GetCurrentThreadId() );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetWindowsHookEx (USER.291)
|
|
* SetWindowsHookEx16 (USER32.@)
|
|
*/
|
|
HHOOK WINAPI SetWindowsHookEx16( INT16 id, HOOKPROC16 proc, HINSTANCE16 hInst,
|
|
HTASK16 hTask )
|
|
{
|
|
if (id == WH_DEBUG)
|
|
{
|
|
FIXME("WH_DEBUG is broken in 16-bit Windows.\n");
|
|
return 0;
|
|
}
|
|
return HOOK_SetHook( id, proc, HOOK_WIN16, GetExePtr(hInst), (DWORD)hTask );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* SetWindowsHookExA (USER32.@)
|
|
*/
|
|
HHOOK WINAPI SetWindowsHookExA( INT id, HOOKPROC proc, HINSTANCE hInst,
|
|
DWORD dwThreadId )
|
|
{
|
|
return HOOK_SetHook( id, proc, HOOK_WIN32A, MapHModuleLS(hInst), dwThreadId );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* SetWindowsHookExW (USER32.@)
|
|
*/
|
|
HHOOK WINAPI SetWindowsHookExW( INT id, HOOKPROC proc, HINSTANCE hInst,
|
|
DWORD dwThreadId )
|
|
{
|
|
return HOOK_SetHook( id, proc, HOOK_WIN32W, MapHModuleLS(hInst), dwThreadId );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* UnhookWindowsHook (USER.234)
|
|
*/
|
|
BOOL16 WINAPI UnhookWindowsHook16( INT16 id, HOOKPROC16 proc )
|
|
{
|
|
return UnhookWindowsHook( id, (HOOKPROC)proc );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* UnhookWindowsHook (USER32.@)
|
|
*/
|
|
BOOL WINAPI UnhookWindowsHook( INT id, HOOKPROC proc )
|
|
{
|
|
HHOOK hook = HOOK_GetHook( id );
|
|
|
|
TRACE("%d %08lx\n", id, (DWORD)proc );
|
|
|
|
while (hook)
|
|
{
|
|
HOOKDATA *data = (HOOKDATA *)USER_HEAP_LIN_ADDR(HHOOK_16(hook));
|
|
if (data->proc == proc) break;
|
|
hook = HOOK_GetNextHook( hook );
|
|
}
|
|
if (!hook) return FALSE;
|
|
return HOOK_RemoveHook( hook );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* UnhookWindowsHookEx (USER.292)
|
|
*/
|
|
BOOL16 WINAPI UnhookWindowsHookEx16( HHOOK hhook )
|
|
{
|
|
return HOOK_RemoveHook(hhook);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* UnhookWindowsHookEx (USER32.@)
|
|
*/
|
|
BOOL WINAPI UnhookWindowsHookEx( HHOOK hhook )
|
|
{
|
|
return HOOK_RemoveHook(hhook);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CallNextHookEx (USER.293)
|
|
* CallNextHookEx16 (USER32.@)
|
|
*
|
|
* I wouldn't have separated this into 16 and 32 bit versions, but I
|
|
* need a way to figure out if I need to do a mapping or not.
|
|
*/
|
|
LRESULT WINAPI CallNextHookEx16( HHOOK hhook, INT16 code, WPARAM16 wParam,
|
|
LPARAM lParam )
|
|
{
|
|
HHOOK next;
|
|
|
|
if (!(next = HOOK_GetNextHook(hhook))) return 0;
|
|
|
|
return HOOK_CallHook( next, HOOK_WIN16, code, wParam, lParam );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CallNextHookEx (USER32.@)
|
|
*
|
|
* There aren't ANSI and UNICODE versions of this.
|
|
*/
|
|
LRESULT WINAPI CallNextHookEx( HHOOK hhook, INT code, WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
HHOOK next;
|
|
INT fromtype; /* figure out Ansi/Unicode */
|
|
HOOKDATA *oldhook;
|
|
|
|
if (!(next = HOOK_GetNextHook(hhook))) return 0;
|
|
|
|
oldhook = (HOOKDATA *)USER_HEAP_LIN_ADDR(HHOOK_16(hhook));
|
|
fromtype = oldhook->flags & HOOK_MAPTYPE;
|
|
|
|
if (fromtype == HOOK_WIN16)
|
|
ERR("called from 16bit hook!\n");
|
|
|
|
return HOOK_CallHook( next, fromtype, code, wParam, lParam );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* DefHookProc (USER.235)
|
|
*/
|
|
LRESULT WINAPI DefHookProc16( INT16 code, WPARAM16 wParam, LPARAM lParam,
|
|
HHOOK *hhook )
|
|
{
|
|
/* Note: the *hhook parameter is never used, since we rely on the
|
|
* current hook value from the task queue to find the next hook. */
|
|
MESSAGEQUEUE *queue;
|
|
|
|
if (!(queue = QUEUE_Current())) return 0;
|
|
return CallNextHookEx16(HHOOK_32(queue->hCurHook), code, wParam, lParam);
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CallMsgFilter (USER.123)
|
|
*/
|
|
BOOL16 WINAPI CallMsgFilter16( SEGPTR msg, INT16 code )
|
|
{
|
|
if (GetSysModalWindow16()) return FALSE;
|
|
if (HOOK_CallHooks16( WH_SYSMSGFILTER, code, 0, (LPARAM)msg )) return TRUE;
|
|
return HOOK_CallHooks16( WH_MSGFILTER, code, 0, (LPARAM)msg );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CallMsgFilter32 (USER.823)
|
|
*/
|
|
BOOL16 WINAPI CallMsgFilter32_16( SEGPTR msg16_32, INT16 code, BOOL16 wHaveParamHigh )
|
|
{
|
|
MSG32_16 *lpmsg16_32 = MapSL(msg16_32);
|
|
|
|
if (wHaveParamHigh == FALSE)
|
|
{
|
|
lpmsg16_32->wParamHigh = 0;
|
|
/* WARNING: msg16_32->msg has to be the first variable in the struct */
|
|
return CallMsgFilter16(msg16_32, code);
|
|
}
|
|
else
|
|
{
|
|
MSG msg32;
|
|
BOOL16 ret;
|
|
|
|
msg32.hwnd = WIN_Handle32( lpmsg16_32->msg.hwnd );
|
|
msg32.message = lpmsg16_32->msg.message;
|
|
msg32.wParam = MAKELONG(lpmsg16_32->msg.wParam, lpmsg16_32->wParamHigh);
|
|
msg32.lParam = lpmsg16_32->msg.lParam;
|
|
msg32.time = lpmsg16_32->msg.time;
|
|
msg32.pt.x = lpmsg16_32->msg.pt.x;
|
|
msg32.pt.y = lpmsg16_32->msg.pt.y;
|
|
|
|
ret = (BOOL16)CallMsgFilterA(&msg32, (INT)code);
|
|
|
|
lpmsg16_32->msg.hwnd = HWND_16( msg32.hwnd );
|
|
lpmsg16_32->msg.message = msg32.message;
|
|
lpmsg16_32->msg.wParam = LOWORD(msg32.wParam);
|
|
lpmsg16_32->msg.lParam = msg32.lParam;
|
|
lpmsg16_32->msg.time = msg32.time;
|
|
lpmsg16_32->msg.pt.x = msg32.pt.x;
|
|
lpmsg16_32->msg.pt.y = msg32.pt.y;
|
|
lpmsg16_32->wParamHigh = HIWORD(msg32.wParam);
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CallMsgFilterA (USER32.@)
|
|
*
|
|
* FIXME: There are ANSI and UNICODE versions of this, plus an unspecified
|
|
* version, plus USER (the 16bit one) has a CallMsgFilter32 function.
|
|
*/
|
|
BOOL WINAPI CallMsgFilterA( LPMSG msg, INT code )
|
|
{
|
|
if (GetSysModalWindow16()) return FALSE; /* ??? */
|
|
if (HOOK_CallHooksA( WH_SYSMSGFILTER, code, 0, (LPARAM)msg ))
|
|
return TRUE;
|
|
return HOOK_CallHooksA( WH_MSGFILTER, code, 0, (LPARAM)msg );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CallMsgFilterW (USER32.@)
|
|
*/
|
|
BOOL WINAPI CallMsgFilterW( LPMSG msg, INT code )
|
|
{
|
|
if (GetSysModalWindow16()) return FALSE; /* ??? */
|
|
if (HOOK_CallHooksW( WH_SYSMSGFILTER, code, 0, (LPARAM)msg ))
|
|
return TRUE;
|
|
return HOOK_CallHooksW( WH_MSGFILTER, code, 0, (LPARAM)msg );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetWinEventHook [USER32.@]
|
|
*
|
|
* Set up an event hook for a set of events.
|
|
*
|
|
* PARAMS
|
|
* dwMin [I] Lowest event handled by pfnProc
|
|
* dwMax [I] Highest event handled by pfnProc
|
|
* hModule [I] DLL containing pfnProc
|
|
* pfnProc [I] Callback event hook function
|
|
* dwProcess [I] Process to get events from, or 0 for all processes
|
|
* dwThread [I] Thread to get events from, or 0 for all threads
|
|
* dwFlags [I] Flags indicating the status of pfnProc
|
|
*
|
|
* RETURNS
|
|
* Success: A handle representing the hook.
|
|
* Failure: A NULL handle.
|
|
*
|
|
* BUGS
|
|
* Not implemented.
|
|
*/
|
|
HWINEVENTHOOK WINAPI SetWinEventHook(DWORD dwMin, DWORD dwMax, HMODULE hModule,
|
|
WINEVENTPROC pfnProc, DWORD dwProcess,
|
|
DWORD dwThread, DWORD dwFlags)
|
|
{
|
|
FIXME("(%ld,%ld,0x%08x,%p,%ld,%ld,0x%08lx)-stub!\n", dwMin, dwMax, hModule,
|
|
pfnProc, dwProcess, dwThread, dwFlags);
|
|
|
|
return (HWINEVENTHOOK)0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* UnhookWinEvent [USER32.@]
|
|
*
|
|
* Remove an event hook for a set of events.
|
|
*
|
|
* PARAMS
|
|
* hEventHook [I] Event hook to remove
|
|
*
|
|
* RETURNS
|
|
* Success: TRUE. The event hook has been removed.
|
|
* Failure: FALSE, if hEventHook is invalid.
|
|
*
|
|
* BUGS
|
|
* Not implemented.
|
|
*/
|
|
BOOL WINAPI UnhookWinEvent(HWINEVENTHOOK hEventHook)
|
|
{
|
|
FIXME("(%p)-stub!\n", (void*)hEventHook);
|
|
|
|
if (!hEventHook)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NotifyWinEvent [USER32.@]
|
|
*
|
|
* Inform the OS that an event has occurred.
|
|
*
|
|
* PARAMS
|
|
* dwEvent [I] Id of the event
|
|
* hWnd [I] Window holding the object that created the event
|
|
* nId [I] Type of object that created the event
|
|
* nChildId [I] Child object of nId, or CHILDID_SELF.
|
|
*
|
|
* RETURNS
|
|
* Nothing.
|
|
*
|
|
* BUGS
|
|
* Not implemented.
|
|
*/
|
|
VOID WINAPI NotifyWinEvent(DWORD dwEvent, HWND hWnd, LONG nId, LONG nChildId)
|
|
{
|
|
FIXME("(%ld,0x%08x,%ld,%ld)-stub!\n", dwEvent, hWnd, nId, nChildId);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* IsWinEventHookInstalled [USER32.@]
|
|
*
|
|
* Determine if an event hook is installed for an event.
|
|
*
|
|
* PARAMS
|
|
* dwEvent [I] Id of the event
|
|
*
|
|
* RETURNS
|
|
* TRUE, If there are any hooks installed for the event.
|
|
* FALSE, Otherwise.
|
|
*
|
|
* BUGS
|
|
* Not implemented.
|
|
*/
|
|
BOOL WINAPI IsWinEventHookInstalled(DWORD dwEvent)
|
|
{
|
|
FIXME("(%ld)-stub!\n", dwEvent);
|
|
return TRUE;
|
|
}
|