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

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