2 * Window procedure callbacks
4 * Copyright 1995 Martin von Loewis
5 * Copyright 1996 Alexandre Julliard
12 #include "wine/winbase16.h"
13 #include "wine/winuser16.h"
14 #include "stackframe.h"
15 #include "builtin16.h"
17 #include "selectors.h"
21 #include "debugtools.h"
28 DECLARE_DEBUG_CHANNEL(msg
);
29 DECLARE_DEBUG_CHANNEL(relay
);
30 DECLARE_DEBUG_CHANNEL(win
);
32 /* Window procedure 16-to-32-bit thunk,
33 * see BuildSpec16File() in tools/build.c */
38 WORD pushw_bp
; /* pushw %bp */
39 BYTE pushl_func
; /* pushl $proc */
41 WORD pushw_ax
; /* pushw %ax */
42 BYTE pushl_relay
; /* pushl $relay */
43 void (*relay
)(); /* WINPROC_Thunk16To32A/W() */
44 BYTE lcall
; /* lcall cs:glue */
45 void (*glue
)(); /* __wine_call_from_16_long */
46 WORD cs
; /* __FLATCS */
47 WORD lret
; /* lret $10 */
49 } WINPROC_THUNK_FROM16
;
52 /* Window procedure 32-to-16-bit thunk,
53 * see BuildSpec32File() in tools/build.c */
57 BYTE popl_eax
; /* popl %eax (return address) */
58 BYTE pushl_func
; /* pushl $proc */
59 WNDPROC16 proc WINE_PACKED
;
60 BYTE pushl_eax
; /* pushl %eax */
61 BYTE jmp
; /* jmp relay (relative jump)*/
62 void (*relay
)() WINE_PACKED
; /* WINPROC_CallProc32ATo16() */
63 } WINPROC_THUNK_FROM32
;
65 /* Simple jmp to call 32-bit procedure directly */
68 BYTE jmp
; /* jmp proc (relative jump) */
69 WNDPROC proc WINE_PACKED
;
74 WINPROC_THUNK_FROM16 t_from16
;
75 WINPROC_THUNK_FROM32 t_from32
;
78 typedef struct tagWINDOWPROC
80 WINPROC_THUNK thunk
; /* Thunk */
81 WINPROC_JUMP jmp
; /* Jump */
82 struct tagWINDOWPROC
*next
; /* Next window proc */
83 UINT magic
; /* Magic number */
84 WINDOWPROCTYPE type
; /* Function type */
85 WINDOWPROCUSER user
; /* Function user */
88 #define WINPROC_MAGIC ('W' | ('P' << 8) | ('R' << 16) | ('C' << 24))
90 #define WINPROC_THUNKPROC(pproc) \
91 (((pproc)->type == WIN_PROC_16) ? \
92 (WNDPROC16)((pproc)->thunk.t_from32.proc) : \
93 (WNDPROC16)((pproc)->thunk.t_from16.proc))
95 static LRESULT WINAPI
WINPROC_CallProc32ATo16( WNDPROC16 func
, HWND hwnd
,
96 UINT msg
, WPARAM wParam
,
98 static LRESULT WINAPI
WINPROC_CallProc32WTo16( WNDPROC16 func
, HWND hwnd
,
99 UINT msg
, WPARAM wParam
,
101 static LRESULT WINAPI
WINPROC_Thunk16To32A( WNDPROC func
, LPBYTE args
);
102 static LRESULT WINAPI
WINPROC_Thunk16To32W( WNDPROC func
, LPBYTE args
);
104 static HANDLE WinProcHeap
;
107 /**********************************************************************
110 BOOL
WINPROC_Init(void)
112 WinProcHeap
= HeapCreate( HEAP_WINE_SEGPTR
| HEAP_WINE_CODESEG
, 0, 0 );
115 WARN_(relay
)("Unable to create winproc heap\n" );
123 /* Some window procedures modify register they shouldn't, or are not
124 * properly declared stdcall; so we need a small assembly wrapper to
126 extern LRESULT
WINPROC_wrapper( WNDPROC proc
, HWND hwnd
, UINT msg
,
127 WPARAM wParam
, LPARAM lParam
);
128 __ASM_GLOBAL_FUNC( WINPROC_wrapper
,
138 "movl 8(%ebp),%eax\n\t"
140 "leal -12(%ebp),%esp\n\t"
147 static inline LRESULT
WINPROC_wrapper( WNDPROC proc
, HWND hwnd
, UINT msg
,
148 WPARAM wParam
, LPARAM lParam
)
150 return proc( hwnd
, msg
, wParam
, lParam
);
152 #endif /* __i386__ */
154 /**********************************************************************
155 * WINPROC_CallWndProc32
157 * Call a 32-bit WndProc.
159 static LRESULT
WINPROC_CallWndProc( WNDPROC proc
, HWND hwnd
, UINT msg
,
160 WPARAM wParam
, LPARAM lParam
)
165 TRACE_(relay
)("(wndproc=%p,hwnd=%08x,msg=%s,wp=%08x,lp=%08lx)\n",
166 proc
, hwnd
, SPY_GetMsgName(msg
), wParam
, lParam
);
167 /* To avoid any deadlocks, all the locks on the windows structures
168 must be suspended before the control is passed to the application */
169 iWndsLocks
= WIN_SuspendWndsLock();
170 retvalue
= WINPROC_wrapper( proc
, hwnd
, msg
, wParam
, lParam
);
171 WIN_RestoreWndsLock(iWndsLocks
);
172 TRACE_(relay
)("(wndproc=%p,hwnd=%08x,msg=%s,wp=%08x,lp=%08lx) ret=%08lx\n",
173 proc
, hwnd
, SPY_GetMsgName(msg
), wParam
, lParam
, retvalue
);
177 /***********************************************************************
178 * WINPROC_CallWndProc16
180 * Call a 16-bit window procedure
182 static LRESULT WINAPI
WINPROC_CallWndProc16( WNDPROC16 proc
, HWND16 hwnd
,
183 UINT16 msg
, WPARAM16 wParam
,
189 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
191 TEB
*teb
= NtCurrentTeb();
194 /* Window procedures want ax = hInstance, ds = es = ss */
196 memset(&context
, '\0', sizeof(context
));
197 context
.SegDs
= context
.SegEs
= SELECTOROF(teb
->cur_stack
);
198 context
.Eax
= wndPtr
? wndPtr
->hInstance
: context
.SegDs
;
199 context
.SegCs
= SELECTOROF(proc
);
200 context
.Eip
= OFFSETOF(proc
);
201 context
.Ebp
= OFFSETOF(teb
->cur_stack
)
202 + (WORD
)&((STACK16FRAME
*)0)->bp
;
204 WIN_ReleaseWndPtr(wndPtr
);
208 /* Some programs (eg. the "Undocumented Windows" examples, JWP) only
209 work if structures passed in lParam are placed in the stack/data
210 segment. Programmers easily make the mistake of converting lParam
211 to a near rather than a far pointer, since Windows apparently
212 allows this. We copy the structures to the 16 bit stack; this is
213 ugly but makes these programs work. */
218 offset
= sizeof(CREATESTRUCT16
); break;
220 offset
= sizeof(DRAWITEMSTRUCT16
); break;
222 offset
= sizeof(COMPAREITEMSTRUCT16
); break;
226 void *s
= PTR_SEG_TO_LIN(lParam
);
227 lParam
= stack16_push( offset
);
228 memcpy( PTR_SEG_TO_LIN(lParam
), s
, offset
);
232 iWndsLocks
= WIN_SuspendWndsLock();
234 args
= (WORD
*)THREAD_STACK16(teb
) - 5;
235 args
[0] = LOWORD(lParam
);
236 args
[1] = HIWORD(lParam
);
241 CallTo16RegisterShort( &context
, 5 * sizeof(WORD
) );
242 ret
= MAKELONG( LOWORD(context
.Eax
), LOWORD(context
.Edx
) );
243 if (offset
) stack16_pop( offset
);
245 WIN_RestoreWndsLock(iWndsLocks
);
251 /**********************************************************************
254 * Return a pointer to the win proc.
256 static WINDOWPROC
*WINPROC_GetPtr( WNDPROC16 handle
)
261 /* Check for a linear pointer */
263 if (HEAP_IsInsideHeap( WinProcHeap
, 0, (LPVOID
)handle
))
265 ptr
= (BYTE
*)handle
;
266 /* First check if it is the jmp address */
267 if (*ptr
== 0xe9 /* jmp */) ptr
-= (int)&((WINDOWPROC
*)0)->jmp
-
268 (int)&((WINDOWPROC
*)0)->thunk
;
269 /* Now it must be the thunk address */
270 if (*ptr
== 0x58 /* popl eax */) ptr
-= (int)&((WINDOWPROC
*)0)->thunk
;
271 /* Now we have a pointer to the WINDOWPROC struct */
272 if (((WINDOWPROC
*)ptr
)->magic
== WINPROC_MAGIC
)
273 return (WINDOWPROC
*)ptr
;
276 /* Check for a segmented pointer */
278 if (!IsBadReadPtr16((SEGPTR
)handle
,sizeof(WINDOWPROC
)-sizeof(proc
->thunk
)))
280 ptr
= (BYTE
*)PTR_SEG_TO_LIN(handle
);
281 if (!HEAP_IsInsideHeap( WinProcHeap
, 0, ptr
)) return NULL
;
282 /* It must be the thunk address */
283 if (*ptr
== 0x58 /* popl eax */) ptr
-= (int)&((WINDOWPROC
*)0)->thunk
;
284 /* Now we have a pointer to the WINDOWPROC struct */
285 if (((WINDOWPROC
*)ptr
)->magic
== WINPROC_MAGIC
)
286 return (WINDOWPROC
*)ptr
;
293 /**********************************************************************
294 * WINPROC_AllocWinProc
296 * Allocate a new window procedure.
298 static WINDOWPROC
*WINPROC_AllocWinProc( WNDPROC16 func
, WINDOWPROCTYPE type
,
299 WINDOWPROCUSER user
)
301 WINDOWPROC
*proc
, *oldproc
;
303 /* Allocate a window procedure */
305 if (!(proc
= HeapAlloc( WinProcHeap
, 0, sizeof(WINDOWPROC
) ))) return 0;
307 /* Check if the function is already a win proc */
309 if ((oldproc
= WINPROC_GetPtr( func
)))
318 proc
->thunk
.t_from32
.popl_eax
= 0x58; /* popl %eax */
319 proc
->thunk
.t_from32
.pushl_func
= 0x68; /* pushl $proc */
320 proc
->thunk
.t_from32
.proc
= func
;
321 proc
->thunk
.t_from32
.pushl_eax
= 0x50; /* pushl %eax */
322 proc
->thunk
.t_from32
.jmp
= 0xe9; /* jmp relay*/
323 proc
->thunk
.t_from32
.relay
= /* relative jump */
324 (void(*)())((DWORD
)WINPROC_CallProc32ATo16
-
325 (DWORD
)(&proc
->thunk
.t_from32
.relay
+ 1));
329 proc
->thunk
.t_from16
.pushw_bp
= 0x5566; /* pushw %bp */
330 proc
->thunk
.t_from16
.pushl_func
= 0x68; /* pushl $proc */
331 proc
->thunk
.t_from16
.proc
= (FARPROC
)func
;
332 proc
->thunk
.t_from16
.pushw_ax
= 0x5066; /* pushw %ax */
333 proc
->thunk
.t_from16
.pushl_relay
= 0x68; /* pushl $relay */
334 proc
->thunk
.t_from16
.relay
= (type
== WIN_PROC_32A
) ?
335 (void(*)())WINPROC_Thunk16To32A
:
336 (void(*)())WINPROC_Thunk16To32W
;
337 proc
->thunk
.t_from16
.lcall
= 0x9a; /* lcall cs:glue */
338 proc
->thunk
.t_from16
.glue
= (void*)__wine_call_from_16_long
;
339 proc
->thunk
.t_from16
.cs
= __get_cs();
340 proc
->thunk
.t_from16
.lret
= 0xca66;
341 proc
->thunk
.t_from16
.nArgs
= 10;
342 proc
->jmp
.jmp
= 0xe9;
343 /* Fixup relative jump */
344 proc
->jmp
.proc
= (WNDPROC
)((DWORD
)func
-
345 (DWORD
)(&proc
->jmp
.proc
+ 1));
348 /* Should not happen */
351 proc
->magic
= WINPROC_MAGIC
;
356 TRACE_(win
)("(%08x,%d): returning %08x\n",
357 (UINT
)func
, type
, (UINT
)proc
);
362 /**********************************************************************
365 * Get a window procedure pointer that can be passed to the Windows program.
367 WNDPROC16
WINPROC_GetProc( HWINDOWPROC proc
, WINDOWPROCTYPE type
)
369 if (!proc
) return NULL
;
370 if (type
== WIN_PROC_16
) /* We want a 16:16 address */
372 if (((WINDOWPROC
*)proc
)->type
== WIN_PROC_16
)
373 return ((WINDOWPROC
*)proc
)->thunk
.t_from32
.proc
;
375 return (WNDPROC16
)HEAP_GetSegptr( WinProcHeap
, 0,
376 &((WINDOWPROC
*)proc
)->thunk
);
378 else /* We want a 32-bit address */
380 if (((WINDOWPROC
*)proc
)->type
== WIN_PROC_16
)
381 return (WNDPROC16
)&((WINDOWPROC
*)proc
)->thunk
;
382 else if (type
!= ((WINDOWPROC
*)proc
)->type
)
383 /* Have to return the jmp address if types don't match */
384 return (WNDPROC16
)&((WINDOWPROC
*)proc
)->jmp
;
386 /* Some Win16 programs want to get back the proc they set */
387 return (WNDPROC16
)((WINDOWPROC
*)proc
)->thunk
.t_from16
.proc
;
392 /**********************************************************************
395 * Set the window procedure for a window or class. There are
396 * three tree classes of winproc callbacks:
398 * 1) class -> wp - not subclassed
399 * class -> wp -> wp -> wp -> wp - SetClassLong()
401 * 2) window -' / - not subclassed
402 * window -> wp -> wp ' - SetWindowLong()
404 * 3) timer -> wp - SetTimer()
406 * Initially, winproc of the window points to the current winproc
407 * thunk of its class. Subclassing prepends a new thunk to the
408 * window winproc chain at the head of the list. Thus, window thunk
409 * list includes class thunks and the latter are preserved when the
410 * window is destroyed.
413 BOOL
WINPROC_SetProc( HWINDOWPROC
*pFirst
, WNDPROC16 func
,
414 WINDOWPROCTYPE type
, WINDOWPROCUSER user
)
416 BOOL bRecycle
= FALSE
;
417 WINDOWPROC
*proc
, **ppPrev
;
419 /* Check if function is already in the list */
421 ppPrev
= (WINDOWPROC
**)pFirst
;
422 proc
= WINPROC_GetPtr( func
);
429 if ((*ppPrev
)->user
!= user
)
431 /* terminal thunk is being restored */
433 WINPROC_FreeProc( *pFirst
, (*ppPrev
)->user
);
434 *(WINDOWPROC
**)pFirst
= *ppPrev
;
443 if (((*ppPrev
)->type
== type
) &&
444 (func
== WINPROC_THUNKPROC(*ppPrev
)))
451 /* WPF_CLASS thunk terminates window thunk list */
452 if ((*ppPrev
)->user
!= user
) break;
453 ppPrev
= &(*ppPrev
)->next
;
458 /* Extract this thunk from the list */
460 *ppPrev
= proc
->next
;
462 else /* Allocate a new one */
464 if (proc
) /* Was already a win proc */
467 func
= WINPROC_THUNKPROC(proc
);
469 proc
= WINPROC_AllocWinProc( func
, type
, user
);
470 if (!proc
) return FALSE
;
473 /* Add the win proc at the head of the list */
475 TRACE_(win
)("(%08x,%08x,%d): res=%08x\n",
476 (UINT
)*pFirst
, (UINT
)func
, type
, (UINT
)proc
);
477 proc
->next
= *(WINDOWPROC
**)pFirst
;
478 *(WINDOWPROC
**)pFirst
= proc
;
483 /**********************************************************************
486 * Free a list of win procs.
488 void WINPROC_FreeProc( HWINDOWPROC proc
, WINDOWPROCUSER user
)
492 WINDOWPROC
*next
= ((WINDOWPROC
*)proc
)->next
;
493 if (((WINDOWPROC
*)proc
)->user
!= user
) break;
494 TRACE_(win
)("freeing %08x\n", (UINT
)proc
);
495 HeapFree( WinProcHeap
, 0, proc
);
501 /**********************************************************************
502 * WINPROC_GetProcType
504 * Return the window procedure type.
506 WINDOWPROCTYPE
WINPROC_GetProcType( HWINDOWPROC proc
)
509 (((WINDOWPROC
*)proc
)->magic
!= WINPROC_MAGIC
))
510 return WIN_PROC_INVALID
;
511 return ((WINDOWPROC
*)proc
)->type
;
513 /**********************************************************************
514 * WINPROC_TestCBForStr
516 * Return TRUE if the lparam is a string
518 static BOOL
WINPROC_TestCBForStr ( HWND hwnd
)
521 WND
* wnd
= WIN_FindWndPtr(hwnd
);
522 retvalue
= ( !(LOWORD(wnd
->dwStyle
) & (CBS_OWNERDRAWFIXED
| CBS_OWNERDRAWVARIABLE
)) ||
523 (LOWORD(wnd
->dwStyle
) & CBS_HASSTRINGS
) );
524 WIN_ReleaseWndPtr(wnd
);
527 /**********************************************************************
528 * WINPROC_TestLBForStr
530 * Return TRUE if the lparam is a string
532 static BOOL
WINPROC_TestLBForStr ( HWND hwnd
)
535 WND
* wnd
= WIN_FindWndPtr(hwnd
);
536 retvalue
= ( !(LOWORD(wnd
->dwStyle
) & (LBS_OWNERDRAWFIXED
| LBS_OWNERDRAWVARIABLE
)) ||
537 (LOWORD(wnd
->dwStyle
) & LBS_HASSTRINGS
) );
538 WIN_ReleaseWndPtr(wnd
);
542 /**********************************************************************
543 * WINPROC_MapMsg32ATo32W
545 * Map a message from Ansi to Unicode.
546 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
549 * WM_CHARTOITEM, WM_MENUCHAR
552 * WM_GETTEXT/WM_SETTEXT and static control with SS_ICON style:
553 * the first four bytes are the handle of the icon
554 * when the WM_SETTEXT message has been used to set the icon
556 INT
WINPROC_MapMsg32ATo32W( HWND hwnd
, UINT msg
, WPARAM
*pwparam
, LPARAM
*plparam
)
562 LPARAM
*ptr
= (LPARAM
*)HeapAlloc( GetProcessHeap(), 0,
563 *pwparam
* sizeof(WCHAR
) + sizeof(LPARAM
) );
565 *ptr
++ = *plparam
; /* Store previous lParam */
566 *plparam
= (LPARAM
)ptr
;
569 /* lparam is string (0-terminated) */
571 case WM_WININICHANGE
:
574 case CB_FINDSTRINGEXACT
:
575 case CB_SELECTSTRING
:
579 case LB_SELECTSTRING
:
581 *plparam
= (LPARAM
)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR
)*plparam
);
582 return (*plparam
? 1 : -1);
588 { CREATESTRUCTW cs
; /* new structure */
589 LPCWSTR lpszName
; /* allocated Name */
590 LPCWSTR lpszClass
; /* allocated Class */
593 struct s
*xs
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(struct s
));
595 xs
->cs
= *(CREATESTRUCTW
*)*plparam
;
596 if (HIWORD(xs
->cs
.lpszName
))
597 xs
->lpszName
= xs
->cs
.lpszName
= HEAP_strdupAtoW( GetProcessHeap(), 0,
598 (LPCSTR
)xs
->cs
.lpszName
);
599 if (HIWORD(xs
->cs
.lpszClass
))
600 xs
->lpszClass
= xs
->cs
.lpszClass
= HEAP_strdupAtoW( GetProcessHeap(), 0,
601 (LPCSTR
)xs
->cs
.lpszClass
);
602 *plparam
= (LPARAM
)xs
;
607 MDICREATESTRUCTW
*cs
=
608 (MDICREATESTRUCTW
*)HeapAlloc( GetProcessHeap(), 0, sizeof(*cs
) );
610 *cs
= *(MDICREATESTRUCTW
*)*plparam
;
611 if (HIWORD(cs
->szClass
))
612 cs
->szClass
= HEAP_strdupAtoW( GetProcessHeap(), 0,
613 (LPCSTR
)cs
->szClass
);
614 if (HIWORD(cs
->szTitle
))
615 cs
->szTitle
= HEAP_strdupAtoW( GetProcessHeap(), 0,
616 (LPCSTR
)cs
->szTitle
);
617 *plparam
= (LPARAM
)cs
;
623 case LB_INSERTSTRING
:
624 if ( WINPROC_TestLBForStr( hwnd
))
625 *plparam
= (LPARAM
)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR
)*plparam
);
626 return (*plparam
? 1 : -1);
628 case LB_GETTEXT
: /* fixme: fixed sized buffer */
629 { if ( WINPROC_TestLBForStr( hwnd
))
630 { LPARAM
*ptr
= (LPARAM
*)HeapAlloc( GetProcessHeap(), 0, 256 * sizeof(WCHAR
) + sizeof(LPARAM
) );
632 *ptr
++ = *plparam
; /* Store previous lParam */
633 *plparam
= (LPARAM
)ptr
;
640 case CB_INSERTSTRING
:
641 if ( WINPROC_TestCBForStr( hwnd
))
642 *plparam
= (LPARAM
)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR
)*plparam
);
643 return (*plparam
? 1 : -1);
645 case CB_GETLBTEXT
: /* fixme: fixed sized buffer */
646 { if ( WINPROC_TestCBForStr( hwnd
))
647 { LPARAM
*ptr
= (LPARAM
*)HeapAlloc( GetProcessHeap(), 0, 256 * sizeof(WCHAR
) + sizeof(LPARAM
) );
649 *ptr
++ = *plparam
; /* Store previous lParam */
650 *plparam
= (LPARAM
)ptr
;
657 { WORD len
= (WORD
)*plparam
;
658 LPARAM
*ptr
= (LPARAM
*) HeapAlloc( GetProcessHeap(), 0, sizeof(LPARAM
) + sizeof (WORD
) + len
*sizeof(WCHAR
) );
660 *ptr
++ = *plparam
; /* Store previous lParam */
661 *((WORD
*) ptr
) = len
; /* Store the length */
662 *plparam
= (LPARAM
)ptr
;
673 MultiByteToWideChar(CP_ACP
, 0, &ch
, 1, &wch
, 1);
678 case WM_ASKCBFORMATNAME
:
679 case WM_DEVMODECHANGE
:
680 case WM_PAINTCLIPBOARD
:
681 case WM_SIZECLIPBOARD
:
682 case EM_SETPASSWORDCHAR
:
683 FIXME_(msg
)("message %s (0x%x) needs translation, please report\n", SPY_GetMsgName(msg
), msg
);
685 default: /* No translation needed */
691 /**********************************************************************
692 * WINPROC_UnmapMsg32ATo32W
694 * Unmap a message that was mapped from Ansi to Unicode.
696 void WINPROC_UnmapMsg32ATo32W( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
702 LPARAM
*ptr
= (LPARAM
*)lParam
- 1;
703 if (wParam
> 0 && !WideCharToMultiByte( CP_ACP
, 0, (LPWSTR
)lParam
, -1,
704 (LPSTR
)*ptr
, wParam
, NULL
, NULL
))
705 ((LPSTR
)*ptr
)[wParam
-1] = 0;
706 HeapFree( GetProcessHeap(), 0, ptr
);
714 { CREATESTRUCTW cs
; /* new structure */
715 LPWSTR lpszName
; /* allocated Name */
716 LPWSTR lpszClass
; /* allocated Class */
718 struct s
*xs
= (struct s
*)lParam
;
719 if (xs
->lpszName
) HeapFree( GetProcessHeap(), 0, xs
->lpszName
);
720 if (xs
->lpszClass
) HeapFree( GetProcessHeap(), 0, xs
->lpszClass
);
721 HeapFree( GetProcessHeap(), 0, xs
);
727 MDICREATESTRUCTW
*cs
= (MDICREATESTRUCTW
*)lParam
;
728 if (HIWORD(cs
->szTitle
))
729 HeapFree( GetProcessHeap(), 0, (LPVOID
)cs
->szTitle
);
730 if (HIWORD(cs
->szClass
))
731 HeapFree( GetProcessHeap(), 0, (LPVOID
)cs
->szClass
);
732 HeapFree( GetProcessHeap(), 0, cs
);
737 case WM_WININICHANGE
:
740 case CB_FINDSTRINGEXACT
:
741 case CB_SELECTSTRING
:
745 case LB_SELECTSTRING
:
747 HeapFree( GetProcessHeap(), 0, (void *)lParam
);
752 case LB_INSERTSTRING
:
753 if ( WINPROC_TestLBForStr( hwnd
))
754 HeapFree( GetProcessHeap(), 0, (void *)lParam
);
758 { if ( WINPROC_TestLBForStr( hwnd
))
759 { LPARAM
*ptr
= (LPARAM
*)lParam
- 1;
760 WideCharToMultiByte( CP_ACP
, 0, (LPWSTR
)lParam
, -1, (LPSTR
)*ptr
, 0x7fffffff, NULL
, NULL
);
761 HeapFree( GetProcessHeap(), 0, ptr
);
768 case CB_INSERTSTRING
:
769 if ( WINPROC_TestCBForStr( hwnd
))
770 HeapFree( GetProcessHeap(), 0, (void *)lParam
);
774 { if ( WINPROC_TestCBForStr( hwnd
))
775 { LPARAM
*ptr
= (LPARAM
*)lParam
- 1;
776 WideCharToMultiByte( CP_ACP
, 0, (LPWSTR
)lParam
, -1, (LPSTR
)*ptr
, 0x7fffffff, NULL
, NULL
);
777 HeapFree( GetProcessHeap(), 0, ptr
);
784 { LPARAM
* ptr
= (LPARAM
*)lParam
- 1; /* get the old lParam */
785 WORD len
= *(WORD
*) lParam
;
786 if (len
> 0 && !WideCharToMultiByte( CP_ACP
, 0, (LPWSTR
)lParam
, -1,
787 (LPSTR
)*ptr
, len
, NULL
, NULL
))
788 ((LPSTR
)*ptr
)[len
-1] = 0;
789 HeapFree( GetProcessHeap(), 0, ptr
);
796 /**********************************************************************
797 * WINPROC_MapMsg32WTo32A
799 * Map a message from Unicode to Ansi.
800 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
802 INT
WINPROC_MapMsg32WTo32A( HWND hwnd
, UINT msg
, WPARAM
*pwparam
, LPARAM
*plparam
)
808 LPARAM
*ptr
= (LPARAM
*)HeapAlloc( GetProcessHeap(), 0,
809 *pwparam
+ sizeof(LPARAM
) );
811 *ptr
++ = *plparam
; /* Store previous lParam */
812 *plparam
= (LPARAM
)ptr
;
817 case WM_WININICHANGE
:
820 case CB_FINDSTRINGEXACT
:
821 case CB_SELECTSTRING
:
825 case LB_SELECTSTRING
:
827 *plparam
= (LPARAM
)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR
)*plparam
);
828 return (*plparam
? 1 : -1);
833 CREATESTRUCTA
*cs
= (CREATESTRUCTA
*)HeapAlloc( GetProcessHeap(), 0,
836 *cs
= *(CREATESTRUCTA
*)*plparam
;
837 if (HIWORD(cs
->lpszName
))
838 cs
->lpszName
= HEAP_strdupWtoA( GetProcessHeap(), 0,
839 (LPCWSTR
)cs
->lpszName
);
840 if (HIWORD(cs
->lpszClass
))
841 cs
->lpszClass
= HEAP_strdupWtoA( GetProcessHeap(), 0,
842 (LPCWSTR
)cs
->lpszClass
);
843 *plparam
= (LPARAM
)cs
;
848 MDICREATESTRUCTA
*cs
=
849 (MDICREATESTRUCTA
*)HeapAlloc( GetProcessHeap(), 0, sizeof(*cs
) );
851 *cs
= *(MDICREATESTRUCTA
*)*plparam
;
852 if (HIWORD(cs
->szTitle
))
853 cs
->szTitle
= HEAP_strdupWtoA( GetProcessHeap(), 0,
854 (LPCWSTR
)cs
->szTitle
);
855 if (HIWORD(cs
->szClass
))
856 cs
->szClass
= HEAP_strdupWtoA( GetProcessHeap(), 0,
857 (LPCWSTR
)cs
->szClass
);
858 *plparam
= (LPARAM
)cs
;
864 case LB_INSERTSTRING
:
865 if ( WINPROC_TestLBForStr( hwnd
))
866 *plparam
= (LPARAM
)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR
)*plparam
);
867 return (*plparam
? 1 : -1);
869 case LB_GETTEXT
: /* fixme: fixed sized buffer */
870 { if ( WINPROC_TestLBForStr( hwnd
))
871 { LPARAM
*ptr
= (LPARAM
*)HeapAlloc( GetProcessHeap(), 0, 256 + sizeof(LPARAM
) );
873 *ptr
++ = *plparam
; /* Store previous lParam */
874 *plparam
= (LPARAM
)ptr
;
881 case CB_INSERTSTRING
:
882 if ( WINPROC_TestCBForStr( hwnd
))
883 *plparam
= (LPARAM
)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR
)*plparam
);
884 return (*plparam
? 1 : -1);
886 case CB_GETLBTEXT
: /* fixme: fixed sized buffer */
887 { if ( WINPROC_TestCBForStr( hwnd
))
888 { LPARAM
*ptr
= (LPARAM
*)HeapAlloc( GetProcessHeap(), 0, 256 + sizeof(LPARAM
) );
890 *ptr
++ = *plparam
; /* Store previous lParam */
891 *plparam
= (LPARAM
)ptr
;
898 { WORD len
= (WORD
)*plparam
;
899 LPARAM
*ptr
= (LPARAM
*) HeapAlloc( GetProcessHeap(), 0, sizeof(LPARAM
) + sizeof (WORD
) + len
*sizeof(CHAR
) );
901 *ptr
++ = *plparam
; /* Store previous lParam */
902 *((WORD
*) ptr
) = len
; /* Store the length */
903 *plparam
= (LPARAM
)ptr
;
912 WCHAR wch
= *pwparam
;
914 WideCharToMultiByte( CP_ACP
, 0, &wch
, 1, &ch
, 1, NULL
, NULL
);
919 case WM_ASKCBFORMATNAME
:
920 case WM_DEVMODECHANGE
:
921 case WM_PAINTCLIPBOARD
:
922 case WM_SIZECLIPBOARD
:
923 case EM_SETPASSWORDCHAR
:
924 FIXME_(msg
)("message %s (%04x) needs translation, please report\n",SPY_GetMsgName(msg
),msg
);
926 default: /* No translation needed */
932 /**********************************************************************
933 * WINPROC_UnmapMsg32WTo32A
935 * Unmap a message that was mapped from Unicode to Ansi.
937 void WINPROC_UnmapMsg32WTo32A( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
943 LPARAM
*ptr
= (LPARAM
*)lParam
- 1;
946 if (!MultiByteToWideChar( CP_ACP
, 0, (LPSTR
)lParam
, -1, (LPWSTR
)*ptr
, wParam
))
947 ((LPWSTR
)*ptr
)[wParam
-1] = 0;
949 HeapFree( GetProcessHeap(), 0, ptr
);
954 case WM_WININICHANGE
:
957 case CB_FINDSTRINGEXACT
:
958 case CB_SELECTSTRING
:
962 case LB_SELECTSTRING
:
964 HeapFree( GetProcessHeap(), 0, (void *)lParam
);
970 CREATESTRUCTA
*cs
= (CREATESTRUCTA
*)lParam
;
971 if (HIWORD(cs
->lpszName
))
972 HeapFree( GetProcessHeap(), 0, (LPVOID
)cs
->lpszName
);
973 if (HIWORD(cs
->lpszClass
))
974 HeapFree( GetProcessHeap(), 0, (LPVOID
)cs
->lpszClass
);
975 HeapFree( GetProcessHeap(), 0, cs
);
981 MDICREATESTRUCTA
*cs
= (MDICREATESTRUCTA
*)lParam
;
982 if (HIWORD(cs
->szTitle
))
983 HeapFree( GetProcessHeap(), 0, (LPVOID
)cs
->szTitle
);
984 if (HIWORD(cs
->szClass
))
985 HeapFree( GetProcessHeap(), 0, (LPVOID
)cs
->szClass
);
986 HeapFree( GetProcessHeap(), 0, cs
);
992 case LB_INSERTSTRING
:
993 if ( WINPROC_TestLBForStr( hwnd
))
994 HeapFree( GetProcessHeap(), 0, (void *)lParam
);
998 if ( WINPROC_TestLBForStr( hwnd
))
1000 LPARAM
*ptr
= (LPARAM
*)lParam
- 1;
1001 MultiByteToWideChar( CP_ACP
, 0, (LPSTR
)lParam
, -1, (LPWSTR
)*ptr
, 0x7fffffff );
1002 HeapFree( GetProcessHeap(), 0, ptr
);
1008 case CB_INSERTSTRING
:
1009 if ( WINPROC_TestCBForStr( hwnd
))
1010 HeapFree( GetProcessHeap(), 0, (void *)lParam
);
1014 if ( WINPROC_TestCBForStr( hwnd
))
1016 LPARAM
*ptr
= (LPARAM
*)lParam
- 1;
1017 MultiByteToWideChar( CP_ACP
, 0, (LPSTR
)lParam
, -1, (LPWSTR
)*ptr
, 0x7fffffff );
1018 HeapFree( GetProcessHeap(), 0, ptr
);
1022 /* Multiline edit */
1024 { LPARAM
* ptr
= (LPARAM
*)lParam
- 1; /* get the old lparam */
1025 WORD len
= *(WORD
*)ptr
;
1028 if (!MultiByteToWideChar( CP_ACP
, 0, (LPSTR
)lParam
, -1, (LPWSTR
)*ptr
, len
))
1029 ((LPWSTR
)*ptr
)[len
-1] = 0;
1031 HeapFree( GetProcessHeap(), 0, ptr
);
1038 /**********************************************************************
1039 * WINPROC_MapMsg16To32A
1041 * Map a message from 16- to 32-bit Ansi.
1042 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1044 INT
WINPROC_MapMsg16To32A( UINT16 msg16
, WPARAM16 wParam16
, UINT
*pmsg32
,
1045 WPARAM
*pwparam32
, LPARAM
*plparam
)
1047 *pmsg32
= (UINT
)msg16
;
1048 *pwparam32
= (WPARAM
)wParam16
;
1055 *pwparam32
= MAKEWPARAM( wParam16
, HIWORD(*plparam
) );
1056 *plparam
= (LPARAM
)(HWND
)LOWORD(*plparam
);
1060 *pwparam32
= MAKEWPARAM( wParam16
, LOWORD(*plparam
) );
1061 *plparam
= (LPARAM
)(HWND
)HIWORD(*plparam
);
1064 if ( HIWORD(*plparam
) > CTLCOLOR_STATIC
) return -1;
1065 *pmsg32
= WM_CTLCOLORMSGBOX
+ HIWORD(*plparam
);
1066 *pwparam32
= (WPARAM
)(HDC
)wParam16
;
1067 *plparam
= (LPARAM
)(HWND
)LOWORD(*plparam
);
1069 case WM_COMPAREITEM
:
1071 COMPAREITEMSTRUCT16
* cis16
= (COMPAREITEMSTRUCT16
*)PTR_SEG_TO_LIN(*plparam
);
1072 COMPAREITEMSTRUCT
*cis
= (COMPAREITEMSTRUCT
*)
1073 HeapAlloc(GetProcessHeap(), 0, sizeof(*cis
));
1074 if (!cis
) return -1;
1075 cis
->CtlType
= cis16
->CtlType
;
1076 cis
->CtlID
= cis16
->CtlID
;
1077 cis
->hwndItem
= cis16
->hwndItem
;
1078 cis
->itemID1
= cis16
->itemID1
;
1079 cis
->itemData1
= cis16
->itemData1
;
1080 cis
->itemID2
= cis16
->itemID2
;
1081 cis
->itemData2
= cis16
->itemData2
;
1082 cis
->dwLocaleId
= 0; /* FIXME */
1083 *plparam
= (LPARAM
)cis
;
1088 DELETEITEMSTRUCT16
* dis16
= (DELETEITEMSTRUCT16
*)PTR_SEG_TO_LIN(*plparam
);
1089 DELETEITEMSTRUCT
*dis
= (DELETEITEMSTRUCT
*)
1090 HeapAlloc(GetProcessHeap(), 0, sizeof(*dis
));
1091 if (!dis
) return -1;
1092 dis
->CtlType
= dis16
->CtlType
;
1093 dis
->CtlID
= dis16
->CtlID
;
1094 dis
->hwndItem
= dis16
->hwndItem
;
1095 dis
->itemData
= dis16
->itemData
;
1096 *plparam
= (LPARAM
)dis
;
1099 case WM_MEASUREITEM
:
1101 MEASUREITEMSTRUCT16
* mis16
= (MEASUREITEMSTRUCT16
*)PTR_SEG_TO_LIN(*plparam
);
1102 MEASUREITEMSTRUCT
*mis
= (MEASUREITEMSTRUCT
*)
1103 HeapAlloc(GetProcessHeap(), 0,
1104 sizeof(*mis
) + sizeof(LPARAM
));
1105 if (!mis
) return -1;
1106 mis
->CtlType
= mis16
->CtlType
;
1107 mis
->CtlID
= mis16
->CtlID
;
1108 mis
->itemID
= mis16
->itemID
;
1109 mis
->itemWidth
= mis16
->itemWidth
;
1110 mis
->itemHeight
= mis16
->itemHeight
;
1111 mis
->itemData
= mis16
->itemData
;
1112 *(LPARAM
*)(mis
+ 1) = *plparam
; /* Store the previous lParam */
1113 *plparam
= (LPARAM
)mis
;
1118 DRAWITEMSTRUCT16
* dis16
= (DRAWITEMSTRUCT16
*)PTR_SEG_TO_LIN(*plparam
);
1119 DRAWITEMSTRUCT
*dis
= (DRAWITEMSTRUCT
*)HeapAlloc(GetProcessHeap(), 0,
1121 if (!dis
) return -1;
1122 dis
->CtlType
= dis16
->CtlType
;
1123 dis
->CtlID
= dis16
->CtlID
;
1124 dis
->itemID
= dis16
->itemID
;
1125 dis
->itemAction
= dis16
->itemAction
;
1126 dis
->itemState
= dis16
->itemState
;
1127 dis
->hwndItem
= dis16
->hwndItem
;
1128 dis
->hDC
= dis16
->hDC
;
1129 dis
->itemData
= dis16
->itemData
;
1130 CONV_RECT16TO32( &dis16
->rcItem
, &dis
->rcItem
);
1131 *plparam
= (LPARAM
)dis
;
1134 case WM_GETMINMAXINFO
:
1136 MINMAXINFO
*mmi
= (MINMAXINFO
*)HeapAlloc( GetProcessHeap(), 0,
1137 sizeof(*mmi
) + sizeof(LPARAM
));
1138 if (!mmi
) return -1;
1139 STRUCT32_MINMAXINFO16to32( (MINMAXINFO16
*)PTR_SEG_TO_LIN(*plparam
),
1141 *(LPARAM
*)(mmi
+ 1) = *plparam
; /* Store the previous lParam */
1142 *plparam
= (LPARAM
)mmi
;
1147 *plparam
= (LPARAM
)PTR_SEG_TO_LIN(*plparam
);
1151 MDICREATESTRUCT16
*cs16
=
1152 (MDICREATESTRUCT16
*)PTR_SEG_TO_LIN(*plparam
);
1153 MDICREATESTRUCTA
*cs
=
1154 (MDICREATESTRUCTA
*)HeapAlloc( GetProcessHeap(), 0,
1155 sizeof(*cs
) + sizeof(LPARAM
) );
1157 STRUCT32_MDICREATESTRUCT16to32A( cs16
, cs
);
1158 cs
->szTitle
= (LPCSTR
)PTR_SEG_TO_LIN(cs16
->szTitle
);
1159 cs
->szClass
= (LPCSTR
)PTR_SEG_TO_LIN(cs16
->szClass
);
1160 *(LPARAM
*)(cs
+ 1) = *plparam
; /* Store the previous lParam */
1161 *plparam
= (LPARAM
)cs
;
1164 case WM_MDIGETACTIVE
:
1165 *plparam
= (LPARAM
)HeapAlloc( GetProcessHeap(), 0, sizeof(BOOL
) );
1166 *(BOOL
*)(*plparam
) = 0;
1170 *pmsg32
=WM_MDIREFRESHMENU
;
1171 *pwparam32
= (WPARAM
)(HMENU
)LOWORD(*plparam
);
1172 *plparam
= (LPARAM
)(HMENU
)HIWORD(*plparam
);
1175 *pwparam32
= MAKEWPARAM( wParam16
, LOWORD(*plparam
) );
1176 *plparam
= (LPARAM
)(HMENU
)HIWORD(*plparam
);
1179 if((LOWORD(*plparam
) & MF_POPUP
) && (LOWORD(*plparam
) != 0xFFFF))
1181 HMENU hmenu
=(HMENU
)HIWORD(*plparam
);
1182 UINT Pos
=MENU_FindSubMenu( &hmenu
, wParam16
);
1183 if(Pos
==0xFFFF) Pos
=0; /* NO_SELECTED_ITEM */
1184 *pwparam32
= MAKEWPARAM( Pos
, LOWORD(*plparam
) );
1186 else *pwparam32
= MAKEWPARAM( wParam16
, LOWORD(*plparam
) );
1187 *plparam
= (LPARAM
)(HMENU
)HIWORD(*plparam
);
1189 case WM_MDIACTIVATE
:
1192 *pwparam32
= (WPARAM
)(HWND
)HIWORD(*plparam
);
1193 *plparam
= (LPARAM
)(HWND
)LOWORD(*plparam
);
1195 else /* message sent to MDI client */
1196 *pwparam32
= wParam16
;
1200 NCCALCSIZE_PARAMS16
*nc16
;
1201 NCCALCSIZE_PARAMS
*nc
;
1203 nc
= (NCCALCSIZE_PARAMS
*)HeapAlloc( GetProcessHeap(), 0,
1204 sizeof(*nc
) + sizeof(LPARAM
) );
1206 nc16
= (NCCALCSIZE_PARAMS16
*)PTR_SEG_TO_LIN(*plparam
);
1207 CONV_RECT16TO32( &nc16
->rgrc
[0], &nc
->rgrc
[0] );
1210 nc
->lppos
= (WINDOWPOS
*)HeapAlloc( GetProcessHeap(), 0,
1211 sizeof(*nc
->lppos
) );
1212 CONV_RECT16TO32( &nc16
->rgrc
[1], &nc
->rgrc
[1] );
1213 CONV_RECT16TO32( &nc16
->rgrc
[2], &nc
->rgrc
[2] );
1214 if (nc
->lppos
) STRUCT32_WINDOWPOS16to32( (WINDOWPOS16
*)PTR_SEG_TO_LIN(nc16
->lppos
), nc
->lppos
);
1216 *(LPARAM
*)(nc
+ 1) = *plparam
; /* Store the previous lParam */
1217 *plparam
= (LPARAM
)nc
;
1223 CREATESTRUCT16
*cs16
= (CREATESTRUCT16
*)PTR_SEG_TO_LIN(*plparam
);
1224 CREATESTRUCTA
*cs
= (CREATESTRUCTA
*)HeapAlloc( GetProcessHeap(), 0,
1225 sizeof(*cs
) + sizeof(LPARAM
) );
1227 STRUCT32_CREATESTRUCT16to32A( cs16
, cs
);
1228 cs
->lpszName
= (LPCSTR
)PTR_SEG_TO_LIN(cs16
->lpszName
);
1229 cs
->lpszClass
= (LPCSTR
)PTR_SEG_TO_LIN(cs16
->lpszClass
);
1230 *(LPARAM
*)(cs
+ 1) = *plparam
; /* Store the previous lParam */
1231 *plparam
= (LPARAM
)cs
;
1234 case WM_PARENTNOTIFY
:
1235 if ((wParam16
== WM_CREATE
) || (wParam16
== WM_DESTROY
))
1237 *pwparam32
= MAKEWPARAM( wParam16
, HIWORD(*plparam
) );
1238 *plparam
= (LPARAM
)(HWND
)LOWORD(*plparam
);
1241 case WM_WINDOWPOSCHANGING
:
1242 case WM_WINDOWPOSCHANGED
:
1244 WINDOWPOS
*wp
= (WINDOWPOS
*)HeapAlloc( GetProcessHeap(), 0,
1245 sizeof(*wp
) + sizeof(LPARAM
) );
1247 STRUCT32_WINDOWPOS16to32( (WINDOWPOS16
*)PTR_SEG_TO_LIN(*plparam
),
1249 *(LPARAM
*)(wp
+ 1) = *plparam
; /* Store the previous lParam */
1250 *plparam
= (LPARAM
)wp
;
1256 LPMSG16 msg16
= (LPMSG16
)PTR_SEG_TO_LIN(*plparam
);
1257 LPMSG msg32
= (LPMSG
)HeapAlloc( GetProcessHeap(), 0, sizeof(MSG
) );
1259 if (!msg32
) return -1;
1260 msg32
->hwnd
= msg16
->hwnd
;
1261 msg32
->lParam
= msg16
->lParam
;
1262 msg32
->time
= msg16
->time
;
1263 CONV_POINT16TO32(&msg16
->pt
,&msg32
->pt
);
1264 /* this is right, right? */
1265 if (WINPROC_MapMsg16To32A(msg16
->message
,msg16
->wParam
,
1266 &msg32
->message
,&msg32
->wParam
,
1267 &msg32
->lParam
)<0) {
1268 HeapFree( GetProcessHeap(), 0, msg32
);
1271 *plparam
= (LPARAM
)msg32
;
1276 *plparam
= (LPARAM
)PTR_SEG_TO_LIN(*plparam
);
1278 case WM_ACTIVATEAPP
:
1280 { /* We need this when SetActiveWindow sends a Sendmessage16() to
1281 a 32bit window. Might be superflous with 32bit interprocess
1284 HTASK16 htask
= (HTASK16
) *plparam
;
1285 DWORD idThread
= (DWORD
)((TDB
*)GlobalLock16(htask
))->teb
->tid
;
1286 *plparam
= (LPARAM
) idThread
;
1289 case WM_ASKCBFORMATNAME
:
1290 case WM_DEVMODECHANGE
:
1291 case WM_PAINTCLIPBOARD
:
1292 case WM_SIZECLIPBOARD
:
1293 case WM_WININICHANGE
:
1294 FIXME_(msg
)("message %04x needs translation\n",msg16
);
1297 default: /* No translation needed */
1303 /**********************************************************************
1304 * WINPROC_UnmapMsg16To32A
1306 * Unmap a message that was mapped from 16- to 32-bit Ansi.
1308 LRESULT
WINPROC_UnmapMsg16To32A( HWND16 hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
,
1313 case WM_COMPAREITEM
:
1316 HeapFree( GetProcessHeap(), 0, (LPVOID
)lParam
);
1318 case WM_MEASUREITEM
:
1320 MEASUREITEMSTRUCT16
*mis16
;
1321 MEASUREITEMSTRUCT
*mis
= (MEASUREITEMSTRUCT
*)lParam
;
1322 lParam
= *(LPARAM
*)(mis
+ 1);
1323 mis16
= (MEASUREITEMSTRUCT16
*)PTR_SEG_TO_LIN(lParam
);
1324 mis16
->itemWidth
= (UINT16
)mis
->itemWidth
;
1325 mis16
->itemHeight
= (UINT16
)mis
->itemHeight
;
1326 HeapFree( GetProcessHeap(), 0, mis
);
1329 case WM_GETMINMAXINFO
:
1331 MINMAXINFO
*mmi
= (MINMAXINFO
*)lParam
;
1332 lParam
= *(LPARAM
*)(mmi
+ 1);
1333 STRUCT32_MINMAXINFO32to16( mmi
,
1334 (MINMAXINFO16
*)PTR_SEG_TO_LIN(lParam
));
1335 HeapFree( GetProcessHeap(), 0, mmi
);
1340 MDICREATESTRUCTA
*cs
= (MDICREATESTRUCTA
*)lParam
;
1341 lParam
= *(LPARAM
*)(cs
+ 1);
1342 STRUCT32_MDICREATESTRUCT32Ato16( cs
,
1343 (MDICREATESTRUCT16
*)PTR_SEG_TO_LIN(lParam
) );
1344 HeapFree( GetProcessHeap(), 0, cs
);
1347 case WM_MDIGETACTIVE
:
1348 result
= MAKELONG( LOWORD(result
), (BOOL16
)(*(BOOL
*)lParam
) );
1349 HeapFree( GetProcessHeap(), 0, (BOOL
*)lParam
);
1353 NCCALCSIZE_PARAMS16
*nc16
;
1354 NCCALCSIZE_PARAMS
*nc
= (NCCALCSIZE_PARAMS
*)lParam
;
1355 lParam
= *(LPARAM
*)(nc
+ 1);
1356 nc16
= (NCCALCSIZE_PARAMS16
*)PTR_SEG_TO_LIN(lParam
);
1357 CONV_RECT32TO16( &nc
->rgrc
[0], &nc16
->rgrc
[0] );
1360 CONV_RECT32TO16( &nc
->rgrc
[1], &nc16
->rgrc
[1] );
1361 CONV_RECT32TO16( &nc
->rgrc
[2], &nc16
->rgrc
[2] );
1364 STRUCT32_WINDOWPOS32to16( nc
->lppos
,
1365 (WINDOWPOS16
*)PTR_SEG_TO_LIN(nc16
->lppos
));
1366 HeapFree( GetProcessHeap(), 0, nc
->lppos
);
1369 HeapFree( GetProcessHeap(), 0, nc
);
1375 CREATESTRUCTA
*cs
= (CREATESTRUCTA
*)lParam
;
1376 lParam
= *(LPARAM
*)(cs
+ 1);
1377 STRUCT32_CREATESTRUCT32Ato16( cs
,
1378 (CREATESTRUCT16
*)PTR_SEG_TO_LIN(lParam
) );
1379 HeapFree( GetProcessHeap(), 0, cs
);
1382 case WM_WINDOWPOSCHANGING
:
1383 case WM_WINDOWPOSCHANGED
:
1385 WINDOWPOS
*wp
= (WINDOWPOS
*)lParam
;
1386 lParam
= *(LPARAM
*)(wp
+ 1);
1387 STRUCT32_WINDOWPOS32to16(wp
,(WINDOWPOS16
*)PTR_SEG_TO_LIN(lParam
));
1388 HeapFree( GetProcessHeap(), 0, wp
);
1394 LPMSG msg32
= (LPMSG
)lParam
;
1396 WINPROC_UnmapMsg16To32A( hwnd
, msg32
->message
, msg32
->wParam
, msg32
->lParam
,
1398 HeapFree( GetProcessHeap(), 0, msg32
);
1406 /**********************************************************************
1407 * WINPROC_MapMsg16To32W
1409 * Map a message from 16- to 32-bit Unicode.
1410 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1412 INT
WINPROC_MapMsg16To32W( HWND16 hwnd
, UINT16 msg16
, WPARAM16 wParam16
, UINT
*pmsg32
,
1413 WPARAM
*pwparam32
, LPARAM
*plparam
)
1419 *plparam
= (LPARAM
)PTR_SEG_TO_LIN(*plparam
);
1420 return WINPROC_MapMsg32ATo32W( hwnd
, *pmsg32
, pwparam32
, plparam
);
1424 CREATESTRUCT16
*cs16
= (CREATESTRUCT16
*)PTR_SEG_TO_LIN(*plparam
);
1425 CREATESTRUCTW
*cs
= (CREATESTRUCTW
*)HeapAlloc( GetProcessHeap(), 0,
1426 sizeof(*cs
) + sizeof(LPARAM
) );
1428 STRUCT32_CREATESTRUCT16to32A( cs16
, (CREATESTRUCTA
*)cs
);
1429 cs
->lpszName
= (LPCWSTR
)PTR_SEG_TO_LIN(cs16
->lpszName
);
1430 cs
->lpszClass
= (LPCWSTR
)PTR_SEG_TO_LIN(cs16
->lpszClass
);
1431 if (HIWORD(cs
->lpszName
))
1432 cs
->lpszName
= HEAP_strdupAtoW( GetProcessHeap(), 0,
1433 (LPCSTR
)cs
->lpszName
);
1434 if (HIWORD(cs
->lpszClass
))
1435 cs
->lpszClass
= HEAP_strdupAtoW( GetProcessHeap(), 0,
1436 (LPCSTR
)cs
->lpszClass
);
1437 *(LPARAM
*)(cs
+ 1) = *plparam
; /* Store the previous lParam */
1438 *plparam
= (LPARAM
)cs
;
1443 MDICREATESTRUCT16
*cs16
=
1444 (MDICREATESTRUCT16
*)PTR_SEG_TO_LIN(*plparam
);
1445 MDICREATESTRUCTW
*cs
=
1446 (MDICREATESTRUCTW
*)HeapAlloc( GetProcessHeap(), 0,
1447 sizeof(*cs
) + sizeof(LPARAM
) );
1449 STRUCT32_MDICREATESTRUCT16to32A( cs16
, (MDICREATESTRUCTA
*)cs
);
1450 cs
->szTitle
= (LPCWSTR
)PTR_SEG_TO_LIN(cs16
->szTitle
);
1451 cs
->szClass
= (LPCWSTR
)PTR_SEG_TO_LIN(cs16
->szClass
);
1452 if (HIWORD(cs
->szTitle
))
1453 cs
->szTitle
= HEAP_strdupAtoW( GetProcessHeap(), 0,
1454 (LPCSTR
)cs
->szTitle
);
1455 if (HIWORD(cs
->szClass
))
1456 cs
->szClass
= HEAP_strdupAtoW( GetProcessHeap(), 0,
1457 (LPCSTR
)cs
->szClass
);
1458 *(LPARAM
*)(cs
+ 1) = *plparam
; /* Store the previous lParam */
1459 *plparam
= (LPARAM
)cs
;
1465 LPMSG16 msg16
= (LPMSG16
)PTR_SEG_TO_LIN(*plparam
);
1466 LPMSG msg32
= (LPMSG
)HeapAlloc( GetProcessHeap(), 0, sizeof(MSG
) );
1468 if (!msg32
) return -1;
1469 msg32
->hwnd
= msg16
->hwnd
;
1470 msg32
->lParam
= msg16
->lParam
;
1471 msg32
->time
= msg16
->time
;
1472 CONV_POINT16TO32(&msg16
->pt
,&msg32
->pt
);
1473 /* this is right, right? */
1474 if (WINPROC_MapMsg16To32W(hwnd
, msg16
->message
,msg16
->wParam
,
1475 &msg32
->message
,&msg32
->wParam
,
1476 &msg32
->lParam
)<0) {
1477 HeapFree( GetProcessHeap(), 0, msg32
);
1480 *plparam
= (LPARAM
)msg32
;
1488 case WM_SYSDEADCHAR
:
1492 MultiByteToWideChar( CP_ACP
, 0, &ch
, 1, &wch
, 1);
1497 default: /* No Unicode translation needed */
1498 return WINPROC_MapMsg16To32A( msg16
, wParam16
, pmsg32
,
1499 pwparam32
, plparam
);
1504 /**********************************************************************
1505 * WINPROC_UnmapMsg16To32W
1507 * Unmap a message that was mapped from 16- to 32-bit Unicode.
1509 LRESULT
WINPROC_UnmapMsg16To32W( HWND16 hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
,
1516 WINPROC_UnmapMsg32ATo32W( hwnd
, msg
, wParam
, lParam
);
1521 CREATESTRUCTW
*cs
= (CREATESTRUCTW
*)lParam
;
1522 lParam
= *(LPARAM
*)(cs
+ 1);
1523 STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCTA
*)cs
,
1524 (CREATESTRUCT16
*)PTR_SEG_TO_LIN(lParam
) );
1525 if (HIWORD(cs
->lpszName
))
1526 HeapFree( GetProcessHeap(), 0, (LPVOID
)cs
->lpszName
);
1527 if (HIWORD(cs
->lpszClass
))
1528 HeapFree( GetProcessHeap(), 0, (LPVOID
)cs
->lpszClass
);
1529 HeapFree( GetProcessHeap(), 0, cs
);
1534 MDICREATESTRUCTW
*cs
= (MDICREATESTRUCTW
*)lParam
;
1535 lParam
= *(LPARAM
*)(cs
+ 1);
1536 STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCTA
*)cs
,
1537 (MDICREATESTRUCT16
*)PTR_SEG_TO_LIN(lParam
) );
1538 if (HIWORD(cs
->szTitle
))
1539 HeapFree( GetProcessHeap(), 0, (LPVOID
)cs
->szTitle
);
1540 if (HIWORD(cs
->szClass
))
1541 HeapFree( GetProcessHeap(), 0, (LPVOID
)cs
->szClass
);
1542 HeapFree( GetProcessHeap(), 0, cs
);
1548 LPMSG msg32
= (LPMSG
)lParam
;
1550 WINPROC_UnmapMsg16To32W( hwnd
, msg32
->message
, msg32
->wParam
, msg32
->lParam
,
1552 HeapFree( GetProcessHeap(), 0, msg32
);
1556 return WINPROC_UnmapMsg16To32A( hwnd
, msg
, wParam
, lParam
, result
);
1562 /**********************************************************************
1563 * WINPROC_MapMsg32ATo16
1565 * Map a message from 32-bit Ansi to 16-bit.
1566 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1568 INT
WINPROC_MapMsg32ATo16( HWND hwnd
, UINT msg32
, WPARAM wParam32
,
1569 UINT16
*pmsg16
, WPARAM16
*pwparam16
,
1572 *pmsg16
= (UINT16
)msg32
;
1573 *pwparam16
= (WPARAM16
)LOWORD(wParam32
);
1581 *pmsg16
= (UINT16
)msg32
+ (BM_GETCHECK16
- BM_GETCHECK
);
1590 case EM_SCROLLCARET
:
1593 case EM_GETLINECOUNT
:
1605 case EM_LINEFROMCHAR
:
1606 case EM_SETTABSTOPS
:
1607 case EM_SETPASSWORDCHAR
:
1608 case EM_EMPTYUNDOBUFFER
:
1609 case EM_GETFIRSTVISIBLELINE
:
1610 case EM_SETREADONLY
:
1611 case EM_SETWORDBREAKPROC
:
1612 case EM_GETWORDBREAKPROC
:
1613 case EM_GETPASSWORDCHAR
:
1614 *pmsg16
= (UINT16
)msg32
+ (EM_GETSEL16
- EM_GETSEL
);
1619 case LB_DELETESTRING
:
1620 case LB_GETANCHORINDEX
:
1621 case LB_GETCARETINDEX
:
1624 case LB_GETHORIZONTALEXTENT
:
1625 case LB_GETITEMDATA
:
1626 case LB_GETITEMHEIGHT
:
1628 case LB_GETSELCOUNT
:
1630 case LB_GETTOPINDEX
:
1631 case LB_RESETCONTENT
:
1632 case LB_SELITEMRANGE
:
1633 case LB_SELITEMRANGEEX
:
1634 case LB_SETANCHORINDEX
:
1635 case LB_SETCARETINDEX
:
1636 case LB_SETCOLUMNWIDTH
:
1638 case LB_SETHORIZONTALEXTENT
:
1639 case LB_SETITEMDATA
:
1640 case LB_SETITEMHEIGHT
:
1642 case LB_SETTOPINDEX
:
1643 *pmsg16
= (UINT16
)msg32
+ (LB_ADDSTRING16
- LB_ADDSTRING
);
1645 case CB_DELETESTRING
:
1647 case CB_GETLBTEXTLEN
:
1649 case CB_RESETCONTENT
:
1653 case CB_SHOWDROPDOWN
:
1654 case CB_SETITEMDATA
:
1655 case CB_SETITEMHEIGHT
:
1656 case CB_GETITEMHEIGHT
:
1657 case CB_SETEXTENDEDUI
:
1658 case CB_GETEXTENDEDUI
:
1659 case CB_GETDROPPEDSTATE
:
1660 *pmsg16
= (UINT16
)msg32
+ (CB_GETEDITSEL16
- CB_GETEDITSEL
);
1663 *pmsg16
= CB_GETEDITSEL16
;
1668 case LB_FINDSTRINGEXACT
:
1669 case LB_INSERTSTRING
:
1670 case LB_SELECTSTRING
:
1674 LPSTR str
= SEGPTR_STRDUP( (LPSTR
)*plparam
);
1675 if (!str
) return -1;
1676 *plparam
= (LPARAM
)SEGPTR_GET(str
);
1678 *pmsg16
= (UINT16
)msg32
+ (LB_ADDSTRING16
- LB_ADDSTRING
);
1683 case CB_FINDSTRINGEXACT
:
1684 case CB_INSERTSTRING
:
1685 case CB_SELECTSTRING
:
1688 LPSTR str
= SEGPTR_STRDUP( (LPSTR
)*plparam
);
1689 if (!str
) return -1;
1690 *plparam
= (LPARAM
)SEGPTR_GET(str
);
1692 *pmsg16
= (UINT16
)msg32
+ (CB_GETEDITSEL16
- CB_GETEDITSEL
);
1695 case LB_GETITEMRECT
:
1698 rect
= (RECT16
*)SEGPTR_ALLOC( sizeof(RECT16
) + sizeof(LPARAM
) );
1699 if (!rect
) return -1;
1700 *(LPARAM
*)(rect
+ 1) = *plparam
; /* Store the previous lParam */
1701 *plparam
= (LPARAM
)SEGPTR_GET(rect
);
1703 *pmsg16
= LB_GETITEMRECT16
;
1705 case LB_GETSELITEMS
:
1708 *pwparam16
= (WPARAM16
)min( wParam32
, 0x7f80 ); /* Must be < 64K */
1709 if (!(items
= SEGPTR_ALLOC( *pwparam16
* sizeof(INT16
)
1710 + sizeof(LPARAM
)))) return -1;
1711 *((LPARAM
*)items
)++ = *plparam
; /* Store the previous lParam */
1712 *plparam
= (LPARAM
)SEGPTR_GET(items
);
1714 *pmsg16
= LB_GETSELITEMS16
;
1716 case LB_SETTABSTOPS
:
1721 *pwparam16
= (WPARAM16
)min( wParam32
, 0x7f80 ); /* Must be < 64K */
1722 if (!(stops
= SEGPTR_ALLOC( *pwparam16
* sizeof(INT16
)
1723 + sizeof(LPARAM
)))) return -1;
1724 for (i
= 0; i
< *pwparam16
; i
++) stops
[i
] = *((LPINT
)*plparam
+i
);
1725 *plparam
= (LPARAM
)SEGPTR_GET(stops
);
1728 *pmsg16
= LB_SETTABSTOPS16
;
1731 case CB_GETDROPPEDCONTROLRECT
:
1734 rect
= (RECT16
*)SEGPTR_ALLOC( sizeof(RECT16
) + sizeof(LPARAM
) );
1735 if (!rect
) return -1;
1736 *(LPARAM
*)(rect
+ 1) = *plparam
; /* Store the previous lParam */
1737 *plparam
= (LPARAM
)SEGPTR_GET(rect
);
1739 *pmsg16
= CB_GETDROPPEDCONTROLRECT16
;
1743 *plparam
= (LPARAM
)MapLS( (LPVOID
)(*plparam
) );
1744 *pmsg16
= LB_GETTEXT16
;
1748 *plparam
= (LPARAM
)MapLS( (LPVOID
)(*plparam
) );
1749 *pmsg16
= CB_GETLBTEXT16
;
1754 *plparam
= MAKELONG( (INT16
)(INT
)wParam32
, (INT16
)*plparam
);
1755 *pmsg16
= EM_SETSEL16
;
1762 *plparam
= MAKELPARAM( (HWND16
)*plparam
, HIWORD(wParam32
) );
1766 *plparam
= MAKELPARAM( HIWORD(wParam32
), (HWND16
)*plparam
);
1768 case WM_CTLCOLORMSGBOX
:
1769 case WM_CTLCOLOREDIT
:
1770 case WM_CTLCOLORLISTBOX
:
1771 case WM_CTLCOLORBTN
:
1772 case WM_CTLCOLORDLG
:
1773 case WM_CTLCOLORSCROLLBAR
:
1774 case WM_CTLCOLORSTATIC
:
1775 *pmsg16
= WM_CTLCOLOR
;
1776 *plparam
= MAKELPARAM( (HWND16
)*plparam
,
1777 (WORD
)msg32
- WM_CTLCOLORMSGBOX
);
1779 case WM_COMPAREITEM
:
1781 COMPAREITEMSTRUCT
*cis32
= (COMPAREITEMSTRUCT
*)*plparam
;
1782 COMPAREITEMSTRUCT16
*cis
= SEGPTR_NEW(COMPAREITEMSTRUCT16
);
1783 if (!cis
) return -1;
1784 cis
->CtlType
= (UINT16
)cis32
->CtlType
;
1785 cis
->CtlID
= (UINT16
)cis32
->CtlID
;
1786 cis
->hwndItem
= (HWND16
)cis32
->hwndItem
;
1787 cis
->itemID1
= (UINT16
)cis32
->itemID1
;
1788 cis
->itemData1
= cis32
->itemData1
;
1789 cis
->itemID2
= (UINT16
)cis32
->itemID2
;
1790 cis
->itemData2
= cis32
->itemData2
;
1791 *plparam
= (LPARAM
)SEGPTR_GET(cis
);
1796 DELETEITEMSTRUCT
*dis32
= (DELETEITEMSTRUCT
*)*plparam
;
1797 DELETEITEMSTRUCT16
*dis
= SEGPTR_NEW(DELETEITEMSTRUCT16
);
1798 if (!dis
) return -1;
1799 dis
->CtlType
= (UINT16
)dis32
->CtlType
;
1800 dis
->CtlID
= (UINT16
)dis32
->CtlID
;
1801 dis
->itemID
= (UINT16
)dis32
->itemID
;
1802 dis
->hwndItem
= (HWND16
)dis32
->hwndItem
;
1803 dis
->itemData
= dis32
->itemData
;
1804 *plparam
= (LPARAM
)SEGPTR_GET(dis
);
1809 DRAWITEMSTRUCT
*dis32
= (DRAWITEMSTRUCT
*)*plparam
;
1810 DRAWITEMSTRUCT16
*dis
= SEGPTR_NEW(DRAWITEMSTRUCT16
);
1811 if (!dis
) return -1;
1812 dis
->CtlType
= (UINT16
)dis32
->CtlType
;
1813 dis
->CtlID
= (UINT16
)dis32
->CtlID
;
1814 dis
->itemID
= (UINT16
)dis32
->itemID
;
1815 dis
->itemAction
= (UINT16
)dis32
->itemAction
;
1816 dis
->itemState
= (UINT16
)dis32
->itemState
;
1817 dis
->hwndItem
= (HWND16
)dis32
->hwndItem
;
1818 dis
->hDC
= (HDC16
)dis32
->hDC
;
1819 dis
->itemData
= dis32
->itemData
;
1820 CONV_RECT32TO16( &dis32
->rcItem
, &dis
->rcItem
);
1821 *plparam
= (LPARAM
)SEGPTR_GET(dis
);
1824 case WM_MEASUREITEM
:
1826 MEASUREITEMSTRUCT
*mis32
= (MEASUREITEMSTRUCT
*)*plparam
;
1827 MEASUREITEMSTRUCT16
*mis
= (MEASUREITEMSTRUCT16
*)
1828 SEGPTR_ALLOC(sizeof(*mis
)+sizeof(LPARAM
));
1829 if (!mis
) return -1;
1830 mis
->CtlType
= (UINT16
)mis32
->CtlType
;
1831 mis
->CtlID
= (UINT16
)mis32
->CtlID
;
1832 mis
->itemID
= (UINT16
)mis32
->itemID
;
1833 mis
->itemWidth
= (UINT16
)mis32
->itemWidth
;
1834 mis
->itemHeight
= (UINT16
)mis32
->itemHeight
;
1835 mis
->itemData
= mis32
->itemData
;
1836 *(LPARAM
*)(mis
+ 1) = *plparam
; /* Store the previous lParam */
1837 *plparam
= (LPARAM
)SEGPTR_GET(mis
);
1840 case WM_GETMINMAXINFO
:
1842 MINMAXINFO16
*mmi
= (MINMAXINFO16
*)SEGPTR_ALLOC( sizeof(*mmi
) +
1844 if (!mmi
) return -1;
1845 STRUCT32_MINMAXINFO32to16( (MINMAXINFO
*)*plparam
, mmi
);
1846 *(LPARAM
*)(mmi
+ 1) = *plparam
; /* Store the previous lParam */
1847 *plparam
= (LPARAM
)SEGPTR_GET(mmi
);
1853 *pwparam16
= (WPARAM16
)min( wParam32
, 0xff80 ); /* Must be < 64K */
1854 if (!(str
= SEGPTR_ALLOC(*pwparam16
+ sizeof(LPARAM
)))) return -1;
1855 *((LPARAM
*)str
)++ = *plparam
; /* Store the previous lParam */
1856 *plparam
= (LPARAM
)SEGPTR_GET(str
);
1861 MDICREATESTRUCT16
*cs
;
1862 MDICREATESTRUCTA
*cs32
= (MDICREATESTRUCTA
*)*plparam
;
1865 if (!(cs
= SEGPTR_NEW(MDICREATESTRUCT16
))) return -1;
1866 STRUCT32_MDICREATESTRUCT32Ato16( cs32
, cs
);
1867 name
= SEGPTR_STRDUP( cs32
->szTitle
);
1868 cls
= SEGPTR_STRDUP( cs32
->szClass
);
1869 cs
->szTitle
= SEGPTR_GET(name
);
1870 cs
->szClass
= SEGPTR_GET(cls
);
1871 *plparam
= (LPARAM
)SEGPTR_GET(cs
);
1874 case WM_MDIGETACTIVE
:
1877 *plparam
= MAKELPARAM( (HMENU16
)LOWORD(wParam32
),
1878 (HMENU16
)LOWORD(*plparam
) );
1879 *pwparam16
= (*plparam
== 0);
1882 if(HIWORD(wParam32
) & MF_POPUP
)
1885 if (((UINT
)HIWORD(wParam32
) != 0xFFFF) || (*plparam
))
1887 if((hmenu
= GetSubMenu((HMENU16
)*plparam
, *pwparam16
)))
1893 *plparam
= MAKELPARAM( HIWORD(wParam32
), (HMENU16
)*plparam
);
1895 case WM_MDIACTIVATE
:
1897 WND
*tempWnd
= WIN_FindWndPtr(hwnd
);
1898 if( WIDGETS_IsControl(tempWnd
, BIC32_MDICLIENT
) )
1900 *pwparam16
= (HWND
)wParam32
;
1905 *pwparam16
= ((HWND
)*plparam
== hwnd
);
1906 *plparam
= MAKELPARAM( (HWND16
)LOWORD(*plparam
),
1907 (HWND16
)LOWORD(wParam32
) );
1909 WIN_ReleaseWndPtr(tempWnd
);
1914 NCCALCSIZE_PARAMS
*nc32
= (NCCALCSIZE_PARAMS
*)*plparam
;
1915 NCCALCSIZE_PARAMS16
*nc
= (NCCALCSIZE_PARAMS16
*)SEGPTR_ALLOC( sizeof(*nc
) + sizeof(LPARAM
) );
1918 CONV_RECT32TO16( &nc32
->rgrc
[0], &nc
->rgrc
[0] );
1922 CONV_RECT32TO16( &nc32
->rgrc
[1], &nc
->rgrc
[1] );
1923 CONV_RECT32TO16( &nc32
->rgrc
[2], &nc
->rgrc
[2] );
1924 if (!(wp
= SEGPTR_NEW(WINDOWPOS16
)))
1929 STRUCT32_WINDOWPOS32to16( nc32
->lppos
, wp
);
1930 nc
->lppos
= SEGPTR_GET(wp
);
1932 *(LPARAM
*)(nc
+ 1) = *plparam
; /* Store the previous lParam */
1933 *plparam
= (LPARAM
)SEGPTR_GET(nc
);
1940 CREATESTRUCTA
*cs32
= (CREATESTRUCTA
*)*plparam
;
1943 if (!(cs
= SEGPTR_NEW(CREATESTRUCT16
))) return -1;
1944 STRUCT32_CREATESTRUCT32Ato16( cs32
, cs
);
1945 name
= SEGPTR_STRDUP( cs32
->lpszName
);
1946 cls
= SEGPTR_STRDUP( cs32
->lpszClass
);
1947 cs
->lpszName
= SEGPTR_GET(name
);
1948 cs
->lpszClass
= SEGPTR_GET(cls
);
1949 *plparam
= (LPARAM
)SEGPTR_GET(cs
);
1952 case WM_PARENTNOTIFY
:
1953 if ((LOWORD(wParam32
)==WM_CREATE
) || (LOWORD(wParam32
)==WM_DESTROY
))
1954 *plparam
= MAKELPARAM( (HWND16
)*plparam
, HIWORD(wParam32
));
1955 /* else nothing to do */
1958 *plparam
= MapLS( (NMHDR
*)*plparam
); /* NMHDR is already 32-bit */
1962 LPSTR str
= SEGPTR_STRDUP( (LPSTR
)*plparam
);
1963 if (!str
) return -1;
1964 *plparam
= (LPARAM
)SEGPTR_GET(str
);
1967 case WM_WINDOWPOSCHANGING
:
1968 case WM_WINDOWPOSCHANGED
:
1970 WINDOWPOS16
*wp
= (WINDOWPOS16
*)SEGPTR_ALLOC( sizeof(*wp
) +
1973 STRUCT32_WINDOWPOS32to16( (WINDOWPOS
*)*plparam
, wp
);
1974 *(LPARAM
*)(wp
+ 1) = *plparam
; /* Store the previous lParam */
1975 *plparam
= (LPARAM
)SEGPTR_GET(wp
);
1980 LPMSG msg32
= (LPMSG
) *plparam
;
1981 LPMSG16 msg16
= (LPMSG16
) SEGPTR_NEW( MSG16
);
1983 if (!msg16
) return -1;
1984 msg16
->hwnd
= msg32
->hwnd
;
1985 msg16
->lParam
= msg32
->lParam
;
1986 msg16
->time
= msg32
->time
;
1987 CONV_POINT32TO16(&msg32
->pt
,&msg16
->pt
);
1988 /* this is right, right? */
1989 if (WINPROC_MapMsg32ATo16(msg32
->hwnd
,msg32
->message
,msg32
->wParam
,
1990 &msg16
->message
,&msg16
->wParam
, &msg16
->lParam
)<0) {
1991 SEGPTR_FREE( msg16
);
1994 *plparam
= (LPARAM
)SEGPTR_GET(msg16
);
1999 case WM_ACTIVATEAPP
:
2001 *plparam
= (LPARAM
)THREAD_IdToTEB((DWORD
) *plparam
)->htask16
;
2004 case WM_ASKCBFORMATNAME
:
2005 case WM_DEVMODECHANGE
:
2006 case WM_PAINTCLIPBOARD
:
2007 case WM_SIZECLIPBOARD
:
2008 case WM_WININICHANGE
:
2009 FIXME_(msg
)("message %04x needs translation\n", msg32
);
2011 case WM_SIZING
: /* should not be send to 16-bit apps */
2013 default: /* No translation needed */
2019 /**********************************************************************
2020 * WINPROC_UnmapMsg32ATo16
2022 * Unmap a message that was mapped from 32-bit Ansi to 16-bit.
2024 void WINPROC_UnmapMsg32ATo16( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
,
2033 case LB_FINDSTRINGEXACT
:
2034 case LB_INSERTSTRING
:
2035 case LB_SELECTSTRING
:
2036 case LB_SETTABSTOPS
:
2039 case CB_FINDSTRINGEXACT
:
2040 case CB_INSERTSTRING
:
2041 case CB_SELECTSTRING
:
2043 case WM_COMPAREITEM
:
2047 SEGPTR_FREE( PTR_SEG_TO_LIN(p16
->lParam
) );
2050 case CB_GETDROPPEDCONTROLRECT
:
2051 case LB_GETITEMRECT
:
2053 RECT16
*rect
= (RECT16
*)PTR_SEG_TO_LIN(p16
->lParam
);
2054 p16
->lParam
= *(LPARAM
*)(rect
+ 1);
2055 CONV_RECT16TO32( rect
, (RECT
*)(p16
->lParam
));
2056 SEGPTR_FREE( rect
);
2059 case LB_GETSELITEMS
:
2062 LPINT16 items
= (LPINT16
)PTR_SEG_TO_LIN(lParam
);
2063 p16
->lParam
= *((LPARAM
*)items
- 1);
2064 for (i
= 0; i
< p16
->wParam
; i
++) *((LPINT
)(p16
->lParam
) + i
) = items
[i
];
2065 SEGPTR_FREE( (LPARAM
*)items
- 1 );
2071 *((LPUINT
)(wParam
)) = LOWORD(p16
->lResult
);
2073 *((LPUINT
)(lParam
)) = HIWORD(p16
->lResult
); /* FIXME: substract 1? */
2078 UnMapLS( (SEGPTR
)(p16
->lParam
) );
2081 case WM_MEASUREITEM
:
2083 MEASUREITEMSTRUCT16
*mis
= (MEASUREITEMSTRUCT16
*)PTR_SEG_TO_LIN(p16
->lParam
);
2084 MEASUREITEMSTRUCT
*mis32
= *(MEASUREITEMSTRUCT
**)(mis
+ 1);
2085 mis32
->itemWidth
= mis
->itemWidth
;
2086 mis32
->itemHeight
= mis
->itemHeight
;
2090 case WM_GETMINMAXINFO
:
2092 MINMAXINFO16
*mmi
= (MINMAXINFO16
*)PTR_SEG_TO_LIN(p16
->lParam
);
2093 p16
->lParam
= *(LPARAM
*)(mmi
+ 1);
2094 STRUCT32_MINMAXINFO16to32( mmi
, (MINMAXINFO
*)(p16
->lParam
) );
2100 LPSTR str
= (LPSTR
)PTR_SEG_TO_LIN(p16
->lParam
);
2101 p16
->lParam
= *((LPARAM
*)str
- 1);
2102 lstrcpynA( (LPSTR
)(p16
->lParam
), str
, p16
->wParam
);
2103 SEGPTR_FREE( (LPARAM
*)str
- 1 );
2108 MDICREATESTRUCT16
*cs
= (MDICREATESTRUCT16
*)PTR_SEG_TO_LIN(p16
->lParam
);
2109 SEGPTR_FREE( PTR_SEG_TO_LIN(cs
->szTitle
) );
2110 SEGPTR_FREE( PTR_SEG_TO_LIN(cs
->szClass
) );
2114 case WM_MDIGETACTIVE
:
2115 if (lParam
) *(BOOL
*)lParam
= (BOOL16
)HIWORD(p16
->lResult
);
2116 p16
->lResult
= (HWND
)LOWORD(p16
->lResult
);
2120 NCCALCSIZE_PARAMS
*nc32
;
2121 NCCALCSIZE_PARAMS16
*nc
= (NCCALCSIZE_PARAMS16
*)PTR_SEG_TO_LIN(p16
->lParam
);
2122 p16
->lParam
= *(LPARAM
*)(nc
+ 1);
2123 nc32
= (NCCALCSIZE_PARAMS
*)(p16
->lParam
);
2124 CONV_RECT16TO32( &nc
->rgrc
[0], &nc32
->rgrc
[0] );
2127 CONV_RECT16TO32( &nc
->rgrc
[1], &nc32
->rgrc
[1] );
2128 CONV_RECT16TO32( &nc
->rgrc
[2], &nc32
->rgrc
[2] );
2129 STRUCT32_WINDOWPOS16to32( (WINDOWPOS16
*)PTR_SEG_TO_LIN(nc
->lppos
),
2131 SEGPTR_FREE( PTR_SEG_TO_LIN(nc
->lppos
) );
2139 CREATESTRUCT16
*cs
= (CREATESTRUCT16
*)PTR_SEG_TO_LIN(p16
->lParam
);
2140 SEGPTR_FREE( PTR_SEG_TO_LIN(cs
->lpszName
) );
2141 SEGPTR_FREE( PTR_SEG_TO_LIN(cs
->lpszClass
) );
2145 case WM_WINDOWPOSCHANGING
:
2146 case WM_WINDOWPOSCHANGED
:
2148 WINDOWPOS16
*wp
= (WINDOWPOS16
*)PTR_SEG_TO_LIN(p16
->lParam
);
2149 p16
->lParam
= *(LPARAM
*)(wp
+ 1);
2150 STRUCT32_WINDOWPOS16to32( wp
, (WINDOWPOS
*)p16
->lParam
);
2155 UnMapLS(p16
->lParam
);
2160 LPMSG16 msg16
= (LPMSG16
)PTR_SEG_TO_LIN(p16
->lParam
);
2162 msgp16
.wParam
=msg16
->wParam
;
2163 msgp16
.lParam
=msg16
->lParam
;
2164 WINPROC_UnmapMsg32ATo16(((LPMSG
)lParam
)->hwnd
, ((LPMSG
)lParam
)->message
,
2165 ((LPMSG
)lParam
)->wParam
, ((LPMSG
)lParam
)->lParam
,
2174 /**********************************************************************
2175 * WINPROC_MapMsg32WTo16
2177 * Map a message from 32-bit Unicode to 16-bit.
2178 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
2180 INT
WINPROC_MapMsg32WTo16( HWND hwnd
, UINT msg32
, WPARAM wParam32
,
2181 UINT16
*pmsg16
, WPARAM16
*pwparam16
,
2188 case LB_FINDSTRINGEXACT
:
2189 case LB_INSERTSTRING
:
2190 case LB_SELECTSTRING
:
2194 LPSTR str
= SEGPTR_STRDUP_WtoA( (LPWSTR
)*plparam
);
2195 if (!str
) return -1;
2196 *pwparam16
= (WPARAM16
)LOWORD(wParam32
);
2197 *plparam
= (LPARAM
)SEGPTR_GET(str
);
2199 *pmsg16
= (UINT16
)msg32
+ (LB_ADDSTRING16
- LB_ADDSTRING
);
2204 case CB_FINDSTRINGEXACT
:
2205 case CB_INSERTSTRING
:
2206 case CB_SELECTSTRING
:
2209 LPSTR str
= SEGPTR_STRDUP_WtoA( (LPWSTR
)*plparam
);
2210 if (!str
) return -1;
2211 *pwparam16
= (WPARAM16
)LOWORD(wParam32
);
2212 *plparam
= (LPARAM
)SEGPTR_GET(str
);
2214 *pmsg16
= (UINT16
)msg32
+ (CB_ADDSTRING16
- CB_ADDSTRING
);
2221 CREATESTRUCTW
*cs32
= (CREATESTRUCTW
*)*plparam
;
2224 if (!(cs
= SEGPTR_NEW(CREATESTRUCT16
))) return -1;
2225 STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCTA
*)cs32
, cs
);
2226 name
= SEGPTR_STRDUP_WtoA( cs32
->lpszName
);
2227 cls
= SEGPTR_STRDUP_WtoA( cs32
->lpszClass
);
2228 cs
->lpszName
= SEGPTR_GET(name
);
2229 cs
->lpszClass
= SEGPTR_GET(cls
);
2230 *pmsg16
= (UINT16
)msg32
;
2231 *pwparam16
= (WPARAM16
)LOWORD(wParam32
);
2232 *plparam
= (LPARAM
)SEGPTR_GET(cs
);
2237 MDICREATESTRUCT16
*cs
;
2238 MDICREATESTRUCTW
*cs32
= (MDICREATESTRUCTW
*)*plparam
;
2241 if (!(cs
= SEGPTR_NEW(MDICREATESTRUCT16
))) return -1;
2242 STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCTA
*)cs32
, cs
);
2243 name
= SEGPTR_STRDUP_WtoA( cs32
->szTitle
);
2244 cls
= SEGPTR_STRDUP_WtoA( cs32
->szClass
);
2245 cs
->szTitle
= SEGPTR_GET(name
);
2246 cs
->szClass
= SEGPTR_GET(cls
);
2247 *pmsg16
= (UINT16
)msg32
;
2248 *pwparam16
= (WPARAM16
)LOWORD(wParam32
);
2249 *plparam
= (LPARAM
)SEGPTR_GET(cs
);
2254 LPSTR str
= SEGPTR_STRDUP_WtoA( (LPWSTR
)*plparam
);
2255 if (!str
) return -1;
2256 *pmsg16
= (UINT16
)msg32
;
2257 *pwparam16
= (WPARAM16
)LOWORD(wParam32
);
2258 *plparam
= (LPARAM
)SEGPTR_GET(str
);
2263 if ( WINPROC_TestLBForStr( hwnd
))
2265 LPSTR str
= (LPSTR
) SEGPTR_ALLOC( 256 ); /* fixme: fixed sized buffer */
2266 if (!str
) return -1;
2267 *pmsg16
= (msg32
== LB_GETTEXT
)? LB_GETTEXT16
: CB_GETLBTEXT16
;
2268 *pwparam16
= (WPARAM16
)LOWORD(wParam32
);
2269 *plparam
= (LPARAM
)SEGPTR_GET(str
);
2276 case WM_SYSDEADCHAR
:
2278 WCHAR wch
= wParam32
;
2280 WideCharToMultiByte( CP_ACP
, 0, &wch
, 1, &ch
, 1, NULL
, NULL
);
2285 default: /* No Unicode translation needed (?) */
2286 return WINPROC_MapMsg32ATo16( hwnd
, msg32
, wParam32
, pmsg16
,
2287 pwparam16
, plparam
);
2292 /**********************************************************************
2293 * WINPROC_UnmapMsg32WTo16
2295 * Unmap a message that was mapped from 32-bit Unicode to 16-bit.
2297 void WINPROC_UnmapMsg32WTo16( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
,
2304 LPSTR str
= (LPSTR
)PTR_SEG_TO_LIN(p16
->lParam
);
2305 p16
->lParam
= *((LPARAM
*)str
- 1);
2306 MultiByteToWideChar( CP_ACP
, 0, str
, -1, (LPWSTR
)p16
->lParam
, 0x7fffffff );
2307 SEGPTR_FREE( (LPARAM
*)str
- 1 );
2312 if ( WINPROC_TestLBForStr( hwnd
))
2314 LPSTR str
= (LPSTR
)PTR_SEG_TO_LIN(p16
->lParam
);
2315 MultiByteToWideChar( CP_ACP
, 0, str
, -1, (LPWSTR
)lParam
, 0x7fffffff );
2316 SEGPTR_FREE( (LPARAM
*) str
);
2320 WINPROC_UnmapMsg32ATo16( hwnd
, msg
, wParam
, lParam
, p16
);
2326 /**********************************************************************
2327 * WINPROC_CallProc32ATo32W
2329 * Call a window procedure, translating args from Ansi to Unicode.
2331 static LRESULT
WINPROC_CallProc32ATo32W( WNDPROC func
, HWND hwnd
,
2332 UINT msg
, WPARAM wParam
,
2337 if (WINPROC_MapMsg32ATo32W( hwnd
, msg
, &wParam
, &lParam
) == -1) return 0;
2338 result
= WINPROC_CallWndProc( func
, hwnd
, msg
, wParam
, lParam
);
2339 WINPROC_UnmapMsg32ATo32W( hwnd
, msg
, wParam
, lParam
);
2344 /**********************************************************************
2345 * WINPROC_CallProc32WTo32A
2347 * Call a window procedure, translating args from Unicode to Ansi.
2349 static LRESULT
WINPROC_CallProc32WTo32A( WNDPROC func
, HWND hwnd
,
2350 UINT msg
, WPARAM wParam
,
2355 if (WINPROC_MapMsg32WTo32A( hwnd
, msg
, &wParam
, &lParam
) == -1) return 0;
2356 result
= WINPROC_CallWndProc( func
, hwnd
, msg
, wParam
, lParam
);
2357 WINPROC_UnmapMsg32WTo32A( hwnd
, msg
, wParam
, lParam
);
2362 /**********************************************************************
2363 * WINPROC_CallProc16To32A
2365 * Call a 32-bit window procedure, translating the 16-bit args.
2367 static LRESULT
WINPROC_CallProc16To32A( WNDPROC func
, HWND16 hwnd
,
2368 UINT16 msg
, WPARAM16 wParam
,
2375 if (WINPROC_MapMsg16To32A( msg
, wParam
, &msg32
, &wParam32
, &lParam
) == -1)
2377 result
= WINPROC_CallWndProc( func
, hwnd
, msg32
, wParam32
, lParam
);
2378 return WINPROC_UnmapMsg16To32A( hwnd
, msg32
, wParam32
, lParam
, result
);
2381 /**********************************************************************
2382 * WINPROC_Thunk16To32A
2384 static LRESULT WINAPI
WINPROC_Thunk16To32A( WNDPROC func
, LPBYTE args
)
2386 HWND16 hwnd
= *(HWND16
*)( args
+8 );
2387 UINT16 msg
= *(HWND16
*)( args
+6 );
2388 WPARAM16 wParam
= *(HWND16
*)( args
+4 );
2389 LPARAM lParam
= *(LPARAM
*)( args
+0 );
2391 return WINPROC_CallProc16To32A( func
, hwnd
, msg
, wParam
, lParam
);
2395 /**********************************************************************
2396 * WINPROC_CallProc16To32W
2398 * Call a 32-bit window procedure, translating the 16-bit args.
2400 static LRESULT
WINPROC_CallProc16To32W( WNDPROC func
, HWND16 hwnd
,
2401 UINT16 msg
, WPARAM16 wParam
,
2408 if (WINPROC_MapMsg16To32W( hwnd
, msg
, wParam
, &msg32
, &wParam32
, &lParam
) == -1)
2411 result
= WINPROC_CallWndProc( func
, hwnd
, msg32
, wParam32
, lParam
);
2413 return WINPROC_UnmapMsg16To32W( hwnd
, msg32
, wParam32
, lParam
, result
);
2416 /**********************************************************************
2417 * WINPROC_Thunk16To32W
2419 static LRESULT WINAPI
WINPROC_Thunk16To32W( WNDPROC func
, LPBYTE args
)
2421 HWND16 hwnd
= *(HWND16
*)( args
+8 );
2422 UINT16 msg
= *(HWND16
*)( args
+6 );
2423 WPARAM16 wParam
= *(HWND16
*)( args
+4 );
2424 LPARAM lParam
= *(LPARAM
*)( args
+0 );
2426 return WINPROC_CallProc16To32W( func
, hwnd
, msg
, wParam
, lParam
);
2429 /**********************************************************************
2430 * WINPROC_CallProc32ATo16
2432 * Call a 16-bit window procedure, translating the 32-bit args.
2434 static LRESULT WINAPI
WINPROC_CallProc32ATo16( WNDPROC16 func
, HWND hwnd
,
2435 UINT msg
, WPARAM wParam
,
2441 mp16
.lParam
= lParam
;
2442 if (WINPROC_MapMsg32ATo16( hwnd
, msg
, wParam
,
2443 &msg16
, &mp16
.wParam
, &mp16
.lParam
) == -1)
2445 mp16
.lResult
= WINPROC_CallWndProc16( func
, hwnd
, msg16
,
2446 mp16
.wParam
, mp16
.lParam
);
2447 WINPROC_UnmapMsg32ATo16( hwnd
, msg
, wParam
, lParam
, &mp16
);
2448 return mp16
.lResult
;
2452 /**********************************************************************
2453 * WINPROC_CallProc32WTo16
2455 * Call a 16-bit window procedure, translating the 32-bit args.
2457 static LRESULT WINAPI
WINPROC_CallProc32WTo16( WNDPROC16 func
, HWND hwnd
,
2458 UINT msg
, WPARAM wParam
,
2464 mp16
.lParam
= lParam
;
2465 if (WINPROC_MapMsg32WTo16( hwnd
, msg
, wParam
, &msg16
, &mp16
.wParam
,
2466 &mp16
.lParam
) == -1)
2468 mp16
.lResult
= WINPROC_CallWndProc16( func
, hwnd
, msg16
,
2469 mp16
.wParam
, mp16
.lParam
);
2470 WINPROC_UnmapMsg32WTo16( hwnd
, msg
, wParam
, lParam
, &mp16
);
2471 return mp16
.lResult
;
2475 /**********************************************************************
2476 * CallWindowProc16 (USER.122)
2478 LRESULT WINAPI
CallWindowProc16( WNDPROC16 func
, HWND16 hwnd
, UINT16 msg
,
2479 WPARAM16 wParam
, LPARAM lParam
)
2481 WINDOWPROC
*proc
= WINPROC_GetPtr( func
);
2484 return WINPROC_CallWndProc16( func
, hwnd
, msg
, wParam
, lParam
);
2487 func
= WINPROC_GetProc( (HWINDOWPROC
)proc
, WIN_PROC_16
);
2488 return WINPROC_CallWndProc16( func
, hwnd
, msg
, wParam
, lParam
);
2494 if (!proc
->thunk
.t_from32
.proc
) return 0;
2495 return WINPROC_CallWndProc16( proc
->thunk
.t_from32
.proc
,
2496 hwnd
, msg
, wParam
, lParam
);
2498 if (!proc
->thunk
.t_from16
.proc
) return 0;
2499 return WINPROC_CallProc16To32A( proc
->thunk
.t_from16
.proc
,
2500 hwnd
, msg
, wParam
, lParam
);
2502 if (!proc
->thunk
.t_from16
.proc
) return 0;
2503 return WINPROC_CallProc16To32W( proc
->thunk
.t_from16
.proc
,
2504 hwnd
, msg
, wParam
, lParam
);
2506 WARN_(relay
)("Invalid proc %p\n", proc
);
2512 /**********************************************************************
2513 * CallWindowProcA (USER32.18)
2515 * The CallWindowProc() function invokes the windows procedure _func_,
2516 * with _hwnd_ as the target window, the message specified by _msg_, and
2517 * the message parameters _wParam_ and _lParam_.
2519 * Some kinds of argument conversion may be done, I'm not sure what.
2521 * CallWindowProc() may be used for windows subclassing. Use
2522 * SetWindowLong() to set a new windows procedure for windows of the
2523 * subclass, and handle subclassed messages in the new windows
2524 * procedure. The new windows procedure may then use CallWindowProc()
2525 * with _func_ set to the parent class's windows procedure to dispatch
2526 * the message to the superclass.
2530 * The return value is message dependent.
2536 LRESULT WINAPI
CallWindowProcA(
2537 WNDPROC func
, /* window procedure */
2538 HWND hwnd
, /* target window */
2539 UINT msg
, /* message */
2540 WPARAM wParam
, /* message dependent parameter */
2541 LPARAM lParam
/* message dependent parameter */
2543 WINDOWPROC
*proc
= WINPROC_GetPtr( (WNDPROC16
)func
);
2545 if (!proc
) return WINPROC_CallWndProc( func
, hwnd
, msg
, wParam
, lParam
);
2548 func
= WINPROC_GetProc( (HWINDOWPROC
)proc
, WIN_PROC_32A
);
2549 return WINPROC_CallWndProc( func
, hwnd
, msg
, wParam
, lParam
);
2555 if (!proc
->thunk
.t_from32
.proc
) return 0;
2556 return WINPROC_CallProc32ATo16( proc
->thunk
.t_from32
.proc
,
2557 hwnd
, msg
, wParam
, lParam
);
2559 if (!proc
->thunk
.t_from16
.proc
) return 0;
2560 return WINPROC_CallWndProc( proc
->thunk
.t_from16
.proc
,
2561 hwnd
, msg
, wParam
, lParam
);
2563 if (!proc
->thunk
.t_from16
.proc
) return 0;
2564 return WINPROC_CallProc32ATo32W( proc
->thunk
.t_from16
.proc
,
2565 hwnd
, msg
, wParam
, lParam
);
2567 WARN_(relay
)("Invalid proc %p\n", proc
);
2573 /**********************************************************************
2574 * CallWindowProcW (USER32.19)
2576 LRESULT WINAPI
CallWindowProcW( WNDPROC func
, HWND hwnd
, UINT msg
,
2577 WPARAM wParam
, LPARAM lParam
)
2579 WINDOWPROC
*proc
= WINPROC_GetPtr( (WNDPROC16
)func
);
2581 if (!proc
) return WINPROC_CallWndProc( func
, hwnd
, msg
, wParam
, lParam
);
2584 func
= WINPROC_GetProc( (HWINDOWPROC
)proc
, WIN_PROC_32W
);
2585 return WINPROC_CallWndProc( func
, hwnd
, msg
, wParam
, lParam
);
2591 if (!proc
->thunk
.t_from32
.proc
) return 0;
2592 return WINPROC_CallProc32WTo16( proc
->thunk
.t_from32
.proc
,
2593 hwnd
, msg
, wParam
, lParam
);
2595 if (!proc
->thunk
.t_from16
.proc
) return 0;
2596 return WINPROC_CallProc32WTo32A( proc
->thunk
.t_from16
.proc
,
2597 hwnd
, msg
, wParam
, lParam
);
2599 if (!proc
->thunk
.t_from16
.proc
) return 0;
2600 return WINPROC_CallWndProc( proc
->thunk
.t_from16
.proc
,
2601 hwnd
, msg
, wParam
, lParam
);
2603 WARN_(relay
)("Invalid proc %p\n", proc
);