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

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