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