crypt32: Add name value tests.
[wine] / dlls / user / winproc.c
1 /*
2  * Window procedure callbacks
3  *
4  * Copyright 1995 Martin von Loewis
5  * Copyright 1996 Alexandre Julliard
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <stdarg.h>
27 #include <string.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wingdi.h"
32 #include "wownt32.h"
33 #include "wine/winbase16.h"
34 #include "wine/winuser16.h"
35 #include "controls.h"
36 #include "win.h"
37 #include "winproc.h"
38 #include "user_private.h"
39 #include "dde.h"
40 #include "winternl.h"
41 #include "wine/unicode.h"
42 #include "wine/debug.h"
43
44 WINE_DECLARE_DEBUG_CHANNEL(msg);
45 WINE_DECLARE_DEBUG_CHANNEL(relay);
46 WINE_DEFAULT_DEBUG_CHANNEL(win);
47
48 typedef struct tagWINDOWPROC
49 {
50     WNDPROC16      proc16;   /* 16-bit window proc */
51     WNDPROC        procA;    /* ASCII window proc */
52     WNDPROC        procW;    /* Unicode window proc */
53 } WINDOWPROC;
54
55 #define WINPROC_HANDLE (~0UL >> 16)
56 #define MAX_WINPROCS  8192
57
58 static WINDOWPROC winproc_array[MAX_WINPROCS];
59 static UINT winproc_used;
60
61 static CRITICAL_SECTION winproc_cs;
62 static CRITICAL_SECTION_DEBUG critsect_debug =
63 {
64     0, 0, &winproc_cs,
65     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
66       0, 0, { (DWORD_PTR)(__FILE__ ": winproc_cs") }
67 };
68 static CRITICAL_SECTION winproc_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
69
70 static inline void *get_buffer( void *static_buffer, size_t size, size_t need )
71 {
72     if (size >= need) return static_buffer;
73     return HeapAlloc( GetProcessHeap(), 0, need );
74 }
75
76 static inline void free_buffer( void *static_buffer, void *buffer )
77 {
78     if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
79 }
80
81 /* find an existing winproc for a given 16-bit function and type */
82 /* FIXME: probably should do something more clever than a linear search */
83 static inline WINDOWPROC *find_winproc16( WNDPROC16 func )
84 {
85     unsigned int i;
86
87     for (i = 0; i < winproc_used; i++)
88     {
89         if (winproc_array[i].proc16 == func) return &winproc_array[i];
90     }
91     return NULL;
92 }
93
94 /* find an existing winproc for a given function and type */
95 /* FIXME: probably should do something more clever than a linear search */
96 static inline WINDOWPROC *find_winproc( WNDPROC funcA, WNDPROC funcW )
97 {
98     unsigned int i;
99
100     for (i = 0; i < winproc_used; i++)
101     {
102         if (funcA && winproc_array[i].procA != funcA) continue;
103         if (funcW && winproc_array[i].procW != funcW) continue;
104         return &winproc_array[i];
105     }
106     return NULL;
107 }
108
109 /* return the window proc for a given handle, or NULL for an invalid handle */
110 static inline WINDOWPROC *handle_to_proc( WNDPROC handle )
111 {
112     UINT index = LOWORD(handle);
113     if ((ULONG_PTR)handle >> 16 != WINPROC_HANDLE) return NULL;
114     if (index >= winproc_used) return NULL;
115     return &winproc_array[index];
116 }
117
118 /* create a handle for a given window proc */
119 static inline WNDPROC proc_to_handle( WINDOWPROC *proc )
120 {
121     return (WNDPROC)(ULONG_PTR)((proc - winproc_array) | (WINPROC_HANDLE << 16));
122 }
123
124 /* allocate and initialize a new winproc */
125 static inline WINDOWPROC *alloc_winproc( WNDPROC funcA, WNDPROC funcW )
126 {
127     WINDOWPROC *proc;
128
129     /* check if the function is already a win proc */
130     if (funcA && (proc = handle_to_proc( funcA ))) return proc;
131     if (funcW && (proc = handle_to_proc( funcW ))) return proc;
132     if (!funcA && !funcW) return NULL;
133
134     EnterCriticalSection( &winproc_cs );
135
136     /* check if we already have a winproc for that function */
137     if (!(proc = find_winproc( funcA, funcW )))
138     {
139         if (winproc_used < MAX_WINPROCS)
140         {
141             proc = &winproc_array[winproc_used++];
142             proc->procA = funcA;
143             proc->procW = funcW;
144             TRACE( "allocated %p for %p/%p (%d/%d used)\n",
145                    proc_to_handle(proc), funcA, funcW, winproc_used, MAX_WINPROCS );
146         }
147         else FIXME( "too many winprocs, cannot allocate one for %p/%p\n", funcA, funcW );
148     }
149     else TRACE( "reusing %p for %p/%p\n", proc_to_handle(proc), funcA, funcW );
150
151     LeaveCriticalSection( &winproc_cs );
152     return proc;
153 }
154
155
156 #ifdef __i386__
157
158 #include "pshpack1.h"
159
160 /* Window procedure 16-to-32-bit thunk */
161 typedef struct
162 {
163     BYTE        popl_eax;        /* popl  %eax (return address) */
164     BYTE        pushl_func;      /* pushl $proc */
165     WINDOWPROC *proc;
166     BYTE        pushl_eax;       /* pushl %eax */
167     BYTE        ljmp;            /* ljmp relay*/
168     DWORD       relay_offset;    /* __wine_call_wndproc */
169     WORD        relay_sel;
170 } WINPROC_THUNK;
171
172 #include "poppack.h"
173
174 #define MAX_THUNKS  (0x10000 / sizeof(WINPROC_THUNK))
175
176 static WINPROC_THUNK *thunk_array;
177 static UINT thunk_selector;
178 static UINT thunk_used;
179
180 /* return the window proc for a given handle, or NULL for an invalid handle */
181 static inline WINDOWPROC *handle16_to_proc( WNDPROC16 handle )
182 {
183     if (HIWORD(handle) == thunk_selector)
184     {
185         UINT index = LOWORD(handle) / sizeof(WINPROC_THUNK);
186         /* check alignment */
187         if (index * sizeof(WINPROC_THUNK) != LOWORD(handle)) return NULL;
188         /* check array limits */
189         if (index >= thunk_used) return NULL;
190         return thunk_array[index].proc;
191     }
192     return handle_to_proc( (WNDPROC)handle );
193 }
194
195 /* allocate a 16-bit thunk for an existing window proc */
196 static WNDPROC16 alloc_win16_thunk( WINDOWPROC *proc )
197 {
198     static FARPROC16 relay;
199     UINT i;
200
201     if (proc->proc16) return proc->proc16;
202
203     EnterCriticalSection( &winproc_cs );
204
205     if (!thunk_array)  /* allocate the array and its selector */
206     {
207         LDT_ENTRY entry;
208
209         if (!(thunk_selector = wine_ldt_alloc_entries(1))) goto done;
210         if (!(thunk_array = VirtualAlloc( NULL, MAX_THUNKS * sizeof(WINPROC_THUNK), MEM_COMMIT,
211                                           PAGE_EXECUTE_READWRITE ))) goto done;
212         wine_ldt_set_base( &entry, thunk_array );
213         wine_ldt_set_limit( &entry, MAX_THUNKS * sizeof(WINPROC_THUNK) - 1 );
214         wine_ldt_set_flags( &entry, WINE_LDT_FLAGS_CODE | WINE_LDT_FLAGS_32BIT );
215         wine_ldt_set_entry( thunk_selector, &entry );
216         relay = GetProcAddress16( GetModuleHandle16("user"), "__wine_call_wndproc" );
217     }
218
219     /* check if it already exists */
220     for (i = 0; i < thunk_used; i++) if (thunk_array[i].proc == proc) break;
221
222     if (i == thunk_used)  /* create a new one */
223     {
224         WINPROC_THUNK *thunk;
225
226         if (thunk_used >= MAX_THUNKS) goto done;
227         thunk = &thunk_array[thunk_used++];
228         thunk->popl_eax     = 0x58;   /* popl  %eax */
229         thunk->pushl_func   = 0x68;   /* pushl $proc */
230         thunk->proc         = proc;
231         thunk->pushl_eax    = 0x50;   /* pushl %eax */
232         thunk->ljmp         = 0xea;   /* ljmp   relay*/
233         thunk->relay_offset = OFFSETOF(relay);
234         thunk->relay_sel    = SELECTOROF(relay);
235     }
236     proc->proc16 = (WNDPROC16)MAKESEGPTR( thunk_selector, i * sizeof(WINPROC_THUNK) );
237 done:
238     LeaveCriticalSection( &winproc_cs );
239     return proc->proc16;
240 }
241
242 #else  /* __i386__ */
243
244 static inline WINDOWPROC *handle16_to_proc( WNDPROC16 handle )
245 {
246     return handle_to_proc( (WNDPROC)handle );
247 }
248
249 static inline WNDPROC16 alloc_win16_thunk( WINDOWPROC *proc )
250 {
251     return 0;
252 }
253
254 #endif  /* __i386__ */
255
256
257 #ifdef __i386__
258 /* Some window procedures modify register they shouldn't, or are not
259  * properly declared stdcall; so we need a small assembly wrapper to
260  * call them. */
261 extern LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
262                                 WPARAM wParam, LPARAM lParam );
263 __ASM_GLOBAL_FUNC( WINPROC_wrapper,
264                    "pushl %ebp\n\t"
265                    "movl %esp,%ebp\n\t"
266                    "pushl %edi\n\t"
267                    "pushl %esi\n\t"
268                    "pushl %ebx\n\t"
269                    "subl $12,%esp\n\t"
270                    "pushl 24(%ebp)\n\t"
271                    "pushl 20(%ebp)\n\t"
272                    "pushl 16(%ebp)\n\t"
273                    "pushl 12(%ebp)\n\t"
274                    "movl 8(%ebp),%eax\n\t"
275                    "call *%eax\n\t"
276                    "leal -12(%ebp),%esp\n\t"
277                    "popl %ebx\n\t"
278                    "popl %esi\n\t"
279                    "popl %edi\n\t"
280                    "leave\n\t"
281                    "ret" );
282 #else
283 static inline LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
284                                        WPARAM wParam, LPARAM lParam )
285 {
286     return proc( hwnd, msg, wParam, lParam );
287 }
288 #endif  /* __i386__ */
289
290 static void RECT16to32( const RECT16 *from, RECT *to )
291 {
292     to->left   = from->left;
293     to->top    = from->top;
294     to->right  = from->right;
295     to->bottom = from->bottom;
296 }
297
298 static void RECT32to16( const RECT *from, RECT16 *to )
299 {
300     to->left   = from->left;
301     to->top    = from->top;
302     to->right  = from->right;
303     to->bottom = from->bottom;
304 }
305
306 static void MINMAXINFO32to16( const MINMAXINFO *from, MINMAXINFO16 *to )
307 {
308     to->ptReserved.x     = from->ptReserved.x;
309     to->ptReserved.y     = from->ptReserved.y;
310     to->ptMaxSize.x      = from->ptMaxSize.x;
311     to->ptMaxSize.y      = from->ptMaxSize.y;
312     to->ptMaxPosition.x  = from->ptMaxPosition.x;
313     to->ptMaxPosition.y  = from->ptMaxPosition.y;
314     to->ptMinTrackSize.x = from->ptMinTrackSize.x;
315     to->ptMinTrackSize.y = from->ptMinTrackSize.y;
316     to->ptMaxTrackSize.x = from->ptMaxTrackSize.x;
317     to->ptMaxTrackSize.y = from->ptMaxTrackSize.y;
318 }
319
320 static void MINMAXINFO16to32( const MINMAXINFO16 *from, MINMAXINFO *to )
321 {
322     to->ptReserved.x     = from->ptReserved.x;
323     to->ptReserved.y     = from->ptReserved.y;
324     to->ptMaxSize.x      = from->ptMaxSize.x;
325     to->ptMaxSize.y      = from->ptMaxSize.y;
326     to->ptMaxPosition.x  = from->ptMaxPosition.x;
327     to->ptMaxPosition.y  = from->ptMaxPosition.y;
328     to->ptMinTrackSize.x = from->ptMinTrackSize.x;
329     to->ptMinTrackSize.y = from->ptMinTrackSize.y;
330     to->ptMaxTrackSize.x = from->ptMaxTrackSize.x;
331     to->ptMaxTrackSize.y = from->ptMaxTrackSize.y;
332 }
333
334 static void WINDOWPOS32to16( const WINDOWPOS* from, WINDOWPOS16* to )
335 {
336     to->hwnd            = HWND_16(from->hwnd);
337     to->hwndInsertAfter = HWND_16(from->hwndInsertAfter);
338     to->x               = from->x;
339     to->y               = from->y;
340     to->cx              = from->cx;
341     to->cy              = from->cy;
342     to->flags           = from->flags;
343 }
344
345 static void WINDOWPOS16to32( const WINDOWPOS16* from, WINDOWPOS* to )
346 {
347     to->hwnd            = WIN_Handle32(from->hwnd);
348     to->hwndInsertAfter = (from->hwndInsertAfter == (HWND16)-1) ?
349                            HWND_TOPMOST : WIN_Handle32(from->hwndInsertAfter);
350     to->x               = from->x;
351     to->y               = from->y;
352     to->cx              = from->cx;
353     to->cy              = from->cy;
354     to->flags           = from->flags;
355 }
356
357 /* The strings are not copied */
358 static void CREATESTRUCT32Ato16( const CREATESTRUCTA* from, CREATESTRUCT16* to )
359 {
360     to->lpCreateParams = (SEGPTR)from->lpCreateParams;
361     to->hInstance      = HINSTANCE_16(from->hInstance);
362     to->hMenu          = HMENU_16(from->hMenu);
363     to->hwndParent     = HWND_16(from->hwndParent);
364     to->cy             = from->cy;
365     to->cx             = from->cx;
366     to->y              = from->y;
367     to->x              = from->x;
368     to->style          = from->style;
369     to->dwExStyle      = from->dwExStyle;
370 }
371
372 static void CREATESTRUCT16to32A( const CREATESTRUCT16* from, CREATESTRUCTA *to )
373
374 {
375     to->lpCreateParams = (LPVOID)from->lpCreateParams;
376     to->hInstance      = HINSTANCE_32(from->hInstance);
377     to->hMenu          = HMENU_32(from->hMenu);
378     to->hwndParent     = WIN_Handle32(from->hwndParent);
379     to->cy             = from->cy;
380     to->cx             = from->cx;
381     to->y              = from->y;
382     to->x              = from->x;
383     to->style          = from->style;
384     to->dwExStyle      = from->dwExStyle;
385     to->lpszName       = MapSL(from->lpszName);
386     to->lpszClass      = MapSL(from->lpszClass);
387 }
388
389 /* The strings are not copied */
390 static void MDICREATESTRUCT32Ato16( const MDICREATESTRUCTA* from, MDICREATESTRUCT16* to )
391 {
392     to->hOwner = HINSTANCE_16(from->hOwner);
393     to->x      = from->x;
394     to->y      = from->y;
395     to->cx     = from->cx;
396     to->cy     = from->cy;
397     to->style  = from->style;
398     to->lParam = from->lParam;
399 }
400
401 static void MDICREATESTRUCT16to32A( const MDICREATESTRUCT16* from, MDICREATESTRUCTA *to )
402 {
403     to->hOwner = HINSTANCE_32(from->hOwner);
404     to->x      = from->x;
405     to->y      = from->y;
406     to->cx     = from->cx;
407     to->cy     = from->cy;
408     to->style  = from->style;
409     to->lParam = from->lParam;
410     to->szTitle = MapSL(from->szTitle);
411     to->szClass = MapSL(from->szClass);
412 }
413
414 static WPARAM map_wparam_char_AtoW( WPARAM wParam, DWORD len )
415 {
416     CHAR ch[2];
417     WCHAR wch;
418
419     ch[0] = (wParam >> 8);
420     ch[1] = wParam & 0xff;
421     if (len > 1 && ch[0])
422         RtlMultiByteToUnicodeN( &wch, sizeof(wch), NULL, ch, 2 );
423     else
424         RtlMultiByteToUnicodeN( &wch, sizeof(wch), NULL, ch + 1, 1 );
425     return MAKEWPARAM( wch, HIWORD(wParam) );
426 }
427
428 static WPARAM map_wparam_char_WtoA( WPARAM wParam, DWORD len )
429 {
430     WCHAR wch = wParam;
431     BYTE ch[2];
432
433     RtlUnicodeToMultiByteN( (LPSTR)ch, len, &len, &wch, sizeof(wch) );
434     if (len == 2)
435         return MAKEWPARAM( (ch[0] << 8) | ch[1], HIWORD(wParam) );
436     else
437         return MAKEWPARAM( ch[0], HIWORD(wParam) );
438 }
439
440 /* call a 32-bit window procedure */
441 static LRESULT call_window_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT *result, void *arg )
442 {
443     WNDPROC proc = arg;
444
445     USER_CheckNotLock();
446
447     hwnd = WIN_GetFullHandle( hwnd );
448     if (TRACE_ON(relay))
449         DPRINTF( "%04lx:Call window proc %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
450                  GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp );
451
452     *result = WINPROC_wrapper( proc, hwnd, msg, wp, lp );
453
454     if (TRACE_ON(relay))
455         DPRINTF( "%04lx:Ret  window proc %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx) retval=%08lx\n",
456                  GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp, *result );
457     return *result;
458 }
459
460 /* call a 32-bit dialog procedure */
461 static LRESULT call_dialog_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT *result, void *arg )
462 {
463     WNDPROC proc = arg;
464     LRESULT ret;
465
466     USER_CheckNotLock();
467
468     hwnd = WIN_GetFullHandle( hwnd );
469     if (TRACE_ON(relay))
470         DPRINTF( "%04lx:Call dialog proc %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
471                  GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp );
472
473     ret = WINPROC_wrapper( proc, hwnd, msg, wp, lp );
474     *result = GetWindowLongPtrW( hwnd, DWLP_MSGRESULT );
475
476     if (TRACE_ON(relay))
477         DPRINTF( "%04lx:Ret  dialog proc %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx) retval=%08lx result=%08lx\n",
478                  GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp, ret, *result );
479     return ret;
480 }
481
482 /* call a 16-bit window procedure */
483 static LRESULT call_window_proc16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam,
484                                    LRESULT *result, void *arg )
485 {
486     WNDPROC16 proc = arg;
487     CONTEXT86 context;
488     size_t size = 0;
489     struct
490     {
491         WORD params[5];
492         union
493         {
494             CREATESTRUCT16 cs16;
495             DRAWITEMSTRUCT16 dis16;
496             COMPAREITEMSTRUCT16 cis16;
497         } u;
498     } args;
499
500     USER_CheckNotLock();
501
502     /* Window procedures want ax = hInstance, ds = es = ss */
503
504     memset(&context, 0, sizeof(context));
505     context.SegDs = context.SegEs = SELECTOROF(NtCurrentTeb()->WOW32Reserved);
506     context.SegFs = wine_get_fs();
507     context.SegGs = wine_get_gs();
508     if (!(context.Eax = GetWindowWord( HWND_32(hwnd), GWLP_HINSTANCE ))) context.Eax = context.SegDs;
509     context.SegCs = SELECTOROF(proc);
510     context.Eip   = OFFSETOF(proc);
511     context.Ebp   = OFFSETOF(NtCurrentTeb()->WOW32Reserved) + (WORD)&((STACK16FRAME*)0)->bp;
512
513     if (lParam)
514     {
515         /* Some programs (eg. the "Undocumented Windows" examples, JWP) only
516            work if structures passed in lParam are placed in the stack/data
517            segment. Programmers easily make the mistake of converting lParam
518            to a near rather than a far pointer, since Windows apparently
519            allows this. We copy the structures to the 16 bit stack; this is
520            ugly but makes these programs work. */
521         switch (msg)
522         {
523           case WM_CREATE:
524           case WM_NCCREATE:
525             size = sizeof(CREATESTRUCT16); break;
526           case WM_DRAWITEM:
527             size = sizeof(DRAWITEMSTRUCT16); break;
528           case WM_COMPAREITEM:
529             size = sizeof(COMPAREITEMSTRUCT16); break;
530         }
531         if (size)
532         {
533             memcpy( &args.u, MapSL(lParam), size );
534             lParam = (SEGPTR)NtCurrentTeb()->WOW32Reserved - size;
535         }
536     }
537
538     args.params[4] = hwnd;
539     args.params[3] = msg;
540     args.params[2] = wParam;
541     args.params[1] = HIWORD(lParam);
542     args.params[0] = LOWORD(lParam);
543     WOWCallback16Ex( 0, WCB16_REGS, sizeof(args.params) + size, &args, (DWORD *)&context );
544     *result = MAKELONG( LOWORD(context.Eax), LOWORD(context.Edx) );
545     return *result;
546 }
547
548 /* call a 16-bit dialog procedure */
549 static LRESULT call_dialog_proc16( HWND16 hwnd, UINT16 msg, WPARAM16 wp, LPARAM lp,
550                                    LRESULT *result, void *arg )
551 {
552     LRESULT ret = call_window_proc16( hwnd, msg, wp, lp, result, arg );
553     *result = GetWindowLongPtrW( WIN_Handle32(hwnd), DWLP_MSGRESULT );
554     return LOWORD(ret);
555 }
556
557 /* helper callback for 32W->16 conversion */
558 static LRESULT call_window_proc_Ato16( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
559                                        LRESULT *result, void *arg )
560 {
561     return WINPROC_CallProc32ATo16( call_window_proc16, hwnd, msg, wp, lp, result, arg );
562 }
563
564 /* helper callback for 32W->16 conversion */
565 static LRESULT call_dialog_proc_Ato16( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
566                                        LRESULT *result, void *arg )
567 {
568     return WINPROC_CallProc32ATo16( call_dialog_proc16, hwnd, msg, wp, lp, result, arg );
569 }
570
571 /* helper callback for 16->32W conversion */
572 static LRESULT call_window_proc_AtoW( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
573                                       LRESULT *result, void *arg )
574 {
575     return WINPROC_CallProcAtoW( call_window_proc, hwnd, msg, wp, lp, result, arg );
576 }
577
578 /* helper callback for 16->32W conversion */
579 static LRESULT call_dialog_proc_AtoW( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
580                                       LRESULT *result, void *arg )
581 {
582     return WINPROC_CallProcAtoW( call_dialog_proc, hwnd, msg, wp, lp, result, arg );
583 }
584
585
586 /**********************************************************************
587  *           WINPROC_GetProc16
588  *
589  * Get a window procedure pointer that can be passed to the Windows program.
590  */
591 WNDPROC16 WINPROC_GetProc16( WNDPROC proc, BOOL unicode )
592 {
593     WINDOWPROC *ptr;
594
595     if (unicode) ptr = alloc_winproc( NULL, proc );
596     else ptr = alloc_winproc( proc, NULL );
597
598     if (!ptr) return 0;
599     return alloc_win16_thunk( ptr );
600 }
601
602
603 /**********************************************************************
604  *           WINPROC_GetProc
605  *
606  * Get a window procedure pointer that can be passed to the Windows program.
607  */
608 WNDPROC WINPROC_GetProc( WNDPROC proc, BOOL unicode )
609 {
610     WINDOWPROC *ptr = handle_to_proc( proc );
611
612     if (!ptr) return proc;
613     if (unicode)
614     {
615         if (ptr->procW) return ptr->procW;
616         return proc;
617     }
618     else
619     {
620         if (ptr->procA) return ptr->procA;
621         return proc;
622     }
623 }
624
625
626 /**********************************************************************
627  *           WINPROC_AllocProc16
628  *
629  * Allocate a window procedure for a window or class.
630  *
631  * Note that allocated winprocs are never freed; the idea is that even if an app creates a
632  * lot of windows, it will usually only have a limited number of window procedures, so the
633  * array won't grow too large, and this way we avoid the need to track allocations per window.
634  */
635 WNDPROC WINPROC_AllocProc16( WNDPROC16 func )
636 {
637     WINDOWPROC *proc;
638
639     if (!func) return NULL;
640
641     /* check if the function is already a win proc */
642     if (!(proc = handle16_to_proc( func )))
643     {
644         EnterCriticalSection( &winproc_cs );
645
646         /* then check if we already have a winproc for that function */
647         if (!(proc = find_winproc16( func )))
648         {
649             if (winproc_used < MAX_WINPROCS)
650             {
651                 proc = &winproc_array[winproc_used++];
652                 proc->proc16 = func;
653                 TRACE( "allocated %p for %p/16-bit (%d/%d used)\n",
654                        proc_to_handle(proc), func, winproc_used, MAX_WINPROCS );
655             }
656             else FIXME( "too many winprocs, cannot allocate one for 16-bit %p\n", func );
657         }
658         else TRACE( "reusing %p for %p/16-bit\n", proc_to_handle(proc), func );
659
660         LeaveCriticalSection( &winproc_cs );
661     }
662     return proc_to_handle( proc );
663 }
664
665
666 /**********************************************************************
667  *           WINPROC_AllocProc
668  *
669  * Allocate a window procedure for a window or class.
670  *
671  * Note that allocated winprocs are never freed; the idea is that even if an app creates a
672  * lot of windows, it will usually only have a limited number of window procedures, so the
673  * array won't grow too large, and this way we avoid the need to track allocations per window.
674  */
675 WNDPROC WINPROC_AllocProc( WNDPROC funcA, WNDPROC funcW )
676 {
677     WINDOWPROC *proc;
678
679     if (!(proc = alloc_winproc( funcA, funcW ))) return NULL;
680     return proc_to_handle( proc );
681 }
682
683
684 /**********************************************************************
685  *           WINPROC_IsUnicode
686  *
687  * Return the window procedure type, or the default value if not a winproc handle.
688  */
689 BOOL WINPROC_IsUnicode( WNDPROC proc, BOOL def_val )
690 {
691     WINDOWPROC *ptr = handle_to_proc( proc );
692
693     if (!ptr) return def_val;
694     if (ptr->procA && ptr->procW) return def_val;  /* can be both */
695     return (ptr->procW != NULL);
696 }
697
698
699 /**********************************************************************
700  *           WINPROC_TestLBForStr
701  *
702  * Return TRUE if the lparam is a string
703  */
704 inline static BOOL WINPROC_TestLBForStr( HWND hwnd, UINT msg )
705 {
706     DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
707     if (msg <= CB_MSGMAX)
708         return (!(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) || (style & CBS_HASSTRINGS));
709     else
710         return (!(style & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) || (style & LBS_HASSTRINGS));
711
712 }
713
714
715 static UINT convert_handle_16_to_32(HANDLE16 src, unsigned int flags)
716 {
717     HANDLE      dst;
718     UINT        sz = GlobalSize16(src);
719     LPSTR       ptr16, ptr32;
720
721     if (!(dst = GlobalAlloc(flags, sz)))
722         return 0;
723     ptr16 = GlobalLock16(src);
724     ptr32 = GlobalLock(dst);
725     if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr32, ptr16, sz);
726     GlobalUnlock16(src);
727     GlobalUnlock(dst);
728
729     return (UINT)dst;
730 }
731
732 static HANDLE16 convert_handle_32_to_16(UINT src, unsigned int flags)
733 {
734     HANDLE16    dst;
735     UINT        sz = GlobalSize((HANDLE)src);
736     LPSTR       ptr16, ptr32;
737
738     if (!(dst = GlobalAlloc16(flags, sz)))
739         return 0;
740     ptr32 = GlobalLock((HANDLE)src);
741     ptr16 = GlobalLock16(dst);
742     if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr16, ptr32, sz);
743     GlobalUnlock((HANDLE)src);
744     GlobalUnlock16(dst);
745
746     return dst;
747 }
748
749
750 /**********************************************************************
751  *           WINPROC_CallProcAtoW
752  *
753  * Call a window procedure, translating args from Ansi to Unicode.
754  */
755 LRESULT WINPROC_CallProcAtoW( winproc_callback_t callback, HWND hwnd, UINT msg, WPARAM wParam,
756                               LPARAM lParam, LRESULT *result, void *arg )
757 {
758     LRESULT ret = 0;
759
760     TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
761                 hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
762
763     switch(msg)
764     {
765     case WM_NCCREATE:
766     case WM_CREATE:
767         {
768             WCHAR *ptr, buffer[512];
769             CREATESTRUCTA *csA = (CREATESTRUCTA *)lParam;
770             CREATESTRUCTW csW = *(CREATESTRUCTW *)csA;
771             MDICREATESTRUCTW mdi_cs;
772             DWORD name_lenA = 0, name_lenW = 0, class_lenA = 0, class_lenW = 0;
773
774             if (HIWORD(csA->lpszClass))
775             {
776                 class_lenA = strlen(csA->lpszClass) + 1;
777                 RtlMultiByteToUnicodeSize( &class_lenW, csA->lpszClass, class_lenA );
778             }
779             if (HIWORD(csA->lpszName))
780             {
781                 name_lenA = strlen(csA->lpszName) + 1;
782                 RtlMultiByteToUnicodeSize( &name_lenW, csA->lpszName, name_lenA );
783             }
784
785             if (!(ptr = get_buffer( buffer, sizeof(buffer), class_lenW + name_lenW ))) break;
786
787             if (class_lenW)
788             {
789                 csW.lpszClass = ptr;
790                 RtlMultiByteToUnicodeN( ptr, class_lenW, NULL, csA->lpszClass, class_lenA );
791             }
792             if (name_lenW)
793             {
794                 csW.lpszName = ptr + class_lenW/sizeof(WCHAR);
795                 RtlMultiByteToUnicodeN( ptr + class_lenW/sizeof(WCHAR), name_lenW, NULL,
796                                         csA->lpszName, name_lenA );
797             }
798
799             if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
800             {
801                 mdi_cs = *(MDICREATESTRUCTW *)csA->lpCreateParams;
802                 mdi_cs.szTitle = csW.lpszName;
803                 mdi_cs.szClass = csW.lpszClass;
804                 csW.lpCreateParams = &mdi_cs;
805             }
806
807             ret = callback( hwnd, msg, wParam, (LPARAM)&csW, result, arg );
808             free_buffer( buffer, ptr );
809         }
810         break;
811
812     case WM_MDICREATE:
813         {
814             WCHAR *ptr, buffer[512];
815             DWORD title_lenA = 0, title_lenW = 0, class_lenA = 0, class_lenW = 0;
816             MDICREATESTRUCTA *csA = (MDICREATESTRUCTA *)lParam;
817             MDICREATESTRUCTW csW;
818
819             memcpy( &csW, csA, sizeof(csW) );
820
821             if (HIWORD(csA->szTitle))
822             {
823                 title_lenA = strlen(csA->szTitle) + 1;
824                 RtlMultiByteToUnicodeSize( &title_lenW, csA->szTitle, title_lenA );
825             }
826             if (HIWORD(csA->szClass))
827             {
828                 class_lenA = strlen(csA->szClass) + 1;
829                 RtlMultiByteToUnicodeSize( &class_lenW, csA->szClass, class_lenA );
830             }
831
832             if (!(ptr = get_buffer( buffer, sizeof(buffer), title_lenW + class_lenW ))) break;
833
834             if (title_lenW)
835             {
836                 csW.szTitle = ptr;
837                 RtlMultiByteToUnicodeN( ptr, title_lenW, NULL, csA->szTitle, title_lenA );
838             }
839             if (class_lenW)
840             {
841                 csW.szClass = ptr + title_lenW/sizeof(WCHAR);
842                 RtlMultiByteToUnicodeN( ptr + title_lenW/sizeof(WCHAR), class_lenW, NULL,
843                                         csA->szClass, class_lenA );
844             }
845             ret = callback( hwnd, msg, wParam, (LPARAM)&csW, result, arg );
846             free_buffer( buffer, ptr );
847         }
848         break;
849
850     case WM_GETTEXT:
851     case WM_ASKCBFORMATNAME:
852         {
853             WCHAR *ptr, buffer[512];
854             LPSTR str = (LPSTR)lParam;
855             DWORD len = wParam * sizeof(WCHAR);
856
857             if (!(ptr = get_buffer( buffer, sizeof(buffer), len ))) break;
858             ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
859             if (*result && wParam)
860             {
861                 RtlUnicodeToMultiByteN( str, wParam - 1, &len, ptr, strlenW(ptr) * sizeof(WCHAR) );
862                 str[len] = 0;
863                 *result = len;
864             }
865             free_buffer( buffer, ptr );
866         }
867         break;
868
869     case LB_ADDSTRING:
870     case LB_INSERTSTRING:
871     case LB_FINDSTRING:
872     case LB_FINDSTRINGEXACT:
873     case LB_SELECTSTRING:
874     case CB_ADDSTRING:
875     case CB_INSERTSTRING:
876     case CB_FINDSTRING:
877     case CB_FINDSTRINGEXACT:
878     case CB_SELECTSTRING:
879         if (!lParam || !WINPROC_TestLBForStr( hwnd, msg ))
880         {
881             ret = callback( hwnd, msg, wParam, lParam, result, arg );
882             break;
883         }
884         /* fall through */
885     case WM_SETTEXT:
886     case WM_WININICHANGE:
887     case WM_DEVMODECHANGE:
888     case CB_DIR:
889     case LB_DIR:
890     case LB_ADDFILE:
891     case EM_REPLACESEL:
892         if (!lParam) ret = callback( hwnd, msg, wParam, lParam, result, arg );
893         else
894         {
895             WCHAR *ptr, buffer[512];
896             LPCSTR strA = (LPCSTR)lParam;
897             DWORD lenW, lenA = strlen(strA) + 1;
898
899             RtlMultiByteToUnicodeSize( &lenW, strA, lenA );
900             if ((ptr = get_buffer( buffer, sizeof(buffer), lenW )))
901             {
902                 RtlMultiByteToUnicodeN( ptr, lenW, NULL, strA, lenA );
903                 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
904                 free_buffer( buffer, ptr );
905             }
906         }
907         break;
908
909     case LB_GETTEXT:
910     case CB_GETLBTEXT:
911         if (lParam && WINPROC_TestLBForStr( hwnd, msg ))
912         {
913             WCHAR buffer[512];  /* FIXME: fixed sized buffer */
914
915             ret = callback( hwnd, msg, wParam, (LPARAM)buffer, result, arg );
916             if (*result >= 0)
917             {
918                 DWORD len;
919                 RtlUnicodeToMultiByteN( (LPSTR)lParam, ~0u, &len,
920                                         buffer, (strlenW(buffer) + 1) * sizeof(WCHAR) );
921                 *result = len - 1;
922             }
923         }
924         else ret = callback( hwnd, msg, wParam, lParam, result, arg );
925         break;
926
927     case EM_GETLINE:
928         {
929             WCHAR *ptr, buffer[512];
930             WORD len = *(WORD *)lParam;
931
932             if (!(ptr = get_buffer( buffer, sizeof(buffer), len * sizeof(WCHAR) ))) break;
933             *((WORD *)ptr) = len;   /* store the length */
934             ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
935             if (*result)
936             {
937                 DWORD reslen;
938                 RtlUnicodeToMultiByteN( (LPSTR)lParam, len, &reslen, ptr, *result * sizeof(WCHAR) );
939                 if (reslen < len) ((LPSTR)lParam)[reslen] = 0;
940                 *result = reslen;
941             }
942             free_buffer( buffer, ptr );
943         }
944         break;
945
946     case WM_GETDLGCODE:
947         if (lParam)
948         {
949             MSG newmsg = *(MSG *)lParam;
950             switch(newmsg.message)
951             {
952             case WM_CHAR:
953             case WM_DEADCHAR:
954             case WM_SYSCHAR:
955             case WM_SYSDEADCHAR:
956                 newmsg.wParam = map_wparam_char_AtoW( newmsg.wParam, 1 );
957                 break;
958             case WM_IME_CHAR:
959                 newmsg.wParam = map_wparam_char_AtoW( newmsg.wParam, 2 );
960                 break;
961             }
962             ret = callback( hwnd, msg, wParam, (LPARAM)&newmsg, result, arg );
963         }
964         else ret = callback( hwnd, msg, wParam, lParam, result, arg );
965         break;
966
967     case WM_CHARTOITEM:
968     case WM_MENUCHAR:
969     case WM_CHAR:
970     case WM_DEADCHAR:
971     case WM_SYSCHAR:
972     case WM_SYSDEADCHAR:
973     case EM_SETPASSWORDCHAR:
974         ret = callback( hwnd, msg, map_wparam_char_AtoW(wParam,1), lParam, result, arg );
975         break;
976
977     case WM_IME_CHAR:
978         ret = callback( hwnd, msg, map_wparam_char_AtoW(wParam,2), lParam, result, arg );
979         break;
980
981     case WM_GETTEXTLENGTH:
982     case CB_GETLBTEXTLEN:
983     case LB_GETTEXTLEN:
984         ret = callback( hwnd, msg, wParam, lParam, result, arg );
985         if (*result >= 0)
986         {
987             WCHAR *ptr, buffer[512];
988             LRESULT tmp;
989             DWORD len = *result + 1;
990             /* Determine respective GETTEXT message */
991             UINT msgGetText = (msg == WM_GETTEXTLENGTH) ? WM_GETTEXT :
992                               ((msg == CB_GETLBTEXTLEN) ? CB_GETLBTEXT : LB_GETTEXT);
993             /* wParam differs between the messages */
994             WPARAM wp = (msg == WM_GETTEXTLENGTH) ? len : wParam;
995
996             if (!(ptr = get_buffer( buffer, sizeof(buffer), len * sizeof(WCHAR) ))) break;
997
998             if (callback == call_window_proc)  /* FIXME: hack */
999                 callback( hwnd, msgGetText, wp, (LPARAM)ptr, &tmp, arg );
1000             else
1001                 tmp = SendMessageW( hwnd, msgGetText, wp, (LPARAM)ptr );
1002             RtlUnicodeToMultiByteSize( &len, ptr, tmp * sizeof(WCHAR) );
1003             *result = len;
1004             free_buffer( buffer, ptr );
1005         }
1006         break;
1007
1008     case WM_PAINTCLIPBOARD:
1009     case WM_SIZECLIPBOARD:
1010         FIXME_(msg)( "message %s (0x%x) needs translation, please report\n",
1011                      SPY_GetMsgName(msg, hwnd), msg );
1012         break;
1013
1014     default:
1015         ret = callback( hwnd, msg, wParam, lParam, result, arg );
1016         break;
1017     }
1018     return ret;
1019 }
1020
1021
1022 /**********************************************************************
1023  *           WINPROC_CallProcWtoA
1024  *
1025  * Call a window procedure, translating args from Unicode to Ansi.
1026  */
1027 static LRESULT WINPROC_CallProcWtoA( winproc_callback_t callback, HWND hwnd, UINT msg, WPARAM wParam,
1028                                      LPARAM lParam, LRESULT *result, void *arg )
1029 {
1030     LRESULT ret = 0;
1031
1032     TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
1033                 hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
1034
1035     switch(msg)
1036     {
1037     case WM_NCCREATE:
1038     case WM_CREATE:
1039         {   /* csW->lpszName and csW->lpszClass are NOT supposed to be atoms
1040              * at this point.
1041              */
1042             char buffer[1024], *cls, *name;
1043             CREATESTRUCTW *csW = (CREATESTRUCTW *)lParam;
1044             CREATESTRUCTA csA = *(CREATESTRUCTA *)csW;
1045             MDICREATESTRUCTA mdi_cs;
1046             DWORD name_lenA, name_lenW, class_lenA, class_lenW;
1047
1048             class_lenW = strlenW(csW->lpszClass) * sizeof(WCHAR);
1049             RtlUnicodeToMultiByteSize(&class_lenA, csW->lpszClass, class_lenW);
1050
1051             if (csW->lpszName)
1052             {
1053                 name_lenW = strlenW(csW->lpszName) * sizeof(WCHAR);
1054                 RtlUnicodeToMultiByteSize(&name_lenA, csW->lpszName, name_lenW);
1055             }
1056             else
1057                 name_lenW = name_lenA = 0;
1058
1059             if (!(cls = get_buffer( buffer, sizeof(buffer), class_lenA + name_lenA + 2 ))) break;
1060
1061             RtlUnicodeToMultiByteN(cls, class_lenA, NULL, csW->lpszClass, class_lenW);
1062             cls[class_lenA] = 0;
1063             csA.lpszClass = cls;
1064
1065             if (csW->lpszName)
1066             {
1067                 name = cls + class_lenA + 1;
1068                 RtlUnicodeToMultiByteN(name, name_lenA, NULL, csW->lpszName, name_lenW);
1069                 name[name_lenA] = 0;
1070                 csA.lpszName = name;
1071             }
1072
1073             if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
1074             {
1075                 mdi_cs = *(MDICREATESTRUCTA *)csW->lpCreateParams;
1076                 mdi_cs.szTitle = csA.lpszName;
1077                 mdi_cs.szClass = csA.lpszClass;
1078                 csA.lpCreateParams = &mdi_cs;
1079             }
1080
1081             ret = callback( hwnd, msg, wParam, (LPARAM)&csA, result, arg );
1082             free_buffer( buffer, cls );
1083         }
1084         break;
1085
1086     case WM_GETTEXT:
1087     case WM_ASKCBFORMATNAME:
1088         {
1089             char *ptr, buffer[512];
1090             DWORD len = wParam * 2;
1091
1092             if (!(ptr = get_buffer( buffer, sizeof(buffer), len ))) break;
1093             ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
1094             if (*result && len)
1095             {
1096                 RtlMultiByteToUnicodeN( (LPWSTR)lParam, wParam*sizeof(WCHAR), &len, ptr, strlen(ptr)+1 );
1097                 *result = len/sizeof(WCHAR) - 1;  /* do not count terminating null */
1098                 ((LPWSTR)lParam)[*result] = 0;
1099             }
1100             free_buffer( buffer, ptr );
1101         }
1102         break;
1103
1104     case LB_ADDSTRING:
1105     case LB_INSERTSTRING:
1106     case LB_FINDSTRING:
1107     case LB_FINDSTRINGEXACT:
1108     case LB_SELECTSTRING:
1109     case CB_ADDSTRING:
1110     case CB_INSERTSTRING:
1111     case CB_FINDSTRING:
1112     case CB_FINDSTRINGEXACT:
1113     case CB_SELECTSTRING:
1114         if (!lParam || !WINPROC_TestLBForStr( hwnd, msg ))
1115         {
1116             ret = callback( hwnd, msg, wParam, lParam, result, arg );
1117             break;
1118         }
1119         /* fall through */
1120     case WM_SETTEXT:
1121     case WM_WININICHANGE:
1122     case WM_DEVMODECHANGE:
1123     case CB_DIR:
1124     case LB_DIR:
1125     case LB_ADDFILE:
1126     case EM_REPLACESEL:
1127         if (!lParam) ret = callback( hwnd, msg, wParam, lParam, result, arg );
1128         else
1129         {
1130             char *ptr, buffer[512];
1131             LPCWSTR strW = (LPCWSTR)lParam;
1132             DWORD lenA, lenW = (strlenW(strW) + 1) * sizeof(WCHAR);
1133
1134             RtlUnicodeToMultiByteSize( &lenA, strW, lenW );
1135             if ((ptr = get_buffer( buffer, sizeof(buffer), lenA )))
1136             {
1137                 RtlUnicodeToMultiByteN( ptr, lenA, NULL, strW, lenW );
1138                 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
1139                 free_buffer( buffer, ptr );
1140             }
1141         }
1142         break;
1143
1144     case WM_MDICREATE:
1145         {
1146             char *ptr, buffer[1024];
1147             DWORD title_lenA = 0, title_lenW = 0, class_lenA = 0, class_lenW = 0;
1148             MDICREATESTRUCTW *csW = (MDICREATESTRUCTW *)lParam;
1149             MDICREATESTRUCTA csA;
1150
1151             memcpy( &csA, csW, sizeof(csA) );
1152
1153             if (HIWORD(csW->szTitle))
1154             {
1155                 title_lenW = (strlenW(csW->szTitle) + 1) * sizeof(WCHAR);
1156                 RtlUnicodeToMultiByteSize( &title_lenA, csW->szTitle, title_lenW );
1157             }
1158             if (HIWORD(csW->szClass))
1159             {
1160                 class_lenW = (strlenW(csW->szClass) + 1) * sizeof(WCHAR);
1161                 RtlUnicodeToMultiByteSize( &class_lenA, csW->szClass, class_lenW );
1162             }
1163
1164             if (!(ptr = get_buffer( buffer, sizeof(buffer), title_lenA + class_lenA ))) break;
1165
1166             if (title_lenA)
1167             {
1168                 RtlUnicodeToMultiByteN( ptr, title_lenA, NULL, csW->szTitle, title_lenW );
1169                 csA.szTitle = ptr;
1170             }
1171             if (class_lenA)
1172             {
1173                 RtlUnicodeToMultiByteN( ptr + title_lenA, class_lenA, NULL, csW->szClass, class_lenW );
1174                 csA.szClass = ptr + title_lenA;
1175             }
1176             ret = callback( hwnd, msg, wParam, (LPARAM)&csA, result, arg );
1177             free_buffer( buffer, ptr );
1178         }
1179         break;
1180
1181     case LB_GETTEXT:
1182     case CB_GETLBTEXT:
1183         if (lParam && WINPROC_TestLBForStr( hwnd, msg ))
1184         {
1185             char buffer[512];  /* FIXME: fixed sized buffer */
1186
1187             ret = callback( hwnd, msg, wParam, (LPARAM)buffer, result, arg );
1188             if (*result >= 0)
1189             {
1190                 DWORD len;
1191                 RtlMultiByteToUnicodeN( (LPWSTR)lParam, ~0u, &len, buffer, strlen(buffer) + 1 );
1192                 *result = len / sizeof(WCHAR) - 1;
1193             }
1194         }
1195         else ret = callback( hwnd, msg, wParam, lParam, result, arg );
1196         break;
1197
1198     case EM_GETLINE:
1199         {
1200             char *ptr, buffer[512];
1201             WORD len = *(WORD *)lParam;
1202
1203             if (!(ptr = get_buffer( buffer, sizeof(buffer), len * 2 ))) break;
1204             *((WORD *)ptr) = len * 2;   /* store the length */
1205             ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
1206             if (*result)
1207             {
1208                 DWORD reslen;
1209                 RtlMultiByteToUnicodeN( (LPWSTR)lParam, len*sizeof(WCHAR), &reslen, ptr, *result );
1210                 *result = reslen / sizeof(WCHAR);
1211                 if (*result < len) ((LPWSTR)lParam)[*result] = 0;
1212             }
1213             free_buffer( buffer, ptr );
1214         }
1215         break;
1216
1217     case WM_GETDLGCODE:
1218         if (lParam)
1219         {
1220             MSG newmsg = *(MSG *)lParam;
1221             switch(newmsg.message)
1222             {
1223             case WM_CHAR:
1224             case WM_DEADCHAR:
1225             case WM_SYSCHAR:
1226             case WM_SYSDEADCHAR:
1227                 newmsg.wParam = map_wparam_char_WtoA( newmsg.wParam, 1 );
1228                 break;
1229             case WM_IME_CHAR:
1230                 newmsg.wParam = map_wparam_char_WtoA( newmsg.wParam, 2 );
1231                 break;
1232             }
1233             ret = callback( hwnd, msg, wParam, (LPARAM)&newmsg, result, arg );
1234         }
1235         else ret = callback( hwnd, msg, wParam, lParam, result, arg );
1236         break;
1237
1238     case WM_CHARTOITEM:
1239     case WM_MENUCHAR:
1240     case WM_CHAR:
1241     case WM_DEADCHAR:
1242     case WM_SYSCHAR:
1243     case WM_SYSDEADCHAR:
1244     case EM_SETPASSWORDCHAR:
1245         ret = callback( hwnd, msg, map_wparam_char_WtoA(wParam,1), lParam, result, arg );
1246         break;
1247
1248     case WM_IME_CHAR:
1249         ret = callback( hwnd, msg, map_wparam_char_WtoA(wParam,2), lParam, result, arg );
1250         break;
1251
1252     case WM_PAINTCLIPBOARD:
1253     case WM_SIZECLIPBOARD:
1254         FIXME_(msg)( "message %s (%04x) needs translation, please report\n",
1255                      SPY_GetMsgName(msg, hwnd), msg );
1256         break;
1257
1258     default:
1259         ret = callback( hwnd, msg, wParam, lParam, result, arg );
1260         break;
1261     }
1262
1263     return ret;
1264 }
1265
1266
1267 /**********************************************************************
1268  *           WINPROC_CallProc16To32A
1269  */
1270 LRESULT WINPROC_CallProc16To32A( winproc_callback_t callback, HWND16 hwnd, UINT16 msg,
1271                                  WPARAM16 wParam, LPARAM lParam, LRESULT *result, void *arg )
1272 {
1273     LRESULT ret = 0;
1274     HWND hwnd32 = WIN_Handle32( hwnd );
1275
1276     TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
1277                  hwnd32, SPY_GetMsgName(msg, hwnd32), wParam, lParam);
1278
1279     switch(msg)
1280     {
1281     case WM_NCCREATE:
1282     case WM_CREATE:
1283         {
1284             CREATESTRUCT16 *cs16 = MapSL(lParam);
1285             CREATESTRUCTA cs;
1286             MDICREATESTRUCTA mdi_cs;
1287
1288             CREATESTRUCT16to32A( cs16, &cs );
1289             if (GetWindowLongW(hwnd32, GWL_EXSTYLE) & WS_EX_MDICHILD)
1290             {
1291                 MDICREATESTRUCT16 *mdi_cs16 = MapSL(cs16->lpCreateParams);
1292                 MDICREATESTRUCT16to32A(mdi_cs16, &mdi_cs);
1293                 cs.lpCreateParams = &mdi_cs;
1294             }
1295             ret = callback( hwnd32, msg, wParam, (LPARAM)&cs, result, arg );
1296             CREATESTRUCT32Ato16( &cs, cs16 );
1297         }
1298         break;
1299     case WM_MDICREATE:
1300         {
1301             MDICREATESTRUCT16 *cs16 = MapSL(lParam);
1302             MDICREATESTRUCTA cs;
1303
1304             MDICREATESTRUCT16to32A( cs16, &cs );
1305             ret = callback( hwnd32, msg, wParam, (LPARAM)&cs, result, arg );
1306             MDICREATESTRUCT32Ato16( &cs, cs16 );
1307         }
1308         break;
1309     case WM_MDIACTIVATE:
1310         if (lParam)
1311             ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32( HIWORD(lParam) ),
1312                             (LPARAM)WIN_Handle32( LOWORD(lParam) ), result, arg );
1313         else /* message sent to MDI client */
1314             ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1315         break;
1316     case WM_MDIGETACTIVE:
1317         {
1318             BOOL maximized = FALSE;
1319             ret = callback( hwnd32, msg, wParam, (LPARAM)&maximized, result, arg );
1320             *result = MAKELRESULT( LOWORD(*result), maximized );
1321         }
1322         break;
1323     case WM_MDISETMENU:
1324         ret = callback( hwnd32, wParam ? WM_MDIREFRESHMENU : WM_MDISETMENU,
1325                         (WPARAM)HMENU_32(LOWORD(lParam)), (LPARAM)HMENU_32(HIWORD(lParam)),
1326                         result, arg );
1327         break;
1328     case WM_GETMINMAXINFO:
1329         {
1330             MINMAXINFO16 *mmi16 = MapSL(lParam);
1331             MINMAXINFO mmi;
1332
1333             MINMAXINFO16to32( mmi16, &mmi );
1334             ret = callback( hwnd32, msg, wParam, (LPARAM)&mmi, result, arg );
1335             MINMAXINFO32to16( &mmi, mmi16 );
1336         }
1337         break;
1338     case WM_WINDOWPOSCHANGING:
1339     case WM_WINDOWPOSCHANGED:
1340         {
1341             WINDOWPOS16 *winpos16 = MapSL(lParam);
1342             WINDOWPOS winpos;
1343
1344             WINDOWPOS16to32( winpos16, &winpos );
1345             ret = callback( hwnd32, msg, wParam, (LPARAM)&winpos, result, arg );
1346             WINDOWPOS32to16( &winpos, winpos16 );
1347         }
1348         break;
1349     case WM_NCCALCSIZE:
1350         {
1351             NCCALCSIZE_PARAMS16 *nc16 = MapSL(lParam);
1352             NCCALCSIZE_PARAMS nc;
1353             WINDOWPOS winpos;
1354
1355             RECT16to32( &nc16->rgrc[0], &nc.rgrc[0] );
1356             if (wParam)
1357             {
1358                 RECT16to32( &nc16->rgrc[1], &nc.rgrc[1] );
1359                 RECT16to32( &nc16->rgrc[2], &nc.rgrc[2] );
1360                 WINDOWPOS16to32( MapSL(nc16->lppos), &winpos );
1361                 nc.lppos = &winpos;
1362             }
1363             ret = callback( hwnd32, msg, wParam, (LPARAM)&nc, result, arg );
1364             RECT32to16( &nc.rgrc[0], &nc16->rgrc[0] );
1365             if (wParam)
1366             {
1367                 RECT32to16( &nc.rgrc[1], &nc16->rgrc[1] );
1368                 RECT32to16( &nc.rgrc[2], &nc16->rgrc[2] );
1369                 WINDOWPOS32to16( &winpos, MapSL(nc16->lppos) );
1370             }
1371         }
1372         break;
1373     case WM_COMPAREITEM:
1374         {
1375             COMPAREITEMSTRUCT16* cis16 = MapSL(lParam);
1376             COMPAREITEMSTRUCT cis;
1377             cis.CtlType    = cis16->CtlType;
1378             cis.CtlID      = cis16->CtlID;
1379             cis.hwndItem   = WIN_Handle32( cis16->hwndItem );
1380             cis.itemID1    = cis16->itemID1;
1381             cis.itemData1  = cis16->itemData1;
1382             cis.itemID2    = cis16->itemID2;
1383             cis.itemData2  = cis16->itemData2;
1384             cis.dwLocaleId = 0;  /* FIXME */
1385             ret = callback( hwnd32, msg, wParam, (LPARAM)&cis, result, arg );
1386         }
1387         break;
1388     case WM_DELETEITEM:
1389         {
1390             DELETEITEMSTRUCT16* dis16 = MapSL(lParam);
1391             DELETEITEMSTRUCT dis;
1392             dis.CtlType  = dis16->CtlType;
1393             dis.CtlID    = dis16->CtlID;
1394             dis.hwndItem = WIN_Handle32( dis16->hwndItem );
1395             dis.itemData = dis16->itemData;
1396             ret = callback( hwnd32, msg, wParam, (LPARAM)&dis, result, arg );
1397         }
1398         break;
1399     case WM_MEASUREITEM:
1400         {
1401             MEASUREITEMSTRUCT16* mis16 = MapSL(lParam);
1402             MEASUREITEMSTRUCT mis;
1403             mis.CtlType    = mis16->CtlType;
1404             mis.CtlID      = mis16->CtlID;
1405             mis.itemID     = mis16->itemID;
1406             mis.itemWidth  = mis16->itemWidth;
1407             mis.itemHeight = mis16->itemHeight;
1408             mis.itemData   = mis16->itemData;
1409             ret = callback( hwnd32, msg, wParam, (LPARAM)&mis, result, arg );
1410             mis16->itemWidth  = (UINT16)mis.itemWidth;
1411             mis16->itemHeight = (UINT16)mis.itemHeight;
1412         }
1413         break;
1414     case WM_DRAWITEM:
1415         {
1416             DRAWITEMSTRUCT16* dis16 = MapSL(lParam);
1417             DRAWITEMSTRUCT dis;
1418             dis.CtlType       = dis16->CtlType;
1419             dis.CtlID         = dis16->CtlID;
1420             dis.itemID        = dis16->itemID;
1421             dis.itemAction    = dis16->itemAction;
1422             dis.itemState     = dis16->itemState;
1423             dis.hwndItem      = (dis.CtlType == ODT_MENU) ? (HWND)HMENU_32(dis16->hwndItem)
1424                                                           : WIN_Handle32( dis16->hwndItem );
1425             dis.hDC           = HDC_32(dis16->hDC);
1426             dis.itemData      = dis16->itemData;
1427             dis.rcItem.left   = dis16->rcItem.left;
1428             dis.rcItem.top    = dis16->rcItem.top;
1429             dis.rcItem.right  = dis16->rcItem.right;
1430             dis.rcItem.bottom = dis16->rcItem.bottom;
1431             ret = callback( hwnd32, msg, wParam, (LPARAM)&dis, result, arg );
1432         }
1433         break;
1434     case WM_COPYDATA:
1435         {
1436             COPYDATASTRUCT16 *cds16 = MapSL(lParam);
1437             COPYDATASTRUCT cds;
1438             cds.dwData = cds16->dwData;
1439             cds.cbData = cds16->cbData;
1440             cds.lpData = MapSL(cds16->lpData);
1441             ret = callback( hwnd32, msg, wParam, (LPARAM)&cds, result, arg );
1442         }
1443         break;
1444     case WM_GETDLGCODE:
1445         if (lParam)
1446         {
1447             MSG16 *msg16 = MapSL(lParam);
1448             MSG msg32;
1449             msg32.hwnd    = WIN_Handle32( msg16->hwnd );
1450             msg32.message = msg16->message;
1451             msg32.wParam  = msg16->wParam;
1452             msg32.lParam  = msg16->lParam;
1453             msg32.time    = msg16->time;
1454             msg32.pt.x    = msg16->pt.x;
1455             msg32.pt.y    = msg16->pt.y;
1456             ret = callback( hwnd32, msg, wParam, (LPARAM)&msg32, result, arg );
1457         }
1458         else
1459             ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1460         break;
1461     case WM_NEXTMENU:
1462         {
1463             MDINEXTMENU next;
1464             next.hmenuIn   = (HMENU)lParam;
1465             next.hmenuNext = 0;
1466             next.hwndNext  = 0;
1467             ret = callback( hwnd32, msg, wParam, (LPARAM)&next, result, arg );
1468             *result = MAKELONG( HMENU_16(next.hmenuNext), HWND_16(next.hwndNext) );
1469         }
1470         break;
1471     case WM_ACTIVATE:
1472     case WM_CHARTOITEM:
1473     case WM_COMMAND:
1474     case WM_VKEYTOITEM:
1475         ret = callback( hwnd32, msg, MAKEWPARAM( wParam, HIWORD(lParam) ),
1476                         (LPARAM)WIN_Handle32( LOWORD(lParam) ), result, arg );
1477         break;
1478     case WM_HSCROLL:
1479     case WM_VSCROLL:
1480         ret = callback( hwnd32, msg, MAKEWPARAM( wParam, LOWORD(lParam) ),
1481                         (LPARAM)WIN_Handle32( HIWORD(lParam) ), result, arg );
1482         break;
1483     case WM_CTLCOLOR:
1484         if (HIWORD(lParam) <= CTLCOLOR_STATIC)
1485             ret = callback( hwnd32, WM_CTLCOLORMSGBOX + HIWORD(lParam),
1486                             (WPARAM)HDC_32(wParam), (LPARAM)WIN_Handle32( LOWORD(lParam) ),
1487                             result, arg );
1488         break;
1489     case WM_GETTEXT:
1490     case WM_SETTEXT:
1491     case WM_WININICHANGE:
1492     case WM_DEVMODECHANGE:
1493     case WM_ASKCBFORMATNAME:
1494     case WM_NOTIFY:
1495         ret = callback( hwnd32, msg, wParam, (LPARAM)MapSL(lParam), result, arg );
1496         break;
1497     case WM_MENUCHAR:
1498         ret = callback( hwnd32, msg, MAKEWPARAM( wParam, LOWORD(lParam) ),
1499                         (LPARAM)HMENU_32(HIWORD(lParam)), result, arg );
1500         break;
1501     case WM_MENUSELECT:
1502         if((LOWORD(lParam) & MF_POPUP) && (LOWORD(lParam) != 0xFFFF))
1503         {
1504             HMENU hmenu = HMENU_32(HIWORD(lParam));
1505             UINT pos = MENU_FindSubMenu( &hmenu, HMENU_32(wParam) );
1506             if (pos == 0xffff) pos = 0;  /* NO_SELECTED_ITEM */
1507             wParam = pos;
1508         }
1509         ret = callback( hwnd32, msg, MAKEWPARAM( wParam, LOWORD(lParam) ),
1510                         (LPARAM)HMENU_32(HIWORD(lParam)), result, arg );
1511         break;
1512     case WM_PARENTNOTIFY:
1513         if ((wParam == WM_CREATE) || (wParam == WM_DESTROY))
1514             ret = callback( hwnd32, msg, MAKEWPARAM( wParam, HIWORD(lParam) ),
1515                             (LPARAM)WIN_Handle32( LOWORD(lParam) ), result, arg );
1516         else
1517             ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1518         break;
1519     case WM_ACTIVATEAPP:
1520         /* We need this when SetActiveWindow sends a Sendmessage16() to
1521          * a 32bit window. Might be superflous with 32bit interprocess
1522          * message queues. */
1523         if (lParam) lParam = HTASK_32(lParam);
1524         ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1525         break;
1526     case WM_DDE_INITIATE:
1527     case WM_DDE_TERMINATE:
1528     case WM_DDE_UNADVISE:
1529     case WM_DDE_REQUEST:
1530         ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32(wParam), lParam, result, arg );
1531         break;
1532     case WM_DDE_ADVISE:
1533     case WM_DDE_DATA:
1534     case WM_DDE_POKE:
1535         {
1536             HANDLE16 lo16 = LOWORD(lParam);
1537             UINT lo32 = 0;
1538             if (lo16 && !(lo32 = convert_handle_16_to_32(lo16, GMEM_DDESHARE))) break;
1539             lParam = PackDDElParam( msg, lo32, HIWORD(lParam) );
1540             ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32(wParam), lParam, result, arg );
1541         }
1542         break; /* FIXME don't know how to free allocated memory (handle)  !! */
1543     case WM_DDE_ACK:
1544         {
1545             UINT lo = LOWORD(lParam);
1546             UINT hi = HIWORD(lParam);
1547             int flag = 0;
1548             char buf[2];
1549
1550             if (GlobalGetAtomNameA(hi, buf, 2) > 0) flag |= 1;
1551             if (GlobalSize16(hi) != 0) flag |= 2;
1552             switch (flag)
1553             {
1554             case 0:
1555                 if (hi)
1556                 {
1557                     MESSAGE("DDE_ACK: neither atom nor handle!!!\n");
1558                     hi = 0;
1559                 }
1560                 break;
1561             case 1:
1562                 break; /* atom, nothing to do */
1563             case 3:
1564                 MESSAGE("DDE_ACK: %x both atom and handle... choosing handle\n", hi);
1565                 /* fall thru */
1566             case 2:
1567                 hi = convert_handle_16_to_32(hi, GMEM_DDESHARE);
1568                 break;
1569             }
1570             lParam = PackDDElParam( WM_DDE_ACK, lo, hi );
1571             ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32(wParam), lParam, result, arg );
1572         }
1573         break; /* FIXME don't know how to free allocated memory (handle) !! */
1574     case WM_DDE_EXECUTE:
1575         lParam = convert_handle_16_to_32( lParam, GMEM_DDESHARE );
1576         ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1577         break; /* FIXME don't know how to free allocated memory (handle) !! */
1578     case WM_PAINTCLIPBOARD:
1579     case WM_SIZECLIPBOARD:
1580         FIXME_(msg)( "message %04x needs translation\n", msg );
1581         break;
1582     default:
1583         ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1584         break;
1585     }
1586     return ret;
1587 }
1588
1589
1590 /**********************************************************************
1591  *           __wine_call_wndproc   (USER.1010)
1592  */
1593 LRESULT WINAPI __wine_call_wndproc( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam,
1594                                     WINDOWPROC *proc )
1595 {
1596     LRESULT result;
1597
1598     if (proc->procA)
1599         WINPROC_CallProc16To32A( call_window_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
1600     else
1601         WINPROC_CallProc16To32A( call_window_proc_AtoW, hwnd, msg, wParam, lParam, &result, proc->procW );
1602     return result;
1603 }
1604
1605
1606 /**********************************************************************
1607  *           WINPROC_CallProc32ATo16
1608  *
1609  * Call a 16-bit window procedure, translating the 32-bit args.
1610  */
1611 LRESULT WINPROC_CallProc32ATo16( winproc_callback16_t callback, HWND hwnd, UINT msg,
1612                                  WPARAM wParam, LPARAM lParam, LRESULT *result, void *arg )
1613 {
1614     LRESULT ret = 0;
1615
1616     TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
1617                 hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
1618
1619     switch(msg)
1620     {
1621     case WM_NCCREATE:
1622     case WM_CREATE:
1623         {
1624             CREATESTRUCTA *cs32 = (CREATESTRUCTA *)lParam;
1625             CREATESTRUCT16 cs;
1626             MDICREATESTRUCT16 mdi_cs16;
1627             BOOL mdi_child = (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD);
1628
1629             CREATESTRUCT32Ato16( cs32, &cs );
1630             cs.lpszName  = MapLS( cs32->lpszName );
1631             cs.lpszClass = MapLS( cs32->lpszClass );
1632
1633             if (mdi_child)
1634             {
1635                 MDICREATESTRUCTA *mdi_cs = (MDICREATESTRUCTA *)cs32->lpCreateParams;
1636                 MDICREATESTRUCT32Ato16( mdi_cs, &mdi_cs16 );
1637                 mdi_cs16.szTitle = MapLS( mdi_cs->szTitle );
1638                 mdi_cs16.szClass = MapLS( mdi_cs->szClass );
1639                 cs.lpCreateParams = MapLS( &mdi_cs16 );
1640             }
1641             lParam = MapLS( &cs );
1642             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1643             UnMapLS( lParam );
1644             UnMapLS( cs.lpszName );
1645             UnMapLS( cs.lpszClass );
1646             if (mdi_child)
1647             {
1648                 UnMapLS( cs.lpCreateParams );
1649                 UnMapLS( mdi_cs16.szTitle );
1650                 UnMapLS( mdi_cs16.szClass );
1651             }
1652         }
1653         break;
1654     case WM_MDICREATE:
1655         {
1656             MDICREATESTRUCTA *cs32 = (MDICREATESTRUCTA *)lParam;
1657             MDICREATESTRUCT16 cs;
1658
1659             MDICREATESTRUCT32Ato16( cs32, &cs );
1660             cs.szTitle = MapLS( cs32->szTitle );
1661             cs.szClass = MapLS( cs32->szClass );
1662             lParam = MapLS( &cs );
1663             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1664             UnMapLS( lParam );
1665             UnMapLS( cs.szTitle );
1666             UnMapLS( cs.szClass );
1667         }
1668         break;
1669     case WM_MDIACTIVATE:
1670         if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_MDICHILD)
1671             ret = callback( HWND_16(hwnd), msg, ((HWND)lParam == hwnd),
1672                             MAKELPARAM( LOWORD(lParam), LOWORD(wParam) ), result, arg );
1673         else
1674             ret = callback( HWND_16(hwnd), msg, HWND_16( (HWND)wParam ), 0, result, arg );
1675         break;
1676     case WM_MDIGETACTIVE:
1677         ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1678         if (lParam) *(BOOL *)lParam = (BOOL16)HIWORD(*result);
1679         *result = (LRESULT)WIN_Handle32( LOWORD(*result) );
1680         break;
1681     case WM_MDISETMENU:
1682         ret = callback( HWND_16(hwnd), msg, (lParam == 0),
1683                         MAKELPARAM( LOWORD(wParam), LOWORD(lParam) ), result, arg );
1684         break;
1685     case WM_GETMINMAXINFO:
1686         {
1687             MINMAXINFO *mmi32 = (MINMAXINFO *)lParam;
1688             MINMAXINFO16 mmi;
1689
1690             MINMAXINFO32to16( mmi32, &mmi );
1691             lParam = MapLS( &mmi );
1692             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1693             UnMapLS( lParam );
1694             MINMAXINFO16to32( &mmi, mmi32 );
1695         }
1696         break;
1697     case WM_NCCALCSIZE:
1698         {
1699             NCCALCSIZE_PARAMS *nc32 = (NCCALCSIZE_PARAMS *)lParam;
1700             NCCALCSIZE_PARAMS16 nc;
1701             WINDOWPOS16 winpos;
1702
1703             RECT32to16( &nc32->rgrc[0], &nc.rgrc[0] );
1704             if (wParam)
1705             {
1706                 RECT32to16( &nc32->rgrc[1], &nc.rgrc[1] );
1707                 RECT32to16( &nc32->rgrc[2], &nc.rgrc[2] );
1708                 WINDOWPOS32to16( nc32->lppos, &winpos );
1709                 nc.lppos = MapLS( &winpos );
1710             }
1711             lParam = MapLS( &nc );
1712             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1713             UnMapLS( lParam );
1714             RECT16to32( &nc.rgrc[0], &nc32->rgrc[0] );
1715             if (wParam)
1716             {
1717                 RECT16to32( &nc.rgrc[1], &nc32->rgrc[1] );
1718                 RECT16to32( &nc.rgrc[2], &nc32->rgrc[2] );
1719                 WINDOWPOS16to32( &winpos, nc32->lppos );
1720                 UnMapLS( nc.lppos );
1721             }
1722         }
1723         break;
1724     case WM_WINDOWPOSCHANGING:
1725     case WM_WINDOWPOSCHANGED:
1726         {
1727             WINDOWPOS *winpos32 = (WINDOWPOS *)lParam;
1728             WINDOWPOS16 winpos;
1729
1730             WINDOWPOS32to16( winpos32, &winpos );
1731             lParam = MapLS( &winpos );
1732             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1733             UnMapLS( lParam );
1734             WINDOWPOS16to32( &winpos, winpos32 );
1735         }
1736         break;
1737     case WM_COMPAREITEM:
1738         {
1739             COMPAREITEMSTRUCT *cis32 = (COMPAREITEMSTRUCT *)lParam;
1740             COMPAREITEMSTRUCT16 cis;
1741             cis.CtlType    = cis32->CtlType;
1742             cis.CtlID      = cis32->CtlID;
1743             cis.hwndItem   = HWND_16( cis32->hwndItem );
1744             cis.itemID1    = cis32->itemID1;
1745             cis.itemData1  = cis32->itemData1;
1746             cis.itemID2    = cis32->itemID2;
1747             cis.itemData2  = cis32->itemData2;
1748             lParam = MapLS( &cis );
1749             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1750             UnMapLS( lParam );
1751         }
1752         break;
1753     case WM_DELETEITEM:
1754         {
1755             DELETEITEMSTRUCT *dis32 = (DELETEITEMSTRUCT *)lParam;
1756             DELETEITEMSTRUCT16 dis;
1757             dis.CtlType  = dis32->CtlType;
1758             dis.CtlID    = dis32->CtlID;
1759             dis.itemID   = dis32->itemID;
1760             dis.hwndItem = (dis.CtlType == ODT_MENU) ? (HWND16)LOWORD(dis32->hwndItem)
1761                                                      : HWND_16( dis32->hwndItem );
1762             dis.itemData = dis32->itemData;
1763             lParam = MapLS( &dis );
1764             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1765             UnMapLS( lParam );
1766         }
1767         break;
1768     case WM_DRAWITEM:
1769         {
1770             DRAWITEMSTRUCT *dis32 = (DRAWITEMSTRUCT *)lParam;
1771             DRAWITEMSTRUCT16 dis;
1772             dis.CtlType       = dis32->CtlType;
1773             dis.CtlID         = dis32->CtlID;
1774             dis.itemID        = dis32->itemID;
1775             dis.itemAction    = dis32->itemAction;
1776             dis.itemState     = dis32->itemState;
1777             dis.hwndItem      = HWND_16( dis32->hwndItem );
1778             dis.hDC           = HDC_16(dis32->hDC);
1779             dis.itemData      = dis32->itemData;
1780             dis.rcItem.left   = dis32->rcItem.left;
1781             dis.rcItem.top    = dis32->rcItem.top;
1782             dis.rcItem.right  = dis32->rcItem.right;
1783             dis.rcItem.bottom = dis32->rcItem.bottom;
1784             lParam = MapLS( &dis );
1785             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1786             UnMapLS( lParam );
1787         }
1788         break;
1789     case WM_MEASUREITEM:
1790         {
1791             MEASUREITEMSTRUCT *mis32 = (MEASUREITEMSTRUCT *)lParam;
1792             MEASUREITEMSTRUCT16 mis;
1793             mis.CtlType    = mis32->CtlType;
1794             mis.CtlID      = mis32->CtlID;
1795             mis.itemID     = mis32->itemID;
1796             mis.itemWidth  = mis32->itemWidth;
1797             mis.itemHeight = mis32->itemHeight;
1798             mis.itemData   = mis32->itemData;
1799             lParam = MapLS( &mis );
1800             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1801             UnMapLS( lParam );
1802             mis32->itemWidth  = mis.itemWidth;
1803             mis32->itemHeight = mis.itemHeight;
1804         }
1805         break;
1806     case WM_COPYDATA:
1807         {
1808             COPYDATASTRUCT *cds32 = (COPYDATASTRUCT *)lParam;
1809             COPYDATASTRUCT16 cds;
1810
1811             cds.dwData = cds32->dwData;
1812             cds.cbData = cds32->cbData;
1813             cds.lpData = MapLS( cds32->lpData );
1814             lParam = MapLS( &cds );
1815             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1816             UnMapLS( lParam );
1817             UnMapLS( cds.lpData );
1818         }
1819         break;
1820     case WM_GETDLGCODE:
1821         if (lParam)
1822         {
1823             MSG *msg32 = (MSG *)lParam;
1824             MSG16 msg16;
1825
1826             msg16.hwnd    = HWND_16( msg32->hwnd );
1827             msg16.message = msg32->message;
1828             msg16.wParam  = msg32->wParam;
1829             msg16.lParam  = msg32->lParam;
1830             msg16.time    = msg32->time;
1831             msg16.pt.x    = msg32->pt.x;
1832             msg16.pt.y    = msg32->pt.y;
1833             lParam = MapLS( &msg16 );
1834             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1835             UnMapLS( lParam );
1836         }
1837         else
1838             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1839         break;
1840     case WM_NEXTMENU:
1841         {
1842             MDINEXTMENU *next = (MDINEXTMENU *)lParam;
1843             ret = callback( HWND_16(hwnd), msg, wParam, (LPARAM)next->hmenuIn, result, arg );
1844             next->hmenuNext = HMENU_32( LOWORD(*result) );
1845             next->hwndNext  = WIN_Handle32( HIWORD(*result) );
1846             *result = 0;
1847         }
1848         break;
1849     case WM_GETTEXT:
1850     case WM_ASKCBFORMATNAME:
1851         wParam = min( wParam, 0xff80 ); /* Must be < 64K */
1852         /* fall through */
1853     case WM_NOTIFY:
1854     case WM_SETTEXT:
1855     case WM_WININICHANGE:
1856     case WM_DEVMODECHANGE:
1857         lParam = MapLS( (void *)lParam );
1858         ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1859         UnMapLS( lParam );
1860         break;
1861     case WM_ACTIVATE:
1862     case WM_CHARTOITEM:
1863     case WM_COMMAND:
1864     case WM_VKEYTOITEM:
1865         ret = callback( HWND_16(hwnd), msg, wParam, MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ),
1866                         result, arg );
1867         break;
1868     case WM_HSCROLL:
1869     case WM_VSCROLL:
1870         ret = callback( HWND_16(hwnd), msg, wParam, MAKELPARAM( HIWORD(wParam), (HWND16)lParam ),
1871                         result, arg );
1872         break;
1873     case WM_CTLCOLORMSGBOX:
1874     case WM_CTLCOLOREDIT:
1875     case WM_CTLCOLORLISTBOX:
1876     case WM_CTLCOLORBTN:
1877     case WM_CTLCOLORDLG:
1878     case WM_CTLCOLORSCROLLBAR:
1879     case WM_CTLCOLORSTATIC:
1880         ret = callback( HWND_16(hwnd), WM_CTLCOLOR, wParam,
1881                         MAKELPARAM( (HWND16)lParam, msg - WM_CTLCOLORMSGBOX ), result, arg );
1882         break;
1883     case WM_MENUSELECT:
1884         if(HIWORD(wParam) & MF_POPUP)
1885         {
1886             HMENU hmenu;
1887             if ((HIWORD(wParam) != 0xffff) || lParam)
1888             {
1889                 if ((hmenu = GetSubMenu( (HMENU)lParam, LOWORD(wParam) )))
1890                 {
1891                     ret = callback( HWND_16(hwnd), msg, HMENU_16(hmenu),
1892                                     MAKELPARAM( HIWORD(wParam), (HMENU16)lParam ), result, arg );
1893                     break;
1894                 }
1895             }
1896         }
1897         /* fall through */
1898     case WM_MENUCHAR:
1899         ret = callback( HWND_16(hwnd), msg, wParam,
1900                         MAKELPARAM( HIWORD(wParam), (HMENU16)lParam ), result, arg );
1901         break;
1902     case WM_PARENTNOTIFY:
1903         if ((LOWORD(wParam) == WM_CREATE) || (LOWORD(wParam) == WM_DESTROY))
1904             ret = callback( HWND_16(hwnd), msg, wParam,
1905                             MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ), result, arg );
1906         else
1907             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1908         break;
1909     case WM_ACTIVATEAPP:
1910         ret = callback( HWND_16(hwnd), msg, wParam, HTASK_16( (HANDLE)lParam ), result, arg );
1911         break;
1912     case WM_PAINT:
1913         if (IsIconic( hwnd ) && GetClassLongPtrW( hwnd, GCLP_HICON ))
1914             ret = callback( HWND_16(hwnd), WM_PAINTICON, 1, lParam, result, arg );
1915         else
1916             ret = callback( HWND_16(hwnd), WM_PAINT, wParam, lParam, result, arg );
1917         break;
1918     case WM_ERASEBKGND:
1919         if (IsIconic( hwnd ) && GetClassLongPtrW( hwnd, GCLP_HICON )) msg = WM_ICONERASEBKGND;
1920         ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1921         break;
1922     case WM_DDE_INITIATE:
1923     case WM_DDE_TERMINATE:
1924     case WM_DDE_UNADVISE:
1925     case WM_DDE_REQUEST:
1926         ret = callback( HWND_16(hwnd), msg, HWND_16((HWND)wParam), lParam, result, arg );
1927         break;
1928     case WM_DDE_ADVISE:
1929     case WM_DDE_DATA:
1930     case WM_DDE_POKE:
1931         {
1932             UINT_PTR lo32, hi;
1933             HANDLE16 lo16 = 0;
1934
1935             UnpackDDElParam( msg, lParam, &lo32, &hi );
1936             if (lo32 && !(lo16 = convert_handle_32_to_16(lo32, GMEM_DDESHARE))) break;
1937             ret = callback( HWND_16(hwnd), msg, HWND_16((HWND)wParam),
1938                             MAKELPARAM(lo16, hi), result, arg );
1939         }
1940         break; /* FIXME don't know how to free allocated memory (handle)  !! */
1941     case WM_DDE_ACK:
1942         {
1943             UINT_PTR lo, hi;
1944             int flag = 0;
1945             char buf[2];
1946
1947             UnpackDDElParam( msg, lParam, &lo, &hi );
1948
1949             if (GlobalGetAtomNameA((ATOM)hi, buf, sizeof(buf)) > 0) flag |= 1;
1950             if (GlobalSize((HANDLE)hi) != 0) flag |= 2;
1951             switch (flag)
1952             {
1953             case 0:
1954                 if (hi)
1955                 {
1956                     MESSAGE("DDE_ACK: neither atom nor handle!!!\n");
1957                     hi = 0;
1958                 }
1959                 break;
1960             case 1:
1961                 break; /* atom, nothing to do */
1962             case 3:
1963                 MESSAGE("DDE_ACK: %x both atom and handle... choosing handle\n", hi);
1964                 /* fall thru */
1965             case 2:
1966                 hi = convert_handle_32_to_16(hi, GMEM_DDESHARE);
1967                 break;
1968             }
1969             ret = callback( HWND_16(hwnd), msg, HWND_16((HWND)wParam),
1970                             MAKELPARAM(lo, hi), result, arg );
1971         }
1972         break; /* FIXME don't know how to free allocated memory (handle) !! */
1973     case WM_DDE_EXECUTE:
1974         lParam = convert_handle_32_to_16(lParam, GMEM_DDESHARE);
1975         ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1976         break; /* FIXME don't know how to free allocated memory (handle) !! */
1977     case SBM_SETRANGE:
1978         ret = callback( HWND_16(hwnd), SBM_SETRANGE16, 0, MAKELPARAM(wParam, lParam), result, arg );
1979         break;
1980     case SBM_GETRANGE:
1981         ret = callback( HWND_16(hwnd), SBM_GETRANGE16, wParam, lParam, result, arg );
1982         *(LPINT)wParam = LOWORD(*result);
1983         *(LPINT)lParam = HIWORD(*result);
1984         break;
1985     case BM_GETCHECK:
1986     case BM_SETCHECK:
1987     case BM_GETSTATE:
1988     case BM_SETSTATE:
1989     case BM_SETSTYLE:
1990         ret = callback( HWND_16(hwnd), msg + BM_GETCHECK16 - BM_GETCHECK, wParam, lParam, result, arg );
1991         break;
1992     case EM_GETSEL:
1993     case EM_GETRECT:
1994     case EM_SETRECT:
1995     case EM_SETRECTNP:
1996     case EM_SCROLL:
1997     case EM_LINESCROLL:
1998     case EM_SCROLLCARET:
1999     case EM_GETMODIFY:
2000     case EM_SETMODIFY:
2001     case EM_GETLINECOUNT:
2002     case EM_LINEINDEX:
2003     case EM_SETHANDLE:
2004     case EM_GETHANDLE:
2005     case EM_GETTHUMB:
2006     case EM_LINELENGTH:
2007     case EM_REPLACESEL:
2008     case EM_GETLINE:
2009     case EM_LIMITTEXT:
2010     case EM_CANUNDO:
2011     case EM_UNDO:
2012     case EM_FMTLINES:
2013     case EM_LINEFROMCHAR:
2014     case EM_SETTABSTOPS:
2015     case EM_SETPASSWORDCHAR:
2016     case EM_EMPTYUNDOBUFFER:
2017     case EM_GETFIRSTVISIBLELINE:
2018     case EM_SETREADONLY:
2019     case EM_SETWORDBREAKPROC:
2020     case EM_GETWORDBREAKPROC:
2021     case EM_GETPASSWORDCHAR:
2022         ret = callback( HWND_16(hwnd), msg + EM_GETSEL16 - EM_GETSEL, wParam, lParam, result, arg );
2023         break;
2024     case EM_SETSEL:
2025         ret = callback( HWND_16(hwnd), EM_SETSEL16, 0, MAKELPARAM( wParam, lParam ), result, arg );
2026         break;
2027     case LB_CARETOFF:
2028     case LB_CARETON:
2029     case LB_DELETESTRING:
2030     case LB_GETANCHORINDEX:
2031     case LB_GETCARETINDEX:
2032     case LB_GETCOUNT:
2033     case LB_GETCURSEL:
2034     case LB_GETHORIZONTALEXTENT:
2035     case LB_GETITEMDATA:
2036     case LB_GETITEMHEIGHT:
2037     case LB_GETSEL:
2038     case LB_GETSELCOUNT:
2039     case LB_GETTEXTLEN:
2040     case LB_GETTOPINDEX:
2041     case LB_RESETCONTENT:
2042     case LB_SELITEMRANGE:
2043     case LB_SELITEMRANGEEX:
2044     case LB_SETANCHORINDEX:
2045     case LB_SETCARETINDEX:
2046     case LB_SETCOLUMNWIDTH:
2047     case LB_SETCURSEL:
2048     case LB_SETHORIZONTALEXTENT:
2049     case LB_SETITEMDATA:
2050     case LB_SETITEMHEIGHT:
2051     case LB_SETSEL:
2052     case LB_SETTOPINDEX:
2053         ret = callback( HWND_16(hwnd), msg + LB_ADDSTRING16 - LB_ADDSTRING, wParam, lParam, result, arg );
2054         break;
2055     case LB_ADDSTRING:
2056     case LB_FINDSTRING:
2057     case LB_FINDSTRINGEXACT:
2058     case LB_INSERTSTRING:
2059     case LB_SELECTSTRING:
2060     case LB_GETTEXT:
2061     case LB_DIR:
2062     case LB_ADDFILE:
2063         lParam = MapLS( (LPSTR)lParam );
2064         ret = callback( HWND_16(hwnd), msg + LB_ADDSTRING16 - LB_ADDSTRING, wParam, lParam, result, arg );
2065         UnMapLS( lParam );
2066         break;
2067     case LB_GETSELITEMS:
2068         {
2069             INT *items32 = (INT *)lParam;
2070             INT16 *items, buffer[512];
2071             unsigned int i;
2072
2073             wParam = min( wParam, 0x7f80 ); /* Must be < 64K */
2074             if (!(items = get_buffer( buffer, sizeof(buffer), wParam * sizeof(INT16) ))) break;
2075             lParam = MapLS( items );
2076             ret = callback( HWND_16(hwnd), LB_GETSELITEMS16, wParam, lParam, result, arg );
2077             UnMapLS( lParam );
2078             for (i = 0; i < wParam; i++) items32[i] = items[i];
2079             free_buffer( buffer, items );
2080         }
2081         break;
2082     case LB_SETTABSTOPS:
2083         if (wParam)
2084         {
2085             INT *stops32 = (INT *)lParam;
2086             INT16 *stops, buffer[512];
2087             unsigned int i;
2088
2089             wParam = min( wParam, 0x7f80 ); /* Must be < 64K */
2090             if (!(stops = get_buffer( buffer, sizeof(buffer), wParam * sizeof(INT16) ))) break;
2091             for (i = 0; i < wParam; i++) stops[i] = stops32[i];
2092             lParam = MapLS( stops );
2093             ret = callback( HWND_16(hwnd), LB_SETTABSTOPS16, wParam, lParam, result, arg );
2094             UnMapLS( lParam );
2095             free_buffer( buffer, stops );
2096         }
2097         else ret = callback( HWND_16(hwnd), LB_SETTABSTOPS16, wParam, lParam, result, arg );
2098         break;
2099     case CB_DELETESTRING:
2100     case CB_GETCOUNT:
2101     case CB_GETLBTEXTLEN:
2102     case CB_LIMITTEXT:
2103     case CB_RESETCONTENT:
2104     case CB_SETEDITSEL:
2105     case CB_GETCURSEL:
2106     case CB_SETCURSEL:
2107     case CB_SHOWDROPDOWN:
2108     case CB_SETITEMDATA:
2109     case CB_SETITEMHEIGHT:
2110     case CB_GETITEMHEIGHT:
2111     case CB_SETEXTENDEDUI:
2112     case CB_GETEXTENDEDUI:
2113     case CB_GETDROPPEDSTATE:
2114         ret = callback( HWND_16(hwnd), msg + CB_GETEDITSEL16 - CB_GETEDITSEL, wParam, lParam, result, arg );
2115         break;
2116     case CB_GETEDITSEL:
2117         ret = callback( HWND_16(hwnd), CB_GETEDITSEL16, wParam, lParam, result, arg );
2118         if (wParam) *((PUINT)(wParam)) = LOWORD(*result);
2119         if (lParam) *((PUINT)(lParam)) = HIWORD(*result);  /* FIXME: substract 1? */
2120         break;
2121     case CB_ADDSTRING:
2122     case CB_FINDSTRING:
2123     case CB_FINDSTRINGEXACT:
2124     case CB_INSERTSTRING:
2125     case CB_SELECTSTRING:
2126     case CB_DIR:
2127     case CB_GETLBTEXT:
2128         lParam = MapLS( (LPSTR)lParam );
2129         ret = callback( HWND_16(hwnd), msg + CB_GETEDITSEL16 - CB_GETEDITSEL, wParam, lParam, result, arg );
2130         UnMapLS( lParam );
2131         break;
2132     case LB_GETITEMRECT:
2133     case CB_GETDROPPEDCONTROLRECT:
2134         {
2135             RECT *r32 = (RECT *)lParam;
2136             RECT16 rect;
2137             lParam = MapLS( &rect );
2138             ret = callback( HWND_16(hwnd),
2139                             (msg == LB_GETITEMRECT) ? LB_GETITEMRECT16 : CB_GETDROPPEDCONTROLRECT16,
2140                             wParam, lParam, result, arg );
2141             UnMapLS( lParam );
2142             RECT16to32( &rect, r32 );
2143         }
2144         break;
2145     case WM_PAINTCLIPBOARD:
2146     case WM_SIZECLIPBOARD:
2147         FIXME_(msg)( "message %04x needs translation\n", msg );
2148         break;
2149     /* the following messages should not be sent to 16-bit apps */
2150     case WM_SIZING:
2151     case WM_MOVING:
2152     case WM_CAPTURECHANGED:
2153     case WM_STYLECHANGING:
2154     case WM_STYLECHANGED:
2155         break;
2156     default:
2157         ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
2158         break;
2159     }
2160     return ret;
2161 }
2162
2163
2164 /**********************************************************************
2165  *              CallWindowProc (USER.122)
2166  */
2167 LRESULT WINAPI CallWindowProc16( WNDPROC16 func, HWND16 hwnd, UINT16 msg,
2168                                  WPARAM16 wParam, LPARAM lParam )
2169 {
2170     WINDOWPROC *proc;
2171     LRESULT result;
2172
2173     if (!func) return 0;
2174
2175     if (!(proc = handle16_to_proc( func )))
2176         call_window_proc16( hwnd, msg, wParam, lParam, &result, func );
2177     else if (proc->procA)
2178         WINPROC_CallProc16To32A( call_window_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
2179     else if (proc->procW)
2180         WINPROC_CallProc16To32A( call_window_proc_AtoW, hwnd, msg, wParam, lParam, &result, proc->procW );
2181     else
2182         call_window_proc16( hwnd, msg, wParam, lParam, &result, proc->proc16 );
2183
2184     return result;
2185 }
2186
2187
2188 /**********************************************************************
2189  *              CallWindowProcA (USER32.@)
2190  *
2191  * The CallWindowProc() function invokes the windows procedure _func_,
2192  * with _hwnd_ as the target window, the message specified by _msg_, and
2193  * the message parameters _wParam_ and _lParam_.
2194  *
2195  * Some kinds of argument conversion may be done, I'm not sure what.
2196  *
2197  * CallWindowProc() may be used for windows subclassing. Use
2198  * SetWindowLong() to set a new windows procedure for windows of the
2199  * subclass, and handle subclassed messages in the new windows
2200  * procedure. The new windows procedure may then use CallWindowProc()
2201  * with _func_ set to the parent class's windows procedure to dispatch
2202  * the message to the superclass.
2203  *
2204  * RETURNS
2205  *
2206  *    The return value is message dependent.
2207  *
2208  * CONFORMANCE
2209  *
2210  *   ECMA-234, Win32
2211  */
2212 LRESULT WINAPI CallWindowProcA(
2213     WNDPROC func,  /* [in] window procedure */
2214     HWND hwnd,     /* [in] target window */
2215     UINT msg,      /* [in] message */
2216     WPARAM wParam, /* [in] message dependent parameter */
2217     LPARAM lParam  /* [in] message dependent parameter */
2218 ) {
2219     WINDOWPROC *proc;
2220     LRESULT result;
2221
2222     if (!func) return 0;
2223
2224     if (!(proc = handle_to_proc( func )))
2225         call_window_proc( hwnd, msg, wParam, lParam, &result, func );
2226     else if (proc->procA)
2227         call_window_proc( hwnd, msg, wParam, lParam, &result, proc->procA );
2228     else if (proc->procW)
2229         WINPROC_CallProcAtoW( call_window_proc, hwnd, msg, wParam, lParam, &result, proc->procW );
2230     else
2231         WINPROC_CallProc32ATo16( call_window_proc16, hwnd, msg, wParam, lParam, &result, proc->proc16 );
2232     return result;
2233 }
2234
2235
2236 /**********************************************************************
2237  *              CallWindowProcW (USER32.@)
2238  *
2239  * See CallWindowProcA.
2240  */
2241 LRESULT WINAPI CallWindowProcW( WNDPROC func, HWND hwnd, UINT msg,
2242                                   WPARAM wParam, LPARAM lParam )
2243 {
2244     WINDOWPROC *proc;
2245     LRESULT result;
2246
2247     if (!func) return 0;
2248
2249     if (!(proc = handle_to_proc( func )))
2250         call_window_proc( hwnd, msg, wParam, lParam, &result, func );
2251     else if (proc->procW)
2252         call_window_proc( hwnd, msg, wParam, lParam, &result, proc->procW );
2253     else if (proc->procA)
2254         WINPROC_CallProcWtoA( call_window_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
2255     else
2256         WINPROC_CallProcWtoA( call_window_proc_Ato16, hwnd, msg, wParam, lParam, &result, proc->proc16 );
2257     return result;
2258 }
2259
2260
2261 /**********************************************************************
2262  *              WINPROC_CallDlgProc16
2263  */
2264 INT_PTR WINPROC_CallDlgProc16( DLGPROC16 func, HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam )
2265 {
2266     WINDOWPROC *proc;
2267     LRESULT result;
2268     INT_PTR ret;
2269
2270     if (!func) return 0;
2271
2272     if (!(proc = handle16_to_proc( (WNDPROC16)func )))
2273     {
2274         ret = call_dialog_proc16( hwnd, msg, wParam, lParam, &result, func );
2275     }
2276     else if (proc->procA)
2277     {
2278         ret = WINPROC_CallProc16To32A( call_dialog_proc, hwnd, msg, wParam, lParam,
2279                                        &result, proc->procA );
2280         SetWindowLongPtrW( WIN_Handle32(hwnd), DWLP_MSGRESULT, result );
2281     }
2282     else if (proc->procW)
2283     {
2284         ret = WINPROC_CallProc16To32A( call_dialog_proc_AtoW, hwnd, msg, wParam, lParam,
2285                                        &result, proc->procW );
2286         SetWindowLongPtrW( WIN_Handle32(hwnd), DWLP_MSGRESULT, result );
2287     }
2288     else
2289     {
2290         ret = call_dialog_proc16( hwnd, msg, wParam, lParam, &result, proc->proc16 );
2291     }
2292     return ret;
2293 }
2294
2295
2296 /**********************************************************************
2297  *              WINPROC_CallDlgProcA
2298  */
2299 INT_PTR WINPROC_CallDlgProcA( DLGPROC func, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
2300 {
2301     WINDOWPROC *proc;
2302     LRESULT result;
2303     INT_PTR ret;
2304
2305     if (!func) return 0;
2306
2307     if (!(proc = handle_to_proc( (WNDPROC)func )))
2308         ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, func );
2309     else if (proc->procA)
2310         ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, proc->procA );
2311     else if (proc->procW)
2312     {
2313         ret = WINPROC_CallProcAtoW( call_dialog_proc, hwnd, msg, wParam, lParam, &result, proc->procW );
2314         SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
2315     }
2316     else
2317     {
2318         ret = WINPROC_CallProc32ATo16( call_dialog_proc16, hwnd, msg, wParam, lParam, &result, proc->proc16 );
2319         SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
2320     }
2321     return ret;
2322 }
2323
2324
2325 /**********************************************************************
2326  *              WINPROC_CallDlgProcW
2327  */
2328 INT_PTR WINPROC_CallDlgProcW( DLGPROC func, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
2329 {
2330     WINDOWPROC *proc;
2331     LRESULT result;
2332     INT_PTR ret;
2333
2334     if (!func) return 0;
2335
2336     if (!(proc = handle_to_proc( (WNDPROC)func )))
2337         ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, func );
2338     else if (proc->procW)
2339         ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, proc->procW );
2340     else if (proc->procA)
2341     {
2342         ret = WINPROC_CallProcWtoA( call_dialog_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
2343         SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
2344     }
2345     else
2346     {
2347         ret = WINPROC_CallProcWtoA( call_dialog_proc_Ato16, hwnd, msg, wParam, lParam, &result, proc->proc16 );
2348         SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
2349     }
2350     return ret;
2351 }