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