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