dlls/user.exe16/message.c

   1 /*
   2  * 16-bit messaging support
   3  *
   4  * Copyright 2001 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <stdarg.h>
  26 #include <string.h>
  27
  28 #include "wine/winuser16.h"
  29 #include "wownt32.h"
  30 #include "winerror.h"
  31 #include "dde.h"
  32 #include "user_private.h"
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(msg);
  36 WINE_DECLARE_DEBUG_CHANNEL(message);
  37
  38 DWORD USER16_AlertableWait = 0;
  39
  40 struct wow_handlers32 wow_handlers32;
  41
  42 static LRESULT send_message_callback( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
  43                                       LRESULT *result, void *arg )
  44 {
  45     *result = SendMessageA( hwnd, msg, wp, lp );
  46     return *result;
  47 }
  48
  49 static LRESULT post_message_callback( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
  50                                       LRESULT *result, void *arg )
  51 {
  52     *result = 0;
  53     return PostMessageA( hwnd, msg, wp, lp );
  54 }
  55
  56 static LRESULT post_thread_message_callback( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
  57                                              LRESULT *result, void *arg )
  58 {
  59     DWORD_PTR tid = (DWORD_PTR)arg;
  60     *result = 0;
  61     return PostThreadMessageA( tid, msg, wp, lp );
  62 }
  63
  64 static LRESULT get_message_callback( HWND16 hwnd, UINT16 msg, WPARAM16 wp, LPARAM lp,
  65                                      LRESULT *result, void *arg )
  66 {
  67     MSG16 *msg16 = arg;
  68
  69     msg16->hwnd    = hwnd;
  70     msg16->message = msg;
  71     msg16->wParam  = wp;
  72     msg16->lParam  = lp;
  73     *result = 0;
  74     return 0;
  75 }
  76
  77 static LRESULT defdlg_proc_callback( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
  78                                      LRESULT *result, void *arg )
  79 {
  80     *result = DefDlgProcA( hwnd, msg, wp, lp );
  81     return *result;
  82 }
  83
  84 static LRESULT call_window_proc_callback( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
  85                                           LRESULT *result, void *arg )
  86 {
  87     WNDPROC proc = arg;
  88     *result = CallWindowProcA( proc, hwnd, msg, wp, lp );
  89     return *result;
  90 }
  91
  92
  93 /**********************************************************************
  94  * Support for window procedure thunks
  95  */
  96
  97 #include "pshpack1.h"
  98 typedef struct
  99 {
 100     BYTE        popl_eax;        /* popl  %eax (return address) */
 101     BYTE        pushl_func;      /* pushl $proc */
 102     WNDPROC     proc;
 103     BYTE        pushl_eax;       /* pushl %eax */
 104     BYTE        ljmp;            /* ljmp relay*/
 105     DWORD       relay_offset;    /* __wine_call_wndproc */
 106     WORD        relay_sel;
 107 } WINPROC_THUNK;
 108 #include "poppack.h"
 109
 110 #define WINPROC_HANDLE (~0u >> 16)
 111 #define MAX_WINPROCS32 4096
 112 #define MAX_WINPROCS16 1024
 113
 114 static WNDPROC16 winproc16_array[MAX_WINPROCS16];
 115 static unsigned int winproc16_used;
 116
 117 static WINPROC_THUNK *thunk_array;
 118 static UINT thunk_selector;
 119
 120 /* return the window proc index for a given handle, or -1 for an invalid handle
 121  * indices 0 .. MAX_WINPROCS32-1 are for 32-bit procs,
 122  * indices MAX_WINPROCS32 .. MAX_WINPROCS32+MAX_WINPROCS16-1 for 16-bit procs */
 123 static int winproc_to_index( WNDPROC16 handle )
 124 {
 125     unsigned int index;
 126
 127     if (HIWORD(handle) == thunk_selector)
 128     {
 129         index = LOWORD(handle) / sizeof(WINPROC_THUNK);
 130         /* check alignment */
 131         if (index * sizeof(WINPROC_THUNK) != LOWORD(handle)) return -1;
 132         /* check array limits */
 133         if (index >= MAX_WINPROCS32) return -1;
 134     }
 135     else
 136     {
 137         index = LOWORD(handle);
 138         if ((ULONG_PTR)handle >> 16 != WINPROC_HANDLE) return -1;
 139         /* check array limits */
 140         if (index >= winproc16_used + MAX_WINPROCS32) return -1;
 141     }
 142     return index;
 143 }
 144
 145 /* allocate a 16-bit thunk for an existing window proc */
 146 static WNDPROC16 alloc_win16_thunk( WNDPROC handle )
 147 {
 148     static FARPROC16 relay;
 149     WINPROC_THUNK *thunk;
 150     UINT index = LOWORD( handle );
 151
 152     if (index >= MAX_WINPROCS32)  /* already a 16-bit proc */
 153         return winproc16_array[index - MAX_WINPROCS32];
 154
 155     if (!thunk_array)  /* allocate the array and its selector */
 156     {
 157         LDT_ENTRY entry;
 158
 159         assert( MAX_WINPROCS16 * sizeof(WINPROC_THUNK) <= 0x10000 );
 160
 161         if (!(thunk_selector = wine_ldt_alloc_entries(1))) return NULL;
 162         if (!(thunk_array = VirtualAlloc( NULL, MAX_WINPROCS16 * sizeof(WINPROC_THUNK), MEM_COMMIT,
 163                                           PAGE_EXECUTE_READWRITE ))) return NULL;
 164         wine_ldt_set_base( &entry, thunk_array );
 165         wine_ldt_set_limit( &entry, MAX_WINPROCS16 * sizeof(WINPROC_THUNK) - 1 );
 166         wine_ldt_set_flags( &entry, WINE_LDT_FLAGS_CODE | WINE_LDT_FLAGS_32BIT );
 167         wine_ldt_set_entry( thunk_selector, &entry );
 168         relay = GetProcAddress16( GetModuleHandle16("user"), "__wine_call_wndproc" );
 169     }
 170
 171     thunk = &thunk_array[index];
 172     thunk->popl_eax     = 0x58;   /* popl  %eax */
 173     thunk->pushl_func   = 0x68;   /* pushl $proc */
 174     thunk->proc         = handle;
 175     thunk->pushl_eax    = 0x50;   /* pushl %eax */
 176     thunk->ljmp         = 0xea;   /* ljmp   relay*/
 177     thunk->relay_offset = OFFSETOF(relay);
 178     thunk->relay_sel    = SELECTOROF(relay);
 179     return (WNDPROC16)MAKESEGPTR( thunk_selector, index * sizeof(WINPROC_THUNK) );
 180 }
 181
 182 /**********************************************************************
 183  *           WINPROC_AllocProc16
 184  */
 185 WNDPROC WINPROC_AllocProc16( WNDPROC16 func )
 186 {
 187     int index;
 188     WNDPROC ret;
 189
 190     if (!func) return NULL;
 191
 192     /* check if the function is already a win proc */
 193     if ((index = winproc_to_index( func )) != -1)
 194         return (WNDPROC)(ULONG_PTR)(index | (WINPROC_HANDLE << 16));
 195
 196     /* then check if we already have a winproc for that function */
 197     for (index = 0; index < winproc16_used; index++)
 198         if (winproc16_array[index] == func) goto done;
 199
 200     if (winproc16_used >= MAX_WINPROCS16)
 201     {
 202         FIXME( "too many winprocs, cannot allocate one for 16-bit %p\n", func );
 203         return NULL;
 204     }
 205     winproc16_array[winproc16_used++] = func;
 206
 207 done:
 208     ret = (WNDPROC)(ULONG_PTR)((index + MAX_WINPROCS32) | (WINPROC_HANDLE << 16));
 209     TRACE( "returning %p for %p/16-bit (%d/%d used)\n",
 210            ret, func, winproc16_used, MAX_WINPROCS16 );
 211     return ret;
 212 }
 213
 214 /**********************************************************************
 215  *           WINPROC_GetProc16
 216  *
 217  * Get a window procedure pointer that can be passed to the Windows program.
 218  */
 219 WNDPROC16 WINPROC_GetProc16( WNDPROC proc, BOOL unicode )
 220 {
 221     WNDPROC winproc = wow_handlers32.alloc_winproc( proc, unicode );
 222
 223     if ((ULONG_PTR)winproc >> 16 != WINPROC_HANDLE) return (WNDPROC16)winproc;
 224     return alloc_win16_thunk( winproc );
 225 }
 226
 227 /* call a 16-bit window procedure */
 228 static LRESULT call_window_proc16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam,
 229                                    LRESULT *result, void *arg )
 230 {
 231     WNDPROC16 func = arg;
 232     int index = winproc_to_index( func );
 233     CONTEXT context;
 234     size_t size = 0;
 235     struct
 236     {
 237         WORD params[5];
 238         union
 239         {
 240             CREATESTRUCT16 cs16;
 241             DRAWITEMSTRUCT16 dis16;
 242             COMPAREITEMSTRUCT16 cis16;
 243         } u;
 244     } args;
 245
 246     if (index >= MAX_WINPROCS32) func = winproc16_array[index - MAX_WINPROCS32];
 247
 248     /* Window procedures want ax = hInstance, ds = es = ss */
 249
 250     memset(&context, 0, sizeof(context));
 251     context.SegDs = context.SegEs = SELECTOROF(NtCurrentTeb()->WOW32Reserved);
 252     context.SegFs = wine_get_fs();
 253     context.SegGs = wine_get_gs();
 254     if (!(context.Eax = GetWindowWord( HWND_32(hwnd), GWLP_HINSTANCE ))) context.Eax = context.SegDs;
 255     context.SegCs = SELECTOROF(func);
 256     context.Eip   = OFFSETOF(func);
 257     context.Ebp   = OFFSETOF(NtCurrentTeb()->WOW32Reserved) + FIELD_OFFSET(STACK16FRAME, bp);
 258
 259     if (lParam)
 260     {
 261         /* Some programs (eg. the "Undocumented Windows" examples, JWP) only
 262            work if structures passed in lParam are placed in the stack/data
 263            segment. Programmers easily make the mistake of converting lParam
 264            to a near rather than a far pointer, since Windows apparently
 265            allows this. We copy the structures to the 16 bit stack; this is
 266            ugly but makes these programs work. */
 267         switch (msg)
 268         {
 269           case WM_CREATE:
 270           case WM_NCCREATE:
 271             size = sizeof(CREATESTRUCT16); break;
 272           case WM_DRAWITEM:
 273             size = sizeof(DRAWITEMSTRUCT16); break;
 274           case WM_COMPAREITEM:
 275             size = sizeof(COMPAREITEMSTRUCT16); break;
 276         }
 277         if (size)
 278         {
 279             memcpy( &args.u, MapSL(lParam), size );
 280             lParam = PtrToUlong(NtCurrentTeb()->WOW32Reserved) - size;
 281         }
 282     }
 283
 284     args.params[4] = hwnd;
 285     args.params[3] = msg;
 286     args.params[2] = wParam;
 287     args.params[1] = HIWORD(lParam);
 288     args.params[0] = LOWORD(lParam);
 289     WOWCallback16Ex( 0, WCB16_REGS, sizeof(args.params) + size, &args, (DWORD *)&context );
 290     *result = MAKELONG( LOWORD(context.Eax), LOWORD(context.Edx) );
 291     return *result;
 292 }
 293
 294 static LRESULT call_dialog_proc16( HWND16 hwnd, UINT16 msg, WPARAM16 wp, LPARAM lp,
 295                                    LRESULT *result, void *arg )
 296 {
 297     LRESULT ret = call_window_proc16( hwnd, msg, wp, lp, result, arg );
 298     *result = GetWindowLongPtrW( WIN_Handle32(hwnd), DWLP_MSGRESULT );
 299     return LOWORD(ret);
 300 }
 301
 302 static LRESULT call_window_proc_Ato16( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
 303                                        LRESULT *result, void *arg )
 304 {
 305     return WINPROC_CallProc32ATo16( call_window_proc16, hwnd, msg, wp, lp, result, arg );
 306 }
 307
 308 static LRESULT call_dialog_proc_Ato16( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
 309                                        LRESULT *result, void *arg )
 310 {
 311     return WINPROC_CallProc32ATo16( call_dialog_proc16, hwnd, msg, wp, lp, result, arg );
 312 }
 313
 314
 315
 316 /**********************************************************************
 317  * Support for Edit word break proc thunks
 318  */
 319
 320 #define MAX_THUNKS 32
 321
 322 #include <pshpack1.h>
 323 static struct word_break_thunk
 324 {
 325     BYTE                popl_eax;       /* popl  %eax (return address) */
 326     BYTE                pushl_proc16;   /* pushl proc16 */
 327     EDITWORDBREAKPROC16 proc16;
 328     BYTE                pushl_eax;      /* pushl %eax */
 329     BYTE                jmp;            /* ljmp call_word_break_proc16 */
 330     DWORD               callback;
 331 } *word_break_thunks;
 332 #include <poppack.h>
 333
 334 /**********************************************************************
 335  *           call_word_break_proc16
 336  */
 337 static INT16 CALLBACK call_word_break_proc16( SEGPTR proc16, LPSTR text, INT index, INT count, INT action )
 338 {
 339     SEGPTR segptr;
 340     WORD args[5];
 341     DWORD result;
 342
 343     segptr = MapLS( text );
 344     args[4] = SELECTOROF(segptr);
 345     args[3] = OFFSETOF(segptr);
 346     args[2] = index;
 347     args[1] = count;
 348     args[0] = action;
 349     WOWCallback16Ex( proc16, WCB16_PASCAL, sizeof(args), args, &result );
 350     UnMapLS( segptr );
 351     return LOWORD(result);
 352 }
 353
 354 /******************************************************************
 355  *              add_word_break_thunk
 356  */
 357 static struct word_break_thunk *add_word_break_thunk( EDITWORDBREAKPROC16 proc16 )
 358 {
 359     struct word_break_thunk *thunk;
 360
 361     if (!word_break_thunks)
 362     {
 363         word_break_thunks = VirtualAlloc( NULL, MAX_THUNKS * sizeof(*thunk),
 364                                           MEM_COMMIT, PAGE_EXECUTE_READWRITE );
 365         if (!word_break_thunks) return NULL;
 366
 367         for (thunk = word_break_thunks; thunk < &word_break_thunks[MAX_THUNKS]; thunk++)
 368         {
 369             thunk->popl_eax     = 0x58;   /* popl  %eax */
 370             thunk->pushl_proc16 = 0x68;   /* pushl proc16 */
 371             thunk->pushl_eax    = 0x50;   /* pushl %eax */
 372             thunk->jmp          = 0xe9;   /* jmp call_word_break_proc16 */
 373             thunk->callback     = (char *)call_word_break_proc16 - (char *)(&thunk->callback + 1);
 374         }
 375     }
 376     for (thunk = word_break_thunks; thunk < &word_break_thunks[MAX_THUNKS]; thunk++)
 377         if (thunk->proc16 == proc16) return thunk;
 378
 379     for (thunk = word_break_thunks; thunk < &word_break_thunks[MAX_THUNKS]; thunk++)
 380     {
 381         if (thunk->proc16) continue;
 382         thunk->proc16 = proc16;
 383         return thunk;
 384     }
 385     FIXME("Out of word break thunks\n");
 386     return NULL;
 387 }
 388
 389 /******************************************************************
 390  *              get_word_break_thunk
 391  */
 392 static EDITWORDBREAKPROC16 get_word_break_thunk( EDITWORDBREAKPROCA proc )
 393 {
 394     struct word_break_thunk *thunk = (struct word_break_thunk *)proc;
 395     if (word_break_thunks && thunk >= word_break_thunks && thunk < &word_break_thunks[MAX_THUNKS])
 396         return thunk->proc16;
 397     return NULL;
 398 }
 399
 400
 401 /***********************************************************************
 402  * Support for 16<->32 message mapping
 403  */
 404
 405 static inline void *get_buffer( void *static_buffer, size_t size, size_t need )
 406 {
 407     if (size >= need) return static_buffer;
 408     return HeapAlloc( GetProcessHeap(), 0, need );
 409 }
 410
 411 static inline void free_buffer( void *static_buffer, void *buffer )
 412 {
 413     if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
 414 }
 415
 416 static void RECT16to32( const RECT16 *from, RECT *to )
 417 {
 418     to->left   = from->left;
 419     to->top    = from->top;
 420     to->right  = from->right;
 421     to->bottom = from->bottom;
 422 }
 423
 424 static void RECT32to16( const RECT *from, RECT16 *to )
 425 {
 426     to->left   = from->left;
 427     to->top    = from->top;
 428     to->right  = from->right;
 429     to->bottom = from->bottom;
 430 }
 431
 432 static void MINMAXINFO32to16( const MINMAXINFO *from, MINMAXINFO16 *to )
 433 {
 434     to->ptReserved.x     = from->ptReserved.x;
 435     to->ptReserved.y     = from->ptReserved.y;
 436     to->ptMaxSize.x      = from->ptMaxSize.x;
 437     to->ptMaxSize.y      = from->ptMaxSize.y;
 438     to->ptMaxPosition.x  = from->ptMaxPosition.x;
 439     to->ptMaxPosition.y  = from->ptMaxPosition.y;
 440     to->ptMinTrackSize.x = from->ptMinTrackSize.x;
 441     to->ptMinTrackSize.y = from->ptMinTrackSize.y;
 442     to->ptMaxTrackSize.x = from->ptMaxTrackSize.x;
 443     to->ptMaxTrackSize.y = from->ptMaxTrackSize.y;
 444 }
 445
 446 static void MINMAXINFO16to32( const MINMAXINFO16 *from, MINMAXINFO *to )
 447 {
 448     to->ptReserved.x     = from->ptReserved.x;
 449     to->ptReserved.y     = from->ptReserved.y;
 450     to->ptMaxSize.x      = from->ptMaxSize.x;
 451     to->ptMaxSize.y      = from->ptMaxSize.y;
 452     to->ptMaxPosition.x  = from->ptMaxPosition.x;
 453     to->ptMaxPosition.y  = from->ptMaxPosition.y;
 454     to->ptMinTrackSize.x = from->ptMinTrackSize.x;
 455     to->ptMinTrackSize.y = from->ptMinTrackSize.y;
 456     to->ptMaxTrackSize.x = from->ptMaxTrackSize.x;
 457     to->ptMaxTrackSize.y = from->ptMaxTrackSize.y;
 458 }
 459
 460 static void WINDOWPOS32to16( const WINDOWPOS* from, WINDOWPOS16* to )
 461 {
 462     to->hwnd            = HWND_16(from->hwnd);
 463     to->hwndInsertAfter = HWND_16(from->hwndInsertAfter);
 464     to->x               = from->x;
 465     to->y               = from->y;
 466     to->cx              = from->cx;
 467     to->cy              = from->cy;
 468     to->flags           = from->flags;
 469 }
 470
 471 static void WINDOWPOS16to32( const WINDOWPOS16* from, WINDOWPOS* to )
 472 {
 473     to->hwnd            = WIN_Handle32(from->hwnd);
 474     to->hwndInsertAfter = (from->hwndInsertAfter == (HWND16)-1) ?
 475                            HWND_TOPMOST : WIN_Handle32(from->hwndInsertAfter);
 476     to->x               = from->x;
 477     to->y               = from->y;
 478     to->cx              = from->cx;
 479     to->cy              = from->cy;
 480     to->flags           = from->flags;
 481 }
 482
 483 /* The strings are not copied */
 484 static void CREATESTRUCT32Ato16( const CREATESTRUCTA* from, CREATESTRUCT16* to )
 485 {
 486     to->lpCreateParams = (SEGPTR)from->lpCreateParams;
 487     to->hInstance      = HINSTANCE_16(from->hInstance);
 488     to->hMenu          = HMENU_16(from->hMenu);
 489     to->hwndParent     = HWND_16(from->hwndParent);
 490     to->cy             = from->cy;
 491     to->cx             = from->cx;
 492     to->y              = from->y;
 493     to->x              = from->x;
 494     to->style          = from->style;
 495     to->dwExStyle      = from->dwExStyle;
 496 }
 497
 498 static void CREATESTRUCT16to32A( const CREATESTRUCT16* from, CREATESTRUCTA *to )
 499
 500 {
 501     to->lpCreateParams = (LPVOID)from->lpCreateParams;
 502     to->hInstance      = HINSTANCE_32(from->hInstance);
 503     to->hMenu          = HMENU_32(from->hMenu);
 504     to->hwndParent     = WIN_Handle32(from->hwndParent);
 505     to->cy             = from->cy;
 506     to->cx             = from->cx;
 507     to->y              = from->y;
 508     to->x              = from->x;
 509     to->style          = from->style;
 510     to->dwExStyle      = from->dwExStyle;
 511     to->lpszName       = MapSL(from->lpszName);
 512     to->lpszClass      = MapSL(from->lpszClass);
 513 }
 514
 515 /* The strings are not copied */
 516 static void MDICREATESTRUCT32Ato16( const MDICREATESTRUCTA* from, MDICREATESTRUCT16* to )
 517 {
 518     to->hOwner = HINSTANCE_16(from->hOwner);
 519     to->x      = from->x;
 520     to->y      = from->y;
 521     to->cx     = from->cx;
 522     to->cy     = from->cy;
 523     to->style  = from->style;
 524     to->lParam = from->lParam;
 525 }
 526
 527 static void MDICREATESTRUCT16to32A( const MDICREATESTRUCT16* from, MDICREATESTRUCTA *to )
 528 {
 529     to->hOwner = HINSTANCE_32(from->hOwner);
 530     to->x      = from->x;
 531     to->y      = from->y;
 532     to->cx     = from->cx;
 533     to->cy     = from->cy;
 534     to->style  = from->style;
 535     to->lParam = from->lParam;
 536     to->szTitle = MapSL(from->szTitle);
 537     to->szClass = MapSL(from->szClass);
 538 }
 539
 540 static UINT_PTR convert_handle_16_to_32(HANDLE16 src, unsigned int flags)
 541 {
 542     HANDLE      dst;
 543     UINT        sz = GlobalSize16(src);
 544     LPSTR       ptr16, ptr32;
 545
 546     if (!(dst = GlobalAlloc(flags, sz)))
 547         return 0;
 548     ptr16 = GlobalLock16(src);
 549     ptr32 = GlobalLock(dst);
 550     if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr32, ptr16, sz);
 551     GlobalUnlock16(src);
 552     GlobalUnlock(dst);
 553
 554     return (UINT_PTR)dst;
 555 }
 556
 557 static HANDLE16 convert_handle_32_to_16(UINT_PTR src, unsigned int flags)
 558 {
 559     HANDLE16    dst;
 560     UINT        sz = GlobalSize((HANDLE)src);
 561     LPSTR       ptr16, ptr32;
 562
 563     if (!(dst = GlobalAlloc16(flags, sz)))
 564         return 0;
 565     ptr32 = GlobalLock((HANDLE)src);
 566     ptr16 = GlobalLock16(dst);
 567     if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr16, ptr32, sz);
 568     GlobalUnlock((HANDLE)src);
 569     GlobalUnlock16(dst);
 570
 571     return dst;
 572 }
 573
 574 static BOOL is_old_app( HWND hwnd )
 575 {
 576     HINSTANCE inst = (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
 577     return inst && !((ULONG_PTR)inst >> 16) && (GetExpWinVer16(LOWORD(inst)) & 0xFF00) == 0x0300;
 578 }
 579
 580 static int find_sub_menu( HMENU *hmenu, HMENU16 target )
 581 {
 582     int i, pos, count = GetMenuItemCount( *hmenu );
 583
 584     for (i = 0; i < count; i++)
 585     {
 586         HMENU sub = GetSubMenu( *hmenu, i );
 587         if (!sub) continue;
 588         if (HMENU_16(sub) == target) return i;
 589         if ((pos = find_sub_menu( &sub, target )) != -1)
 590         {
 591             *hmenu = sub;
 592             return pos;
 593         }
 594     }
 595     return -1;
 596 }
 597
 598 /**********************************************************************
 599  *           WINPROC_CallProc16To32A
 600  */
 601 LRESULT WINPROC_CallProc16To32A( winproc_callback_t callback, HWND16 hwnd, UINT16 msg,
 602                                  WPARAM16 wParam, LPARAM lParam, LRESULT *result, void *arg )
 603 {
 604     LRESULT ret = 0;
 605     HWND hwnd32 = WIN_Handle32( hwnd );
 606
 607     switch(msg)
 608     {
 609     case WM_NCCREATE:
 610     case WM_CREATE:
 611         {
 612             CREATESTRUCT16 *cs16 = MapSL(lParam);
 613             CREATESTRUCTA cs;
 614             MDICREATESTRUCTA mdi_cs;
 615
 616             CREATESTRUCT16to32A( cs16, &cs );
 617             if (GetWindowLongW(hwnd32, GWL_EXSTYLE) & WS_EX_MDICHILD)
 618             {
 619                 MDICREATESTRUCT16 *mdi_cs16 = MapSL(cs16->lpCreateParams);
 620                 MDICREATESTRUCT16to32A(mdi_cs16, &mdi_cs);
 621                 cs.lpCreateParams = &mdi_cs;
 622             }
 623             ret = callback( hwnd32, msg, wParam, (LPARAM)&cs, result, arg );
 624             CREATESTRUCT32Ato16( &cs, cs16 );
 625         }
 626         break;
 627     case WM_MDICREATE:
 628         {
 629             MDICREATESTRUCT16 *cs16 = MapSL(lParam);
 630             MDICREATESTRUCTA cs;
 631
 632             MDICREATESTRUCT16to32A( cs16, &cs );
 633             ret = callback( hwnd32, msg, wParam, (LPARAM)&cs, result, arg );
 634             MDICREATESTRUCT32Ato16( &cs, cs16 );
 635         }
 636         break;
 637     case WM_MDIACTIVATE:
 638         if (lParam)
 639             ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32( HIWORD(lParam) ),
 640                             (LPARAM)WIN_Handle32( LOWORD(lParam) ), result, arg );
 641         else /* message sent to MDI client */
 642             ret = callback( hwnd32, msg, wParam, lParam, result, arg );
 643         break;
 644     case WM_MDIGETACTIVE:
 645         {
 646             BOOL maximized = FALSE;
 647             ret = callback( hwnd32, msg, wParam, (LPARAM)&maximized, result, arg );
 648             *result = MAKELRESULT( LOWORD(*result), maximized );
 649         }
 650         break;
 651     case WM_MDISETMENU:
 652         ret = callback( hwnd32, wParam ? WM_MDIREFRESHMENU : WM_MDISETMENU,
 653                         (WPARAM)HMENU_32(LOWORD(lParam)), (LPARAM)HMENU_32(HIWORD(lParam)),
 654                         result, arg );
 655         break;
 656     case WM_GETMINMAXINFO:
 657         {
 658             MINMAXINFO16 *mmi16 = MapSL(lParam);
 659             MINMAXINFO mmi;
 660
 661             MINMAXINFO16to32( mmi16, &mmi );
 662             ret = callback( hwnd32, msg, wParam, (LPARAM)&mmi, result, arg );
 663             MINMAXINFO32to16( &mmi, mmi16 );
 664         }
 665         break;
 666     case WM_WINDOWPOSCHANGING:
 667     case WM_WINDOWPOSCHANGED:
 668         {
 669             WINDOWPOS16 *winpos16 = MapSL(lParam);
 670             WINDOWPOS winpos;
 671
 672             WINDOWPOS16to32( winpos16, &winpos );
 673             ret = callback( hwnd32, msg, wParam, (LPARAM)&winpos, result, arg );
 674             WINDOWPOS32to16( &winpos, winpos16 );
 675         }
 676         break;
 677     case WM_NCCALCSIZE:
 678         {
 679             NCCALCSIZE_PARAMS16 *nc16 = MapSL(lParam);
 680             NCCALCSIZE_PARAMS nc;
 681             WINDOWPOS winpos;
 682
 683             RECT16to32( &nc16->rgrc[0], &nc.rgrc[0] );
 684             if (wParam)
 685             {
 686                 RECT16to32( &nc16->rgrc[1], &nc.rgrc[1] );
 687                 RECT16to32( &nc16->rgrc[2], &nc.rgrc[2] );
 688                 WINDOWPOS16to32( MapSL(nc16->lppos), &winpos );
 689                 nc.lppos = &winpos;
 690             }
 691             ret = callback( hwnd32, msg, wParam, (LPARAM)&nc, result, arg );
 692             RECT32to16( &nc.rgrc[0], &nc16->rgrc[0] );
 693             if (wParam)
 694             {
 695                 RECT32to16( &nc.rgrc[1], &nc16->rgrc[1] );
 696                 RECT32to16( &nc.rgrc[2], &nc16->rgrc[2] );
 697                 WINDOWPOS32to16( &winpos, MapSL(nc16->lppos) );
 698             }
 699         }
 700         break;
 701     case WM_COMPAREITEM:
 702         {
 703             COMPAREITEMSTRUCT16* cis16 = MapSL(lParam);
 704             COMPAREITEMSTRUCT cis;
 705             cis.CtlType    = cis16->CtlType;
 706             cis.CtlID      = cis16->CtlID;
 707             cis.hwndItem   = WIN_Handle32( cis16->hwndItem );
 708             cis.itemID1    = cis16->itemID1;
 709             cis.itemData1  = cis16->itemData1;
 710             cis.itemID2    = cis16->itemID2;
 711             cis.itemData2  = cis16->itemData2;
 712             cis.dwLocaleId = 0;  /* FIXME */
 713             ret = callback( hwnd32, msg, wParam, (LPARAM)&cis, result, arg );
 714         }
 715         break;
 716     case WM_DELETEITEM:
 717         {
 718             DELETEITEMSTRUCT16* dis16 = MapSL(lParam);
 719             DELETEITEMSTRUCT dis;
 720             dis.CtlType  = dis16->CtlType;
 721             dis.CtlID    = dis16->CtlID;
 722             dis.hwndItem = WIN_Handle32( dis16->hwndItem );
 723             dis.itemData = dis16->itemData;
 724             ret = callback( hwnd32, msg, wParam, (LPARAM)&dis, result, arg );
 725         }
 726         break;
 727     case WM_MEASUREITEM:
 728         {
 729             MEASUREITEMSTRUCT16* mis16 = MapSL(lParam);
 730             MEASUREITEMSTRUCT mis;
 731             mis.CtlType    = mis16->CtlType;
 732             mis.CtlID      = mis16->CtlID;
 733             mis.itemID     = mis16->itemID;
 734             mis.itemWidth  = mis16->itemWidth;
 735             mis.itemHeight = mis16->itemHeight;
 736             mis.itemData   = mis16->itemData;
 737             ret = callback( hwnd32, msg, wParam, (LPARAM)&mis, result, arg );
 738             mis16->itemWidth  = (UINT16)mis.itemWidth;
 739             mis16->itemHeight = (UINT16)mis.itemHeight;
 740         }
 741         break;
 742     case WM_DRAWITEM:
 743         {
 744             DRAWITEMSTRUCT16* dis16 = MapSL(lParam);
 745             DRAWITEMSTRUCT dis;
 746             dis.CtlType       = dis16->CtlType;
 747             dis.CtlID         = dis16->CtlID;
 748             dis.itemID        = dis16->itemID;
 749             dis.itemAction    = dis16->itemAction;
 750             dis.itemState     = dis16->itemState;
 751             dis.hwndItem      = (dis.CtlType == ODT_MENU) ? (HWND)HMENU_32(dis16->hwndItem)
 752                                                           : WIN_Handle32( dis16->hwndItem );
 753             dis.hDC           = HDC_32(dis16->hDC);
 754             dis.itemData      = dis16->itemData;
 755             dis.rcItem.left   = dis16->rcItem.left;
 756             dis.rcItem.top    = dis16->rcItem.top;
 757             dis.rcItem.right  = dis16->rcItem.right;
 758             dis.rcItem.bottom = dis16->rcItem.bottom;
 759             ret = callback( hwnd32, msg, wParam, (LPARAM)&dis, result, arg );
 760         }
 761         break;
 762     case WM_COPYDATA:
 763         {
 764             COPYDATASTRUCT16 *cds16 = MapSL(lParam);
 765             COPYDATASTRUCT cds;
 766             cds.dwData = cds16->dwData;
 767             cds.cbData = cds16->cbData;
 768             cds.lpData = MapSL(cds16->lpData);
 769             ret = callback( hwnd32, msg, wParam, (LPARAM)&cds, result, arg );
 770         }
 771         break;
 772     case WM_GETDLGCODE:
 773         if (lParam)
 774         {
 775             MSG16 *msg16 = MapSL(lParam);
 776             MSG msg32;
 777             msg32.hwnd    = WIN_Handle32( msg16->hwnd );
 778             msg32.message = msg16->message;
 779             msg32.wParam  = msg16->wParam;
 780             msg32.lParam  = msg16->lParam;
 781             msg32.time    = msg16->time;
 782             msg32.pt.x    = msg16->pt.x;
 783             msg32.pt.y    = msg16->pt.y;
 784             ret = callback( hwnd32, msg, wParam, (LPARAM)&msg32, result, arg );
 785         }
 786         else
 787             ret = callback( hwnd32, msg, wParam, lParam, result, arg );
 788         break;
 789     case WM_NEXTMENU:
 790         {
 791             MDINEXTMENU next;
 792             next.hmenuIn   = (HMENU)lParam;
 793             next.hmenuNext = 0;
 794             next.hwndNext  = 0;
 795             ret = callback( hwnd32, msg, wParam, (LPARAM)&next, result, arg );
 796             *result = MAKELONG( HMENU_16(next.hmenuNext), HWND_16(next.hwndNext) );
 797         }
 798         break;
 799     case WM_ACTIVATE:
 800     case WM_CHARTOITEM:
 801     case WM_COMMAND:
 802     case WM_VKEYTOITEM:
 803         ret = callback( hwnd32, msg, MAKEWPARAM( wParam, HIWORD(lParam) ),
 804                         (LPARAM)WIN_Handle32( LOWORD(lParam) ), result, arg );
 805         break;
 806     case WM_HSCROLL:
 807     case WM_VSCROLL:
 808         ret = callback( hwnd32, msg, MAKEWPARAM( wParam, LOWORD(lParam) ),
 809                         (LPARAM)WIN_Handle32( HIWORD(lParam) ), result, arg );
 810         break;
 811     case WM_CTLCOLOR:
 812         if (HIWORD(lParam) <= CTLCOLOR_STATIC)
 813             ret = callback( hwnd32, WM_CTLCOLORMSGBOX + HIWORD(lParam),
 814                             (WPARAM)HDC_32(wParam), (LPARAM)WIN_Handle32( LOWORD(lParam) ),
 815                             result, arg );
 816         break;
 817     case WM_GETTEXT:
 818     case WM_SETTEXT:
 819     case WM_WININICHANGE:
 820     case WM_DEVMODECHANGE:
 821     case WM_ASKCBFORMATNAME:
 822     case WM_NOTIFY:
 823         ret = callback( hwnd32, msg, wParam, (LPARAM)MapSL(lParam), result, arg );
 824         break;
 825     case WM_MENUCHAR:
 826         ret = callback( hwnd32, msg, MAKEWPARAM( wParam, LOWORD(lParam) ),
 827                         (LPARAM)HMENU_32(HIWORD(lParam)), result, arg );
 828         break;
 829     case WM_MENUSELECT:
 830         if((LOWORD(lParam) & MF_POPUP) && (LOWORD(lParam) != 0xFFFF))
 831         {
 832             HMENU hmenu = HMENU_32(HIWORD(lParam));
 833             int pos = find_sub_menu( &hmenu, wParam );
 834             if (pos == -1) pos = 0;
 835             wParam = pos;
 836         }
 837         ret = callback( hwnd32, msg, MAKEWPARAM( wParam, LOWORD(lParam) ),
 838                         (LPARAM)HMENU_32(HIWORD(lParam)), result, arg );
 839         break;
 840     case WM_PARENTNOTIFY:
 841         if ((wParam == WM_CREATE) || (wParam == WM_DESTROY))
 842             ret = callback( hwnd32, msg, MAKEWPARAM( wParam, HIWORD(lParam) ),
 843                             (LPARAM)WIN_Handle32( LOWORD(lParam) ), result, arg );
 844         else
 845             ret = callback( hwnd32, msg, wParam, lParam, result, arg );
 846         break;
 847     case WM_ACTIVATEAPP:
 848         /* We need this when SetActiveWindow sends a Sendmessage16() to
 849          * a 32-bit window. Might be superfluous with 32-bit interprocess
 850          * message queues. */
 851         if (lParam) lParam = HTASK_32(lParam);
 852         ret = callback( hwnd32, msg, wParam, lParam, result, arg );
 853         break;
 854     case WM_DDE_INITIATE:
 855     case WM_DDE_TERMINATE:
 856     case WM_DDE_UNADVISE:
 857     case WM_DDE_REQUEST:
 858         ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32(wParam), lParam, result, arg );
 859         break;
 860     case WM_DDE_ADVISE:
 861     case WM_DDE_DATA:
 862     case WM_DDE_POKE:
 863         {
 864             HANDLE16 lo16 = LOWORD(lParam);
 865             UINT_PTR lo32 = 0;
 866             if (lo16 && !(lo32 = convert_handle_16_to_32(lo16, GMEM_DDESHARE))) break;
 867             lParam = PackDDElParam( msg, lo32, HIWORD(lParam) );
 868             ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32(wParam), lParam, result, arg );
 869         }
 870         break; /* FIXME don't know how to free allocated memory (handle)  !! */
 871     case WM_DDE_ACK:
 872         {
 873             UINT_PTR lo = LOWORD(lParam);
 874             UINT_PTR hi = HIWORD(lParam);
 875             int flag = 0;
 876             char buf[2];
 877
 878             if (GlobalGetAtomNameA(hi, buf, 2) > 0) flag |= 1;
 879             if (GlobalSize16(hi) != 0) flag |= 2;
 880             switch (flag)
 881             {
 882             case 0:
 883                 if (hi)
 884                 {
 885                     WARN("DDE_ACK: neither atom nor handle!!!\n");
 886                     hi = 0;
 887                 }
 888                 break;
 889             case 1:
 890                 break; /* atom, nothing to do */
 891             case 3:
 892                 WARN("DDE_ACK: %lx both atom and handle... choosing handle\n", hi);
 893                 /* fall through */
 894             case 2:
 895                 hi = convert_handle_16_to_32(hi, GMEM_DDESHARE);
 896                 break;
 897             }
 898             lParam = PackDDElParam( WM_DDE_ACK, lo, hi );
 899             ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32(wParam), lParam, result, arg );
 900         }
 901         break; /* FIXME don't know how to free allocated memory (handle) !! */
 902     case WM_DDE_EXECUTE:
 903         lParam = convert_handle_16_to_32( lParam, GMEM_DDESHARE );
 904         ret = callback( hwnd32, msg, wParam, lParam, result, arg );
 905         break; /* FIXME don't know how to free allocated memory (handle) !! */
 906     case WM_PAINTCLIPBOARD:
 907     case WM_SIZECLIPBOARD:
 908         FIXME_(msg)( "message %04x needs translation\n", msg );
 909         break;
 910     default:
 911         ret = callback( hwnd32, msg, wParam, lParam, result, arg );
 912         break;
 913     }
 914     return ret;
 915 }
 916
 917
 918 /**********************************************************************
 919  *           WINPROC_CallProc32ATo16
 920  *
 921  * Call a 16-bit window procedure, translating the 32-bit args.
 922  */
 923 LRESULT WINPROC_CallProc32ATo16( winproc_callback16_t callback, HWND hwnd, UINT msg,
 924                                  WPARAM wParam, LPARAM lParam, LRESULT *result, void *arg )
 925 {
 926     LRESULT ret = 0;
 927
 928     switch(msg)
 929     {
 930     case WM_NCCREATE:
 931     case WM_CREATE:
 932         {
 933             CREATESTRUCTA *cs32 = (CREATESTRUCTA *)lParam;
 934             CREATESTRUCT16 cs;
 935             MDICREATESTRUCT16 mdi_cs16;
 936             BOOL mdi_child = (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD);
 937
 938             CREATESTRUCT32Ato16( cs32, &cs );
 939             cs.lpszName  = MapLS( cs32->lpszName );
 940             cs.lpszClass = MapLS( cs32->lpszClass );
 941
 942             if (mdi_child)
 943             {
 944                 MDICREATESTRUCTA *mdi_cs = cs32->lpCreateParams;
 945                 MDICREATESTRUCT32Ato16( mdi_cs, &mdi_cs16 );
 946                 mdi_cs16.szTitle = MapLS( mdi_cs->szTitle );
 947                 mdi_cs16.szClass = MapLS( mdi_cs->szClass );
 948                 cs.lpCreateParams = MapLS( &mdi_cs16 );
 949             }
 950             lParam = MapLS( &cs );
 951             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
 952             UnMapLS( lParam );
 953             UnMapLS( cs.lpszName );
 954             UnMapLS( cs.lpszClass );
 955             if (mdi_child)
 956             {
 957                 UnMapLS( cs.lpCreateParams );
 958                 UnMapLS( mdi_cs16.szTitle );
 959                 UnMapLS( mdi_cs16.szClass );
 960             }
 961         }
 962         break;
 963     case WM_MDICREATE:
 964         {
 965             MDICREATESTRUCTA *cs32 = (MDICREATESTRUCTA *)lParam;
 966             MDICREATESTRUCT16 cs;
 967
 968             MDICREATESTRUCT32Ato16( cs32, &cs );
 969             cs.szTitle = MapLS( cs32->szTitle );
 970             cs.szClass = MapLS( cs32->szClass );
 971             lParam = MapLS( &cs );
 972             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
 973             UnMapLS( lParam );
 974             UnMapLS( cs.szTitle );
 975             UnMapLS( cs.szClass );
 976         }
 977         break;
 978     case WM_MDIACTIVATE:
 979         if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_MDICHILD)
 980             ret = callback( HWND_16(hwnd), msg, ((HWND)lParam == hwnd),
 981                             MAKELPARAM( LOWORD(lParam), LOWORD(wParam) ), result, arg );
 982         else
 983             ret = callback( HWND_16(hwnd), msg, HWND_16( wParam ), 0, result, arg );
 984         break;
 985     case WM_MDIGETACTIVE:
 986         ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
 987         if (lParam) *(BOOL *)lParam = (BOOL16)HIWORD(*result);
 988         *result = (LRESULT)WIN_Handle32( LOWORD(*result) );
 989         break;
 990     case WM_MDISETMENU:
 991         ret = callback( HWND_16(hwnd), msg, (lParam == 0),
 992                         MAKELPARAM( LOWORD(wParam), LOWORD(lParam) ), result, arg );
 993         break;
 994     case WM_GETMINMAXINFO:
 995         {
 996             MINMAXINFO *mmi32 = (MINMAXINFO *)lParam;
 997             MINMAXINFO16 mmi;
 998
 999             MINMAXINFO32to16( mmi32, &mmi );
1000             lParam = MapLS( &mmi );
1001             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1002             UnMapLS( lParam );
1003             MINMAXINFO16to32( &mmi, mmi32 );
1004         }
1005         break;
1006     case WM_NCCALCSIZE:
1007         {
1008             NCCALCSIZE_PARAMS *nc32 = (NCCALCSIZE_PARAMS *)lParam;
1009             NCCALCSIZE_PARAMS16 nc;
1010             WINDOWPOS16 winpos;
1011
1012             RECT32to16( &nc32->rgrc[0], &nc.rgrc[0] );
1013             if (wParam)
1014             {
1015                 RECT32to16( &nc32->rgrc[1], &nc.rgrc[1] );
1016                 RECT32to16( &nc32->rgrc[2], &nc.rgrc[2] );
1017                 WINDOWPOS32to16( nc32->lppos, &winpos );
1018                 nc.lppos = MapLS( &winpos );
1019             }
1020             lParam = MapLS( &nc );
1021             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1022             UnMapLS( lParam );
1023             RECT16to32( &nc.rgrc[0], &nc32->rgrc[0] );
1024             if (wParam)
1025             {
1026                 RECT16to32( &nc.rgrc[1], &nc32->rgrc[1] );
1027                 RECT16to32( &nc.rgrc[2], &nc32->rgrc[2] );
1028                 WINDOWPOS16to32( &winpos, nc32->lppos );
1029                 UnMapLS( nc.lppos );
1030             }
1031         }
1032         break;
1033     case WM_WINDOWPOSCHANGING:
1034     case WM_WINDOWPOSCHANGED:
1035         {
1036             WINDOWPOS *winpos32 = (WINDOWPOS *)lParam;
1037             WINDOWPOS16 winpos;
1038
1039             WINDOWPOS32to16( winpos32, &winpos );
1040             lParam = MapLS( &winpos );
1041             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1042             UnMapLS( lParam );
1043             WINDOWPOS16to32( &winpos, winpos32 );
1044         }
1045         break;
1046     case WM_COMPAREITEM:
1047         {
1048             COMPAREITEMSTRUCT *cis32 = (COMPAREITEMSTRUCT *)lParam;
1049             COMPAREITEMSTRUCT16 cis;
1050             cis.CtlType    = cis32->CtlType;
1051             cis.CtlID      = cis32->CtlID;
1052             cis.hwndItem   = HWND_16( cis32->hwndItem );
1053             cis.itemID1    = cis32->itemID1;
1054             cis.itemData1  = cis32->itemData1;
1055             cis.itemID2    = cis32->itemID2;
1056             cis.itemData2  = cis32->itemData2;
1057             lParam = MapLS( &cis );
1058             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1059             UnMapLS( lParam );
1060         }
1061         break;
1062     case WM_DELETEITEM:
1063         {
1064             DELETEITEMSTRUCT *dis32 = (DELETEITEMSTRUCT *)lParam;
1065             DELETEITEMSTRUCT16 dis;
1066             dis.CtlType  = dis32->CtlType;
1067             dis.CtlID    = dis32->CtlID;
1068             dis.itemID   = dis32->itemID;
1069             dis.hwndItem = (dis.CtlType == ODT_MENU) ? (HWND16)LOWORD(dis32->hwndItem)
1070                                                      : HWND_16( dis32->hwndItem );
1071             dis.itemData = dis32->itemData;
1072             lParam = MapLS( &dis );
1073             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1074             UnMapLS( lParam );
1075         }
1076         break;
1077     case WM_DRAWITEM:
1078         {
1079             DRAWITEMSTRUCT *dis32 = (DRAWITEMSTRUCT *)lParam;
1080             DRAWITEMSTRUCT16 dis;
1081             dis.CtlType       = dis32->CtlType;
1082             dis.CtlID         = dis32->CtlID;
1083             dis.itemID        = dis32->itemID;
1084             dis.itemAction    = dis32->itemAction;
1085             dis.itemState     = dis32->itemState;
1086             dis.hwndItem      = HWND_16( dis32->hwndItem );
1087             dis.hDC           = HDC_16(dis32->hDC);
1088             dis.itemData      = dis32->itemData;
1089             dis.rcItem.left   = dis32->rcItem.left;
1090             dis.rcItem.top    = dis32->rcItem.top;
1091             dis.rcItem.right  = dis32->rcItem.right;
1092             dis.rcItem.bottom = dis32->rcItem.bottom;
1093             lParam = MapLS( &dis );
1094             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1095             UnMapLS( lParam );
1096         }
1097         break;
1098     case WM_MEASUREITEM:
1099         {
1100             MEASUREITEMSTRUCT *mis32 = (MEASUREITEMSTRUCT *)lParam;
1101             MEASUREITEMSTRUCT16 mis;
1102             mis.CtlType    = mis32->CtlType;
1103             mis.CtlID      = mis32->CtlID;
1104             mis.itemID     = mis32->itemID;
1105             mis.itemWidth  = mis32->itemWidth;
1106             mis.itemHeight = mis32->itemHeight;
1107             mis.itemData   = mis32->itemData;
1108             lParam = MapLS( &mis );
1109             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1110             UnMapLS( lParam );
1111             mis32->itemWidth  = mis.itemWidth;
1112             mis32->itemHeight = mis.itemHeight;
1113         }
1114         break;
1115     case WM_COPYDATA:
1116         {
1117             COPYDATASTRUCT *cds32 = (COPYDATASTRUCT *)lParam;
1118             COPYDATASTRUCT16 cds;
1119
1120             cds.dwData = cds32->dwData;
1121             cds.cbData = cds32->cbData;
1122             cds.lpData = MapLS( cds32->lpData );
1123             lParam = MapLS( &cds );
1124             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1125             UnMapLS( lParam );
1126             UnMapLS( cds.lpData );
1127         }
1128         break;
1129     case WM_GETDLGCODE:
1130         if (lParam)
1131         {
1132             MSG *msg32 = (MSG *)lParam;
1133             MSG16 msg16;
1134
1135             msg16.hwnd    = HWND_16( msg32->hwnd );
1136             msg16.message = msg32->message;
1137             msg16.wParam  = msg32->wParam;
1138             msg16.lParam  = msg32->lParam;
1139             msg16.time    = msg32->time;
1140             msg16.pt.x    = msg32->pt.x;
1141             msg16.pt.y    = msg32->pt.y;
1142             lParam = MapLS( &msg16 );
1143             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1144             UnMapLS( lParam );
1145         }
1146         else
1147             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1148         break;
1149     case WM_NEXTMENU:
1150         {
1151             MDINEXTMENU *next = (MDINEXTMENU *)lParam;
1152             ret = callback( HWND_16(hwnd), msg, wParam, (LPARAM)next->hmenuIn, result, arg );
1153             next->hmenuNext = HMENU_32( LOWORD(*result) );
1154             next->hwndNext  = WIN_Handle32( HIWORD(*result) );
1155             *result = 0;
1156         }
1157         break;
1158     case WM_GETTEXT:
1159     case WM_ASKCBFORMATNAME:
1160         wParam = min( wParam, 0xff80 ); /* Must be < 64K */
1161         /* fall through */
1162     case WM_NOTIFY:
1163     case WM_SETTEXT:
1164     case WM_WININICHANGE:
1165     case WM_DEVMODECHANGE:
1166         lParam = MapLS( (void *)lParam );
1167         ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1168         UnMapLS( lParam );
1169         break;
1170     case WM_ACTIVATE:
1171     case WM_CHARTOITEM:
1172     case WM_COMMAND:
1173     case WM_VKEYTOITEM:
1174         ret = callback( HWND_16(hwnd), msg, wParam, MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ),
1175                         result, arg );
1176         break;
1177     case WM_HSCROLL:
1178     case WM_VSCROLL:
1179         ret = callback( HWND_16(hwnd), msg, wParam, MAKELPARAM( HIWORD(wParam), (HWND16)lParam ),
1180                         result, arg );
1181         break;
1182     case WM_CTLCOLORMSGBOX:
1183     case WM_CTLCOLOREDIT:
1184     case WM_CTLCOLORLISTBOX:
1185     case WM_CTLCOLORBTN:
1186     case WM_CTLCOLORDLG:
1187     case WM_CTLCOLORSCROLLBAR:
1188     case WM_CTLCOLORSTATIC:
1189         ret = callback( HWND_16(hwnd), WM_CTLCOLOR, wParam,
1190                         MAKELPARAM( (HWND16)lParam, msg - WM_CTLCOLORMSGBOX ), result, arg );
1191         break;
1192     case WM_MENUSELECT:
1193         if(HIWORD(wParam) & MF_POPUP)
1194         {
1195             HMENU hmenu;
1196             if ((HIWORD(wParam) != 0xffff) || lParam)
1197             {
1198                 if ((hmenu = GetSubMenu( (HMENU)lParam, LOWORD(wParam) )))
1199                 {
1200                     ret = callback( HWND_16(hwnd), msg, HMENU_16(hmenu),
1201                                     MAKELPARAM( HIWORD(wParam), (HMENU16)lParam ), result, arg );
1202                     break;
1203                 }
1204             }
1205         }
1206         /* fall through */
1207     case WM_MENUCHAR:
1208         ret = callback( HWND_16(hwnd), msg, wParam,
1209                         MAKELPARAM( HIWORD(wParam), (HMENU16)lParam ), result, arg );
1210         break;
1211     case WM_PARENTNOTIFY:
1212         if ((LOWORD(wParam) == WM_CREATE) || (LOWORD(wParam) == WM_DESTROY))
1213             ret = callback( HWND_16(hwnd), msg, wParam,
1214                             MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ), result, arg );
1215         else
1216             ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1217         break;
1218     case WM_ACTIVATEAPP:
1219         ret = callback( HWND_16(hwnd), msg, wParam, HTASK_16( lParam ), result, arg );
1220         break;
1221     case WM_PAINT:
1222         if (IsIconic( hwnd ) && GetClassLongPtrW( hwnd, GCLP_HICON ))
1223             ret = callback( HWND_16(hwnd), WM_PAINTICON, 1, lParam, result, arg );
1224         else
1225             ret = callback( HWND_16(hwnd), WM_PAINT, wParam, lParam, result, arg );
1226         break;
1227     case WM_ERASEBKGND:
1228         if (IsIconic( hwnd ) && GetClassLongPtrW( hwnd, GCLP_HICON )) msg = WM_ICONERASEBKGND;
1229         ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1230         break;
1231     case WM_DDE_INITIATE:
1232     case WM_DDE_TERMINATE:
1233     case WM_DDE_UNADVISE:
1234     case WM_DDE_REQUEST:
1235         ret = callback( HWND_16(hwnd), msg, HWND_16(wParam), lParam, result, arg );
1236         break;
1237     case WM_DDE_ADVISE:
1238     case WM_DDE_DATA:
1239     case WM_DDE_POKE:
1240         {
1241             UINT_PTR lo32, hi;
1242             HANDLE16 lo16 = 0;
1243
1244             UnpackDDElParam( msg, lParam, &lo32, &hi );
1245             if (lo32 && !(lo16 = convert_handle_32_to_16(lo32, GMEM_DDESHARE))) break;
1246             ret = callback( HWND_16(hwnd), msg, HWND_16(wParam),
1247                             MAKELPARAM(lo16, hi), result, arg );
1248         }
1249         break; /* FIXME don't know how to free allocated memory (handle)  !! */
1250     case WM_DDE_ACK:
1251         {
1252             UINT_PTR lo, hi;
1253             int flag = 0;
1254             char buf[2];
1255
1256             UnpackDDElParam( msg, lParam, &lo, &hi );
1257
1258             if (GlobalGetAtomNameA((ATOM)hi, buf, sizeof(buf)) > 0) flag |= 1;
1259             if (GlobalSize((HANDLE)hi) != 0) flag |= 2;
1260             switch (flag)
1261             {
1262             case 0:
1263                 if (hi)
1264                 {
1265                     WARN("DDE_ACK: neither atom nor handle!!!\n");
1266                     hi = 0;
1267                 }
1268                 break;
1269             case 1:
1270                 break; /* atom, nothing to do */
1271             case 3:
1272                 WARN("DDE_ACK: %lx both atom and handle... choosing handle\n", hi);
1273                 /* fall through */
1274             case 2:
1275                 hi = convert_handle_32_to_16(hi, GMEM_DDESHARE);
1276                 break;
1277             }
1278             ret = callback( HWND_16(hwnd), msg, HWND_16(wParam),
1279                             MAKELPARAM(lo, hi), result, arg );
1280         }
1281         break; /* FIXME don't know how to free allocated memory (handle) !! */
1282     case WM_DDE_EXECUTE:
1283         lParam = convert_handle_32_to_16(lParam, GMEM_DDESHARE);
1284         ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1285         break; /* FIXME don't know how to free allocated memory (handle) !! */
1286     case SBM_SETRANGE:
1287         ret = callback( HWND_16(hwnd), SBM_SETRANGE16, 0, MAKELPARAM(wParam, lParam), result, arg );
1288         break;
1289     case SBM_GETRANGE:
1290         ret = callback( HWND_16(hwnd), SBM_GETRANGE16, wParam, lParam, result, arg );
1291         *(LPINT)wParam = LOWORD(*result);
1292         *(LPINT)lParam = HIWORD(*result);
1293         break;
1294     case BM_GETCHECK:
1295     case BM_SETCHECK:
1296     case BM_GETSTATE:
1297     case BM_SETSTATE:
1298     case BM_SETSTYLE:
1299         ret = callback( HWND_16(hwnd), msg + BM_GETCHECK16 - BM_GETCHECK, wParam, lParam, result, arg );
1300         break;
1301     case EM_GETSEL:
1302     case EM_GETRECT:
1303     case EM_SETRECT:
1304     case EM_SETRECTNP:
1305     case EM_SCROLL:
1306     case EM_LINESCROLL:
1307     case EM_SCROLLCARET:
1308     case EM_GETMODIFY:
1309     case EM_SETMODIFY:
1310     case EM_GETLINECOUNT:
1311     case EM_LINEINDEX:
1312     case EM_SETHANDLE:
1313     case EM_GETHANDLE:
1314     case EM_GETTHUMB:
1315     case EM_LINELENGTH:
1316     case EM_REPLACESEL:
1317     case EM_GETLINE:
1318     case EM_LIMITTEXT:
1319     case EM_CANUNDO:
1320     case EM_UNDO:
1321     case EM_FMTLINES:
1322     case EM_LINEFROMCHAR:
1323     case EM_SETTABSTOPS:
1324     case EM_SETPASSWORDCHAR:
1325     case EM_EMPTYUNDOBUFFER:
1326     case EM_GETFIRSTVISIBLELINE:
1327     case EM_SETREADONLY:
1328     case EM_SETWORDBREAKPROC:
1329     case EM_GETWORDBREAKPROC:
1330     case EM_GETPASSWORDCHAR:
1331         ret = callback( HWND_16(hwnd), msg + EM_GETSEL16 - EM_GETSEL, wParam, lParam, result, arg );
1332         break;
1333     case EM_SETSEL:
1334         ret = callback( HWND_16(hwnd), EM_SETSEL16, 0, MAKELPARAM( wParam, lParam ), result, arg );
1335         break;
1336     case LB_CARETOFF:
1337     case LB_CARETON:
1338     case LB_DELETESTRING:
1339     case LB_GETANCHORINDEX:
1340     case LB_GETCARETINDEX:
1341     case LB_GETCOUNT:
1342     case LB_GETCURSEL:
1343     case LB_GETHORIZONTALEXTENT:
1344     case LB_GETITEMDATA:
1345     case LB_GETITEMHEIGHT:
1346     case LB_GETSEL:
1347     case LB_GETSELCOUNT:
1348     case LB_GETTEXTLEN:
1349     case LB_GETTOPINDEX:
1350     case LB_RESETCONTENT:
1351     case LB_SELITEMRANGE:
1352     case LB_SELITEMRANGEEX:
1353     case LB_SETANCHORINDEX:
1354     case LB_SETCARETINDEX:
1355     case LB_SETCOLUMNWIDTH:
1356     case LB_SETCURSEL:
1357     case LB_SETHORIZONTALEXTENT:
1358     case LB_SETITEMDATA:
1359     case LB_SETITEMHEIGHT:
1360     case LB_SETSEL:
1361     case LB_SETTOPINDEX:
1362         ret = callback( HWND_16(hwnd), msg + LB_ADDSTRING16 - LB_ADDSTRING, wParam, lParam, result, arg );
1363         break;
1364     case LB_ADDSTRING:
1365     case LB_FINDSTRING:
1366     case LB_FINDSTRINGEXACT:
1367     case LB_INSERTSTRING:
1368     case LB_SELECTSTRING:
1369     case LB_GETTEXT:
1370     case LB_DIR:
1371     case LB_ADDFILE:
1372         lParam = MapLS( (LPSTR)lParam );
1373         ret = callback( HWND_16(hwnd), msg + LB_ADDSTRING16 - LB_ADDSTRING, wParam, lParam, result, arg );
1374         UnMapLS( lParam );
1375         break;
1376     case LB_GETSELITEMS:
1377         {
1378             INT *items32 = (INT *)lParam;
1379             INT16 *items, buffer[512];
1380             unsigned int i;
1381
1382             wParam = min( wParam, 0x7f80 ); /* Must be < 64K */
1383             if (!(items = get_buffer( buffer, sizeof(buffer), wParam * sizeof(INT16) ))) break;
1384             lParam = MapLS( items );
1385             ret = callback( HWND_16(hwnd), LB_GETSELITEMS16, wParam, lParam, result, arg );
1386             UnMapLS( lParam );
1387             for (i = 0; i < wParam; i++) items32[i] = items[i];
1388             free_buffer( buffer, items );
1389         }
1390         break;
1391     case LB_SETTABSTOPS:
1392         if (wParam)
1393         {
1394             INT *stops32 = (INT *)lParam;
1395             INT16 *stops, buffer[512];
1396             unsigned int i;
1397
1398             wParam = min( wParam, 0x7f80 ); /* Must be < 64K */
1399             if (!(stops = get_buffer( buffer, sizeof(buffer), wParam * sizeof(INT16) ))) break;
1400             for (i = 0; i < wParam; i++) stops[i] = stops32[i];
1401             lParam = MapLS( stops );
1402             ret = callback( HWND_16(hwnd), LB_SETTABSTOPS16, wParam, lParam, result, arg );
1403             UnMapLS( lParam );
1404             free_buffer( buffer, stops );
1405         }
1406         else ret = callback( HWND_16(hwnd), LB_SETTABSTOPS16, wParam, lParam, result, arg );
1407         break;
1408     case CB_DELETESTRING:
1409     case CB_GETCOUNT:
1410     case CB_GETLBTEXTLEN:
1411     case CB_LIMITTEXT:
1412     case CB_RESETCONTENT:
1413     case CB_SETEDITSEL:
1414     case CB_GETCURSEL:
1415     case CB_SETCURSEL:
1416     case CB_SHOWDROPDOWN:
1417     case CB_SETITEMDATA:
1418     case CB_SETITEMHEIGHT:
1419     case CB_GETITEMHEIGHT:
1420     case CB_SETEXTENDEDUI:
1421     case CB_GETEXTENDEDUI:
1422     case CB_GETDROPPEDSTATE:
1423         ret = callback( HWND_16(hwnd), msg + CB_GETEDITSEL16 - CB_GETEDITSEL, wParam, lParam, result, arg );
1424         break;
1425     case CB_GETEDITSEL:
1426         ret = callback( HWND_16(hwnd), CB_GETEDITSEL16, wParam, lParam, result, arg );
1427         if (wParam) *((PUINT)(wParam)) = LOWORD(*result);
1428         if (lParam) *((PUINT)(lParam)) = HIWORD(*result);  /* FIXME: subtract 1? */
1429         break;
1430     case CB_ADDSTRING:
1431     case CB_FINDSTRING:
1432     case CB_FINDSTRINGEXACT:
1433     case CB_INSERTSTRING:
1434     case CB_SELECTSTRING:
1435     case CB_DIR:
1436     case CB_GETLBTEXT:
1437         lParam = MapLS( (LPSTR)lParam );
1438         ret = callback( HWND_16(hwnd), msg + CB_GETEDITSEL16 - CB_GETEDITSEL, wParam, lParam, result, arg );
1439         UnMapLS( lParam );
1440         break;
1441     case LB_GETITEMRECT:
1442     case CB_GETDROPPEDCONTROLRECT:
1443         {
1444             RECT *r32 = (RECT *)lParam;
1445             RECT16 rect;
1446             lParam = MapLS( &rect );
1447             ret = callback( HWND_16(hwnd),
1448                             (msg == LB_GETITEMRECT) ? LB_GETITEMRECT16 : CB_GETDROPPEDCONTROLRECT16,
1449                             wParam, lParam, result, arg );
1450             UnMapLS( lParam );
1451             RECT16to32( &rect, r32 );
1452         }
1453         break;
1454     case WM_PAINTCLIPBOARD:
1455     case WM_SIZECLIPBOARD:
1456         FIXME_(msg)( "message %04x needs translation\n", msg );
1457         break;
1458     /* the following messages should not be sent to 16-bit apps */
1459     case WM_SIZING:
1460     case WM_MOVING:
1461     case WM_CAPTURECHANGED:
1462     case WM_STYLECHANGING:
1463     case WM_STYLECHANGED:
1464         break;
1465     default:
1466         ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1467         break;
1468     }
1469     return ret;
1470 }
1471
1472
1473 /***********************************************************************
1474  *              SendMessage  (USER.111)
1475  */
1476 LRESULT WINAPI SendMessage16( HWND16 hwnd16, UINT16 msg, WPARAM16 wparam, LPARAM lparam )
1477 {
1478     LRESULT result;
1479     HWND hwnd = WIN_Handle32( hwnd16 );
1480
1481     if (hwnd != HWND_BROADCAST &&
1482         GetWindowThreadProcessId( hwnd, NULL ) == GetCurrentThreadId())
1483     {
1484         /* call 16-bit window proc directly */
1485         WNDPROC16 winproc;
1486
1487         /* first the WH_CALLWNDPROC hook */
1488         call_WH_CALLWNDPROC_hook( hwnd16, msg, wparam, lparam );
1489
1490         if (!(winproc = (WNDPROC16)GetWindowLong16( hwnd16, GWLP_WNDPROC ))) return 0;
1491
1492         TRACE_(message)("(0x%04x) [%04x] wp=%04x lp=%08lx\n", hwnd16, msg, wparam, lparam );
1493         result = CallWindowProc16( winproc, hwnd16, msg, wparam, lparam );
1494         TRACE_(message)("(0x%04x) [%04x] wp=%04x lp=%08lx returned %08lx\n",
1495                         hwnd16, msg, wparam, lparam, result );
1496     }
1497     else  /* map to 32-bit unicode for inter-thread/process message */
1498     {
1499         WINPROC_CallProc16To32A( send_message_callback, hwnd16, msg, wparam, lparam, &result, NULL );
1500     }
1501     return result;
1502 }
1503
1504
1505 /***********************************************************************
1506  *              PostMessage  (USER.110)
1507  */
1508 BOOL16 WINAPI PostMessage16( HWND16 hwnd, UINT16 msg, WPARAM16 wparam, LPARAM lparam )
1509 {
1510     LRESULT unused;
1511     return WINPROC_CallProc16To32A( post_message_callback, hwnd, msg, wparam, lparam, &unused, NULL );
1512 }
1513
1514
1515 /***********************************************************************
1516  *              PostAppMessage (USER.116)
1517  */
1518 BOOL16 WINAPI PostAppMessage16( HTASK16 hTask, UINT16 msg, WPARAM16 wparam, LPARAM lparam )
1519 {
1520     LRESULT unused;
1521     DWORD_PTR tid = HTASK_32( hTask );
1522
1523     if (!tid) return FALSE;
1524     return WINPROC_CallProc16To32A( post_thread_message_callback, 0, msg, wparam, lparam,
1525                                     &unused, (void *)tid );
1526 }
1527
1528
1529 /**********************************************************************
1530  *              CallWindowProc (USER.122)
1531  */
1532 LRESULT WINAPI CallWindowProc16( WNDPROC16 func, HWND16 hwnd, UINT16 msg,
1533                                  WPARAM16 wParam, LPARAM lParam )
1534 {
1535     int index = winproc_to_index( func );
1536     LRESULT result;
1537
1538     if (!func) return 0;
1539
1540     if (index == -1 || index >= MAX_WINPROCS32)
1541         call_window_proc16( hwnd, msg, wParam, lParam, &result, func );
1542     else
1543     {
1544         WNDPROC proc = (WNDPROC)func;
1545         if (thunk_array && thunk_array[index].proc) proc = thunk_array[index].proc;
1546         WINPROC_CallProc16To32A( call_window_proc_callback, hwnd, msg, wParam, lParam, &result, proc );
1547     }
1548     return result;
1549 }
1550
1551
1552 /**********************************************************************
1553  *           __wine_call_wndproc   (USER.1010)
1554  */
1555 LRESULT WINAPI __wine_call_wndproc( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam, WNDPROC proc )
1556 {
1557     LRESULT result;
1558     WINPROC_CallProc16To32A( call_window_proc_callback, hwnd, msg, wParam, lParam, &result, proc );
1559     return result;
1560 }
1561
1562
1563 /***********************************************************************
1564  *              InSendMessage  (USER.192)
1565  */
1566 BOOL16 WINAPI InSendMessage16(void)
1567 {
1568     return InSendMessage();
1569 }
1570
1571
1572 /***********************************************************************
1573  *              ReplyMessage  (USER.115)
1574  */
1575 void WINAPI ReplyMessage16( LRESULT result )
1576 {
1577     ReplyMessage( result );
1578 }
1579
1580
1581 /***********************************************************************
1582  *              PeekMessage32 (USER.819)
1583  */
1584 BOOL16 WINAPI PeekMessage32_16( MSG32_16 *msg16, HWND16 hwnd16,
1585                                 UINT16 first, UINT16 last, UINT16 flags,
1586                                 BOOL16 wHaveParamHigh )
1587 {
1588     MSG msg;
1589     LRESULT unused;
1590     HWND hwnd = WIN_Handle32( hwnd16 );
1591
1592     if(USER16_AlertableWait)
1593         MsgWaitForMultipleObjectsEx( 0, NULL, 0, 0, MWMO_ALERTABLE );
1594     if (!PeekMessageA( &msg, hwnd, first, last, flags )) return FALSE;
1595
1596     msg16->msg.time    = msg.time;
1597     msg16->msg.pt.x    = (INT16)msg.pt.x;
1598     msg16->msg.pt.y    = (INT16)msg.pt.y;
1599     if (wHaveParamHigh) msg16->wParamHigh = HIWORD(msg.wParam);
1600     WINPROC_CallProc32ATo16( get_message_callback, msg.hwnd, msg.message, msg.wParam, msg.lParam,
1601                              &unused, &msg16->msg );
1602     return TRUE;
1603 }
1604
1605
1606 /***********************************************************************
1607  *              DefWindowProc (USER.107)
1608  */
1609 LRESULT WINAPI DefWindowProc16( HWND16 hwnd16, UINT16 msg, WPARAM16 wParam, LPARAM lParam )
1610 {
1611     LRESULT result;
1612     HWND hwnd = WIN_Handle32( hwnd16 );
1613
1614     switch(msg)
1615     {
1616     case WM_NCCREATE:
1617         {
1618             CREATESTRUCT16 *cs16 = MapSL(lParam);
1619             CREATESTRUCTA cs32;
1620
1621             cs32.lpCreateParams = ULongToPtr(cs16->lpCreateParams);
1622             cs32.hInstance      = HINSTANCE_32(cs16->hInstance);
1623             cs32.hMenu          = HMENU_32(cs16->hMenu);
1624             cs32.hwndParent     = WIN_Handle32(cs16->hwndParent);
1625             cs32.cy             = cs16->cy;
1626             cs32.cx             = cs16->cx;
1627             cs32.y              = cs16->y;
1628             cs32.x              = cs16->x;
1629             cs32.style          = cs16->style;
1630             cs32.dwExStyle      = cs16->dwExStyle;
1631             cs32.lpszName       = MapSL(cs16->lpszName);
1632             cs32.lpszClass      = MapSL(cs16->lpszClass);
1633             return DefWindowProcA( hwnd, msg, wParam, (LPARAM)&cs32 );
1634         }
1635     case WM_NCCALCSIZE:
1636         {
1637             RECT16 *rect16 = MapSL(lParam);
1638             RECT rect32;
1639
1640             rect32.left    = rect16->left;
1641             rect32.top     = rect16->top;
1642             rect32.right   = rect16->right;
1643             rect32.bottom  = rect16->bottom;
1644
1645             result = DefWindowProcA( hwnd, msg, wParam, (LPARAM)&rect32 );
1646
1647             rect16->left   = rect32.left;
1648             rect16->top    = rect32.top;
1649             rect16->right  = rect32.right;
1650             rect16->bottom = rect32.bottom;
1651             return result;
1652         }
1653     case WM_WINDOWPOSCHANGING:
1654     case WM_WINDOWPOSCHANGED:
1655         {
1656             WINDOWPOS16 *pos16 = MapSL(lParam);
1657             WINDOWPOS pos32;
1658
1659             pos32.hwnd             = WIN_Handle32(pos16->hwnd);
1660             pos32.hwndInsertAfter  = WIN_Handle32(pos16->hwndInsertAfter);
1661             pos32.x                = pos16->x;
1662             pos32.y                = pos16->y;
1663             pos32.cx               = pos16->cx;
1664             pos32.cy               = pos16->cy;
1665             pos32.flags            = pos16->flags;
1666
1667             result = DefWindowProcA( hwnd, msg, wParam, (LPARAM)&pos32 );
1668
1669             pos16->hwnd            = HWND_16(pos32.hwnd);
1670             pos16->hwndInsertAfter = HWND_16(pos32.hwndInsertAfter);
1671             pos16->x               = pos32.x;
1672             pos16->y               = pos32.y;
1673             pos16->cx              = pos32.cx;
1674             pos16->cy              = pos32.cy;
1675             pos16->flags           = pos32.flags;
1676             return result;
1677         }
1678     case WM_GETTEXT:
1679     case WM_SETTEXT:
1680         return DefWindowProcA( hwnd, msg, wParam, (LPARAM)MapSL(lParam) );
1681     default:
1682         return DefWindowProcA( hwnd, msg, wParam, lParam );
1683     }
1684 }
1685
1686
1687 /***********************************************************************
1688  *              DefDlgProc (USER.308)
1689  */
1690 LRESULT WINAPI DefDlgProc16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam )
1691 {
1692     LRESULT result;
1693     WINPROC_CallProc16To32A( defdlg_proc_callback, hwnd, msg, wParam, lParam, &result, 0 );
1694     return result;
1695 }
1696
1697
1698 /***********************************************************************
1699  *              PeekMessage  (USER.109)
1700  */
1701 BOOL16 WINAPI PeekMessage16( MSG16 *msg, HWND16 hwnd,
1702                              UINT16 first, UINT16 last, UINT16 flags )
1703 {
1704     return PeekMessage32_16( (MSG32_16 *)msg, hwnd, first, last, flags, FALSE );
1705 }
1706
1707
1708 /***********************************************************************
1709  *              GetMessage32  (USER.820)
1710  */
1711 BOOL16 WINAPI GetMessage32_16( MSG32_16 *msg16, HWND16 hwnd16, UINT16 first,
1712                                UINT16 last, BOOL16 wHaveParamHigh )
1713 {
1714     MSG msg;
1715     LRESULT unused;
1716     HWND hwnd = WIN_Handle32( hwnd16 );
1717
1718     if(USER16_AlertableWait)
1719         MsgWaitForMultipleObjectsEx( 0, NULL, INFINITE, 0, MWMO_ALERTABLE );
1720     GetMessageA( &msg, hwnd, first, last );
1721     msg16->msg.time    = msg.time;
1722     msg16->msg.pt.x    = (INT16)msg.pt.x;
1723     msg16->msg.pt.y    = (INT16)msg.pt.y;
1724     if (wHaveParamHigh) msg16->wParamHigh = HIWORD(msg.wParam);
1725     WINPROC_CallProc32ATo16( get_message_callback, msg.hwnd, msg.message, msg.wParam, msg.lParam,
1726                              &unused, &msg16->msg );
1727
1728     TRACE( "message %04x, hwnd %p, filter(%04x - %04x)\n",
1729            msg16->msg.message, hwnd, first, last );
1730
1731     return msg16->msg.message != WM_QUIT;
1732 }
1733
1734
1735 /***********************************************************************
1736  *              GetMessage  (USER.108)
1737  */
1738 BOOL16 WINAPI GetMessage16( MSG16 *msg, HWND16 hwnd, UINT16 first, UINT16 last )
1739 {
1740     return GetMessage32_16( (MSG32_16 *)msg, hwnd, first, last, FALSE );
1741 }
1742
1743
1744 /***********************************************************************
1745  *              TranslateMessage32 (USER.821)
1746  */
1747 BOOL16 WINAPI TranslateMessage32_16( const MSG32_16 *msg, BOOL16 wHaveParamHigh )
1748 {
1749     MSG msg32;
1750
1751     msg32.hwnd    = WIN_Handle32( msg->msg.hwnd );
1752     msg32.message = msg->msg.message;
1753     msg32.wParam  = MAKEWPARAM( msg->msg.wParam, wHaveParamHigh ? msg->wParamHigh : 0 );
1754     msg32.lParam  = msg->msg.lParam;
1755     return TranslateMessage( &msg32 );
1756 }
1757
1758
1759 /***********************************************************************
1760  *              TranslateMessage (USER.113)
1761  */
1762 BOOL16 WINAPI TranslateMessage16( const MSG16 *msg )
1763 {
1764     return TranslateMessage32_16( (const MSG32_16 *)msg, FALSE );
1765 }
1766
1767
1768 /***********************************************************************
1769  *              DispatchMessage (USER.114)
1770  */
1771 LONG WINAPI DispatchMessage16( const MSG16* msg )
1772 {
1773     WNDPROC16 winproc;
1774     LRESULT retval;
1775
1776       /* Process timer messages */
1777     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
1778     {
1779         if (msg->lParam)
1780             return CallWindowProc16( (WNDPROC16)msg->lParam, msg->hwnd,
1781                                      msg->message, msg->wParam, GetTickCount() );
1782     }
1783
1784     if (!(winproc = (WNDPROC16)GetWindowLong16( msg->hwnd, GWLP_WNDPROC )))
1785     {
1786         SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1787         return 0;
1788     }
1789     TRACE_(message)("(0x%04x) [%04x] wp=%04x lp=%08lx\n", msg->hwnd, msg->message, msg->wParam, msg->lParam );
1790     retval = CallWindowProc16( winproc, msg->hwnd, msg->message, msg->wParam, msg->lParam );
1791     TRACE_(message)("(0x%04x) [%04x] wp=%04x lp=%08lx returned %08lx\n",
1792                     msg->hwnd, msg->message, msg->wParam, msg->lParam, retval );
1793     return retval;
1794 }
1795
1796
1797 /***********************************************************************
1798  *              DispatchMessage32 (USER.822)
1799  */
1800 LONG WINAPI DispatchMessage32_16( const MSG32_16 *msg16, BOOL16 wHaveParamHigh )
1801 {
1802     if (wHaveParamHigh == FALSE)
1803         return DispatchMessage16( &msg16->msg );
1804     else
1805     {
1806         MSG msg;
1807
1808         msg.hwnd    = WIN_Handle32( msg16->msg.hwnd );
1809         msg.message = msg16->msg.message;
1810         msg.wParam  = MAKEWPARAM( msg16->msg.wParam, msg16->wParamHigh );
1811         msg.lParam  = msg16->msg.lParam;
1812         msg.time    = msg16->msg.time;
1813         msg.pt.x    = msg16->msg.pt.x;
1814         msg.pt.y    = msg16->msg.pt.y;
1815         return DispatchMessageA( &msg );
1816     }
1817 }
1818
1819
1820 /***********************************************************************
1821  *              IsDialogMessage (USER.90)
1822  */
1823 BOOL16 WINAPI IsDialogMessage16( HWND16 hwndDlg, MSG16 *msg16 )
1824 {
1825     MSG msg;
1826     HWND hwndDlg32;
1827
1828     msg.hwnd  = WIN_Handle32(msg16->hwnd);
1829     hwndDlg32 = WIN_Handle32(hwndDlg);
1830
1831     switch(msg16->message)
1832     {
1833     case WM_KEYDOWN:
1834     case WM_CHAR:
1835     case WM_SYSCHAR:
1836         msg.message = msg16->message;
1837         msg.wParam  = msg16->wParam;
1838         msg.lParam  = msg16->lParam;
1839         return IsDialogMessageA( hwndDlg32, &msg );
1840     }
1841
1842     if ((hwndDlg32 != msg.hwnd) && !IsChild( hwndDlg32, msg.hwnd )) return FALSE;
1843     TranslateMessage16( msg16 );
1844     DispatchMessage16( msg16 );
1845     return TRUE;
1846 }
1847
1848
1849 /***********************************************************************
1850  *              MsgWaitForMultipleObjects  (USER.640)
1851  */
1852 DWORD WINAPI MsgWaitForMultipleObjects16( DWORD count, const HANDLE *handles,
1853                                           BOOL wait_all, DWORD timeout, DWORD mask )
1854 {
1855     return MsgWaitForMultipleObjectsEx( count, handles, timeout, mask,
1856                                         wait_all ? MWMO_WAITALL : 0 );
1857 }
1858
1859
1860 /**********************************************************************
1861  *              SetDoubleClickTime (USER.20)
1862  */
1863 void WINAPI SetDoubleClickTime16( UINT16 interval )
1864 {
1865     SetDoubleClickTime( interval );
1866 }
1867
1868
1869 /**********************************************************************
1870  *              GetDoubleClickTime (USER.21)
1871  */
1872 UINT16 WINAPI GetDoubleClickTime16(void)
1873 {
1874     return GetDoubleClickTime();
1875 }
1876
1877
1878 /***********************************************************************
1879  *              PostQuitMessage (USER.6)
1880  */
1881 void WINAPI PostQuitMessage16( INT16 exitCode )
1882 {
1883     PostQuitMessage( exitCode );
1884 }
1885
1886
1887 /**********************************************************************
1888  *              GetKeyState (USER.106)
1889  */
1890 INT16 WINAPI GetKeyState16(INT16 vkey)
1891 {
1892     return GetKeyState(vkey);
1893 }
1894
1895
1896 /**********************************************************************
1897  *              GetKeyboardState (USER.222)
1898  */
1899 BOOL WINAPI GetKeyboardState16( LPBYTE state )
1900 {
1901     return GetKeyboardState( state );
1902 }
1903
1904
1905 /**********************************************************************
1906  *              SetKeyboardState (USER.223)
1907  */
1908 BOOL WINAPI SetKeyboardState16( LPBYTE state )
1909 {
1910     return SetKeyboardState( state );
1911 }
1912
1913
1914 /***********************************************************************
1915  *              SetMessageQueue (USER.266)
1916  */
1917 BOOL16 WINAPI SetMessageQueue16( INT16 size )
1918 {
1919     return SetMessageQueue( size );
1920 }
1921
1922
1923 /***********************************************************************
1924  *              UserYield (USER.332)
1925  */
1926 void WINAPI UserYield16(void)
1927 {
1928     MSG msg;
1929     PeekMessageW( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE );
1930 }
1931
1932
1933 /***********************************************************************
1934  *              GetQueueStatus (USER.334)
1935  */
1936 DWORD WINAPI GetQueueStatus16( UINT16 flags )
1937 {
1938     return GetQueueStatus( flags );
1939 }
1940
1941
1942 /***********************************************************************
1943  *              GetInputState (USER.335)
1944  */
1945 BOOL16 WINAPI GetInputState16(void)
1946 {
1947     return GetInputState();
1948 }
1949
1950
1951 /**********************************************************************
1952  *           TranslateAccelerator      (USER.178)
1953  */
1954 INT16 WINAPI TranslateAccelerator16( HWND16 hwnd, HACCEL16 hAccel, LPMSG16 msg )
1955 {
1956     MSG msg32;
1957
1958     if (!msg) return 0;
1959     msg32.message = msg->message;
1960     /* msg32.hwnd not used */
1961     msg32.wParam  = msg->wParam;
1962     msg32.lParam  = msg->lParam;
1963     return TranslateAcceleratorW( WIN_Handle32(hwnd), HACCEL_32(hAccel), &msg32 );
1964 }
1965
1966
1967 /**********************************************************************
1968  *              TranslateMDISysAccel (USER.451)
1969  */
1970 BOOL16 WINAPI TranslateMDISysAccel16( HWND16 hwndClient, LPMSG16 msg )
1971 {
1972     if (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
1973     {
1974         MSG msg32;
1975         msg32.hwnd    = WIN_Handle32(msg->hwnd);
1976         msg32.message = msg->message;
1977         msg32.wParam  = msg->wParam;
1978         msg32.lParam  = msg->lParam;
1979         /* MDICLIENTINFO is still the same for win32 and win16 ... */
1980         return TranslateMDISysAccel( WIN_Handle32(hwndClient), &msg32 );
1981     }
1982     return 0;
1983 }
1984
1985
1986 /***********************************************************************
1987  *           button_proc16
1988  */
1989 static LRESULT button_proc16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode )
1990 {
1991     static const UINT msg16_offset = BM_GETCHECK16 - BM_GETCHECK;
1992
1993     switch (msg)
1994     {
1995     case BM_GETCHECK16:
1996     case BM_SETCHECK16:
1997     case BM_GETSTATE16:
1998     case BM_SETSTATE16:
1999     case BM_SETSTYLE16:
2000         return wow_handlers32.button_proc( hwnd, msg - msg16_offset, wParam, lParam, FALSE );
2001     default:
2002         return wow_handlers32.button_proc( hwnd, msg, wParam, lParam, unicode );
2003     }
2004 }
2005
2006
2007 /***********************************************************************
2008  *           combo_proc16
2009  */
2010 static LRESULT combo_proc16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode )
2011 {
2012     static const UINT msg16_offset = CB_GETEDITSEL16 - CB_GETEDITSEL;
2013
2014     switch (msg)
2015     {
2016     case CB_INSERTSTRING16:
2017     case CB_SELECTSTRING16:
2018     case CB_FINDSTRING16:
2019     case CB_FINDSTRINGEXACT16:
2020         wParam = (INT)(INT16)wParam;
2021         /* fall through */
2022     case CB_ADDSTRING16:
2023     {
2024         DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
2025         if ((style & CBS_HASSTRINGS) || !(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)))
2026            lParam = (LPARAM)MapSL(lParam);
2027         msg -= msg16_offset;
2028         break;
2029     }
2030     case CB_SETITEMHEIGHT16:
2031     case CB_GETITEMHEIGHT16:
2032     case CB_SETCURSEL16:
2033     case CB_GETLBTEXTLEN16:
2034     case CB_GETITEMDATA16:
2035     case CB_SETITEMDATA16:
2036         wParam = (INT)(INT16)wParam;    /* signed integer */
2037         msg -= msg16_offset;
2038         break;
2039     case CB_GETDROPPEDCONTROLRECT16:
2040         lParam = (LPARAM)MapSL(lParam);
2041         if (lParam)
2042         {
2043             RECT r;
2044             RECT16 *r16 = (RECT16 *)lParam;
2045             wow_handlers32.combo_proc( hwnd, CB_GETDROPPEDCONTROLRECT, wParam, (LPARAM)&r, FALSE );
2046             r16->left   = r.left;
2047             r16->top    = r.top;
2048             r16->right  = r.right;
2049             r16->bottom = r.bottom;
2050         }
2051         return CB_OKAY;
2052     case CB_DIR16:
2053         if (wParam & DDL_DRIVES) wParam |= DDL_EXCLUSIVE;
2054         lParam = (LPARAM)MapSL(lParam);
2055         msg -= msg16_offset;
2056         break;
2057     case CB_GETLBTEXT16:
2058         wParam = (INT)(INT16)wParam;
2059         lParam = (LPARAM)MapSL(lParam);
2060         msg -= msg16_offset;
2061         break;
2062     case CB_GETEDITSEL16:
2063         wParam = lParam = 0;   /* just in case */
2064         msg -= msg16_offset;
2065         break;
2066     case CB_LIMITTEXT16:
2067     case CB_SETEDITSEL16:
2068     case CB_DELETESTRING16:
2069     case CB_RESETCONTENT16:
2070     case CB_GETDROPPEDSTATE16:
2071     case CB_SHOWDROPDOWN16:
2072     case CB_GETCOUNT16:
2073     case CB_GETCURSEL16:
2074     case CB_SETEXTENDEDUI16:
2075     case CB_GETEXTENDEDUI16:
2076         msg -= msg16_offset;
2077         break;
2078     default:
2079         return wow_handlers32.combo_proc( hwnd, msg, wParam, lParam, unicode );
2080     }
2081     return wow_handlers32.combo_proc( hwnd, msg, wParam, lParam, FALSE );
2082 }
2083
2084 /*********************************************************************
2085  * edit_lock_buffer (internal)
2086  *
2087  * A 16 bit application might send an EM_GETHANDLE message and expect a HLOCAL16
2088  * (16 bit SEG:OFF handler). From that moment on we have to keep using this
2089  * 16 bit memory handler, because it is supposed to be valid at all times after
2090  * EM_GETHANDLE.
2091  * We create a HLOCAL16 buffer in edit_get_handle and copy the text from the
2092  * HLOCAL buffer, when needed
2093  *
2094  */
2095
2096 #define GWW_HANDLE16 sizeof(void*)
2097
2098 static void edit_lock_buffer( HWND hwnd )
2099 {
2100     STACK16FRAME* stack16 = MapSL(PtrToUlong(NtCurrentTeb()->WOW32Reserved));
2101     HLOCAL16 hloc16 = GetWindowWord( hwnd, GWW_HANDLE16 );
2102     HANDLE16 oldDS;
2103     HLOCAL hloc32;
2104     UINT size;
2105
2106     if (!hloc16) return;
2107     if (!(hloc32 = (HLOCAL)wow_handlers32.edit_proc( hwnd, EM_GETHANDLE, 0, 0, FALSE ))) return;
2108
2109     oldDS = stack16->ds;
2110     stack16->ds = GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
2111     size = LocalSize16(hloc16);
2112     if (LocalReAlloc( hloc32, size, LMEM_MOVEABLE ))
2113     {
2114         char *text = MapSL( LocalLock16( hloc16 ));
2115         char *dest = LocalLock( hloc32 );
2116         memcpy( dest, text, size );
2117         LocalUnlock( hloc32 );
2118         LocalUnlock16( hloc16 );
2119     }
2120     stack16->ds = oldDS;
2121
2122 }
2123
2124 static void edit_unlock_buffer( HWND hwnd )
2125 {
2126     STACK16FRAME* stack16 = MapSL(PtrToUlong(NtCurrentTeb()->WOW32Reserved));
2127     HLOCAL16 hloc16 = GetWindowWord( hwnd, GWW_HANDLE16 );
2128     HANDLE16 oldDS;
2129     HLOCAL hloc32;
2130     UINT size;
2131
2132     if (!hloc16) return;
2133     if (!(hloc32 = (HLOCAL)wow_handlers32.edit_proc( hwnd, EM_GETHANDLE, 0, 0, FALSE ))) return;
2134     size = LocalSize( hloc32 );
2135
2136     oldDS = stack16->ds;
2137     stack16->ds = GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
2138     if (LocalReAlloc16( hloc16, size, LMEM_MOVEABLE ))
2139     {
2140         char *text = LocalLock( hloc32 );
2141         char *dest = MapSL( LocalLock16( hloc16 ));
2142         memcpy( dest, text, size );
2143         LocalUnlock( hloc32 );
2144         LocalUnlock16( hloc16 );
2145     }
2146     stack16->ds = oldDS;
2147 }
2148
2149 static HLOCAL16 edit_get_handle( HWND hwnd )
2150 {
2151     CHAR *textA;
2152     UINT alloc_size;
2153     HLOCAL hloc;
2154     STACK16FRAME* stack16;
2155     HANDLE16 oldDS;
2156     HLOCAL16 hloc16 = GetWindowWord( hwnd, GWW_HANDLE16 );
2157
2158     if (hloc16) return hloc16;
2159
2160     if (!(hloc = (HLOCAL)wow_handlers32.edit_proc( hwnd, EM_GETHANDLE, 0, 0, FALSE ))) return 0;
2161     alloc_size = LocalSize( hloc );
2162
2163     stack16 = MapSL(PtrToUlong(NtCurrentTeb()->WOW32Reserved));
2164     oldDS = stack16->ds;
2165     stack16->ds = GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
2166
2167     if (!LocalHeapSize16())
2168     {
2169         if (!LocalInit16(stack16->ds, 0, GlobalSize16(stack16->ds)))
2170         {
2171             ERR("could not initialize local heap\n");
2172             goto done;
2173         }
2174     }
2175
2176     if (!(hloc16 = LocalAlloc16(LMEM_MOVEABLE | LMEM_ZEROINIT, alloc_size)))
2177     {
2178         ERR("could not allocate new 16 bit buffer\n");
2179         goto done;
2180     }
2181
2182     if (!(textA = MapSL(LocalLock16( hloc16))))
2183     {
2184         ERR("could not lock new 16 bit buffer\n");
2185         LocalFree16(hloc16);
2186         hloc16 = 0;
2187         goto done;
2188     }
2189     memcpy( textA, LocalLock( hloc ), alloc_size );
2190     LocalUnlock( hloc );
2191     LocalUnlock16( hloc16 );
2192     SetWindowWord( hwnd, GWW_HANDLE16, hloc16 );
2193
2194 done:
2195     stack16->ds = oldDS;
2196     return hloc16;
2197 }
2198
2199 static void edit_set_handle( HWND hwnd, HLOCAL16 hloc16 )
2200 {
2201     STACK16FRAME* stack16 = MapSL(PtrToUlong(NtCurrentTeb()->WOW32Reserved));
2202     HINSTANCE16 hInstance = GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
2203     HANDLE16 oldDS = stack16->ds;
2204     HLOCAL hloc32;
2205     INT count;
2206     CHAR *text;
2207
2208     if (!(GetWindowLongW( hwnd, GWL_STYLE ) & ES_MULTILINE)) return;
2209     if (!hloc16) return;
2210
2211     stack16->ds = hInstance;
2212     count = LocalSize16(hloc16);
2213     text = MapSL(LocalLock16(hloc16));
2214     if ((hloc32 = LocalAlloc(LMEM_MOVEABLE, count)))
2215     {
2216         memcpy( LocalLock(hloc32), text, count );
2217         LocalUnlock(hloc32);
2218         LocalUnlock16(hloc16);
2219         SetWindowWord( hwnd, GWW_HANDLE16, hloc16 );
2220     }
2221     stack16->ds = oldDS;
2222
2223     if (hloc32) wow_handlers32.edit_proc( hwnd, EM_SETHANDLE, (WPARAM)hloc32, 0, FALSE );
2224 }
2225
2226 static void edit_destroy_handle( HWND hwnd )
2227 {
2228     HLOCAL16 hloc16 = GetWindowWord( hwnd, GWW_HANDLE16 );
2229     if (hloc16)
2230     {
2231         STACK16FRAME* stack16 = MapSL(PtrToUlong(NtCurrentTeb()->WOW32Reserved));
2232         HANDLE16 oldDS = stack16->ds;
2233
2234         stack16->ds = GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
2235         while (LocalUnlock16(hloc16)) ;
2236         LocalFree16(hloc16);
2237         stack16->ds = oldDS;
2238         SetWindowWord( hwnd, GWW_HANDLE16, 0 );
2239     }
2240 }
2241
2242 /*********************************************************************
2243  *      edit_proc16
2244  */
2245 static LRESULT edit_proc16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode )
2246 {
2247     static const UINT msg16_offset = EM_GETSEL16 - EM_GETSEL;
2248     LRESULT result = 0;
2249
2250     edit_lock_buffer( hwnd );
2251     switch (msg)
2252     {
2253     case EM_SCROLL16:
2254     case EM_SCROLLCARET16:
2255     case EM_GETMODIFY16:
2256     case EM_SETMODIFY16:
2257     case EM_GETLINECOUNT16:
2258     case EM_GETTHUMB16:
2259     case EM_LINELENGTH16:
2260     case EM_LIMITTEXT16:
2261     case EM_CANUNDO16:
2262     case EM_UNDO16:
2263     case EM_FMTLINES16:
2264     case EM_LINEFROMCHAR16:
2265     case EM_SETPASSWORDCHAR16:
2266     case EM_EMPTYUNDOBUFFER16:
2267     case EM_SETREADONLY16:
2268     case EM_GETPASSWORDCHAR16:
2269         /* these messages missing from specs */
2270     case WM_USER+15:
2271     case WM_USER+16:
2272     case WM_USER+19:
2273     case WM_USER+26:
2274         result = wow_handlers32.edit_proc( hwnd, msg - msg16_offset, wParam, lParam, FALSE );
2275         break;
2276     case EM_GETSEL16:
2277         result = wow_handlers32.edit_proc( hwnd, msg - msg16_offset, 0, 0, FALSE );
2278         break;
2279     case EM_REPLACESEL16:
2280     case EM_GETLINE16:
2281         result = wow_handlers32.edit_proc( hwnd, msg - msg16_offset, wParam, (LPARAM)MapSL(lParam), FALSE );
2282         break;
2283     case EM_LINESCROLL16:
2284         result = wow_handlers32.edit_proc( hwnd, msg - msg16_offset, (INT)(SHORT)HIWORD(lParam),
2285                                            (INT)(SHORT)LOWORD(lParam), FALSE );
2286         break;
2287     case EM_LINEINDEX16:
2288         if ((INT16)wParam == -1) wParam = -1;
2289         result = wow_handlers32.edit_proc( hwnd, msg - msg16_offset, wParam, lParam, FALSE );
2290         break;
2291     case EM_SETSEL16:
2292         if ((short)LOWORD(lParam) == -1)
2293         {
2294             wParam = -1;
2295             lParam = 0;
2296         }
2297         else
2298         {
2299             wParam = LOWORD(lParam);
2300             lParam = HIWORD(lParam);
2301         }
2302         result = wow_handlers32.edit_proc( hwnd, msg - msg16_offset, wParam, lParam, FALSE );
2303         break;
2304     case EM_GETRECT16:
2305         if (lParam)
2306         {
2307             RECT rect;
2308             RECT16 *r16 = MapSL(lParam);
2309             wow_handlers32.edit_proc( hwnd, msg - msg16_offset, wParam, (LPARAM)&rect, FALSE );
2310             r16->left   = rect.left;
2311             r16->top    = rect.top;
2312             r16->right  = rect.right;
2313             r16->bottom = rect.bottom;
2314         }
2315         break;
2316     case EM_SETRECT16:
2317     case EM_SETRECTNP16:
2318         if (lParam)
2319         {
2320             RECT rect;
2321             RECT16 *r16 = MapSL(lParam);
2322             rect.left   = r16->left;
2323             rect.top    = r16->top;
2324             rect.right  = r16->right;
2325             rect.bottom = r16->bottom;
2326             wow_handlers32.edit_proc( hwnd, msg - msg16_offset, wParam, (LPARAM)&rect, FALSE );
2327         }
2328         break;
2329     case EM_SETHANDLE16:
2330         edit_set_handle( hwnd, (HLOCAL16)wParam );
2331         break;
2332     case EM_GETHANDLE16:
2333         result = edit_get_handle( hwnd );
2334         break;
2335     case EM_SETTABSTOPS16:
2336     {
2337         INT16 *tabs16 = MapSL(lParam);
2338         INT i, count = wParam, *tabs = NULL;
2339         if (count > 0)
2340         {
2341             if (!(tabs = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*tabs) ))) return 0;
2342             for (i = 0; i < count; i++) tabs[i] = tabs16[i];
2343         }
2344         result = wow_handlers32.edit_proc( hwnd, msg - msg16_offset, count, (LPARAM)tabs, FALSE );
2345         HeapFree( GetProcessHeap(), 0, tabs );
2346         break;
2347     }
2348     case EM_GETFIRSTVISIBLELINE16:
2349         if (!(GetWindowLongW( hwnd, GWL_STYLE ) & ES_MULTILINE)) break;
2350         result = wow_handlers32.edit_proc( hwnd, msg - msg16_offset, wParam, lParam, FALSE );
2351         break;
2352     case EM_SETWORDBREAKPROC16:
2353     {
2354         struct word_break_thunk *thunk = add_word_break_thunk( (EDITWORDBREAKPROC16)lParam );
2355         result = wow_handlers32.edit_proc( hwnd, EM_SETWORDBREAKPROC, wParam, (LPARAM)thunk, FALSE );
2356         break;
2357     }
2358     case EM_GETWORDBREAKPROC16:
2359         result = wow_handlers32.edit_proc( hwnd, EM_GETWORDBREAKPROC, wParam, lParam, FALSE );
2360         result = (LRESULT)get_word_break_thunk( (EDITWORDBREAKPROCA)result );
2361         break;
2362     case WM_NCDESTROY:
2363         edit_destroy_handle( hwnd );
2364         return wow_handlers32.edit_proc( hwnd, msg, wParam, lParam, unicode );  /* no unlock on destroy */
2365     case WM_HSCROLL:
2366     case WM_VSCROLL:
2367         if (LOWORD(wParam) == EM_GETTHUMB16 || LOWORD(wParam) == EM_LINESCROLL16) wParam -= msg16_offset;
2368         result = wow_handlers32.edit_proc( hwnd, msg, wParam, lParam, unicode );
2369         break;
2370     default:
2371         result = wow_handlers32.edit_proc( hwnd, msg, wParam, lParam, unicode );
2372         break;
2373     }
2374     edit_unlock_buffer( hwnd );
2375     return result;
2376 }
2377
2378
2379 /***********************************************************************
2380  *           listbox_proc16
2381  */
2382 static LRESULT listbox_proc16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode )
2383 {
2384     static const UINT msg16_offset = LB_ADDSTRING16 - LB_ADDSTRING;
2385     LRESULT ret;
2386
2387     switch (msg)
2388     {
2389     case WM_SIZE:
2390         if (is_old_app( hwnd ))
2391         {
2392             DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
2393             int height, remaining, item_height;
2394             RECT rect;
2395
2396             /* give a margin for error to old 16 bits programs - if we need
2397                less than the height of the nonclient area, round to the
2398                *next* number of items */
2399
2400             if (!(style & LBS_NOINTEGRALHEIGHT) && !(style & LBS_OWNERDRAWVARIABLE))
2401             {
2402                 GetClientRect( hwnd, &rect );
2403                 height = rect.bottom - rect.top;
2404                 item_height = wow_handlers32.listbox_proc( hwnd, LB_GETITEMHEIGHT, 0, 0, FALSE );
2405                 remaining = item_height ? (height % item_height) : 0;
2406                 if ((height > item_height) && remaining)
2407                 {
2408                     GetWindowRect( hwnd, &rect );
2409                     if ((item_height - remaining) <= rect.bottom - rect.top - height)
2410                         remaining = remaining - item_height;
2411                     TRACE( "[%p]: changing height %d -> %d\n", hwnd, height, height - remaining );
2412                     SetWindowPos( hwnd, 0, 0, 0, rect.right - rect.left,
2413                                   rect.bottom - rect.top - remaining,
2414                                   SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE );
2415                     return 0;
2416                 }
2417             }
2418         }
2419         return wow_handlers32.listbox_proc( hwnd, msg, wParam, lParam, unicode );
2420
2421     case LB_RESETCONTENT16:
2422     case LB_DELETESTRING16:
2423     case LB_GETITEMDATA16:
2424     case LB_SETITEMDATA16:
2425     case LB_GETCOUNT16:
2426     case LB_GETTEXTLEN16:
2427     case LB_GETCURSEL16:
2428     case LB_GETTOPINDEX16:
2429     case LB_GETITEMHEIGHT16:
2430     case LB_SETCARETINDEX16:
2431     case LB_GETCARETINDEX16:
2432     case LB_SETTOPINDEX16:
2433     case LB_SETCOLUMNWIDTH16:
2434     case LB_GETSELCOUNT16:
2435     case LB_SELITEMRANGE16:
2436     case LB_SELITEMRANGEEX16:
2437     case LB_GETHORIZONTALEXTENT16:
2438     case LB_SETHORIZONTALEXTENT16:
2439     case LB_GETANCHORINDEX16:
2440     case LB_CARETON16:
2441     case LB_CARETOFF16:
2442         msg -= msg16_offset;
2443         break;
2444     case LB_GETSEL16:
2445     case LB_SETSEL16:
2446     case LB_SETCURSEL16:
2447     case LB_SETANCHORINDEX16:
2448         wParam = (INT)(INT16)wParam;
2449         msg -= msg16_offset;
2450         break;
2451     case LB_INSERTSTRING16:
2452     case LB_FINDSTRING16:
2453     case LB_FINDSTRINGEXACT16:
2454     case LB_SELECTSTRING16:
2455         wParam = (INT)(INT16)wParam;
2456         /* fall through */
2457     case LB_ADDSTRING16:
2458     case LB_ADDFILE16:
2459     {
2460         DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
2461         if ((style & LBS_HASSTRINGS) || !(style & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)))
2462             lParam = (LPARAM)MapSL(lParam);
2463         msg -= msg16_offset;
2464         break;
2465     }
2466     case LB_GETTEXT16:
2467         lParam = (LPARAM)MapSL(lParam);
2468         msg -= msg16_offset;
2469         break;
2470     case LB_SETITEMHEIGHT16:
2471         lParam = LOWORD(lParam);
2472         msg -= msg16_offset;
2473         break;
2474     case LB_GETITEMRECT16:
2475         {
2476             RECT rect;
2477             RECT16 *r16 = MapSL(lParam);
2478             ret = wow_handlers32.listbox_proc( hwnd, LB_GETITEMRECT, (INT16)wParam, (LPARAM)&rect, FALSE );
2479             r16->left   = rect.left;
2480             r16->top    = rect.top;
2481             r16->right  = rect.right;
2482             r16->bottom = rect.bottom;
2483             return ret;
2484         }
2485     case LB_GETSELITEMS16:
2486     {
2487         INT16 *array16 = MapSL( lParam );
2488         INT i, count = (INT16)wParam, *array;
2489         if (!(array = HeapAlloc( GetProcessHeap(), 0, wParam * sizeof(*array) ))) return LB_ERRSPACE;
2490         ret = wow_handlers32.listbox_proc( hwnd, LB_GETSELITEMS, count, (LPARAM)array, FALSE );
2491         for (i = 0; i < ret; i++) array16[i] = array[i];
2492         HeapFree( GetProcessHeap(), 0, array );
2493         return ret;
2494     }
2495     case LB_DIR16:
2496         /* according to Win16 docs, DDL_DRIVES should make DDL_EXCLUSIVE
2497          * be set automatically (this is different in Win32) */
2498         if (wParam & DDL_DRIVES) wParam |= DDL_EXCLUSIVE;
2499         lParam = (LPARAM)MapSL(lParam);
2500         msg -= msg16_offset;
2501         break;
2502     case LB_SETTABSTOPS16:
2503     {
2504         INT i, count, *tabs = NULL;
2505         INT16 *tabs16 = MapSL( lParam );
2506
2507         if ((count = (INT16)wParam) > 0)
2508         {
2509             if (!(tabs = HeapAlloc( GetProcessHeap(), 0, wParam * sizeof(*tabs) ))) return LB_ERRSPACE;
2510             for (i = 0; i < count; i++) tabs[i] = tabs16[i] << 1; /* FIXME */
2511         }
2512         ret = wow_handlers32.listbox_proc( hwnd, LB_SETTABSTOPS, count, (LPARAM)tabs, FALSE );
2513         HeapFree( GetProcessHeap(), 0, tabs );
2514         return ret;
2515     }
2516     default:
2517         return wow_handlers32.listbox_proc( hwnd, msg, wParam, lParam, unicode );
2518     }
2519     return wow_handlers32.listbox_proc( hwnd, msg, wParam, lParam, FALSE );
2520 }
2521
2522
2523 /***********************************************************************
2524  *           mdiclient_proc16
2525  */
2526 static LRESULT mdiclient_proc16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode )
2527 {
2528     if (msg == WM_CREATE)
2529     {
2530         LPCREATESTRUCTA cs = (LPCREATESTRUCTA)lParam;
2531         HINSTANCE instance = (HINSTANCE)GetWindowLongPtrW( hwnd, GWLP_HINSTANCE );
2532         BOOL is_win32 = !instance || ((ULONG_PTR)instance >> 16);
2533
2534         /* Translation layer doesn't know what's in the cs->lpCreateParams
2535          * so we have to keep track of what environment we're in. */
2536         if (!is_win32)
2537         {
2538             void *orig = cs->lpCreateParams;
2539             LRESULT ret;
2540             CLIENTCREATESTRUCT ccs;
2541             CLIENTCREATESTRUCT16 *ccs16 = MapSL( PtrToUlong( orig ));
2542
2543             ccs.hWindowMenu  = HMENU_32(ccs16->hWindowMenu);
2544             ccs.idFirstChild = ccs16->idFirstChild;
2545             cs->lpCreateParams = &ccs;
2546             ret = wow_handlers32.mdiclient_proc( hwnd, msg, wParam, lParam, unicode );
2547             cs->lpCreateParams = orig;
2548             return ret;
2549         }
2550     }
2551     return wow_handlers32.mdiclient_proc( hwnd, msg, wParam, lParam, unicode );
2552 }
2553
2554
2555 /***********************************************************************
2556  *           scrollbar_proc16
2557  */
2558 static LRESULT scrollbar_proc16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode )
2559 {
2560     static const UINT msg16_offset = SBM_SETPOS16 - SBM_SETPOS;
2561
2562     switch (msg)
2563     {
2564     case SBM_SETPOS16:
2565     case SBM_GETPOS16:
2566     case SBM_ENABLE_ARROWS16:
2567         msg -= msg16_offset;
2568         break;
2569     case SBM_SETRANGE16:
2570         msg = wParam ? SBM_SETRANGEREDRAW : SBM_SETRANGE;
2571         wParam = LOWORD(lParam);
2572         lParam = HIWORD(lParam);
2573         break;
2574     case SBM_GETRANGE16:
2575     {
2576         INT min, max;
2577         wow_handlers32.scrollbar_proc( hwnd, SBM_GETRANGE, (WPARAM)&min, (LPARAM)&max, FALSE );
2578         return MAKELRESULT(min, max);
2579     }
2580     default:
2581         return wow_handlers32.scrollbar_proc( hwnd, msg, wParam, lParam, unicode );
2582     }
2583     return wow_handlers32.scrollbar_proc( hwnd, msg, wParam, lParam, FALSE );
2584 }
2585
2586
2587 /***********************************************************************
2588  *           static_proc16
2589  */
2590 static LRESULT static_proc16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, BOOL unicode )
2591 {
2592     switch (msg)
2593     {
2594     case WM_NCCREATE:
2595     {
2596         CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
2597         LRESULT ret = wow_handlers32.static_proc( hwnd, msg, wParam, lParam, unicode );
2598
2599         if (!ret) return 0;
2600         if (((ULONG_PTR)cs->hInstance >> 16)) return ret;  /* 32-bit instance, nothing to do */
2601         switch (cs->style & SS_TYPEMASK)
2602         {
2603         case SS_ICON:
2604             {
2605                 HICON16 icon = LoadIcon16( HINSTANCE_16(cs->hInstance), cs->lpszName );
2606                 if (!icon) icon = LoadCursor16( HINSTANCE_16(cs->hInstance), cs->lpszName );
2607                 if (icon) wow_handlers32.static_proc( hwnd, STM_SETIMAGE, IMAGE_ICON,
2608                                                       (LPARAM)get_icon_32(icon), FALSE );
2609                 break;
2610             }
2611         case SS_BITMAP:
2612             {
2613                 HBITMAP16 bitmap = LoadBitmap16( HINSTANCE_16(cs->hInstance), cs->lpszName );
2614                 if (bitmap) wow_handlers32.static_proc( hwnd, STM_SETIMAGE, IMAGE_BITMAP,
2615                                                         (LPARAM)HBITMAP_32(bitmap), FALSE );
2616                 break;
2617             }
2618         }
2619         return ret;
2620     }
2621     case STM_SETICON16:
2622         wParam = (WPARAM)get_icon_32( (HICON16)wParam );
2623         return wow_handlers32.static_proc( hwnd, STM_SETICON, wParam, lParam, FALSE );
2624     case STM_GETICON16:
2625         return get_icon_16( (HICON)wow_handlers32.static_proc( hwnd, STM_GETICON, wParam, lParam, FALSE ));
2626     default:
2627         return wow_handlers32.static_proc( hwnd, msg, wParam, lParam, unicode );
2628     }
2629 }
2630
2631
2632 /***********************************************************************
2633  *           wait_message16
2634  */
2635 static DWORD wait_message16( DWORD count, const HANDLE *handles, DWORD timeout, DWORD mask, DWORD flags )
2636 {
2637     DWORD lock, ret;
2638
2639     ReleaseThunkLock( &lock );
2640     ret = wow_handlers32.wait_message( count, handles, timeout, mask, flags );
2641     RestoreThunkLock( lock );
2642     return ret;
2643 }
2644
2645
2646 /***********************************************************************
2647  *           create_window16
2648  */
2649 HWND create_window16( CREATESTRUCTW *cs, LPCWSTR className, HINSTANCE instance, BOOL unicode )
2650 {
2651     /* map to module handle */
2652     if (instance && !((ULONG_PTR)instance >> 16))
2653         instance = HINSTANCE_32( GetExePtr( HINSTANCE_16(instance) ));
2654
2655     return wow_handlers32.create_window( cs, className, instance, unicode );
2656 }
2657
2658
2659 /***********************************************************************
2660  *           free_icon_param
2661  */
2662 static void free_icon_param( ULONG_PTR param )
2663 {
2664     GlobalFree16( LOWORD(param) );
2665 }
2666
2667
2668 void register_wow_handlers(void)
2669 {
2670     static const struct wow_handlers16 handlers16 =
2671     {
2672         button_proc16,
2673         combo_proc16,
2674         edit_proc16,
2675         listbox_proc16,
2676         mdiclient_proc16,
2677         scrollbar_proc16,
2678         static_proc16,
2679         wait_message16,
2680         create_window16,
2681         call_window_proc_Ato16,
2682         call_dialog_proc_Ato16,
2683         free_icon_param
2684     };
2685
2686     UserRegisterWowHandlers( &handlers16, &wow_handlers32 );
2687 }