Silence some warnings due to casts between pointer and integers of
[wine] / windows / 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <string.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wingdi.h"
30 #include "wownt32.h"
31 #include "wine/winbase16.h"
32 #include "wine/winuser16.h"
33 #include "stackframe.h"
34 #include "selectors.h"
35 #include "controls.h"
36 #include "heap.h"
37 #include "struct32.h"
38 #include "win.h"
39 #include "winproc.h"
40 #include "wine/debug.h"
41 #include "spy.h"
42 #include "thread.h"
43 #include "dde.h"
44
45 WINE_DECLARE_DEBUG_CHANNEL(msg);
46 WINE_DECLARE_DEBUG_CHANNEL(relay);
47 WINE_DECLARE_DEBUG_CHANNEL(win);
48
49 #include "pshpack1.h"
50
51 /* Window procedure 16-to-32-bit thunk */
52 typedef struct
53 {
54     BYTE       popl_eax;             /* popl  %eax (return address) */
55     BYTE       pushl_func;           /* pushl $proc */
56     WNDPROC    proc;
57     BYTE       pushl_eax;            /* pushl %eax */
58     BYTE       ljmp;                 /* ljmp relay*/
59     DWORD      relay_offset;         /* __wine_call_wndproc_32A/W */
60     WORD       relay_sel;
61 } WINPROC_THUNK_FROM16;
62
63 /* Window procedure 32-to-16-bit thunk */
64 typedef struct
65 {
66     BYTE       popl_eax;             /* popl  %eax (return address) */
67     BYTE       pushl_func;           /* pushl $proc */
68     WNDPROC16  proc;
69     BYTE       pushl_eax;            /* pushl %eax */
70     BYTE       jmp;                  /* jmp   relay (relative jump)*/
71     void     (*relay)();             /* WINPROC_CallProc32ATo16() */
72 } WINPROC_THUNK_FROM32;
73
74 /* Simple jmp to call 32-bit procedure directly */
75 typedef struct
76 {
77     BYTE       jmp;                  /* jmp  proc (relative jump) */
78     WNDPROC    proc;
79 } WINPROC_JUMP;
80 #include "poppack.h"
81
82 typedef union
83 {
84     WINPROC_THUNK_FROM16  t_from16;
85     WINPROC_THUNK_FROM32  t_from32;
86 } WINPROC_THUNK;
87
88 typedef struct tagWINDOWPROC
89 {
90     WINPROC_THUNK         thunk;    /* Thunk */
91     WINPROC_JUMP          jmp;      /* Jump */
92     struct tagWINDOWPROC *next;     /* Next window proc */
93     UINT                magic;    /* Magic number */
94     WINDOWPROCTYPE        type;     /* Function type */
95     WINDOWPROCUSER        user;     /* Function user */
96 } WINDOWPROC;
97
98 #define WINPROC_MAGIC  ('W' | ('P' << 8) | ('R' << 16) | ('C' << 24))
99
100 #define WINPROC_THUNKPROC(pproc) \
101     (((pproc)->type == WIN_PROC_16) ? \
102           (WNDPROC16)((pproc)->thunk.t_from32.proc) : \
103           (WNDPROC16)((pproc)->thunk.t_from16.proc))
104
105 static LRESULT WINAPI WINPROC_CallProc32ATo16( WNDPROC16 func, HWND hwnd,
106                                                UINT msg, WPARAM wParam,
107                                                LPARAM lParam );
108 static LRESULT WINAPI WINPROC_CallProc32WTo16( WNDPROC16 func, HWND hwnd,
109                                                UINT msg, WPARAM wParam,
110                                                LPARAM lParam );
111
112 static HANDLE WinProcHeap;
113 static WORD WinProcSel;
114
115
116 /**********************************************************************
117  *           WINPROC_Init
118  */
119 BOOL WINPROC_Init(void)
120 {
121     WinProcHeap = HeapCreate( 0, 0x10000, 0x10000 );
122     WinProcSel = SELECTOR_AllocBlock( (void *)WinProcHeap, 0x10000,
123                                       WINE_LDT_FLAGS_CODE | WINE_LDT_FLAGS_32BIT );
124     if (!WinProcHeap || !WinProcSel)
125     {
126         WARN_(relay)("Unable to create winproc heap\n" );
127         return FALSE;
128     }
129     return TRUE;
130 }
131
132
133 #ifdef __i386__
134 /* Some window procedures modify register they shouldn't, or are not
135  * properly declared stdcall; so we need a small assembly wrapper to
136  * call them. */
137 extern LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
138                                 WPARAM wParam, LPARAM lParam );
139 __ASM_GLOBAL_FUNC( WINPROC_wrapper,
140                    "pushl %ebp\n\t"
141                    "movl %esp,%ebp\n\t"
142                    "pushl %edi\n\t"
143                    "pushl %esi\n\t"
144                    "pushl %ebx\n\t"
145                    "pushl 24(%ebp)\n\t"
146                    "pushl 20(%ebp)\n\t"
147                    "pushl 16(%ebp)\n\t"
148                    "pushl 12(%ebp)\n\t"
149                    "movl 8(%ebp),%eax\n\t"
150                    "call *%eax\n\t"
151                    "leal -12(%ebp),%esp\n\t"
152                    "popl %ebx\n\t"
153                    "popl %esi\n\t"
154                    "popl %edi\n\t"
155                    "leave\n\t"
156                    "ret" );
157 #else
158 static inline LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
159                                        WPARAM wParam, LPARAM lParam )
160 {
161     return proc( hwnd, msg, wParam, lParam );
162 }
163 #endif  /* __i386__ */
164
165 /**********************************************************************
166  *           WINPROC_CallWndProc32
167  *
168  * Call a 32-bit WndProc.
169  */
170 static LRESULT WINPROC_CallWndProc( WNDPROC proc, HWND hwnd, UINT msg,
171                                       WPARAM wParam, LPARAM lParam )
172 {
173     LRESULT retvalue;
174     int iWndsLocks;
175
176     hwnd = WIN_GetFullHandle( hwnd );
177     if (TRACE_ON(relay))
178         DPRINTF( "%08lx:Call window proc %p (hwnd=%08x,msg=%s,wp=%08x,lp=%08lx)\n",
179                  GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam );
180     /* To avoid any deadlocks, all the locks on the windows structures
181        must be suspended before the control is passed to the application */
182     iWndsLocks = WIN_SuspendWndsLock();
183     retvalue = WINPROC_wrapper( proc, hwnd, msg, wParam, lParam );
184     WIN_RestoreWndsLock(iWndsLocks);
185
186     if (TRACE_ON(relay))
187         DPRINTF( "%08lx:Ret  window proc %p (hwnd=%08x,msg=%s,wp=%08x,lp=%08lx) retval=%08lx\n",
188                  GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam, retvalue );
189     return retvalue;
190 }
191
192 /***********************************************************************
193  *           WINPROC_CallWndProc16
194  *
195  * Call a 16-bit window procedure
196  */
197 static LRESULT WINAPI WINPROC_CallWndProc16( WNDPROC16 proc, HWND16 hwnd,
198                                              UINT16 msg, WPARAM16 wParam,
199                                              LPARAM lParam )
200 {
201     CONTEXT86 context;
202     LRESULT ret;
203     WORD *args;
204     DWORD offset = 0;
205     TEB *teb = NtCurrentTeb();
206     int iWndsLocks;
207
208     /* Window procedures want ax = hInstance, ds = es = ss */
209
210     memset(&context, '\0', sizeof(context));
211     context.SegDs = context.SegEs = SELECTOROF(teb->cur_stack);
212     if (!(context.Eax = GetWindowWord16( hwnd, GWL_HINSTANCE ))) context.Eax = context.SegDs;
213     context.SegCs = SELECTOROF(proc);
214     context.Eip   = OFFSETOF(proc);
215     context.Ebp   = OFFSETOF(teb->cur_stack)
216                         + (WORD)&((STACK16FRAME*)0)->bp;
217
218     if (lParam)
219     {
220         /* Some programs (eg. the "Undocumented Windows" examples, JWP) only
221            work if structures passed in lParam are placed in the stack/data
222            segment. Programmers easily make the mistake of converting lParam
223            to a near rather than a far pointer, since Windows apparently
224            allows this. We copy the structures to the 16 bit stack; this is
225            ugly but makes these programs work. */
226         switch (msg)
227         {
228           case WM_CREATE:
229           case WM_NCCREATE:
230             offset = sizeof(CREATESTRUCT16); break;
231           case WM_DRAWITEM:
232             offset = sizeof(DRAWITEMSTRUCT16); break;
233           case WM_COMPAREITEM:
234             offset = sizeof(COMPAREITEMSTRUCT16); break;
235         }
236         if (offset)
237         {
238             void *s = MapSL(lParam);
239             lParam = stack16_push( offset );
240             memcpy( MapSL(lParam), s, offset );
241         }
242     }
243
244     iWndsLocks = WIN_SuspendWndsLock();
245
246     args = (WORD *)THREAD_STACK16(teb) - 5;
247     args[0] = LOWORD(lParam);
248     args[1] = HIWORD(lParam);
249     args[2] = wParam;
250     args[3] = msg;
251     args[4] = hwnd;
252
253     wine_call_to_16_regs_short( &context, 5 * sizeof(WORD) );
254     ret = MAKELONG( LOWORD(context.Eax), LOWORD(context.Edx) );
255     if (offset) stack16_pop( offset );
256
257     WIN_RestoreWndsLock(iWndsLocks);
258
259     return ret;
260 }
261
262
263 /**********************************************************************
264  *           WINPROC_GetPtr
265  *
266  * Return a pointer to the win proc.
267  */
268 static WINDOWPROC *WINPROC_GetPtr( WNDPROC16 handle )
269 {
270     BYTE *ptr;
271     WINDOWPROC *proc;
272
273     /* ptr cannot be < 64K */
274     if (!HIWORD(handle)) return NULL;
275
276     /* Check for a linear pointer */
277
278     ptr = (BYTE *)handle;
279     /* First check if it is the jmp address */
280     proc = (WINDOWPROC *)(ptr - (int)&((WINDOWPROC *)0)->jmp);
281     if (HeapValidate( WinProcHeap, 0, proc ) && (proc->magic == WINPROC_MAGIC))
282         return proc;
283     /* Now it must be the thunk address */
284     proc = (WINDOWPROC *)(ptr - (int)&((WINDOWPROC *)0)->thunk);
285     if (HeapValidate( WinProcHeap, 0, proc ) && (proc->magic == WINPROC_MAGIC))
286         return proc;
287
288     /* Check for a segmented pointer */
289
290     if (!IsBadReadPtr16( (SEGPTR)handle, sizeof(proc->thunk) ))
291     {
292         ptr = MapSL( (SEGPTR)handle );
293         /* It must be the thunk address */
294         proc = (WINDOWPROC *)(ptr - (int)&((WINDOWPROC *)0)->thunk);
295         if (HeapValidate( WinProcHeap, 0, proc ) && (proc->magic == WINPROC_MAGIC))
296             return proc;
297     }
298
299     return NULL;
300 }
301
302
303 /**********************************************************************
304  *           WINPROC_AllocWinProc
305  *
306  * Allocate a new window procedure.
307  */
308 static WINDOWPROC *WINPROC_AllocWinProc( WNDPROC16 func, WINDOWPROCTYPE type,
309                                          WINDOWPROCUSER user )
310 {
311     static FARPROC16 relay_32A, relay_32W;
312
313     WINDOWPROC *proc, *oldproc;
314
315     /* Allocate a window procedure */
316
317     if (!(proc = HeapAlloc( WinProcHeap, 0, sizeof(WINDOWPROC) ))) return 0;
318
319     /* Check if the function is already a win proc */
320
321     if ((oldproc = WINPROC_GetPtr( func )))
322     {
323         *proc = *oldproc;
324     }
325     else
326     {
327         switch(type)
328         {
329         case WIN_PROC_16:
330             proc->thunk.t_from32.popl_eax    = 0x58;   /* popl  %eax */
331             proc->thunk.t_from32.pushl_func  = 0x68;   /* pushl $proc */
332             proc->thunk.t_from32.proc        = func;
333             proc->thunk.t_from32.pushl_eax   = 0x50;   /* pushl %eax */
334             proc->thunk.t_from32.jmp         = 0xe9;   /* jmp   relay*/
335             proc->thunk.t_from32.relay =  /* relative jump */
336                 (void(*)())((DWORD)WINPROC_CallProc32ATo16 -
337                                      (DWORD)(&proc->thunk.t_from32.relay + 1));
338             break;
339         case WIN_PROC_32A:
340             if (!relay_32A) relay_32A = GetProcAddress16( GetModuleHandle16("user"),
341                                                           "__wine_call_wndproc_32A" );
342             proc->thunk.t_from16.popl_eax     = 0x58;   /* popl  %eax */
343             proc->thunk.t_from16.pushl_func   = 0x68;   /* pushl $proc */
344             proc->thunk.t_from16.proc         = (WNDPROC)func;
345             proc->thunk.t_from16.pushl_eax    = 0x50;   /* pushl %eax */
346             proc->thunk.t_from16.ljmp         = 0xea;   /* ljmp   relay*/
347             proc->thunk.t_from16.relay_offset = OFFSETOF(relay_32A);
348             proc->thunk.t_from16.relay_sel    = SELECTOROF(relay_32A);
349             proc->jmp.jmp  = 0xe9;
350             /* Fixup relative jump */
351             proc->jmp.proc = (WNDPROC)((DWORD)func - (DWORD)(&proc->jmp.proc + 1));
352             break;
353         case WIN_PROC_32W:
354             if (!relay_32W) relay_32W = GetProcAddress16( GetModuleHandle16("user"),
355                                                           "__wine_call_wndproc_32W" );
356             proc->thunk.t_from16.popl_eax     = 0x58;   /* popl  %eax */
357             proc->thunk.t_from16.pushl_func   = 0x68;   /* pushl $proc */
358             proc->thunk.t_from16.proc         = (WNDPROC)func;
359             proc->thunk.t_from16.pushl_eax    = 0x50;   /* pushl %eax */
360             proc->thunk.t_from16.ljmp         = 0xea;   /* ljmp   relay*/
361             proc->thunk.t_from16.relay_offset = OFFSETOF(relay_32W);
362             proc->thunk.t_from16.relay_sel    = SELECTOROF(relay_32W);
363             proc->jmp.jmp  = 0xe9;
364             /* Fixup relative jump */
365             proc->jmp.proc = (WNDPROC)((DWORD)func - (DWORD)(&proc->jmp.proc + 1));
366             break;
367         default:
368             /* Should not happen */
369             break;
370         }
371         proc->magic = WINPROC_MAGIC;
372         proc->type  = type;
373         proc->user  = user;
374     }
375     proc->next  = NULL;
376     TRACE_(win)("(%08x,%d): returning %08x\n",
377                  (UINT)func, type, (UINT)proc );
378     return proc;
379 }
380
381
382 /**********************************************************************
383  *           WINPROC_GetProc
384  *
385  * Get a window procedure pointer that can be passed to the Windows program.
386  */
387 WNDPROC16 WINPROC_GetProc( HWINDOWPROC proc, WINDOWPROCTYPE type )
388 {
389     WINDOWPROC *ptr = (WINDOWPROC *)proc;
390
391     if (!proc) return NULL;
392     if (type == WIN_PROC_16)  /* We want a 16:16 address */
393     {
394         if (ptr->type == WIN_PROC_16)
395             return ptr->thunk.t_from32.proc;
396         else
397             return (WNDPROC16)MAKESEGPTR( WinProcSel, (char *)&ptr->thunk - (char *)WinProcHeap );
398     }
399     else  /* We want a 32-bit address */
400     {
401         if (ptr->type == WIN_PROC_16)
402             return (WNDPROC16)&ptr->thunk;
403         else if (type != ptr->type)
404             /* Have to return the jmp address if types don't match */
405             return (WNDPROC16)&ptr->jmp;
406         else
407             /* Some Win16 programs want to get back the proc they set */
408             return (WNDPROC16)ptr->thunk.t_from16.proc;
409     }
410 }
411
412
413 /**********************************************************************
414  *           WINPROC_SetProc
415  *
416  * Set the window procedure for a window or class. There are
417  * three tree classes of winproc callbacks:
418  *
419  * 1) class  -> wp                      -       not subclassed
420  *    class  -> wp -> wp -> wp -> wp    -       SetClassLong()
421  *             /           /
422  * 2) window -'           /             -       not subclassed
423  *    window -> wp -> wp '              -       SetWindowLong()
424  *
425  * 3) timer  -> wp                      -       SetTimer()
426  *
427  * Initially, winproc of the window points to the current winproc
428  * thunk of its class. Subclassing prepends a new thunk to the
429  * window winproc chain at the head of the list. Thus, window thunk
430  * list includes class thunks and the latter are preserved when the
431  * window is destroyed.
432  *
433  */
434 BOOL WINPROC_SetProc( HWINDOWPROC *pFirst, WNDPROC16 func,
435                         WINDOWPROCTYPE type, WINDOWPROCUSER user )
436 {
437     BOOL bRecycle = FALSE;
438     WINDOWPROC *proc, **ppPrev;
439
440     /* Check if function is already in the list */
441
442     ppPrev = (WINDOWPROC **)pFirst;
443     proc = WINPROC_GetPtr( func );
444     while (*ppPrev)
445     {
446         if (proc)
447         {
448             if (*ppPrev == proc)
449             {
450                 if ((*ppPrev)->user != user)
451                 {
452                     /* terminal thunk is being restored */
453
454                     WINPROC_FreeProc( *pFirst, (*ppPrev)->user );
455                     *(WINDOWPROC **)pFirst = *ppPrev;
456                     return TRUE;
457                 }
458                 bRecycle = TRUE;
459                 break;
460             }
461         }
462         else
463         {
464             if (((*ppPrev)->type == type) &&
465                 (func == WINPROC_THUNKPROC(*ppPrev)))
466             {
467                 if((*ppPrev)->user == user)
468                 {
469                     bRecycle = TRUE;
470                 }
471                 else
472                 {
473                     WINPROC_FreeProc( *ppPrev, user );
474                     *ppPrev = NULL;
475                 }
476                 break;
477             }
478         }
479
480         /* WPF_CLASS thunk terminates window thunk list */
481         if ((*ppPrev)->user != user) break;
482         ppPrev = &(*ppPrev)->next;
483     }
484
485     if (bRecycle)
486     {
487         /* Extract this thunk from the list */
488         proc = *ppPrev;
489         *ppPrev = proc->next;
490     }
491     else  /* Allocate a new one */
492     {
493         if (proc)  /* Was already a win proc */
494         {
495             type = proc->type;
496             func = WINPROC_THUNKPROC(proc);
497         }
498         proc = WINPROC_AllocWinProc( func, type, user );
499         if (!proc) return FALSE;
500     }
501
502     /* Add the win proc at the head of the list */
503
504     TRACE_(win)("(%08x,%08x,%d): res=%08x\n",
505                  (UINT)*pFirst, (UINT)func, type, (UINT)proc );
506     proc->next  = *(WINDOWPROC **)pFirst;
507     *(WINDOWPROC **)pFirst = proc;
508     return TRUE;
509 }
510
511
512 /**********************************************************************
513  *           WINPROC_FreeProc
514  *
515  * Free a list of win procs.
516  */
517 void WINPROC_FreeProc( HWINDOWPROC proc, WINDOWPROCUSER user )
518 {
519     while (proc)
520     {
521         WINDOWPROC *next = ((WINDOWPROC *)proc)->next;
522         if (((WINDOWPROC *)proc)->user != user) break;
523         TRACE_(win)("freeing %08x (%d)\n", (UINT)proc, user);
524         HeapFree( WinProcHeap, 0, proc );
525         proc = next;
526     }
527 }
528
529
530 /**********************************************************************
531  *           WINPROC_GetProcType
532  *
533  * Return the window procedure type.
534  */
535 WINDOWPROCTYPE WINPROC_GetProcType( HWINDOWPROC proc )
536 {
537     if (!proc ||
538         (((WINDOWPROC *)proc)->magic != WINPROC_MAGIC))
539         return WIN_PROC_INVALID;
540     return ((WINDOWPROC *)proc)->type;
541 }
542 /**********************************************************************
543  *           WINPROC_TestCBForStr
544  *
545  * Return TRUE if the lparam is a string
546  */
547 inline static BOOL WINPROC_TestCBForStr( HWND hwnd )
548 {
549     DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
550     return (!(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) || (style & CBS_HASSTRINGS));
551 }
552 /**********************************************************************
553  *           WINPROC_TestLBForStr
554  *
555  * Return TRUE if the lparam is a string
556  */
557 inline static BOOL WINPROC_TestLBForStr( HWND hwnd )
558 {
559     DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
560     return (!(style & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) || (style & LBS_HASSTRINGS));
561
562 }
563 /**********************************************************************
564  *           WINPROC_MapMsg32ATo32W
565  *
566  * Map a message from Ansi to Unicode.
567  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
568  *
569  * FIXME:
570  *  WM_GETTEXT/WM_SETTEXT and static control with SS_ICON style:
571  *  the first four bytes are the handle of the icon
572  *  when the WM_SETTEXT message has been used to set the icon
573  */
574 INT WINPROC_MapMsg32ATo32W( HWND hwnd, UINT msg, WPARAM *pwparam, LPARAM *plparam )
575 {
576     switch(msg)
577     {
578     case WM_GETTEXT:
579     case WM_ASKCBFORMATNAME:
580         {
581             LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0,
582                                      *pwparam * sizeof(WCHAR) + sizeof(LPARAM) );
583             if (!ptr) return -1;
584             *ptr++ = *plparam;  /* Store previous lParam */
585             *plparam = (LPARAM)ptr;
586         }
587         return 1;
588     /* lparam is string (0-terminated) */
589     case WM_SETTEXT:
590     case WM_WININICHANGE:
591     case WM_DEVMODECHANGE:
592     case CB_DIR:
593     case LB_DIR:
594     case LB_ADDFILE:
595     case EM_REPLACESEL:
596         if(!*plparam) return 0;
597         *plparam = (LPARAM)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR)*plparam );
598         return (*plparam ? 1 : -1);
599     case WM_GETTEXTLENGTH:
600     case CB_GETLBTEXTLEN:
601     case LB_GETTEXTLEN:
602         return 1;  /* need to map result */
603     case WM_NCCREATE:
604     case WM_CREATE:
605         {
606             struct s
607             { CREATESTRUCTW cs;         /* new structure */
608               LPCWSTR lpszName;         /* allocated Name */
609               LPCWSTR lpszClass;        /* allocated Class */
610             };
611
612             struct s *xs = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct s));
613             if (!xs) return -1;
614             xs->cs = *(CREATESTRUCTW *)*plparam;
615             if (HIWORD(xs->cs.lpszName))
616                 xs->lpszName = xs->cs.lpszName = HEAP_strdupAtoW( GetProcessHeap(), 0,
617                                                                   (LPCSTR)xs->cs.lpszName );
618             if (HIWORD(xs->cs.lpszClass))
619                 xs->lpszClass = xs->cs.lpszClass = HEAP_strdupAtoW( GetProcessHeap(), 0,
620                                                                     (LPCSTR)xs->cs.lpszClass );
621             *plparam = (LPARAM)xs;
622         }
623         return 1;
624     case WM_MDICREATE:
625         {
626             MDICREATESTRUCTW *cs =
627                 (MDICREATESTRUCTW *)HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) );
628             if (!cs) return -1;
629             *cs = *(MDICREATESTRUCTW *)*plparam;
630             if (HIWORD(cs->szClass))
631                 cs->szClass = HEAP_strdupAtoW( GetProcessHeap(), 0,
632                                                (LPCSTR)cs->szClass );
633             if (HIWORD(cs->szTitle))
634                 cs->szTitle = HEAP_strdupAtoW( GetProcessHeap(), 0,
635                                                (LPCSTR)cs->szTitle );
636             *plparam = (LPARAM)cs;
637         }
638         return 1;
639
640 /* Listbox */
641     case LB_ADDSTRING:
642     case LB_INSERTSTRING:
643     case LB_FINDSTRING:
644     case LB_FINDSTRINGEXACT:
645     case LB_SELECTSTRING:
646         if(!*plparam) return 0;
647         if ( WINPROC_TestLBForStr( hwnd ))
648           *plparam = (LPARAM)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR)*plparam );
649         return (*plparam ? 1 : -1);
650
651     case LB_GETTEXT:                /* FIXME: fixed sized buffer */
652         { if ( WINPROC_TestLBForStr( hwnd ))
653           { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 * sizeof(WCHAR) + sizeof(LPARAM) );
654             if (!ptr) return -1;
655             *ptr++ = *plparam;  /* Store previous lParam */
656             *plparam = (LPARAM)ptr;
657           }
658         }
659         return 1;
660
661 /* Combobox */
662     case CB_ADDSTRING:
663     case CB_INSERTSTRING:
664     case CB_FINDSTRINGEXACT:
665     case CB_FINDSTRING:
666     case CB_SELECTSTRING:
667         if(!*plparam) return 0;
668         if ( WINPROC_TestCBForStr( hwnd ))
669           *plparam = (LPARAM)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR)*plparam );
670         return (*plparam ? 1 : -1);
671
672     case CB_GETLBTEXT:    /* FIXME: fixed sized buffer */
673         { if ( WINPROC_TestCBForStr( hwnd ))
674           { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 * sizeof(WCHAR) + sizeof(LPARAM) );
675             if (!ptr) return -1;
676             *ptr++ = *plparam;  /* Store previous lParam */
677             *plparam = (LPARAM)ptr;
678           }
679         }
680         return 1;
681
682 /* Multiline edit */
683     case EM_GETLINE:
684         { WORD len = (WORD)*plparam;
685           LPARAM *ptr = (LPARAM *) HeapAlloc( GetProcessHeap(), 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(WCHAR) );
686           if (!ptr) return -1;
687           *ptr++ = *plparam;  /* Store previous lParam */
688           *((WORD *) ptr) = len;   /* Store the length */
689           *plparam = (LPARAM)ptr;
690         }
691         return 1;
692
693     case WM_CHARTOITEM:
694     case WM_MENUCHAR:
695     case WM_CHAR:
696     case WM_DEADCHAR:
697     case WM_SYSCHAR:
698     case WM_SYSDEADCHAR:
699     case EM_SETPASSWORDCHAR:
700         {
701             BYTE ch = LOWORD(*pwparam);
702             WCHAR wch;
703             MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
704             *pwparam = MAKEWPARAM( wch, HIWORD(*pwparam) );
705         }
706         return 0;
707
708     case WM_PAINTCLIPBOARD:
709     case WM_SIZECLIPBOARD:
710         FIXME_(msg)("message %s (0x%x) needs translation, please report\n", SPY_GetMsgName(msg, hwnd), msg );
711         return -1;
712     default:  /* No translation needed */
713         return 0;
714     }
715 }
716
717
718 /**********************************************************************
719  *           WINPROC_UnmapMsg32ATo32W
720  *
721  * Unmap a message that was mapped from Ansi to Unicode.
722  */
723 LRESULT WINPROC_UnmapMsg32ATo32W( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
724                                   LRESULT result )
725 {
726     switch(msg)
727     {
728     case WM_GETTEXT:
729     case WM_ASKCBFORMATNAME:
730         {
731             LPARAM *ptr = (LPARAM *)lParam - 1;
732             if (wParam > 0 && !WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1,
733                                                     (LPSTR)*ptr, wParam, NULL, NULL ))
734                 ((LPSTR)*ptr)[wParam-1] = 0;
735             HeapFree( GetProcessHeap(), 0, ptr );
736         }
737         break;
738     case WM_GETTEXTLENGTH:
739     case CB_GETLBTEXTLEN:
740     case LB_GETTEXTLEN:
741         /* there may be one DBCS char for each Unicode char */
742         return result * 2;
743     case WM_NCCREATE:
744     case WM_CREATE:
745         {
746             struct s
747             { CREATESTRUCTW cs;         /* new structure */
748               LPWSTR lpszName;          /* allocated Name */
749               LPWSTR lpszClass;         /* allocated Class */
750             };
751             struct s *xs = (struct s *)lParam;
752             if (xs->lpszName)  HeapFree( GetProcessHeap(), 0, xs->lpszName );
753             if (xs->lpszClass) HeapFree( GetProcessHeap(), 0, xs->lpszClass );
754             HeapFree( GetProcessHeap(), 0, xs );
755         }
756         break;
757
758     case WM_MDICREATE:
759         {
760             MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lParam;
761             if (HIWORD(cs->szTitle))
762                 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szTitle );
763             if (HIWORD(cs->szClass))
764                 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szClass );
765             HeapFree( GetProcessHeap(), 0, cs );
766         }
767         break;
768
769     case WM_SETTEXT:
770     case WM_WININICHANGE:
771     case WM_DEVMODECHANGE:
772     case CB_DIR:
773     case LB_DIR:
774     case LB_ADDFILE:
775     case EM_REPLACESEL:
776         HeapFree( GetProcessHeap(), 0, (void *)lParam );
777         break;
778
779 /* Listbox */
780     case LB_ADDSTRING:
781     case LB_INSERTSTRING:
782     case LB_FINDSTRING:
783     case LB_FINDSTRINGEXACT:
784     case LB_SELECTSTRING:
785         if ( WINPROC_TestLBForStr( hwnd ))
786           HeapFree( GetProcessHeap(), 0, (void *)lParam );
787         break;
788
789     case LB_GETTEXT:
790         { if ( WINPROC_TestLBForStr( hwnd ))
791           { LPARAM *ptr = (LPARAM *)lParam - 1;
792             WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1, (LPSTR)*ptr, 0x7fffffff, NULL, NULL );
793             HeapFree( GetProcessHeap(), 0, ptr );
794           }
795         }
796         break;
797
798 /* Combobox */
799     case CB_ADDSTRING:
800     case CB_INSERTSTRING:
801     case CB_FINDSTRING:
802     case CB_FINDSTRINGEXACT:
803     case CB_SELECTSTRING:
804         if ( WINPROC_TestCBForStr( hwnd ))
805           HeapFree( GetProcessHeap(), 0, (void *)lParam );
806         break;
807
808     case CB_GETLBTEXT:
809         { if ( WINPROC_TestCBForStr( hwnd ))
810           { LPARAM *ptr = (LPARAM *)lParam - 1;
811             WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1, (LPSTR)*ptr, 0x7fffffff, NULL, NULL );
812             HeapFree( GetProcessHeap(), 0, ptr );
813           }
814         }
815         break;
816
817 /* Multiline edit */
818     case EM_GETLINE:
819         { LPARAM * ptr = (LPARAM *)lParam - 1;  /* get the old lParam */
820           WORD len = *(WORD *) lParam;
821           if (len > 0 && !WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1,
822                                                (LPSTR)*ptr, len, NULL, NULL ))
823               ((LPSTR)*ptr)[len-1] = 0;
824           HeapFree( GetProcessHeap(), 0, ptr );
825         }
826         break;
827     }
828     return result;
829 }
830
831
832 /**********************************************************************
833  *           WINPROC_MapMsg32WTo32A
834  *
835  * Map a message from Unicode to Ansi.
836  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
837  */
838 INT WINPROC_MapMsg32WTo32A( HWND hwnd, UINT msg, WPARAM *pwparam, LPARAM *plparam )
839 {
840     switch(msg)
841     {
842     case WM_GETTEXT:
843     case WM_ASKCBFORMATNAME:
844         {
845             LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0,
846                                                *pwparam + sizeof(LPARAM) );
847             if (!ptr) return -1;
848             *ptr++ = *plparam;  /* Store previous lParam */
849             *plparam = (LPARAM)ptr;
850         }
851         return 1;
852
853     case WM_SETTEXT:
854     case WM_WININICHANGE:
855     case WM_DEVMODECHANGE:
856     case CB_DIR:
857     case LB_DIR:
858     case LB_ADDFILE:
859     case EM_REPLACESEL:
860         if(!*plparam) return 0;
861         *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
862         return (*plparam ? 1 : -1);
863
864     case WM_NCCREATE:
865     case WM_CREATE:
866         {
867             CREATESTRUCTA *cs = (CREATESTRUCTA *)HeapAlloc( GetProcessHeap(), 0,
868                                                                 sizeof(*cs) );
869             if (!cs) return -1;
870             *cs = *(CREATESTRUCTA *)*plparam;
871             if (HIWORD(cs->lpszName))
872                 cs->lpszName  = HEAP_strdupWtoA( GetProcessHeap(), 0,
873                                                  (LPCWSTR)cs->lpszName );
874             if (HIWORD(cs->lpszClass))
875                 cs->lpszClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
876                                                  (LPCWSTR)cs->lpszClass);
877             *plparam = (LPARAM)cs;
878         }
879         return 1;
880     case WM_MDICREATE:
881         {
882             MDICREATESTRUCTA *cs =
883                 (MDICREATESTRUCTA *)HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) );
884             if (!cs) return -1;
885             *cs = *(MDICREATESTRUCTA *)*plparam;
886             if (HIWORD(cs->szTitle))
887                 cs->szTitle = HEAP_strdupWtoA( GetProcessHeap(), 0,
888                                                (LPCWSTR)cs->szTitle );
889             if (HIWORD(cs->szClass))
890                 cs->szClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
891                                                (LPCWSTR)cs->szClass );
892             *plparam = (LPARAM)cs;
893         }
894         return 1;
895
896 /* Listbox */
897     case LB_ADDSTRING:
898     case LB_INSERTSTRING:
899     case LB_FINDSTRING:
900     case LB_FINDSTRINGEXACT:
901     case LB_SELECTSTRING:
902         if(!*plparam) return 0;
903         if ( WINPROC_TestLBForStr( hwnd ))
904           *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
905         return (*plparam ? 1 : -1);
906
907     case LB_GETTEXT:                    /* FIXME: fixed sized buffer */
908         { if ( WINPROC_TestLBForStr( hwnd ))
909           { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 + sizeof(LPARAM) );
910             if (!ptr) return -1;
911             *ptr++ = *plparam;  /* Store previous lParam */
912             *plparam = (LPARAM)ptr;
913           }
914         }
915         return 1;
916
917 /* Combobox */
918     case CB_ADDSTRING:
919     case CB_INSERTSTRING:
920     case CB_FINDSTRING:
921     case CB_FINDSTRINGEXACT:
922     case CB_SELECTSTRING:
923         if(!*plparam) return 0;
924         if ( WINPROC_TestCBForStr( hwnd ))
925           *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
926         return (*plparam ? 1 : -1);
927
928     case CB_GETLBTEXT:          /* FIXME: fixed sized buffer */
929         { if ( WINPROC_TestCBForStr( hwnd ))
930           { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 + sizeof(LPARAM) );
931             if (!ptr) return -1;
932             *ptr++ = *plparam;  /* Store previous lParam */
933             *plparam = (LPARAM)ptr;
934           }
935         }
936         return 1;
937
938 /* Multiline edit */
939     case EM_GETLINE:
940         { WORD len = (WORD)*plparam;
941           LPARAM *ptr = (LPARAM *) HeapAlloc( GetProcessHeap(), 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(CHAR) );
942           if (!ptr) return -1;
943           *ptr++ = *plparam;  /* Store previous lParam */
944           *((WORD *) ptr) = len;   /* Store the length */
945           *plparam = (LPARAM)ptr;
946         }
947         return 1;
948
949     case WM_CHARTOITEM:
950     case WM_MENUCHAR:
951     case WM_CHAR:
952     case WM_DEADCHAR:
953     case WM_SYSCHAR:
954     case WM_SYSDEADCHAR:
955     case EM_SETPASSWORDCHAR:
956         {
957             WCHAR wch = LOWORD(*pwparam);
958             BYTE ch;
959             WideCharToMultiByte( CP_ACP, 0, &wch, 1, &ch, 1, NULL, NULL );
960             *pwparam = MAKEWPARAM( ch, HIWORD(*pwparam) );
961         }
962         return 0;
963
964     case WM_PAINTCLIPBOARD:
965     case WM_SIZECLIPBOARD:
966         FIXME_(msg)("message %s (%04x) needs translation, please report\n",SPY_GetMsgName(msg, hwnd),msg );
967         return -1;
968     default:  /* No translation needed */
969         return 0;
970     }
971 }
972
973
974 /**********************************************************************
975  *           WINPROC_UnmapMsg32WTo32A
976  *
977  * Unmap a message that was mapped from Unicode to Ansi.
978  */
979 void WINPROC_UnmapMsg32WTo32A( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
980 {
981     switch(msg)
982     {
983     case WM_GETTEXT:
984     case WM_ASKCBFORMATNAME:
985         {
986             LPARAM *ptr = (LPARAM *)lParam - 1;
987             if (wParam)
988             {
989                 if (!MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, (LPWSTR)*ptr, wParam ))
990                     ((LPWSTR)*ptr)[wParam-1] = 0;
991             }
992             HeapFree( GetProcessHeap(), 0, ptr );
993         }
994         break;
995
996     case WM_SETTEXT:
997     case WM_WININICHANGE:
998     case WM_DEVMODECHANGE:
999     case CB_DIR:
1000     case LB_DIR:
1001     case LB_ADDFILE:
1002     case EM_REPLACESEL:
1003         HeapFree( GetProcessHeap(), 0, (void *)lParam );
1004         break;
1005
1006     case WM_NCCREATE:
1007     case WM_CREATE:
1008         {
1009             CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
1010             if (HIWORD(cs->lpszName))
1011                 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszName );
1012             if (HIWORD(cs->lpszClass))
1013                 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszClass );
1014             HeapFree( GetProcessHeap(), 0, cs );
1015         }
1016         break;
1017
1018     case WM_MDICREATE:
1019         {
1020             MDICREATESTRUCTA *cs = (MDICREATESTRUCTA *)lParam;
1021             if (HIWORD(cs->szTitle))
1022                 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szTitle );
1023             if (HIWORD(cs->szClass))
1024                 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szClass );
1025             HeapFree( GetProcessHeap(), 0, cs );
1026         }
1027         break;
1028
1029 /* Listbox */
1030     case LB_ADDSTRING:
1031     case LB_INSERTSTRING:
1032     case LB_FINDSTRING:
1033     case LB_FINDSTRINGEXACT:
1034     case LB_SELECTSTRING:
1035         if ( WINPROC_TestLBForStr( hwnd ))
1036           HeapFree( GetProcessHeap(), 0, (void *)lParam );
1037         break;
1038
1039     case LB_GETTEXT:
1040         if ( WINPROC_TestLBForStr( hwnd ))
1041         {
1042             LPARAM *ptr = (LPARAM *)lParam - 1;
1043             MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, (LPWSTR)*ptr, 0x7fffffff );
1044             HeapFree( GetProcessHeap(), 0, ptr );
1045         }
1046         break;
1047
1048 /* Combobox */
1049     case CB_ADDSTRING:
1050     case CB_INSERTSTRING:
1051     case CB_FINDSTRING:
1052     case CB_FINDSTRINGEXACT:
1053     case CB_SELECTSTRING:
1054         if ( WINPROC_TestCBForStr( hwnd ))
1055           HeapFree( GetProcessHeap(), 0, (void *)lParam );
1056         break;
1057
1058     case CB_GETLBTEXT:
1059         if ( WINPROC_TestCBForStr( hwnd ))
1060         {
1061             LPARAM *ptr = (LPARAM *)lParam - 1;
1062             MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, (LPWSTR)*ptr, 0x7fffffff );
1063             HeapFree( GetProcessHeap(), 0, ptr );
1064         }
1065         break;
1066
1067 /* Multiline edit */
1068     case EM_GETLINE:
1069         { LPARAM * ptr = (LPARAM *)lParam - 1;  /* get the old lparam */
1070           WORD len = *(WORD *)ptr;
1071           if (len)
1072           {
1073               if (!MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, (LPWSTR)*ptr, len ))
1074                   ((LPWSTR)*ptr)[len-1] = 0;
1075           }
1076           HeapFree( GetProcessHeap(), 0, ptr );
1077         }
1078         break;
1079     }
1080 }
1081
1082 static HANDLE convert_handle_16_to_32(HANDLE16 src, unsigned int flags)
1083 {
1084     HANDLE      dst;
1085     UINT        sz = GlobalSize16(src);
1086     LPSTR       ptr16, ptr32;
1087
1088     if (!(dst = GlobalAlloc(flags, sz)))
1089         return 0;
1090     ptr16 = GlobalLock16(src);
1091     ptr32 = GlobalLock(dst);
1092     if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr32, ptr16, sz);
1093     GlobalUnlock16(src);
1094     GlobalUnlock(dst);
1095
1096     return dst;
1097 }
1098
1099 /**********************************************************************
1100  *           WINPROC_MapMsg16To32A
1101  *
1102  * Map a message from 16- to 32-bit Ansi.
1103  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1104  */
1105 INT WINPROC_MapMsg16To32A( HWND hwnd, UINT16 msg16, WPARAM16 wParam16, UINT *pmsg32,
1106                              WPARAM *pwparam32, LPARAM *plparam )
1107 {
1108     *pmsg32 = (UINT)msg16;
1109     *pwparam32 = (WPARAM)wParam16;
1110     switch(msg16)
1111     {
1112     case WM_ACTIVATE:
1113     case WM_CHARTOITEM:
1114     case WM_COMMAND:
1115     case WM_VKEYTOITEM:
1116         *pwparam32 = MAKEWPARAM( wParam16, HIWORD(*plparam) );
1117         *plparam   = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1118         return 0;
1119     case WM_HSCROLL:
1120     case WM_VSCROLL:
1121         *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
1122         *plparam   = (LPARAM)WIN_Handle32( HIWORD(*plparam) );
1123         return 0;
1124     case WM_CTLCOLOR:
1125         if ( HIWORD(*plparam) > CTLCOLOR_STATIC ) return -1;
1126         *pmsg32    = WM_CTLCOLORMSGBOX + HIWORD(*plparam);
1127         *pwparam32 = (WPARAM)HDC_32(wParam16);
1128         *plparam   = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1129         return 0;
1130     case WM_COMPAREITEM:
1131         {
1132             COMPAREITEMSTRUCT16* cis16 = MapSL(*plparam);
1133             COMPAREITEMSTRUCT *cis = (COMPAREITEMSTRUCT *)
1134                                         HeapAlloc(GetProcessHeap(), 0, sizeof(*cis));
1135             if (!cis) return -1;
1136             cis->CtlType    = cis16->CtlType;
1137             cis->CtlID      = cis16->CtlID;
1138             cis->hwndItem   = WIN_Handle32( cis16->hwndItem );
1139             cis->itemID1    = cis16->itemID1;
1140             cis->itemData1  = cis16->itemData1;
1141             cis->itemID2    = cis16->itemID2;
1142             cis->itemData2  = cis16->itemData2;
1143             cis->dwLocaleId = 0;  /* FIXME */
1144             *plparam = (LPARAM)cis;
1145         }
1146         return 1;
1147     case WM_DELETEITEM:
1148         {
1149             DELETEITEMSTRUCT16* dis16 = MapSL(*plparam);
1150             DELETEITEMSTRUCT *dis = (DELETEITEMSTRUCT *)
1151                                         HeapAlloc(GetProcessHeap(), 0, sizeof(*dis));
1152             if (!dis) return -1;
1153             dis->CtlType  = dis16->CtlType;
1154             dis->CtlID    = dis16->CtlID;
1155             dis->hwndItem = WIN_Handle32( dis16->hwndItem );
1156             dis->itemData = dis16->itemData;
1157             *plparam = (LPARAM)dis;
1158         }
1159         return 1;
1160     case WM_MEASUREITEM:
1161         {
1162             MEASUREITEMSTRUCT16* mis16 = MapSL(*plparam);
1163             MEASUREITEMSTRUCT *mis = (MEASUREITEMSTRUCT *)
1164                                         HeapAlloc(GetProcessHeap(), 0,
1165                                                 sizeof(*mis) + sizeof(LPARAM));
1166             if (!mis) return -1;
1167             mis->CtlType    = mis16->CtlType;
1168             mis->CtlID      = mis16->CtlID;
1169             mis->itemID     = mis16->itemID;
1170             mis->itemWidth  = mis16->itemWidth;
1171             mis->itemHeight = mis16->itemHeight;
1172             mis->itemData   = mis16->itemData;
1173             *(LPARAM *)(mis + 1) = *plparam;  /* Store the previous lParam */
1174             *plparam = (LPARAM)mis;
1175         }
1176         return 1;
1177     case WM_DRAWITEM:
1178         {
1179             DRAWITEMSTRUCT16* dis16 = MapSL(*plparam);
1180             DRAWITEMSTRUCT *dis = (DRAWITEMSTRUCT*)HeapAlloc(GetProcessHeap(), 0,
1181                                                                  sizeof(*dis));
1182             if (!dis) return -1;
1183             dis->CtlType    = dis16->CtlType;
1184             dis->CtlID      = dis16->CtlID;
1185             dis->itemID     = dis16->itemID;
1186             dis->itemAction = dis16->itemAction;
1187             dis->itemState  = dis16->itemState;
1188             dis->hwndItem   = (dis->CtlType == ODT_MENU) ? (HWND)HMENU_32(dis16->hwndItem)
1189                                                          : WIN_Handle32( dis16->hwndItem );
1190             dis->hDC        = dis16->hDC;
1191             dis->itemData   = dis16->itemData;
1192             CONV_RECT16TO32( &dis16->rcItem, &dis->rcItem );
1193             *plparam = (LPARAM)dis;
1194         }
1195         return 1;
1196     case WM_GETMINMAXINFO:
1197         {
1198             MINMAXINFO *mmi = (MINMAXINFO *)HeapAlloc( GetProcessHeap(), 0,
1199                                                 sizeof(*mmi) + sizeof(LPARAM));
1200             if (!mmi) return -1;
1201             STRUCT32_MINMAXINFO16to32( MapSL(*plparam), mmi );
1202             *(LPARAM *)(mmi + 1) = *plparam;  /* Store the previous lParam */
1203             *plparam = (LPARAM)mmi;
1204         }
1205         return 1;
1206     case WM_GETTEXT:
1207     case WM_SETTEXT:
1208     case WM_WININICHANGE:
1209     case WM_DEVMODECHANGE:
1210     case WM_ASKCBFORMATNAME:
1211         *plparam = (LPARAM)MapSL(*plparam);
1212         return 0;
1213     case WM_MDICREATE:
1214         {
1215             MDICREATESTRUCT16 *cs16 = MapSL(*plparam);
1216             MDICREATESTRUCTA *cs = HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) + sizeof(LPARAM) );
1217             if (!cs) return -1;
1218             STRUCT32_MDICREATESTRUCT16to32A( cs16, cs );
1219             cs->szTitle = MapSL(cs16->szTitle);
1220             cs->szClass = MapSL(cs16->szClass);
1221             *(LPARAM *)(cs + 1) = *plparam;  /* Store the previous lParam */
1222             *plparam = (LPARAM)cs;
1223         }
1224         return 1;
1225     case WM_MDIGETACTIVE:
1226         *plparam = (LPARAM)HeapAlloc( GetProcessHeap(), 0, sizeof(BOOL) );
1227         *(BOOL*)(*plparam) = 0;
1228         return 1;
1229     case WM_MDISETMENU:
1230         if(wParam16==TRUE)
1231            *pmsg32=WM_MDIREFRESHMENU;
1232         *pwparam32 = (WPARAM)HMENU_32(LOWORD(*plparam));
1233         *plparam   = (LPARAM)HMENU_32(HIWORD(*plparam));
1234         return 0;
1235     case WM_MENUCHAR:
1236         *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
1237         *plparam   = (LPARAM)HMENU_32(HIWORD(*plparam));
1238         return 0;
1239     case WM_MENUSELECT:
1240         if((LOWORD(*plparam) & MF_POPUP) && (LOWORD(*plparam) != 0xFFFF))
1241         {
1242             HMENU hmenu=HMENU_32(HIWORD(*plparam));
1243             UINT Pos=MENU_FindSubMenu( &hmenu, wParam16);
1244             if(Pos==0xFFFF) Pos=0; /* NO_SELECTED_ITEM */
1245             *pwparam32 = MAKEWPARAM( Pos, LOWORD(*plparam) );
1246         }
1247         else *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
1248         *plparam   = (LPARAM)HMENU_32(HIWORD(*plparam));
1249         return 0;
1250     case WM_MDIACTIVATE:
1251         if( *plparam )
1252         {
1253             *pwparam32 = (WPARAM)WIN_Handle32( HIWORD(*plparam) );
1254             *plparam   = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1255         }
1256         else /* message sent to MDI client */
1257             *pwparam32 = wParam16;
1258         return 0;
1259     case WM_NCCALCSIZE:
1260         {
1261             NCCALCSIZE_PARAMS16 *nc16;
1262             NCCALCSIZE_PARAMS *nc;
1263
1264             nc = (NCCALCSIZE_PARAMS *)HeapAlloc( GetProcessHeap(), 0,
1265                                                 sizeof(*nc) + sizeof(LPARAM) );
1266             if (!nc) return -1;
1267             nc16 = MapSL(*plparam);
1268             CONV_RECT16TO32( &nc16->rgrc[0], &nc->rgrc[0] );
1269             if (wParam16)
1270             {
1271                 nc->lppos = (WINDOWPOS *)HeapAlloc( GetProcessHeap(), 0,
1272                                                       sizeof(*nc->lppos) );
1273                 CONV_RECT16TO32( &nc16->rgrc[1], &nc->rgrc[1] );
1274                 CONV_RECT16TO32( &nc16->rgrc[2], &nc->rgrc[2] );
1275                 if (nc->lppos) STRUCT32_WINDOWPOS16to32( MapSL(nc16->lppos), nc->lppos );
1276             }
1277             *(LPARAM *)(nc + 1) = *plparam;  /* Store the previous lParam */
1278             *plparam = (LPARAM)nc;
1279         }
1280         return 1;
1281     case WM_NCCREATE:
1282     case WM_CREATE:
1283         {
1284             CREATESTRUCT16 *cs16 = MapSL(*plparam);
1285             CREATESTRUCTA *cs = (CREATESTRUCTA *)HeapAlloc( GetProcessHeap(), 0,
1286                                                 sizeof(*cs) + sizeof(LPARAM) );
1287             if (!cs) return -1;
1288             STRUCT32_CREATESTRUCT16to32A( cs16, cs );
1289             cs->lpszName  = MapSL(cs16->lpszName);
1290             cs->lpszClass = MapSL(cs16->lpszClass);
1291             *(LPARAM *)(cs + 1) = *plparam;  /* Store the previous lParam */
1292             *plparam = (LPARAM)cs;
1293         }
1294         return 1;
1295     case WM_PARENTNOTIFY:
1296         if ((wParam16 == WM_CREATE) || (wParam16 == WM_DESTROY))
1297         {
1298             *pwparam32 = MAKEWPARAM( wParam16, HIWORD(*plparam) );
1299             *plparam   = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1300         }
1301         return 0;
1302     case WM_WINDOWPOSCHANGING:
1303     case WM_WINDOWPOSCHANGED:
1304         {
1305             WINDOWPOS *wp = (WINDOWPOS *)HeapAlloc( GetProcessHeap(), 0,
1306                                                 sizeof(*wp) + sizeof(LPARAM) );
1307             if (!wp) return -1;
1308             STRUCT32_WINDOWPOS16to32( MapSL(*plparam), wp );
1309             *(LPARAM *)(wp + 1) = *plparam;  /* Store the previous lParam */
1310             *plparam = (LPARAM)wp;
1311         }
1312         return 1;
1313     case WM_GETDLGCODE:
1314         if (*plparam)
1315         {
1316             LPMSG16 msg16 = MapSL(*plparam);
1317             LPMSG msg32 = (LPMSG)HeapAlloc( GetProcessHeap(), 0, sizeof(MSG) );
1318
1319             if (!msg32) return -1;
1320             msg32->hwnd = WIN_Handle32( msg16->hwnd );
1321             msg32->lParam = msg16->lParam;
1322             msg32->time = msg16->time;
1323             CONV_POINT16TO32(&msg16->pt,&msg32->pt);
1324             /* this is right, right? */
1325             if (WINPROC_MapMsg16To32A( msg32->hwnd, msg16->message,msg16->wParam,
1326                                      &msg32->message,&msg32->wParam,
1327                                      &msg32->lParam)<0) {
1328                 HeapFree( GetProcessHeap(), 0, msg32 );
1329                 return -1;
1330             }
1331             *plparam = (LPARAM)msg32;
1332             return 1;
1333         }
1334         else return 0;
1335     case WM_NOTIFY:
1336         *plparam = (LPARAM)MapSL(*plparam);
1337         return 0;
1338     case WM_ACTIVATEAPP:
1339         /* We need this when SetActiveWindow sends a Sendmessage16() to
1340          * a 32bit window. Might be superflous with 32bit interprocess
1341          * message queues. */
1342         if (*plparam) *plparam = HTASK_32( *plparam );
1343         return 0;
1344     case WM_NEXTMENU:
1345         {
1346             MDINEXTMENU *next = HeapAlloc( GetProcessHeap(), 0, sizeof(*next) );
1347             if (!next) return -1;
1348             next->hmenuIn = *plparam;
1349             next->hmenuNext = 0;
1350             next->hwndNext = 0;
1351             *plparam = (LPARAM)next;
1352             return 1;
1353         }
1354     case WM_PAINTCLIPBOARD:
1355     case WM_SIZECLIPBOARD:
1356         FIXME_(msg)("message %04x needs translation\n",msg16 );
1357         return -1;
1358     case WM_DDE_INITIATE:
1359     case WM_DDE_TERMINATE:
1360     case WM_DDE_UNADVISE:
1361     case WM_DDE_REQUEST:
1362         *pwparam32 = (WPARAM)WIN_Handle32(wParam16);
1363         return 0;
1364     case WM_DDE_ADVISE:
1365     case WM_DDE_DATA:
1366     case WM_DDE_POKE:
1367         {
1368             HANDLE16    lo16;
1369             ATOM        hi;
1370             HANDLE      lo32 = 0;
1371
1372             *pwparam32 = (WPARAM)WIN_Handle32(wParam16);
1373             lo16 = LOWORD(*plparam);
1374             hi = HIWORD(*plparam);
1375             if (lo16 && !(lo32 = convert_handle_16_to_32(lo16, GMEM_DDESHARE)))
1376                 return -1;
1377             *plparam = PackDDElParam(msg16, lo32, hi);
1378         }
1379         return 0; /* FIXME don't know how to free allocated memory (handle)  !! */
1380     case WM_DDE_ACK:
1381         {
1382             UINT        lo, hi;
1383             int         flag = 0;
1384             char        buf[2];
1385
1386             *pwparam32 = (WPARAM)WIN_Handle32(wParam16);
1387
1388             lo = LOWORD(*plparam);
1389             hi = HIWORD(*plparam);
1390
1391             if (GlobalGetAtomNameA(hi, buf, 2) > 0) flag |= 1;
1392             if (GlobalSize16(hi) != 0) flag |= 2;
1393             switch (flag)
1394             {
1395             case 0:
1396                 if (hi)
1397                 {
1398                     MESSAGE("DDE_ACK: neither atom nor handle!!!\n");
1399                     hi = 0;
1400                 }
1401                 break;
1402             case 1:
1403                 break; /* atom, nothing to do */
1404             case 3:
1405                 MESSAGE("DDE_ACK: %x both atom and handle... choosing handle\n", hi);
1406                 /* fall thru */
1407             case 2:
1408                 hi = convert_handle_16_to_32(hi, GMEM_DDESHARE);
1409                 break;
1410             }
1411             *plparam = PackDDElParam(WM_DDE_ACK, lo, hi);
1412         }
1413         return 0; /* FIXME don't know how to free allocated memory (handle) !! */
1414     case WM_DDE_EXECUTE:
1415         *plparam = convert_handle_16_to_32(*plparam, GMEM_DDESHARE);
1416         return 0; /* FIXME don't know how to free allocated memory (handle) !! */
1417     default:  /* No translation needed */
1418         return 0;
1419     }
1420 }
1421
1422
1423 /**********************************************************************
1424  *           WINPROC_UnmapMsg16To32A
1425  *
1426  * Unmap a message that was mapped from 16- to 32-bit Ansi.
1427  */
1428 LRESULT WINPROC_UnmapMsg16To32A( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
1429                                  LRESULT result )
1430 {
1431     switch(msg)
1432     {
1433     case WM_COMPAREITEM:
1434     case WM_DELETEITEM:
1435     case WM_DRAWITEM:
1436         HeapFree( GetProcessHeap(), 0, (LPVOID)lParam );
1437         break;
1438     case WM_MEASUREITEM:
1439         {
1440             MEASUREITEMSTRUCT16 *mis16;
1441             MEASUREITEMSTRUCT *mis = (MEASUREITEMSTRUCT *)lParam;
1442             lParam = *(LPARAM *)(mis + 1);
1443             mis16 = MapSL(lParam);
1444             mis16->itemWidth  = (UINT16)mis->itemWidth;
1445             mis16->itemHeight = (UINT16)mis->itemHeight;
1446             HeapFree( GetProcessHeap(), 0, mis );
1447         }
1448         break;
1449     case WM_GETMINMAXINFO:
1450         {
1451             MINMAXINFO *mmi = (MINMAXINFO *)lParam;
1452             lParam = *(LPARAM *)(mmi + 1);
1453             STRUCT32_MINMAXINFO32to16( mmi, MapSL(lParam));
1454             HeapFree( GetProcessHeap(), 0, mmi );
1455         }
1456         break;
1457     case WM_MDICREATE:
1458         {
1459             MDICREATESTRUCTA *cs = (MDICREATESTRUCTA *)lParam;
1460             lParam = *(LPARAM *)(cs + 1);
1461             STRUCT32_MDICREATESTRUCT32Ato16( cs, MapSL(lParam) );
1462             HeapFree( GetProcessHeap(), 0, cs );
1463         }
1464         break;
1465     case WM_MDIGETACTIVE:
1466         result = MAKELONG( LOWORD(result), (BOOL16)(*(BOOL *)lParam) );
1467         HeapFree( GetProcessHeap(), 0, (BOOL *)lParam );
1468         break;
1469     case WM_NCCALCSIZE:
1470         {
1471             NCCALCSIZE_PARAMS16 *nc16;
1472             NCCALCSIZE_PARAMS *nc = (NCCALCSIZE_PARAMS *)lParam;
1473             lParam = *(LPARAM *)(nc + 1);
1474             nc16 = MapSL(lParam);
1475             CONV_RECT32TO16( &nc->rgrc[0], &nc16->rgrc[0] );
1476             if (wParam)
1477             {
1478                 CONV_RECT32TO16( &nc->rgrc[1], &nc16->rgrc[1] );
1479                 CONV_RECT32TO16( &nc->rgrc[2], &nc16->rgrc[2] );
1480                 if (nc->lppos)
1481                 {
1482                     STRUCT32_WINDOWPOS32to16( nc->lppos, MapSL(nc16->lppos));
1483                     HeapFree( GetProcessHeap(), 0, nc->lppos );
1484                 }
1485             }
1486             HeapFree( GetProcessHeap(), 0, nc );
1487         }
1488         break;
1489     case WM_NCCREATE:
1490     case WM_CREATE:
1491         {
1492             CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
1493             lParam = *(LPARAM *)(cs + 1);
1494             STRUCT32_CREATESTRUCT32Ato16( cs, MapSL(lParam) );
1495             HeapFree( GetProcessHeap(), 0, cs );
1496         }
1497         break;
1498     case WM_WINDOWPOSCHANGING:
1499     case WM_WINDOWPOSCHANGED:
1500         {
1501             WINDOWPOS *wp = (WINDOWPOS *)lParam;
1502             lParam = *(LPARAM *)(wp + 1);
1503             STRUCT32_WINDOWPOS32to16(wp, MapSL(lParam));
1504             HeapFree( GetProcessHeap(), 0, wp );
1505         }
1506         break;
1507     case WM_GETDLGCODE:
1508         if (lParam)
1509         {
1510             LPMSG msg32 = (LPMSG)lParam;
1511
1512             WINPROC_UnmapMsg16To32A( hwnd, msg32->message, msg32->wParam, msg32->lParam,
1513                                      result);
1514             HeapFree( GetProcessHeap(), 0, msg32 );
1515         }
1516         break;
1517     case WM_NEXTMENU:
1518         {
1519             MDINEXTMENU *next = (MDINEXTMENU *)lParam;
1520             result = MAKELONG( HMENU_16(next->hmenuNext), HWND_16(next->hwndNext) );
1521             HeapFree( GetProcessHeap(), 0, next );
1522         }
1523         break;
1524     }
1525     return result;
1526 }
1527
1528
1529 /**********************************************************************
1530  *           WINPROC_MapMsg16To32W
1531  *
1532  * Map a message from 16- to 32-bit Unicode.
1533  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1534  */
1535 INT WINPROC_MapMsg16To32W( HWND hwnd, UINT16 msg16, WPARAM16 wParam16, UINT *pmsg32,
1536                            WPARAM *pwparam32, LPARAM *plparam )
1537 {
1538     BYTE ch;
1539     WCHAR wch;
1540
1541     *pmsg32=(UINT)msg16;
1542     *pwparam32 = (WPARAM)wParam16;
1543     switch(msg16)
1544     {
1545     case WM_GETTEXT:
1546     case WM_SETTEXT:
1547     case WM_WININICHANGE:
1548     case WM_DEVMODECHANGE:
1549     case WM_ASKCBFORMATNAME:
1550         *plparam = (LPARAM)MapSL(*plparam);
1551         return WINPROC_MapMsg32ATo32W( hwnd, *pmsg32, pwparam32, plparam );
1552     case WM_GETTEXTLENGTH:
1553     case CB_GETLBTEXTLEN:
1554     case LB_GETTEXTLEN:
1555         return 1;  /* need to map result */
1556     case WM_NCCREATE:
1557     case WM_CREATE:
1558         {
1559             CREATESTRUCT16 *cs16 = MapSL(*plparam);
1560             CREATESTRUCTW *cs = (CREATESTRUCTW *)HeapAlloc( GetProcessHeap(), 0,
1561                                                 sizeof(*cs) + sizeof(LPARAM) );
1562             if (!cs) return -1;
1563             STRUCT32_CREATESTRUCT16to32A( cs16, (CREATESTRUCTA *)cs );
1564             cs->lpszName  = map_str_16_to_32W(cs16->lpszName);
1565             cs->lpszClass = map_str_16_to_32W(cs16->lpszClass);
1566             *(LPARAM *)(cs + 1) = *plparam;  /* Store the previous lParam */
1567             *plparam = (LPARAM)cs;
1568         }
1569         return 1;
1570     case WM_MDICREATE:
1571         {
1572             MDICREATESTRUCT16 *cs16 = MapSL(*plparam);
1573             MDICREATESTRUCTW *cs =
1574                 (MDICREATESTRUCTW *)HeapAlloc( GetProcessHeap(), 0,
1575                                                 sizeof(*cs) + sizeof(LPARAM) );
1576             if (!cs) return -1;
1577             STRUCT32_MDICREATESTRUCT16to32A( cs16, (MDICREATESTRUCTA *)cs );
1578             cs->szTitle = map_str_16_to_32W(cs16->szTitle);
1579             cs->szClass = map_str_16_to_32W(cs16->szClass);
1580             *(LPARAM *)(cs + 1) = *plparam;  /* Store the previous lParam */
1581             *plparam = (LPARAM)cs;
1582         }
1583         return 1;
1584     case WM_GETDLGCODE:
1585         if (*plparam)
1586         {
1587             LPMSG16 msg16 = MapSL(*plparam);
1588             LPMSG msg32 = (LPMSG)HeapAlloc( GetProcessHeap(), 0, sizeof(MSG) );
1589
1590             if (!msg32) return -1;
1591             msg32->hwnd = WIN_Handle32( msg16->hwnd );
1592             msg32->lParam = msg16->lParam;
1593             msg32->time = msg16->time;
1594             CONV_POINT16TO32(&msg16->pt,&msg32->pt);
1595             /* this is right, right? */
1596             if (WINPROC_MapMsg16To32W(hwnd, msg16->message,msg16->wParam,
1597                                      &msg32->message,&msg32->wParam,
1598                                      &msg32->lParam)<0) {
1599                 HeapFree( GetProcessHeap(), 0, msg32 );
1600                 return -1;
1601             }
1602             *plparam = (LPARAM)msg32;
1603             return 1;
1604         }
1605         else return 0;
1606
1607     case WM_CHARTOITEM:
1608         ch = wParam16;
1609         MultiByteToWideChar( CP_ACP, 0, &ch, 1, &wch, 1);
1610         *pwparam32 = MAKEWPARAM( wch, HIWORD(*plparam) );
1611         *plparam   = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1612         return 0;
1613     case WM_MENUCHAR:
1614         ch = wParam16;
1615         MultiByteToWideChar( CP_ACP, 0, &ch, 1, &wch, 1);
1616         *pwparam32 = MAKEWPARAM( wch, LOWORD(*plparam) );
1617         *plparam   = (LPARAM)HMENU_32(HIWORD(*plparam));
1618         return 0;
1619     case WM_CHAR:
1620     case WM_DEADCHAR:
1621     case WM_SYSCHAR:
1622     case WM_SYSDEADCHAR:
1623         ch = wParam16;
1624         MultiByteToWideChar( CP_ACP, 0, &ch, 1, &wch, 1);
1625         *pwparam32 = wch;
1626         return 0;
1627
1628     default:  /* No Unicode translation needed */
1629         return WINPROC_MapMsg16To32A( hwnd, msg16, wParam16, pmsg32,
1630                                       pwparam32, plparam );
1631     }
1632 }
1633
1634
1635 /**********************************************************************
1636  *           WINPROC_UnmapMsg16To32W
1637  *
1638  * Unmap a message that was mapped from 16- to 32-bit Unicode.
1639  */
1640 LRESULT WINPROC_UnmapMsg16To32W( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
1641                                  LRESULT result )
1642 {
1643     switch(msg)
1644     {
1645     case WM_GETTEXT:
1646     case WM_SETTEXT:
1647     case WM_GETTEXTLENGTH:
1648     case CB_GETLBTEXTLEN:
1649     case LB_GETTEXTLEN:
1650     case WM_ASKCBFORMATNAME:
1651         return WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam, result );
1652     case WM_NCCREATE:
1653     case WM_CREATE:
1654         {
1655             CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam;
1656             lParam = *(LPARAM *)(cs + 1);
1657             STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCTA *)cs, MapSL(lParam) );
1658             unmap_str_16_to_32W( cs->lpszName );
1659             unmap_str_16_to_32W( cs->lpszClass );
1660             HeapFree( GetProcessHeap(), 0, cs );
1661         }
1662         break;
1663     case WM_MDICREATE:
1664         {
1665             MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lParam;
1666             lParam = *(LPARAM *)(cs + 1);
1667             STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCTA *)cs, MapSL(lParam) );
1668             unmap_str_16_to_32W( cs->szTitle );
1669             unmap_str_16_to_32W( cs->szClass );
1670             HeapFree( GetProcessHeap(), 0, cs );
1671         }
1672         break;
1673     case WM_GETDLGCODE:
1674         if (lParam)
1675         {
1676             LPMSG msg32 = (LPMSG)lParam;
1677
1678             WINPROC_UnmapMsg16To32W( hwnd, msg32->message, msg32->wParam, msg32->lParam,
1679                                      result);
1680             HeapFree( GetProcessHeap(), 0, msg32 );
1681         }
1682         break;
1683     default:
1684         return WINPROC_UnmapMsg16To32A( hwnd, msg, wParam, lParam, result );
1685     }
1686     return result;
1687 }
1688
1689 static HANDLE16 convert_handle_32_to_16(HANDLE src, unsigned int flags)
1690 {
1691     HANDLE16    dst;
1692     UINT        sz = GlobalSize(src);
1693     LPSTR       ptr16, ptr32;
1694
1695     if (!(dst = GlobalAlloc16(flags, sz)))
1696         return 0;
1697     ptr32 = GlobalLock(src);
1698     ptr16 = GlobalLock16(dst);
1699     if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr16, ptr32, sz);
1700     GlobalUnlock(src);
1701     GlobalUnlock16(dst);
1702
1703     return dst;
1704 }
1705
1706
1707 /**********************************************************************
1708  *           WINPROC_MapMsg32ATo16
1709  *
1710  * Map a message from 32-bit Ansi to 16-bit.
1711  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1712  */
1713 INT WINPROC_MapMsg32ATo16( HWND hwnd, UINT msg32, WPARAM wParam32,
1714                              UINT16 *pmsg16, WPARAM16 *pwparam16,
1715                              LPARAM *plparam )
1716 {
1717     *pmsg16 = (UINT16)msg32;
1718     *pwparam16 = (WPARAM16)LOWORD(wParam32);
1719     switch(msg32)
1720     {
1721     case BM_GETCHECK:
1722     case BM_SETCHECK:
1723     case BM_GETSTATE:
1724     case BM_SETSTATE:
1725     case BM_SETSTYLE:
1726         *pmsg16 = (UINT16)msg32 + (BM_GETCHECK16 - BM_GETCHECK);
1727         return 0;
1728
1729     case EM_GETSEL:
1730     case EM_GETRECT:
1731     case EM_SETRECT:
1732     case EM_SETRECTNP:
1733     case EM_SCROLL:
1734     case EM_LINESCROLL:
1735     case EM_SCROLLCARET:
1736     case EM_GETMODIFY:
1737     case EM_SETMODIFY:
1738     case EM_GETLINECOUNT:
1739     case EM_LINEINDEX:
1740     case EM_SETHANDLE:
1741     case EM_GETHANDLE:
1742     case EM_GETTHUMB:
1743     case EM_LINELENGTH:
1744     case EM_REPLACESEL:
1745     case EM_GETLINE:
1746     case EM_LIMITTEXT:
1747     case EM_CANUNDO:
1748     case EM_UNDO:
1749     case EM_FMTLINES:
1750     case EM_LINEFROMCHAR:
1751     case EM_SETTABSTOPS:
1752     case EM_SETPASSWORDCHAR:
1753     case EM_EMPTYUNDOBUFFER:
1754     case EM_GETFIRSTVISIBLELINE:
1755     case EM_SETREADONLY:
1756     case EM_SETWORDBREAKPROC:
1757     case EM_GETWORDBREAKPROC:
1758     case EM_GETPASSWORDCHAR:
1759         *pmsg16 = (UINT16)msg32 + (EM_GETSEL16 - EM_GETSEL);
1760         return 0;
1761
1762     case LB_CARETOFF:
1763     case LB_CARETON:
1764     case LB_DELETESTRING:
1765     case LB_GETANCHORINDEX:
1766     case LB_GETCARETINDEX:
1767     case LB_GETCOUNT:
1768     case LB_GETCURSEL:
1769     case LB_GETHORIZONTALEXTENT:
1770     case LB_GETITEMDATA:
1771     case LB_GETITEMHEIGHT:
1772     case LB_GETSEL:
1773     case LB_GETSELCOUNT:
1774     case LB_GETTEXTLEN:
1775     case LB_GETTOPINDEX:
1776     case LB_RESETCONTENT:
1777     case LB_SELITEMRANGE:
1778     case LB_SELITEMRANGEEX:
1779     case LB_SETANCHORINDEX:
1780     case LB_SETCARETINDEX:
1781     case LB_SETCOLUMNWIDTH:
1782     case LB_SETCURSEL:
1783     case LB_SETHORIZONTALEXTENT:
1784     case LB_SETITEMDATA:
1785     case LB_SETITEMHEIGHT:
1786     case LB_SETSEL:
1787     case LB_SETTOPINDEX:
1788         *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING);
1789         return 0;
1790     case CB_DELETESTRING:
1791     case CB_GETCOUNT:
1792     case CB_GETLBTEXTLEN:
1793     case CB_LIMITTEXT:
1794     case CB_RESETCONTENT:
1795     case CB_SETEDITSEL:
1796     case CB_GETCURSEL:
1797     case CB_SETCURSEL:
1798     case CB_SHOWDROPDOWN:
1799     case CB_SETITEMDATA:
1800     case CB_SETITEMHEIGHT:
1801     case CB_GETITEMHEIGHT:
1802     case CB_SETEXTENDEDUI:
1803     case CB_GETEXTENDEDUI:
1804     case CB_GETDROPPEDSTATE:
1805         *pmsg16 = (UINT16)msg32 + (CB_GETEDITSEL16 - CB_GETEDITSEL);
1806         return 0;
1807     case CB_GETEDITSEL:
1808         *pmsg16 = CB_GETEDITSEL16;
1809         return 1;
1810
1811     case LB_ADDSTRING:
1812     case LB_FINDSTRING:
1813     case LB_FINDSTRINGEXACT:
1814     case LB_INSERTSTRING:
1815     case LB_SELECTSTRING:
1816     case LB_DIR:
1817     case LB_ADDFILE:
1818         *plparam = (LPARAM)MapLS( (LPSTR)*plparam );
1819         *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING);
1820         return 1;
1821
1822     case CB_ADDSTRING:
1823     case CB_FINDSTRING:
1824     case CB_FINDSTRINGEXACT:
1825     case CB_INSERTSTRING:
1826     case CB_SELECTSTRING:
1827     case CB_DIR:
1828         *plparam = (LPARAM)MapLS( (LPSTR)*plparam );
1829         *pmsg16 = (UINT16)msg32 + (CB_GETEDITSEL16 - CB_GETEDITSEL);
1830         return 1;
1831
1832     case LB_GETITEMRECT:
1833         {
1834             RECT16 *rect = HeapAlloc( GetProcessHeap(), 0, sizeof(RECT16) + sizeof(LPARAM) );
1835             if (!rect) return -1;
1836             *(LPARAM *)(rect + 1) = *plparam;  /* Store the previous lParam */
1837             *plparam = MapLS( rect );
1838         }
1839         *pmsg16 = LB_GETITEMRECT16;
1840         return 1;
1841     case LB_GETSELITEMS:
1842         {
1843             LPINT16 items;
1844             *pwparam16 = (WPARAM16)min( wParam32, 0x7f80 ); /* Must be < 64K */
1845             if (!(items = HeapAlloc( GetProcessHeap(), 0,
1846                                      *pwparam16 * sizeof(INT16) + sizeof(LPARAM)))) return -1;
1847             *((LPARAM *)items)++ = *plparam;  /* Store the previous lParam */
1848             *plparam = MapLS( items );
1849         }
1850         *pmsg16 = LB_GETSELITEMS16;
1851         return 1;
1852     case LB_SETTABSTOPS:
1853         if (wParam32)
1854         {
1855             INT i;
1856             LPINT16 stops;
1857             *pwparam16 = (WPARAM16)min( wParam32, 0x7f80 ); /* Must be < 64K */
1858             if (!(stops = HeapAlloc( GetProcessHeap(), 0,
1859                                      *pwparam16 * sizeof(INT16) + sizeof(LPARAM)))) return -1;
1860             for (i = 0; i < *pwparam16; i++) stops[i] = *((LPINT)*plparam+i);
1861             *plparam = MapLS( stops );
1862             return 1;
1863         }
1864         *pmsg16 = LB_SETTABSTOPS16;
1865         return 0;
1866
1867     case CB_GETDROPPEDCONTROLRECT:
1868         {
1869             RECT16 *rect = HeapAlloc( GetProcessHeap(), 0, sizeof(RECT16) + sizeof(LPARAM) );
1870             if (!rect) return -1;
1871             *(LPARAM *)(rect + 1) = *plparam;  /* Store the previous lParam */
1872             *plparam = (LPARAM)MapLS(rect);
1873         }
1874         *pmsg16 = CB_GETDROPPEDCONTROLRECT16;
1875         return 1;
1876
1877     case LB_GETTEXT:
1878         *plparam = (LPARAM)MapLS( (LPVOID)(*plparam) );
1879         *pmsg16 = LB_GETTEXT16;
1880         return 1;
1881
1882     case CB_GETLBTEXT:
1883         *plparam = (LPARAM)MapLS( (LPVOID)(*plparam) );
1884         *pmsg16 = CB_GETLBTEXT16;
1885         return 1;
1886
1887     case EM_SETSEL:
1888         *pwparam16 = 0;
1889         *plparam = MAKELONG( (INT16)(INT)wParam32, (INT16)*plparam );
1890         *pmsg16 = EM_SETSEL16;
1891         return 0;
1892
1893     case WM_ACTIVATE:
1894     case WM_CHARTOITEM:
1895     case WM_COMMAND:
1896     case WM_VKEYTOITEM:
1897         *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32) );
1898         return 0;
1899     case WM_HSCROLL:
1900     case WM_VSCROLL:
1901         *plparam = MAKELPARAM( HIWORD(wParam32), (HWND16)*plparam );
1902         return 0;
1903     case WM_CTLCOLORMSGBOX:
1904     case WM_CTLCOLOREDIT:
1905     case WM_CTLCOLORLISTBOX:
1906     case WM_CTLCOLORBTN:
1907     case WM_CTLCOLORDLG:
1908     case WM_CTLCOLORSCROLLBAR:
1909     case WM_CTLCOLORSTATIC:
1910         *pmsg16  = WM_CTLCOLOR;
1911         *plparam = MAKELPARAM( (HWND16)*plparam,
1912                                (WORD)msg32 - WM_CTLCOLORMSGBOX );
1913         return 0;
1914     case WM_COMPAREITEM:
1915         {
1916             COMPAREITEMSTRUCT *cis32 = (COMPAREITEMSTRUCT *)*plparam;
1917             COMPAREITEMSTRUCT16 *cis = HeapAlloc( GetProcessHeap(), 0, sizeof(COMPAREITEMSTRUCT16));
1918             if (!cis) return -1;
1919             cis->CtlType    = (UINT16)cis32->CtlType;
1920             cis->CtlID      = (UINT16)cis32->CtlID;
1921             cis->hwndItem   = HWND_16( cis32->hwndItem );
1922             cis->itemID1    = (UINT16)cis32->itemID1;
1923             cis->itemData1  = cis32->itemData1;
1924             cis->itemID2    = (UINT16)cis32->itemID2;
1925             cis->itemData2  = cis32->itemData2;
1926             *plparam = MapLS( cis );
1927         }
1928         return 1;
1929     case WM_DELETEITEM:
1930         {
1931             DELETEITEMSTRUCT *dis32 = (DELETEITEMSTRUCT *)*plparam;
1932             DELETEITEMSTRUCT16 *dis = HeapAlloc( GetProcessHeap(), 0, sizeof(DELETEITEMSTRUCT16) );
1933             if (!dis) return -1;
1934             dis->CtlType  = (UINT16)dis32->CtlType;
1935             dis->CtlID    = (UINT16)dis32->CtlID;
1936             dis->itemID   = (UINT16)dis32->itemID;
1937             dis->hwndItem = (dis->CtlType == ODT_MENU) ? (HWND16)LOWORD(dis32->hwndItem)
1938                                                        : HWND_16( dis32->hwndItem );
1939             dis->itemData = dis32->itemData;
1940             *plparam = MapLS( dis );
1941         }
1942         return 1;
1943     case WM_DRAWITEM:
1944         {
1945             DRAWITEMSTRUCT *dis32 = (DRAWITEMSTRUCT *)*plparam;
1946             DRAWITEMSTRUCT16 *dis = HeapAlloc( GetProcessHeap(), 0, sizeof(DRAWITEMSTRUCT16) );
1947             if (!dis) return -1;
1948             dis->CtlType    = (UINT16)dis32->CtlType;
1949             dis->CtlID      = (UINT16)dis32->CtlID;
1950             dis->itemID     = (UINT16)dis32->itemID;
1951             dis->itemAction = (UINT16)dis32->itemAction;
1952             dis->itemState  = (UINT16)dis32->itemState;
1953             dis->hwndItem   = HWND_16( dis32->hwndItem );
1954             dis->hDC        = HDC_16(dis32->hDC);
1955             dis->itemData   = dis32->itemData;
1956             CONV_RECT32TO16( &dis32->rcItem, &dis->rcItem );
1957             *plparam = MapLS( dis );
1958         }
1959         return 1;
1960     case WM_MEASUREITEM:
1961         {
1962             MEASUREITEMSTRUCT *mis32 = (MEASUREITEMSTRUCT *)*plparam;
1963             MEASUREITEMSTRUCT16 *mis = HeapAlloc( GetProcessHeap(), 0, sizeof(*mis)+sizeof(LPARAM));
1964             if (!mis) return -1;
1965             mis->CtlType    = (UINT16)mis32->CtlType;
1966             mis->CtlID      = (UINT16)mis32->CtlID;
1967             mis->itemID     = (UINT16)mis32->itemID;
1968             mis->itemWidth  = (UINT16)mis32->itemWidth;
1969             mis->itemHeight = (UINT16)mis32->itemHeight;
1970             mis->itemData   = mis32->itemData;
1971             *(LPARAM *)(mis + 1) = *plparam;  /* Store the previous lParam */
1972             *plparam = MapLS( mis );
1973         }
1974         return 1;
1975     case WM_GETMINMAXINFO:
1976         {
1977             MINMAXINFO16 *mmi = HeapAlloc( GetProcessHeap(), 0, sizeof(*mmi) + sizeof(LPARAM) );
1978             if (!mmi) return -1;
1979             STRUCT32_MINMAXINFO32to16( (MINMAXINFO *)*plparam, mmi );
1980             *(LPARAM *)(mmi + 1) = *plparam;  /* Store the previous lParam */
1981             *plparam = MapLS( mmi );
1982         }
1983         return 1;
1984     case WM_GETTEXT:
1985     case WM_ASKCBFORMATNAME:
1986         {
1987             LPSTR str;
1988             *pwparam16 = (WPARAM16)min( wParam32, 0xff80 ); /* Must be < 64K */
1989             if (!(str = HeapAlloc( GetProcessHeap(), 0, *pwparam16 + sizeof(LPARAM)))) return -1;
1990             *((LPARAM *)str)++ = *plparam;  /* Store the previous lParam */
1991             *plparam = MapLS( str );
1992         }
1993         return 1;
1994     case WM_MDICREATE:
1995         {
1996             MDICREATESTRUCT16 *cs;
1997             MDICREATESTRUCTA *cs32 = (MDICREATESTRUCTA *)*plparam;
1998
1999             if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(MDICREATESTRUCT16) ))) return -1;
2000             STRUCT32_MDICREATESTRUCT32Ato16( cs32, cs );
2001             cs->szTitle = MapLS( cs32->szTitle );
2002             cs->szClass = MapLS( cs32->szClass );
2003             *plparam = MapLS( cs );
2004         }
2005         return 1;
2006     case WM_MDIGETACTIVE:
2007         return 1;
2008     case WM_MDISETMENU:
2009         *plparam   = MAKELPARAM( (HMENU16)LOWORD(wParam32),
2010                                  (HMENU16)LOWORD(*plparam) );
2011         *pwparam16 = (*plparam == 0);
2012         return 0;
2013     case WM_MENUSELECT:
2014         if(HIWORD(wParam32) & MF_POPUP)
2015         {
2016             UINT16 hmenu;
2017             if (((UINT)HIWORD(wParam32) != 0xFFFF) || (*plparam))
2018             {
2019                 if((hmenu = GetSubMenu((HMENU16)*plparam, *pwparam16)))
2020                     *pwparam16=hmenu;
2021             }
2022         }
2023         /* fall through */
2024     case WM_MENUCHAR:
2025         *plparam = MAKELPARAM( HIWORD(wParam32), (HMENU16)*plparam );
2026         return 0;
2027     case WM_MDIACTIVATE:
2028         if (GetWindowLongA( hwnd, GWL_EXSTYLE ) & WS_EX_MDICHILD)
2029         {
2030             *pwparam16 = ((HWND)*plparam == hwnd);
2031             *plparam = MAKELPARAM( (HWND16)LOWORD(*plparam),
2032                                    (HWND16)LOWORD(wParam32) );
2033         }
2034         else
2035         {
2036             *pwparam16 = HWND_16( (HWND)wParam32 );
2037             *plparam = 0;
2038         }
2039         return 0;
2040     case WM_NCCALCSIZE:
2041         {
2042             NCCALCSIZE_PARAMS *nc32 = (NCCALCSIZE_PARAMS *)*plparam;
2043             NCCALCSIZE_PARAMS16 *nc = HeapAlloc( GetProcessHeap(), 0, sizeof(*nc) + sizeof(LPARAM));
2044             if (!nc) return -1;
2045
2046             CONV_RECT32TO16( &nc32->rgrc[0], &nc->rgrc[0] );
2047             if (wParam32)
2048             {
2049                 WINDOWPOS16 *wp;
2050                 CONV_RECT32TO16( &nc32->rgrc[1], &nc->rgrc[1] );
2051                 CONV_RECT32TO16( &nc32->rgrc[2], &nc->rgrc[2] );
2052                 if (!(wp = HeapAlloc( GetProcessHeap(), 0, sizeof(WINDOWPOS16) )))
2053                 {
2054                     HeapFree( GetProcessHeap(), 0, nc );
2055                     return -1;
2056                 }
2057                 STRUCT32_WINDOWPOS32to16( nc32->lppos, wp );
2058                 nc->lppos = MapLS( wp );
2059             }
2060             *(LPARAM *)(nc + 1) = *plparam;  /* Store the previous lParam */
2061             *plparam = MapLS( nc );
2062         }
2063         return 1;
2064     case WM_NCCREATE:
2065     case WM_CREATE:
2066         {
2067             CREATESTRUCT16 *cs;
2068             CREATESTRUCTA *cs32 = (CREATESTRUCTA *)*plparam;
2069
2070             if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(CREATESTRUCT16) ))) return -1;
2071             STRUCT32_CREATESTRUCT32Ato16( cs32, cs );
2072             cs->lpszName  = MapLS( cs32->lpszName );
2073             cs->lpszClass = MapLS( cs32->lpszClass );
2074             *plparam = MapLS( cs );
2075         }
2076         return 1;
2077     case WM_PARENTNOTIFY:
2078         if ((LOWORD(wParam32)==WM_CREATE) || (LOWORD(wParam32)==WM_DESTROY))
2079             *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32));
2080         /* else nothing to do */
2081         return 0;
2082     case WM_NOTIFY:
2083         *plparam = MapLS( (NMHDR *)*plparam ); /* NMHDR is already 32-bit */
2084         return 1;
2085     case WM_SETTEXT:
2086     case WM_WININICHANGE:
2087     case WM_DEVMODECHANGE:
2088         *plparam = MapLS( (LPSTR)*plparam );
2089         return 1;
2090     case WM_WINDOWPOSCHANGING:
2091     case WM_WINDOWPOSCHANGED:
2092         {
2093             WINDOWPOS16 *wp = HeapAlloc( GetProcessHeap(), 0, sizeof(*wp) + sizeof(LPARAM) );
2094             if (!wp) return -1;
2095             STRUCT32_WINDOWPOS32to16( (WINDOWPOS *)*plparam, wp );
2096             *(LPARAM *)(wp + 1) = *plparam;  /* Store the previous lParam */
2097             *plparam = MapLS( wp );
2098         }
2099         return 1;
2100     case WM_GETDLGCODE:
2101          if (*plparam) {
2102             LPMSG msg32 = (LPMSG) *plparam;
2103             LPMSG16 msg16 = HeapAlloc( GetProcessHeap(), 0, sizeof(MSG16) );
2104
2105             if (!msg16) return -1;
2106             msg16->hwnd = HWND_16( msg32->hwnd );
2107             msg16->lParam = msg32->lParam;
2108             msg16->time = msg32->time;
2109             CONV_POINT32TO16(&msg32->pt,&msg16->pt);
2110             /* this is right, right? */
2111             if (WINPROC_MapMsg32ATo16(msg32->hwnd,msg32->message,msg32->wParam,
2112                          &msg16->message,&msg16->wParam, &msg16->lParam)<0)
2113             {
2114                 HeapFree( GetProcessHeap(), 0, msg16 );
2115                 return -1;
2116             }
2117             *plparam = MapLS( msg16 );
2118             return 1;
2119         }
2120         return 0;
2121
2122     case WM_ACTIVATEAPP:
2123         if (*plparam) *plparam = HTASK_16( (HANDLE)*plparam );
2124         return 0;
2125     case WM_NEXTMENU:
2126         {
2127             MDINEXTMENU *next = (MDINEXTMENU *)*plparam;
2128             *plparam = next->hmenuIn;
2129             return 1;
2130         }
2131     case WM_PAINTCLIPBOARD:
2132     case WM_SIZECLIPBOARD:
2133         FIXME_(msg)("message %04x needs translation\n", msg32 );
2134         return -1;
2135     /* following messages should not be sent to 16-bit apps */
2136     case WM_SIZING:
2137     case WM_MOVING:
2138     case WM_CAPTURECHANGED:
2139     case WM_STYLECHANGING:
2140     case WM_STYLECHANGED:
2141         return -1;
2142     case WM_DDE_INITIATE:
2143     case WM_DDE_TERMINATE:
2144     case WM_DDE_UNADVISE:
2145     case WM_DDE_REQUEST:
2146         *pwparam16 = HWND_16((HWND)wParam32);
2147         return 0;
2148     case WM_DDE_ADVISE:
2149     case WM_DDE_DATA:
2150     case WM_DDE_POKE:
2151         {
2152             unsigned    lo32, hi;
2153             HANDLE16    lo16 = 0;
2154
2155             *pwparam16 = HWND_16((HWND)wParam32);
2156             UnpackDDElParam(msg32, *plparam, &lo32, &hi);
2157             if (lo32 && !(lo16 = convert_handle_32_to_16(lo32, GMEM_DDESHARE)))
2158                 return -1;
2159             *plparam = MAKELPARAM(lo16, hi);
2160         }
2161         return 0; /* FIXME don't know how to free allocated memory (handle)  !! */
2162     case WM_DDE_ACK:
2163         {
2164             UINT        lo, hi;
2165             int         flag = 0;
2166             char        buf[2];
2167
2168             *pwparam16 = HWND_16((HWND)wParam32);
2169
2170             UnpackDDElParam(msg32, *plparam, &lo, &hi);
2171
2172             if (GlobalGetAtomNameA((ATOM)hi, buf, sizeof(buf)) > 0) flag |= 1;
2173             if (GlobalSize(hi) != 0) flag |= 2;
2174             switch (flag)
2175             {
2176             case 0:
2177                 if (hi)
2178                 {
2179                     MESSAGE("DDE_ACK: neither atom nor handle!!!\n");
2180                     hi = 0;
2181                 }
2182                 break;
2183             case 1:
2184                 break; /* atom, nothing to do */
2185             case 3:
2186                 MESSAGE("DDE_ACK: %x both atom and handle... choosing handle\n", hi);
2187                 /* fall thru */
2188             case 2:
2189                 hi = convert_handle_32_to_16(hi, GMEM_DDESHARE);
2190                 break;
2191             }
2192             *plparam = MAKELPARAM(lo, hi);
2193         }
2194         return 0; /* FIXME don't know how to free allocated memory (handle) !! */
2195     case WM_DDE_EXECUTE:
2196         *plparam = convert_handle_32_to_16(*plparam, GMEM_DDESHARE);
2197         return 0; /* FIXME don't know how to free allocated memory (handle) !! */
2198     default:  /* No translation needed */
2199         return 0;
2200     }
2201 }
2202
2203
2204 /**********************************************************************
2205  *           WINPROC_UnmapMsg32ATo16
2206  *
2207  * Unmap a message that was mapped from 32-bit Ansi to 16-bit.
2208  */
2209 void WINPROC_UnmapMsg32ATo16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
2210                               MSGPARAM16* p16 )
2211 {
2212     switch(msg)
2213     {
2214     case LB_ADDFILE:
2215     case LB_ADDSTRING:
2216     case LB_DIR:
2217     case LB_FINDSTRING:
2218     case LB_FINDSTRINGEXACT:
2219     case LB_INSERTSTRING:
2220     case LB_SELECTSTRING:
2221     case LB_GETTEXT:
2222     case CB_ADDSTRING:
2223     case CB_FINDSTRING:
2224     case CB_FINDSTRINGEXACT:
2225     case CB_INSERTSTRING:
2226     case CB_SELECTSTRING:
2227     case CB_DIR:
2228     case CB_GETLBTEXT:
2229     case WM_SETTEXT:
2230     case WM_WININICHANGE:
2231     case WM_DEVMODECHANGE:
2232         UnMapLS( (SEGPTR)p16->lParam );
2233         break;
2234     case LB_SETTABSTOPS:
2235     case WM_COMPAREITEM:
2236     case WM_DELETEITEM:
2237     case WM_DRAWITEM:
2238         {
2239             void *ptr = MapSL( p16->lParam );
2240             UnMapLS( p16->lParam );
2241             HeapFree( GetProcessHeap(), 0, ptr );
2242         }
2243         break;
2244     case CB_GETDROPPEDCONTROLRECT:
2245     case LB_GETITEMRECT:
2246         {
2247             RECT16 *rect = MapSL(p16->lParam);
2248             UnMapLS( p16->lParam );
2249             p16->lParam = *(LPARAM *)(rect + 1);
2250             CONV_RECT16TO32( rect, (RECT *)(p16->lParam));
2251             HeapFree( GetProcessHeap(), 0, rect );
2252         }
2253         break;
2254     case LB_GETSELITEMS:
2255         {
2256             INT i;
2257             LPINT16 items = MapSL(p16->lParam);
2258             UnMapLS( p16->lParam );
2259             p16->lParam = *((LPARAM *)items - 1);
2260             for (i = 0; i < p16->wParam; i++) *((LPINT)(p16->lParam) + i) = items[i];
2261             HeapFree( GetProcessHeap(), 0, (LPARAM *)items - 1 );
2262         }
2263         break;
2264
2265     case CB_GETEDITSEL:
2266         if( wParam )
2267             *((PUINT)(wParam)) = LOWORD(p16->lResult);
2268         if( lParam )
2269             *((PUINT)(lParam)) = HIWORD(p16->lResult);  /* FIXME: substract 1? */
2270         break;
2271
2272     case WM_MEASUREITEM:
2273         {
2274             MEASUREITEMSTRUCT16 *mis = MapSL(p16->lParam);
2275             MEASUREITEMSTRUCT *mis32 = *(MEASUREITEMSTRUCT **)(mis + 1);
2276             mis32->itemWidth  = mis->itemWidth;
2277             mis32->itemHeight = mis->itemHeight;
2278             UnMapLS( p16->lParam );
2279             HeapFree( GetProcessHeap(), 0, mis );
2280         }
2281         break;
2282     case WM_GETMINMAXINFO:
2283         {
2284             MINMAXINFO16 *mmi = MapSL(p16->lParam);
2285             UnMapLS( p16->lParam );
2286             p16->lParam = *(LPARAM *)(mmi + 1);
2287             STRUCT32_MINMAXINFO16to32( mmi, (MINMAXINFO *)(p16->lParam) );
2288             HeapFree( GetProcessHeap(), 0, mmi );
2289         }
2290         break;
2291     case WM_GETTEXT:
2292     case WM_ASKCBFORMATNAME:
2293         {
2294             LPSTR str = MapSL(p16->lParam);
2295             UnMapLS( p16->lParam );
2296             p16->lParam = *((LPARAM *)str - 1);
2297             lstrcpynA( (LPSTR)(p16->lParam), str, p16->wParam );
2298             HeapFree( GetProcessHeap(), 0, (LPARAM *)str - 1 );
2299         }
2300         break;
2301     case WM_MDICREATE:
2302         {
2303             MDICREATESTRUCT16 *cs = MapSL(p16->lParam);
2304             UnMapLS( cs->szTitle );
2305             UnMapLS( cs->szClass );
2306             UnMapLS( p16->lParam );
2307             HeapFree( GetProcessHeap(), 0, cs );
2308         }
2309         break;
2310     case WM_MDIGETACTIVE:
2311         if (lParam) *(BOOL *)lParam = (BOOL16)HIWORD(p16->lResult);
2312         p16->lResult = (LRESULT)WIN_Handle32( LOWORD(p16->lResult) );
2313         break;
2314     case WM_NCCALCSIZE:
2315         {
2316             NCCALCSIZE_PARAMS *nc32;
2317             NCCALCSIZE_PARAMS16 *nc = MapSL(p16->lParam);
2318             UnMapLS( p16->lParam );
2319             p16->lParam = *(LPARAM *)(nc + 1);
2320             nc32 = (NCCALCSIZE_PARAMS *)(p16->lParam);
2321             CONV_RECT16TO32( &nc->rgrc[0], &nc32->rgrc[0] );
2322             if (p16->wParam)
2323             {
2324                 WINDOWPOS16 *pos = MapSL(nc->lppos);
2325                 UnMapLS( nc->lppos );
2326                 CONV_RECT16TO32( &nc->rgrc[1], &nc32->rgrc[1] );
2327                 CONV_RECT16TO32( &nc->rgrc[2], &nc32->rgrc[2] );
2328                 STRUCT32_WINDOWPOS16to32( pos, nc32->lppos );
2329                 HeapFree( GetProcessHeap(), 0, pos );
2330             }
2331             HeapFree( GetProcessHeap(), 0, nc );
2332         }
2333         break;
2334     case WM_NCCREATE:
2335     case WM_CREATE:
2336         {
2337             CREATESTRUCT16 *cs = MapSL(p16->lParam);
2338             UnMapLS( p16->lParam );
2339             UnMapLS( cs->lpszName );
2340             UnMapLS( cs->lpszClass );
2341             HeapFree( GetProcessHeap(), 0, cs );
2342         }
2343         break;
2344     case WM_WINDOWPOSCHANGING:
2345     case WM_WINDOWPOSCHANGED:
2346         {
2347             WINDOWPOS16 *wp = MapSL(p16->lParam);
2348             UnMapLS( p16->lParam );
2349             p16->lParam = *(LPARAM *)(wp + 1);
2350             STRUCT32_WINDOWPOS16to32( wp, (WINDOWPOS *)p16->lParam );
2351             HeapFree( GetProcessHeap(), 0, wp );
2352         }
2353         break;
2354     case WM_NOTIFY:
2355         UnMapLS(p16->lParam);
2356         break;
2357     case WM_GETDLGCODE:
2358         if (p16->lParam)
2359         {
2360             LPMSG16 msg16 = MapSL(p16->lParam);
2361             MSGPARAM16 msgp16;
2362             UnMapLS( p16->lParam );
2363             msgp16.wParam=msg16->wParam;
2364             msgp16.lParam=msg16->lParam;
2365             WINPROC_UnmapMsg32ATo16(((LPMSG)lParam)->hwnd, ((LPMSG)lParam)->message,
2366                     ((LPMSG)lParam)->wParam, ((LPMSG)lParam)->lParam,
2367                     &msgp16 );
2368             HeapFree( GetProcessHeap(), 0, msg16 );
2369         }
2370         break;
2371     case WM_NEXTMENU:
2372         {
2373             MDINEXTMENU *next = (MDINEXTMENU *)lParam;
2374             next->hmenuNext = LOWORD(p16->lResult);
2375             next->hwndNext = WIN_Handle32( HIWORD(p16->lResult) );
2376             p16->lResult = 0;
2377         }
2378         break;
2379     }
2380 }
2381
2382
2383 /**********************************************************************
2384  *           WINPROC_MapMsg32WTo16
2385  *
2386  * Map a message from 32-bit Unicode to 16-bit.
2387  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
2388  */
2389 INT WINPROC_MapMsg32WTo16( HWND hwnd, UINT msg32, WPARAM wParam32,
2390                              UINT16 *pmsg16, WPARAM16 *pwparam16,
2391                              LPARAM *plparam )
2392 {
2393     BYTE ch;
2394     WCHAR wch;
2395
2396     *pmsg16    = LOWORD(msg32);
2397     *pwparam16 = LOWORD(wParam32);
2398     switch(msg32)
2399     {
2400     case LB_ADDSTRING:
2401     case LB_FINDSTRING:
2402     case LB_FINDSTRINGEXACT:
2403     case LB_INSERTSTRING:
2404     case LB_SELECTSTRING:
2405     case LB_DIR:
2406     case LB_ADDFILE:
2407         *plparam = map_str_32W_to_16( (LPWSTR)*plparam );
2408         *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING);
2409         return 1;
2410
2411     case CB_ADDSTRING:
2412     case CB_FINDSTRING:
2413     case CB_FINDSTRINGEXACT:
2414     case CB_INSERTSTRING:
2415     case CB_SELECTSTRING:
2416     case CB_DIR:
2417         *plparam = map_str_32W_to_16( (LPWSTR)*plparam );
2418         *pmsg16 = (UINT16)msg32 + (CB_ADDSTRING16 - CB_ADDSTRING);
2419         return 1;
2420
2421     case WM_NCCREATE:
2422     case WM_CREATE:
2423         {
2424             CREATESTRUCT16 *cs;
2425             CREATESTRUCTW *cs32 = (CREATESTRUCTW *)*plparam;
2426
2427             if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(CREATESTRUCT16) ))) return -1;
2428             STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCTA *)cs32, cs );
2429             cs->lpszName  = map_str_32W_to_16( cs32->lpszName );
2430             cs->lpszClass = map_str_32W_to_16( cs32->lpszClass );
2431             *plparam   = MapLS(cs);
2432         }
2433         return 1;
2434     case WM_MDICREATE:
2435         {
2436             MDICREATESTRUCT16 *cs;
2437             MDICREATESTRUCTW *cs32 = (MDICREATESTRUCTW *)*plparam;
2438
2439             if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(MDICREATESTRUCT16) ))) return -1;
2440             STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCTA *)cs32, cs );
2441             cs->szTitle = map_str_32W_to_16( cs32->szTitle );
2442             cs->szClass = map_str_32W_to_16( cs32->szClass );
2443             *plparam   = MapLS(cs);
2444         }
2445         return 1;
2446     case WM_SETTEXT:
2447     case WM_WININICHANGE:
2448     case WM_DEVMODECHANGE:
2449         *plparam = map_str_32W_to_16( (LPWSTR)*plparam );
2450         return 1;
2451     case LB_GETTEXT:
2452     case CB_GETLBTEXT:
2453         if ( WINPROC_TestLBForStr( hwnd ))
2454         {
2455             LPSTR str = HeapAlloc( GetProcessHeap(), 0, 256 ); /* FIXME: fixed sized buffer */
2456             if (!str) return -1;
2457             *pmsg16    = (msg32 == LB_GETTEXT)? LB_GETTEXT16 : CB_GETLBTEXT16;
2458             *plparam   = (LPARAM)MapLS(str);
2459         }
2460         return 1;
2461
2462     case WM_CHARTOITEM:
2463         wch = LOWORD(wParam32);
2464         WideCharToMultiByte( CP_ACP, 0, &wch, 1, &ch, 1, NULL, NULL);
2465         *pwparam16 = ch;
2466         *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32) );
2467         return 0;
2468     case WM_MENUCHAR:
2469         wch = LOWORD(wParam32);
2470         WideCharToMultiByte( CP_ACP, 0, &wch, 1, &ch, 1, NULL, NULL);
2471         *pwparam16 = ch;
2472         *plparam = MAKELPARAM( HIWORD(wParam32), (HMENU16)*plparam );
2473         return 0;
2474     case WM_CHAR:
2475     case WM_DEADCHAR:
2476     case WM_SYSCHAR:
2477     case WM_SYSDEADCHAR:
2478         wch = wParam32;
2479         WideCharToMultiByte( CP_ACP, 0, &wch, 1, &ch, 1, NULL, NULL);
2480         *pwparam16 = ch;
2481         return 0;
2482
2483     default:  /* No Unicode translation needed (?) */
2484         return WINPROC_MapMsg32ATo16( hwnd, msg32, wParam32, pmsg16,
2485                                       pwparam16, plparam );
2486     }
2487 }
2488
2489
2490 /**********************************************************************
2491  *           WINPROC_UnmapMsg32WTo16
2492  *
2493  * Unmap a message that was mapped from 32-bit Unicode to 16-bit.
2494  */
2495 void WINPROC_UnmapMsg32WTo16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
2496                               MSGPARAM16* p16 )
2497 {
2498     switch(msg)
2499     {
2500     case LB_ADDSTRING:
2501     case LB_FINDSTRING:
2502     case LB_FINDSTRINGEXACT:
2503     case LB_INSERTSTRING:
2504     case LB_SELECTSTRING:
2505     case LB_DIR:
2506     case LB_ADDFILE:
2507     case CB_ADDSTRING:
2508     case CB_FINDSTRING:
2509     case CB_FINDSTRINGEXACT:
2510     case CB_INSERTSTRING:
2511     case CB_SELECTSTRING:
2512     case CB_DIR:
2513     case WM_SETTEXT:
2514     case WM_WININICHANGE:
2515     case WM_DEVMODECHANGE:
2516         unmap_str_32W_to_16( p16->lParam );
2517         break;
2518     case WM_NCCREATE:
2519     case WM_CREATE:
2520         {
2521             CREATESTRUCT16 *cs = MapSL(p16->lParam);
2522             UnMapLS( p16->lParam );
2523             unmap_str_32W_to_16( cs->lpszName );
2524             unmap_str_32W_to_16( cs->lpszClass );
2525             HeapFree( GetProcessHeap(), 0, cs );
2526         }
2527         break;
2528     case WM_MDICREATE:
2529         {
2530             MDICREATESTRUCT16 *cs = MapSL(p16->lParam);
2531             UnMapLS( p16->lParam );
2532             unmap_str_32W_to_16( cs->szTitle );
2533             unmap_str_32W_to_16( cs->szClass );
2534             HeapFree( GetProcessHeap(), 0, cs );
2535         }
2536         break;
2537     case WM_GETTEXT:
2538     case WM_ASKCBFORMATNAME:
2539         {
2540             LPSTR str = MapSL(p16->lParam);
2541             UnMapLS( p16->lParam );
2542             p16->lParam = *((LPARAM *)str - 1);
2543             MultiByteToWideChar( CP_ACP, 0, str, -1, (LPWSTR)p16->lParam, 0x7fffffff );
2544             HeapFree( GetProcessHeap(), 0, (LPARAM *)str - 1 );
2545         }
2546         break;
2547     case LB_GETTEXT:
2548     case CB_GETLBTEXT:
2549         if ( WINPROC_TestLBForStr( hwnd ))
2550         {
2551             LPSTR str = MapSL(p16->lParam);
2552             UnMapLS( p16->lParam );
2553             MultiByteToWideChar( CP_ACP, 0, str, -1, (LPWSTR)lParam, 0x7fffffff );
2554             HeapFree( GetProcessHeap(), 0, (LPARAM *)str );
2555         }
2556         break;
2557     default:
2558         WINPROC_UnmapMsg32ATo16( hwnd, msg, wParam, lParam, p16 );
2559         break;
2560     }
2561 }
2562
2563
2564 /**********************************************************************
2565  *           WINPROC_CallProc32ATo32W
2566  *
2567  * Call a window procedure, translating args from Ansi to Unicode.
2568  */
2569 static LRESULT WINPROC_CallProc32ATo32W( WNDPROC func, HWND hwnd,
2570                                          UINT msg, WPARAM wParam,
2571                                          LPARAM lParam )
2572 {
2573     LRESULT result;
2574     int unmap;
2575
2576     TRACE_(msg)("func %p (hwnd=%08x,msg=%s,wp=%08x,lp=%08lx)\n",
2577         func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
2578
2579     if( (unmap = WINPROC_MapMsg32ATo32W( hwnd, msg, &wParam, &lParam )) == -1) {
2580         ERR_(msg)("Message translation failed. (msg=%s,wp=%08x,lp=%08lx)\n",
2581                        SPY_GetMsgName(msg, hwnd), wParam, lParam );
2582         return 0;
2583     }
2584     result = WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2585     if (unmap) result = WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam, result );
2586     return result;
2587 }
2588
2589
2590 /**********************************************************************
2591  *           WINPROC_CallProc32WTo32A
2592  *
2593  * Call a window procedure, translating args from Unicode to Ansi.
2594  */
2595 static LRESULT WINPROC_CallProc32WTo32A( WNDPROC func, HWND hwnd,
2596                                          UINT msg, WPARAM wParam,
2597                                          LPARAM lParam )
2598 {
2599     LRESULT result;
2600     int unmap;
2601
2602     TRACE_(msg)("func %p (hwnd=%08x,msg=%s,wp=%08x,lp=%08lx)\n",
2603         func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
2604
2605     if ((unmap = WINPROC_MapMsg32WTo32A( hwnd, msg, &wParam, &lParam )) == -1) {
2606         ERR_(msg)("Message translation failed. (msg=%s,wp=%08x,lp=%08lx)\n",
2607                        SPY_GetMsgName(msg, hwnd), wParam, lParam );
2608         return 0;
2609     }
2610     result = WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2611     if( unmap ) WINPROC_UnmapMsg32WTo32A( hwnd, msg, wParam, lParam );
2612     return result;
2613 }
2614
2615
2616 /**********************************************************************
2617  *           __wine_call_wndproc_32A   (USER.1010)
2618  */
2619 LRESULT WINAPI __wine_call_wndproc_32A( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam,
2620                                         WNDPROC func )
2621 {
2622     LRESULT result;
2623     UINT msg32;
2624     WPARAM wParam32;
2625     HWND hwnd32 = WIN_Handle32( hwnd );
2626
2627     if (WINPROC_MapMsg16To32A( hwnd32, msg, wParam, &msg32, &wParam32, &lParam ) == -1)
2628         return 0;
2629     result = WINPROC_CallWndProc( func, hwnd32, msg32, wParam32, lParam );
2630     return WINPROC_UnmapMsg16To32A( hwnd32, msg32, wParam32, lParam, result );
2631 }
2632
2633
2634 /**********************************************************************
2635  *           __wine_call_wndproc_32W   (USER.1011)
2636  */
2637 LRESULT WINAPI  __wine_call_wndproc_32W( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam,
2638                                          WNDPROC func )
2639 {
2640     LRESULT result;
2641     UINT msg32;
2642     WPARAM wParam32;
2643     HWND hwnd32 = WIN_Handle32( hwnd );
2644
2645     if (WINPROC_MapMsg16To32W( hwnd32, msg, wParam, &msg32, &wParam32, &lParam ) == -1)
2646         return 0;
2647     result = WINPROC_CallWndProc( func, hwnd32, msg32, wParam32, lParam );
2648     return WINPROC_UnmapMsg16To32W( hwnd32, msg32, wParam32, lParam, result );
2649 }
2650
2651
2652 /**********************************************************************
2653  *           WINPROC_CallProc32ATo16
2654  *
2655  * Call a 16-bit window procedure, translating the 32-bit args.
2656  */
2657 static LRESULT WINAPI WINPROC_CallProc32ATo16( WNDPROC16 func, HWND hwnd,
2658                                                UINT msg, WPARAM wParam,
2659                                                LPARAM lParam )
2660 {
2661     UINT16 msg16;
2662     MSGPARAM16 mp16;
2663
2664     TRACE_(msg)("func %p (hwnd=%08x,msg=%s,wp=%08x,lp=%08lx)\n",
2665         func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
2666
2667     mp16.lParam = lParam;
2668     if (WINPROC_MapMsg32ATo16( hwnd, msg, wParam, &msg16, &mp16.wParam, &mp16.lParam ) == -1)
2669         return 0;
2670     mp16.lResult = WINPROC_CallWndProc16( func, HWND_16(hwnd), msg16,
2671                                           mp16.wParam, mp16.lParam );
2672     WINPROC_UnmapMsg32ATo16( hwnd, msg, wParam, lParam, &mp16 );
2673     return mp16.lResult;
2674 }
2675
2676
2677 /**********************************************************************
2678  *           WINPROC_CallProc32WTo16
2679  *
2680  * Call a 16-bit window procedure, translating the 32-bit args.
2681  */
2682 static LRESULT WINAPI WINPROC_CallProc32WTo16( WNDPROC16 func, HWND hwnd,
2683                                                UINT msg, WPARAM wParam,
2684                                                LPARAM lParam )
2685 {
2686     UINT16 msg16;
2687     MSGPARAM16 mp16;
2688
2689     TRACE_(msg)("func %p (hwnd=%08x,msg=%s,wp=%08x,lp=%08lx)\n",
2690         func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
2691
2692     mp16.lParam = lParam;
2693     if (WINPROC_MapMsg32WTo16( hwnd, msg, wParam, &msg16, &mp16.wParam,
2694                                &mp16.lParam ) == -1)
2695         return 0;
2696     mp16.lResult = WINPROC_CallWndProc16( func, HWND_16(hwnd), msg16,
2697                                           mp16.wParam, mp16.lParam );
2698     WINPROC_UnmapMsg32WTo16( hwnd, msg, wParam, lParam, &mp16 );
2699     return mp16.lResult;
2700 }
2701
2702
2703 /**********************************************************************
2704  *              CallWindowProc (USER.122)
2705  */
2706 LRESULT WINAPI CallWindowProc16( WNDPROC16 func, HWND16 hwnd, UINT16 msg,
2707                                  WPARAM16 wParam, LPARAM lParam )
2708 {
2709     WINDOWPROC *proc;
2710
2711     if (!func) return 0;
2712
2713     if (!(proc = WINPROC_GetPtr( func )))
2714         return WINPROC_CallWndProc16( func, hwnd, msg, wParam, lParam );
2715
2716 #if testing
2717     func = WINPROC_GetProc( (HWINDOWPROC)proc, WIN_PROC_16 );
2718     return WINPROC_CallWndProc16( func, hwnd, msg, wParam, lParam );
2719 #endif
2720
2721     switch(proc->type)
2722     {
2723     case WIN_PROC_16:
2724         if (!proc->thunk.t_from32.proc) return 0;
2725         return WINPROC_CallWndProc16( proc->thunk.t_from32.proc,
2726                                       hwnd, msg, wParam, lParam );
2727     case WIN_PROC_32A:
2728         if (!proc->thunk.t_from16.proc) return 0;
2729         return __wine_call_wndproc_32A( hwnd, msg, wParam, lParam, proc->thunk.t_from16.proc );
2730     case WIN_PROC_32W:
2731         if (!proc->thunk.t_from16.proc) return 0;
2732         return __wine_call_wndproc_32W( hwnd, msg, wParam, lParam, proc->thunk.t_from16.proc );
2733     default:
2734         WARN_(relay)("Invalid proc %p\n", proc );
2735         return 0;
2736     }
2737 }
2738
2739
2740 /**********************************************************************
2741  *              CallWindowProcA (USER32.@)
2742  *
2743  * The CallWindowProc() function invokes the windows procedure _func_,
2744  * with _hwnd_ as the target window, the message specified by _msg_, and
2745  * the message parameters _wParam_ and _lParam_.
2746  *
2747  * Some kinds of argument conversion may be done, I'm not sure what.
2748  *
2749  * CallWindowProc() may be used for windows subclassing. Use
2750  * SetWindowLong() to set a new windows procedure for windows of the
2751  * subclass, and handle subclassed messages in the new windows
2752  * procedure. The new windows procedure may then use CallWindowProc()
2753  * with _func_ set to the parent class's windows procedure to dispatch
2754  * the message to the superclass.
2755  *
2756  * RETURNS
2757  *
2758  *    The return value is message dependent.
2759  *
2760  * CONFORMANCE
2761  *
2762  *   ECMA-234, Win32
2763  */
2764 LRESULT WINAPI CallWindowProcA(
2765     WNDPROC func,  /* [in] window procedure */
2766     HWND hwnd,     /* [in] target window */
2767     UINT msg,      /* [in] message */
2768     WPARAM wParam, /* [in] message dependent parameter */
2769     LPARAM lParam  /* [in] message dependent parameter */
2770 ) {
2771     WINDOWPROC *proc = WINPROC_GetPtr( (WNDPROC16)func );
2772
2773     if (!proc) return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2774
2775 #if testing
2776     func = WINPROC_GetProc( (HWINDOWPROC)proc, WIN_PROC_32A );
2777     return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2778 #endif
2779
2780     switch(proc->type)
2781     {
2782     case WIN_PROC_16:
2783         if (!proc->thunk.t_from32.proc) return 0;
2784         return WINPROC_CallProc32ATo16( proc->thunk.t_from32.proc,
2785                                         hwnd, msg, wParam, lParam );
2786     case WIN_PROC_32A:
2787         if (!proc->thunk.t_from16.proc) return 0;
2788         return WINPROC_CallWndProc( proc->thunk.t_from16.proc,
2789                                       hwnd, msg, wParam, lParam );
2790     case WIN_PROC_32W:
2791         if (!proc->thunk.t_from16.proc) return 0;
2792         return WINPROC_CallProc32ATo32W( proc->thunk.t_from16.proc,
2793                                          hwnd, msg, wParam, lParam );
2794     default:
2795         WARN_(relay)("Invalid proc %p\n", proc );
2796         return 0;
2797     }
2798 }
2799
2800
2801 /**********************************************************************
2802  *              CallWindowProcW (USER32.@)
2803  */
2804 LRESULT WINAPI CallWindowProcW( WNDPROC func, HWND hwnd, UINT msg,
2805                                   WPARAM wParam, LPARAM lParam )
2806 {
2807     WINDOWPROC *proc = WINPROC_GetPtr( (WNDPROC16)func );
2808
2809     if (!proc) return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2810
2811 #if testing
2812     func = WINPROC_GetProc( (HWINDOWPROC)proc, WIN_PROC_32W );
2813     return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2814 #endif
2815
2816     switch(proc->type)
2817     {
2818     case WIN_PROC_16:
2819         if (!proc->thunk.t_from32.proc) return 0;
2820         return WINPROC_CallProc32WTo16( proc->thunk.t_from32.proc,
2821                                         hwnd, msg, wParam, lParam );
2822     case WIN_PROC_32A:
2823         if (!proc->thunk.t_from16.proc) return 0;
2824         return WINPROC_CallProc32WTo32A( proc->thunk.t_from16.proc,
2825                                          hwnd, msg, wParam, lParam );
2826     case WIN_PROC_32W:
2827         if (!proc->thunk.t_from16.proc) return 0;
2828         return WINPROC_CallWndProc( proc->thunk.t_from16.proc,
2829                                       hwnd, msg, wParam, lParam );
2830     default:
2831         WARN_(relay)("Invalid proc %p\n", proc );
2832         return 0;
2833     }
2834 }