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