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