git.oblomov.eu Git - wine/blob - dlls/user/winproc.c

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