static control: Support SS_REALSIZEIMAGE.
[wine] / dlls / user / hook16.c
1 /*
2  * Windows 16-bit hook functions
3  *
4  * Copyright 1994, 1995, 2002 Alexandre Julliard
5  * Copyright 1996 Andrew Lewycky
6  *
7  * Based on investigations by Alex Korobka
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  */
23
24 #include <stdarg.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "wownt32.h"
30 #include "wine/winuser16.h"
31 #include "win.h"
32 #include "user_private.h"
33 #include "winproc.h"
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(hook);
37
38
39 static LRESULT CALLBACK call_WH_MSGFILTER( INT code, WPARAM wp, LPARAM lp );
40 static LRESULT CALLBACK call_WH_KEYBOARD( INT code, WPARAM wp, LPARAM lp );
41 static LRESULT CALLBACK call_WH_GETMESSAGE( INT code, WPARAM wp, LPARAM lp );
42 static LRESULT CALLBACK call_WH_CALLWNDPROC( INT code, WPARAM wp, LPARAM lp );
43 static LRESULT CALLBACK call_WH_CBT( INT code, WPARAM wp, LPARAM lp );
44 static LRESULT CALLBACK call_WH_MOUSE( INT code, WPARAM wp, LPARAM lp );
45 static LRESULT CALLBACK call_WH_SHELL( INT code, WPARAM wp, LPARAM lp );
46
47 #define WH_MAXHOOK16 WH_SHELL  /* Win16 only supports up to WH_SHELL */
48 #define NB_HOOKS16 (WH_MAXHOOK16 - WH_MINHOOK + 1)
49
50 static const HOOKPROC hook_procs[NB_HOOKS16] =
51 {
52     call_WH_MSGFILTER,   /* WH_MSGFILTER        */
53     NULL,                /* WH_JOURNALRECORD */
54     NULL,                /* WH_JOURNALPLAYBACK */
55     call_WH_KEYBOARD,    /* WH_KEYBOARD */
56     call_WH_GETMESSAGE,  /* WH_GETMESSAGE */
57     call_WH_CALLWNDPROC, /* WH_CALLWNDPROC */
58     call_WH_CBT,         /* WH_CBT */
59     NULL,                /* WH_SYSMSGFILTER */
60     call_WH_MOUSE,       /* WH_MOUSE */
61     NULL,                /* WH_HARDWARE */
62     NULL,                /* WH_DEBUG */
63     call_WH_SHELL        /* WH_SHELL */
64 };
65
66
67 /* this structure is stored in the thread queue */
68 struct hook16_queue_info
69 {
70     INT        id;                /* id of current hook */
71     HHOOK      hook[NB_HOOKS16];  /* Win32 hook handles */
72     HOOKPROC16 proc[NB_HOOKS16];  /* 16-bit hook procedures */
73 };
74
75
76
77 /***********************************************************************
78  *           map_msg_16_to_32
79  */
80 inline static void map_msg_16_to_32( const MSG16 *msg16, MSG *msg32 )
81 {
82     msg32->hwnd    = WIN_Handle32(msg16->hwnd);
83     msg32->message = msg16->message;
84     msg32->wParam  = msg16->wParam;
85     msg32->lParam  = msg16->lParam;
86     msg32->time    = msg16->time;
87     msg32->pt.x    = msg16->pt.x;
88     msg32->pt.y    = msg16->pt.y;
89 }
90
91
92 /***********************************************************************
93  *           map_msg_32_to_16
94  */
95 inline static void map_msg_32_to_16( const MSG *msg32, MSG16 *msg16 )
96 {
97     msg16->hwnd    = HWND_16(msg32->hwnd);
98     msg16->message = msg32->message;
99     msg16->wParam  = msg32->wParam;
100     msg16->lParam  = msg32->lParam;
101     msg16->time    = msg32->time;
102     msg16->pt.x    = msg32->pt.x;
103     msg16->pt.y    = msg32->pt.y;
104 }
105
106
107 /***********************************************************************
108  *           call_hook_16
109  */
110 static LRESULT call_hook_16( INT id, INT code, WPARAM wp, LPARAM lp )
111 {
112     struct hook16_queue_info *info = get_user_thread_info()->hook16_info;
113     WORD args[4];
114     DWORD ret;
115     INT prev_id = info->id;
116     info->id = id;
117
118     args[3] = code;
119     args[2] = wp;
120     args[1] = HIWORD(lp);
121     args[0] = LOWORD(lp);
122     WOWCallback16Ex( (DWORD)info->proc[id - WH_MINHOOK], WCB16_PASCAL, sizeof(args), args, &ret );
123
124     info->id = prev_id;
125
126     /* Grrr. While the hook procedure is supposed to have an LRESULT return
127        value even in Win16, it seems that for those hook types where the
128        return value is interpreted as BOOL, Windows doesn't actually check
129        the HIWORD ...  Some buggy Win16 programs, notably WINFILE, rely on
130        that, because they neglect to clear DX ... */
131     if (id != WH_JOURNALPLAYBACK) ret = LOWORD( ret );
132     return ret;
133 }
134
135
136 /***********************************************************************
137  *              call_WH_MSGFILTER
138  */
139 static LRESULT CALLBACK call_WH_MSGFILTER( INT code, WPARAM wp, LPARAM lp )
140 {
141     MSG *msg32 = (MSG *)lp;
142     MSG16 msg16;
143     LRESULT ret;
144
145     map_msg_32_to_16( msg32, &msg16 );
146     lp = MapLS( &msg16 );
147     ret = call_hook_16( WH_MSGFILTER, code, wp, lp );
148     UnMapLS( lp );
149     return ret;
150 }
151
152
153 /***********************************************************************
154  *              call_WH_KEYBOARD
155  */
156 static LRESULT CALLBACK call_WH_KEYBOARD( INT code, WPARAM wp, LPARAM lp )
157 {
158     return call_hook_16( WH_KEYBOARD, code, wp, lp );
159 }
160
161
162 /***********************************************************************
163  *              call_WH_GETMESSAGE
164  */
165 static LRESULT CALLBACK call_WH_GETMESSAGE( INT code, WPARAM wp, LPARAM lp )
166 {
167     MSG *msg32 = (MSG *)lp;
168     MSG16 msg16;
169     LRESULT ret;
170
171     map_msg_32_to_16( msg32, &msg16 );
172
173     lp = MapLS( &msg16 );
174     ret = call_hook_16( WH_GETMESSAGE, code, wp, lp );
175     UnMapLS( lp );
176
177     map_msg_16_to_32( &msg16, msg32 );
178     return ret;
179 }
180
181
182 /***********************************************************************
183  *              call_WH_CALLWNDPROC
184  */
185 static LRESULT CALLBACK call_WH_CALLWNDPROC( INT code, WPARAM wp, LPARAM lp )
186 {
187     CWPSTRUCT *cwp32 = (CWPSTRUCT *)lp;
188     CWPSTRUCT16 cwp16;
189     MSGPARAM16 mp16;
190     LRESULT ret;
191
192     cwp16.hwnd   = HWND_16(cwp32->hwnd);
193     cwp16.lParam = cwp32->lParam;
194
195     WINPROC_MapMsg32ATo16( cwp32->hwnd, cwp32->message, cwp32->wParam,
196                            &cwp16.message, &cwp16.wParam, &cwp16.lParam );
197
198     lp = MapLS( &cwp16 );
199     ret = call_hook_16( WH_CALLWNDPROC, code, wp, lp );
200     UnMapLS( lp );
201
202     mp16.wParam  = cwp16.wParam;
203     mp16.lParam  = cwp16.lParam;
204     mp16.lResult = 0;
205     WINPROC_UnmapMsg32ATo16( cwp32->hwnd, cwp32->message, cwp32->wParam, cwp32->lParam, &mp16 );
206     return ret;
207 }
208
209
210 /***********************************************************************
211  *              call_WH_CBT
212  */
213 static LRESULT CALLBACK call_WH_CBT( INT code, WPARAM wp, LPARAM lp )
214 {
215     LRESULT ret = 0;
216
217     switch (code)
218     {
219     case HCBT_CREATEWND:
220         {
221             CBT_CREATEWNDA *cbtcw32 = (CBT_CREATEWNDA *)lp;
222             CBT_CREATEWND16 cbtcw16;
223             CREATESTRUCT16 cs16;
224
225             cs16.lpCreateParams = (SEGPTR)cbtcw32->lpcs->lpCreateParams;
226             cs16.hInstance      = HINSTANCE_16(cbtcw32->lpcs->hInstance);
227             cs16.hMenu          = HMENU_16(cbtcw32->lpcs->hMenu);
228             cs16.hwndParent     = HWND_16(cbtcw32->lpcs->hwndParent);
229             cs16.cy             = cbtcw32->lpcs->cy;
230             cs16.cx             = cbtcw32->lpcs->cx;
231             cs16.y              = cbtcw32->lpcs->y;
232             cs16.x              = cbtcw32->lpcs->x;
233             cs16.style          = cbtcw32->lpcs->style;
234             cs16.lpszName       = MapLS( cbtcw32->lpcs->lpszName );
235             cs16.lpszClass      = MapLS( cbtcw32->lpcs->lpszClass );
236             cs16.dwExStyle      = cbtcw32->lpcs->dwExStyle;
237
238             cbtcw16.lpcs = (CREATESTRUCT16 *)MapLS( &cs16 );
239             cbtcw16.hwndInsertAfter = HWND_16( cbtcw32->hwndInsertAfter );
240
241             lp = MapLS( &cbtcw16 );
242             ret = call_hook_16( WH_CBT, code, wp, lp );
243             UnMapLS( cs16.lpszName );
244             UnMapLS( cs16.lpszClass );
245
246             cbtcw32->hwndInsertAfter = WIN_Handle32( cbtcw16.hwndInsertAfter );
247             UnMapLS( (SEGPTR)cbtcw16.lpcs );
248             UnMapLS( lp );
249             break;
250         }
251
252     case HCBT_ACTIVATE:
253         {
254             CBTACTIVATESTRUCT *cas32 = (CBTACTIVATESTRUCT *)lp;
255             CBTACTIVATESTRUCT16 cas16;
256
257             cas16.fMouse     = cas32->fMouse;
258             cas16.hWndActive = HWND_16( cas32->hWndActive );
259
260             lp = MapLS( &cas16 );
261             ret = call_hook_16( WH_CBT, code, wp, lp );
262             UnMapLS( lp );
263             break;
264         }
265     case HCBT_CLICKSKIPPED:
266         {
267             MOUSEHOOKSTRUCT *ms32 = (MOUSEHOOKSTRUCT *)lp;
268             MOUSEHOOKSTRUCT16 ms16;
269
270             ms16.pt.x         = ms32->pt.x;
271             ms16.pt.y         = ms32->pt.y;
272             ms16.hwnd         = HWND_16( ms32->hwnd );
273             ms16.wHitTestCode = ms32->wHitTestCode;
274             ms16.dwExtraInfo  = ms32->dwExtraInfo;
275
276             lp = MapLS( &ms16 );
277             ret = call_hook_16( WH_CBT, code, wp, lp );
278             UnMapLS( lp );
279             break;
280         }
281     case HCBT_MOVESIZE:
282         {
283             RECT *rect32 = (RECT *)lp;
284             RECT16 rect16;
285
286             rect16.left   = rect32->left;
287             rect16.top    = rect32->top;
288             rect16.right  = rect32->right;
289             rect16.bottom = rect32->bottom;
290             lp = MapLS( &rect16 );
291             ret = call_hook_16( WH_CBT, code, wp, lp );
292             UnMapLS( lp );
293             break;
294         }
295     }
296     return ret;
297 }
298
299
300 /***********************************************************************
301  *              call_WH_MOUSE
302  */
303 static LRESULT CALLBACK call_WH_MOUSE( INT code, WPARAM wp, LPARAM lp )
304 {
305     MOUSEHOOKSTRUCT *ms32 = (MOUSEHOOKSTRUCT *)lp;
306     MOUSEHOOKSTRUCT16 ms16;
307     LRESULT ret;
308
309     ms16.pt.x         = ms32->pt.x;
310     ms16.pt.y         = ms32->pt.y;
311     ms16.hwnd         = HWND_16( ms32->hwnd );
312     ms16.wHitTestCode = ms32->wHitTestCode;
313     ms16.dwExtraInfo  = ms32->dwExtraInfo;
314
315     lp = MapLS( &ms16 );
316     ret = call_hook_16( WH_MOUSE, code, wp, lp );
317     UnMapLS( lp );
318     return ret;
319 }
320
321
322 /***********************************************************************
323  *              call_WH_SHELL
324  */
325 static LRESULT CALLBACK call_WH_SHELL( INT code, WPARAM wp, LPARAM lp )
326 {
327     return call_hook_16( WH_SHELL, code, wp, lp );
328 }
329
330
331 /***********************************************************************
332  *              SetWindowsHook (USER.121)
333  */
334 FARPROC16 WINAPI SetWindowsHook16( INT16 id, HOOKPROC16 proc )
335 {
336     HINSTANCE16 hInst = FarGetOwner16( HIWORD(proc) );
337
338     /* WH_MSGFILTER is the only task-specific hook for SetWindowsHook() */
339     HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
340
341     return (FARPROC16)SetWindowsHookEx16( id, proc, hInst, hTask );
342 }
343
344
345 /***********************************************************************
346  *              SetWindowsHookEx (USER.291)
347  */
348 HHOOK WINAPI SetWindowsHookEx16( INT16 id, HOOKPROC16 proc, HINSTANCE16 hInst, HTASK16 hTask )
349 {
350     struct user_thread_info *thread_info = get_user_thread_info();
351     struct hook16_queue_info *info;
352     HHOOK hook;
353     int index = id - WH_MINHOOK;
354
355     if (id < WH_MINHOOK || id > WH_MAXHOOK16) return 0;
356     if (!hook_procs[index])
357     {
358         FIXME( "hook type %d broken in Win16\n", id );
359         return 0;
360     }
361     if (!hTask) FIXME( "System-global hooks (%d) broken in Win16\n", id );
362     else if (hTask != GetCurrentTask())
363     {
364         FIXME( "setting hook (%d) on other task not supported\n", id );
365         return 0;
366     }
367
368     if (!(info = thread_info->hook16_info))
369     {
370         if (!(info = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*info) ))) return 0;
371         thread_info->hook16_info = info;
372     }
373     if (info->hook[index])
374     {
375         FIXME( "Multiple hooks (%d) for the same task not supported yet\n", id );
376         return 0;
377     }
378     if (!(hook = SetWindowsHookExA( id, hook_procs[index], 0, GetCurrentThreadId() ))) return 0;
379     info->hook[index] = hook;
380     info->proc[index] = proc;
381     return hook;
382 }
383
384
385 /***********************************************************************
386  *              UnhookWindowsHook (USER.234)
387  */
388 BOOL16 WINAPI UnhookWindowsHook16( INT16 id, HOOKPROC16 proc )
389 {
390     struct hook16_queue_info *info;
391     int index = id - WH_MINHOOK;
392
393     if (id < WH_MINHOOK || id > WH_MAXHOOK16) return FALSE;
394     if (!(info = get_user_thread_info()->hook16_info)) return FALSE;
395     if (info->proc[index] != proc) return FALSE;
396     if (!UnhookWindowsHookEx( info->hook[index] )) return FALSE;
397     info->hook[index] = 0;
398     info->proc[index] = 0;
399     return TRUE;
400 }
401
402
403 /***********************************************************************
404  *              UnhookWindowsHookEx (USER.292)
405  */
406 BOOL16 WINAPI UnhookWindowsHookEx16( HHOOK hhook )
407 {
408     struct hook16_queue_info *info;
409     int index;
410
411     if (!(info = get_user_thread_info()->hook16_info)) return FALSE;
412     for (index = 0; index < NB_HOOKS16; index++)
413     {
414         if (info->hook[index] == hhook)
415         {
416             info->hook[index] = 0;
417             info->proc[index] = 0;
418             return UnhookWindowsHookEx( hhook );
419         }
420     }
421     return FALSE;
422 }
423
424
425 /***********************************************************************
426  *              CallMsgFilter32 (USER.823)
427  */
428 BOOL16 WINAPI CallMsgFilter32_16( MSG32_16 *lpmsg16_32, INT16 code, BOOL16 wHaveParamHigh )
429 {
430     MSG msg32;
431     BOOL16 ret;
432
433     if (GetSysModalWindow16()) return FALSE;
434     msg32.hwnd      = WIN_Handle32( lpmsg16_32->msg.hwnd );
435     msg32.message   = lpmsg16_32->msg.message;
436     msg32.lParam    = lpmsg16_32->msg.lParam;
437     msg32.time      = lpmsg16_32->msg.time;
438     msg32.pt.x      = lpmsg16_32->msg.pt.x;
439     msg32.pt.y      = lpmsg16_32->msg.pt.y;
440     if (wHaveParamHigh) msg32.wParam = MAKELONG(lpmsg16_32->msg.wParam, lpmsg16_32->wParamHigh);
441     else msg32.wParam = lpmsg16_32->msg.wParam;
442
443     ret = (BOOL16)CallMsgFilterA(&msg32, code);
444
445     lpmsg16_32->msg.hwnd    = HWND_16( msg32.hwnd );
446     lpmsg16_32->msg.message = msg32.message;
447     lpmsg16_32->msg.wParam  = LOWORD(msg32.wParam);
448     lpmsg16_32->msg.lParam  = msg32.lParam;
449     lpmsg16_32->msg.time    = msg32.time;
450     lpmsg16_32->msg.pt.x    = msg32.pt.x;
451     lpmsg16_32->msg.pt.y    = msg32.pt.y;
452     if (wHaveParamHigh) lpmsg16_32->wParamHigh = HIWORD(msg32.wParam);
453     return ret;
454 }
455
456
457 /***********************************************************************
458  *              CallMsgFilter (USER.123)
459  */
460 BOOL16 WINAPI CallMsgFilter16( MSG16 *msg, INT16 code )
461 {
462     return CallMsgFilter32_16( (MSG32_16 *)msg, code, FALSE );
463 }
464
465
466 /***********************************************************************
467  *              CallNextHookEx (USER.293)
468  */
469 LRESULT WINAPI CallNextHookEx16( HHOOK hhook, INT16 code, WPARAM16 wparam, LPARAM lparam )
470 {
471     struct hook16_queue_info *info;
472     LRESULT ret = 0;
473
474     if (!(info = get_user_thread_info()->hook16_info)) return 0;
475
476     switch (info->id)
477     {
478     case WH_MSGFILTER:
479     {
480         MSG16 *msg16 = MapSL(lparam);
481         MSG msg32;
482
483         map_msg_16_to_32( msg16, &msg32 );
484         ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&msg32 );
485         break;
486     }
487
488     case WH_GETMESSAGE:
489     {
490         MSG16 *msg16 = MapSL(lparam);
491         MSG msg32;
492
493         map_msg_16_to_32( msg16, &msg32 );
494         ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&msg32 );
495         map_msg_32_to_16( &msg32, msg16 );
496         break;
497     }
498
499     case WH_CALLWNDPROC:
500     {
501         CWPSTRUCT16 *cwp16 = MapSL(lparam);
502         CWPSTRUCT cwp32;
503
504         cwp32.hwnd   = WIN_Handle32(cwp16->hwnd);
505         cwp32.lParam = cwp16->lParam;
506
507         WINPROC_MapMsg16To32A( cwp32.hwnd, cwp16->message, cwp16->wParam,
508                                &cwp32.message, &cwp32.wParam, &cwp32.lParam );
509         ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&cwp32 );
510         WINPROC_UnmapMsg16To32A( cwp32.hwnd, cwp32.message, cwp32.wParam, cwp32.lParam, 0 );
511         break;
512     }
513
514     case WH_CBT:
515         switch (code)
516         {
517         case HCBT_CREATEWND:
518             {
519                 CBT_CREATEWNDA cbtcw32;
520                 CREATESTRUCTA cs32;
521                 CBT_CREATEWND16 *cbtcw16 = MapSL(lparam);
522                 CREATESTRUCT16 *cs16 = MapSL( (SEGPTR)cbtcw16->lpcs );
523
524                 cbtcw32.lpcs = &cs32;
525                 cbtcw32.hwndInsertAfter = WIN_Handle32( cbtcw16->hwndInsertAfter );
526
527                 cs32.lpCreateParams = (LPVOID)cs16->lpCreateParams;
528                 cs32.hInstance      = HINSTANCE_32(cs16->hInstance);
529                 cs32.hMenu          = HMENU_32(cs16->hMenu);
530                 cs32.hwndParent     = WIN_Handle32(cs16->hwndParent);
531                 cs32.cy             = cs16->cy;
532                 cs32.cx             = cs16->cx;
533                 cs32.y              = cs16->y;
534                 cs32.x              = cs16->x;
535                 cs32.style          = cs16->style;
536                 cs32.lpszName       = MapSL( cs16->lpszName );
537                 cs32.lpszClass      = MapSL( cs16->lpszClass );
538                 cs32.dwExStyle      = cs16->dwExStyle;
539
540                 ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&cbtcw32 );
541                 cbtcw16->hwndInsertAfter = HWND_16( cbtcw32.hwndInsertAfter );
542                 break;
543             }
544         case HCBT_ACTIVATE:
545             {
546                 CBTACTIVATESTRUCT16 *cas16 = MapSL(lparam);
547                 CBTACTIVATESTRUCT cas32;
548                 cas32.fMouse = cas16->fMouse;
549                 cas32.hWndActive = WIN_Handle32(cas16->hWndActive);
550                 ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&cas32 );
551                 break;
552             }
553         case HCBT_CLICKSKIPPED:
554             {
555                 MOUSEHOOKSTRUCT16 *ms16 = MapSL(lparam);
556                 MOUSEHOOKSTRUCT ms32;
557
558                 ms32.pt.x = ms16->pt.x;
559                 ms32.pt.y = ms16->pt.y;
560                 /* wHitTestCode may be negative, so convince compiler to do
561                    correct sign extension. Yay. :| */
562                 ms32.wHitTestCode = (INT)(INT16)ms16->wHitTestCode;
563                 ms32.dwExtraInfo = ms16->dwExtraInfo;
564                 ms32.hwnd = WIN_Handle32( ms16->hwnd );
565                 ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&ms32 );
566                 break;
567             }
568         case HCBT_MOVESIZE:
569             {
570                 RECT16 *rect16 = MapSL(lparam);
571                 RECT rect32;
572
573                 rect32.left   = rect16->left;
574                 rect32.top    = rect16->top;
575                 rect32.right  = rect16->right;
576                 rect32.bottom = rect16->bottom;
577                 ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&rect32 );
578                 break;
579             }
580         }
581         break;
582
583     case WH_MOUSE:
584     {
585         MOUSEHOOKSTRUCT16 *ms16 = MapSL(lparam);
586         MOUSEHOOKSTRUCT ms32;
587
588         ms32.pt.x = ms16->pt.x;
589         ms32.pt.y = ms16->pt.y;
590         /* wHitTestCode may be negative, so convince compiler to do
591            correct sign extension. Yay. :| */
592         ms32.wHitTestCode = (INT)((INT16)ms16->wHitTestCode);
593         ms32.dwExtraInfo = ms16->dwExtraInfo;
594         ms32.hwnd = WIN_Handle32(ms16->hwnd);
595         ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&ms32 );
596         break;
597     }
598
599     case WH_SHELL:
600     case WH_KEYBOARD:
601         ret = CallNextHookEx( hhook, code, wparam, lparam );
602         break;
603
604     case WH_HARDWARE:
605     case WH_FOREGROUNDIDLE:
606     case WH_CALLWNDPROCRET:
607     case WH_SYSMSGFILTER:
608     case WH_JOURNALRECORD:
609     case WH_JOURNALPLAYBACK:
610     default:
611         FIXME("\t[%i] 16to32 translation unimplemented\n", info->id);
612         ret = CallNextHookEx( hhook, code, wparam, lparam );
613         break;
614     }
615     return ret;
616 }
617
618
619 /***********************************************************************
620  *              DefHookProc (USER.235)
621  */
622 LRESULT WINAPI DefHookProc16( INT16 code, WPARAM16 wparam, LPARAM lparam, HHOOK *hhook )
623 {
624     return CallNextHookEx16( *hhook, code, wparam, lparam );
625 }