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

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