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