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 "wine/winbase16.h"
   9 #include "winuser.h"
  10 #include "callback.h"
  11 #include "heap.h"
  12 #include "selectors.h"
  13 #include "struct32.h"
  14 #include "win.h"
  15 #include "winproc.h"
  16 #include "debug.h"
  17 #include "spy.h"
  18 #include "commctrl.h"
  19 #include "task.h"
  20 #include "thread.h"
  21
  22 /* Window procedure 16-to-32-bit thunk,
  23  * see BuildSpec16Files() in tools/build.c */
  24
  25 typedef struct
  26 {
  27     BYTE       popl_eax;             /* popl  %eax (return address) */
  28     BYTE       pushl_func;           /* pushl $proc */
  29     WNDPROC32  proc WINE_PACKED;
  30     BYTE       pushl_eax;            /* pushl %eax */
  31     WORD       pushw_bp WINE_PACKED; /* pushw %bp */
  32     BYTE       pushl_thunk;          /* pushl $thunkfrom16 */
  33     void     (*thunk32)() WINE_PACKED;
  34     BYTE       lcall;                /* lcall cs:relay */
  35     void     (*relay)() WINE_PACKED; /* WINPROC_CallProc16To32A/W() */
  36     WORD       cs WINE_PACKED;
  37 } WINPROC_THUNK_FROM16;
  38
  39 /* Window procedure 32-to-16-bit thunk,
  40  * see BuildSpec32Files() in tools/build.c */
  41
  42 typedef struct
  43 {
  44     BYTE       popl_eax;             /* popl  %eax (return address) */
  45     BYTE       pushl_func;           /* pushl $proc */
  46     WNDPROC16  proc WINE_PACKED;
  47     BYTE       pushl_eax;            /* pushl %eax */
  48     BYTE       jmp;                  /* jmp   relay (relative jump)*/
  49     void     (*relay)() WINE_PACKED; /* WINPROC_CallProc32ATo16() */
  50 } WINPROC_THUNK_FROM32;
  51
  52 /* Simple jmp to call 32-bit procedure directly */
  53 typedef struct
  54 {
  55     BYTE       jmp;                  /* jmp  proc (relative jump) */
  56     WNDPROC32  proc WINE_PACKED;
  57 } WINPROC_JUMP;
  58
  59 typedef union
  60 {
  61     WINPROC_THUNK_FROM16  t_from16;
  62     WINPROC_THUNK_FROM32  t_from32;
  63 } WINPROC_THUNK;
  64
  65 typedef struct tagWINDOWPROC
  66 {
  67     WINPROC_THUNK         thunk;    /* Thunk */
  68     WINPROC_JUMP          jmp;      /* Jump */
  69     struct tagWINDOWPROC *next;     /* Next window proc */
  70     UINT32                magic;    /* Magic number */
  71     WINDOWPROCTYPE        type;     /* Function type */
  72     WINDOWPROCUSER        user;     /* Function user */
  73 } WINDOWPROC;
  74
  75 #define WINPROC_MAGIC  ('W' | ('P' << 8) | ('R' << 16) | ('C' << 24))
  76
  77 #define WINPROC_THUNKPROC(pproc) \
  78     (((pproc)->type == WIN_PROC_16) ? \
  79           (WNDPROC16)((pproc)->thunk.t_from32.proc) : \
  80           (WNDPROC16)((pproc)->thunk.t_from16.proc))
  81
  82 static LRESULT WINAPI WINPROC_CallProc32ATo16( WNDPROC16 func, HWND32 hwnd,
  83                                                UINT32 msg, WPARAM32 wParam,
  84                                                LPARAM lParam );
  85 static LRESULT WINAPI WINPROC_CallProc32WTo16( WNDPROC16 func, HWND32 hwnd,
  86                                                UINT32 msg, WPARAM32 wParam,
  87                                                LPARAM lParam );
  88 static LRESULT WINPROC_CallProc16To32A( HWND16 hwnd, UINT16 msg,
  89                                         WPARAM16 wParam, LPARAM lParam,
  90                                         WNDPROC32 func );
  91 static LRESULT WINPROC_CallProc16To32W( HWND16 hwnd, UINT16 msg,
  92                                         WPARAM16 wParam, LPARAM lParam,
  93                                         WNDPROC32 func );
  94
  95 static HANDLE32 WinProcHeap;
  96
  97
  98 /**********************************************************************
  99  *           WINPROC_Init
 100  */
 101 BOOL32 WINPROC_Init(void)
 102 {
 103     WinProcHeap = HeapCreate( HEAP_WINE_SEGPTR | HEAP_WINE_CODESEG, 0, 0 );
 104     if (!WinProcHeap)
 105     {
 106         WARN(relay, "Unable to create winproc heap\n" );
 107         return FALSE;
 108     }
 109     return TRUE;
 110 }
 111
 112
 113 /**********************************************************************
 114  *           WINPROC_CallWndProc32
 115  *
 116  * Call a 32-bit WndProc.
 117  */
 118 static LRESULT WINPROC_CallWndProc32( WNDPROC32 proc, HWND32 hwnd, UINT32 msg,
 119                                       WPARAM32 wParam, LPARAM lParam )
 120 {
 121     TRACE(relay, "(wndproc=%p,hwnd=%08x,msg=%s,wp=%08x,lp=%08lx)\n",
 122                    proc, hwnd, SPY_GetMsgName(msg), wParam, lParam );
 123     return proc( hwnd, msg, wParam, lParam );
 124 }
 125
 126
 127 /**********************************************************************
 128  *           WINPROC_GetPtr
 129  *
 130  * Return a pointer to the win proc.
 131  */
 132 static WINDOWPROC *WINPROC_GetPtr( WNDPROC16 handle )
 133 {
 134     BYTE *ptr;
 135     WINDOWPROC *proc;
 136
 137     /* Check for a linear pointer */
 138
 139     if (HEAP_IsInsideHeap( WinProcHeap, 0, (LPVOID)handle ))
 140     {
 141         ptr = (BYTE *)handle;
 142         /* First check if it is the jmp address */
 143         if (*ptr == 0xe9 /* jmp */) ptr -= (int)&((WINDOWPROC *)0)->jmp -
 144                                            (int)&((WINDOWPROC *)0)->thunk;
 145         /* Now it must be the thunk address */
 146         if (*ptr == 0x58 /* popl eax */) ptr -= (int)&((WINDOWPROC *)0)->thunk;
 147         /* Now we have a pointer to the WINDOWPROC struct */
 148         if (((WINDOWPROC *)ptr)->magic == WINPROC_MAGIC)
 149             return (WINDOWPROC *)ptr;
 150     }
 151
 152     /* Check for a segmented pointer */
 153
 154     if (!IsBadReadPtr16((SEGPTR)handle,sizeof(WINDOWPROC)-sizeof(proc->thunk)))
 155     {
 156         ptr = (BYTE *)PTR_SEG_TO_LIN(handle);
 157         if (!HEAP_IsInsideHeap( WinProcHeap, 0, ptr )) return NULL;
 158         /* It must be the thunk address */
 159         if (*ptr == 0x58 /* popl eax */) ptr -= (int)&((WINDOWPROC *)0)->thunk;
 160         /* Now we have a pointer to the WINDOWPROC struct */
 161         if (((WINDOWPROC *)ptr)->magic == WINPROC_MAGIC)
 162             return (WINDOWPROC *)ptr;
 163     }
 164
 165     return NULL;
 166 }
 167
 168
 169 /**********************************************************************
 170  *           WINPROC_AllocWinProc
 171  *
 172  * Allocate a new window procedure.
 173  */
 174 static WINDOWPROC *WINPROC_AllocWinProc( WNDPROC16 func, WINDOWPROCTYPE type,
 175                                          WINDOWPROCUSER user )
 176 {
 177     WINDOWPROC *proc, *oldproc;
 178
 179     /* Allocate a window procedure */
 180
 181     if (!(proc = HeapAlloc( WinProcHeap, 0, sizeof(WINDOWPROC) ))) return 0;
 182
 183     /* Check if the function is already a win proc */
 184
 185     if ((oldproc = WINPROC_GetPtr( func )))
 186     {
 187         *proc = *oldproc;
 188     }
 189     else
 190     {
 191         switch(type)
 192         {
 193         case WIN_PROC_16:
 194             proc->thunk.t_from32.popl_eax    = 0x58;   /* popl  %eax */
 195             proc->thunk.t_from32.pushl_func  = 0x68;   /* pushl $proc */
 196             proc->thunk.t_from32.proc        = func;
 197             proc->thunk.t_from32.pushl_eax   = 0x50;   /* pushl %eax */
 198             proc->thunk.t_from32.jmp         = 0xe9;   /* jmp   relay*/
 199             proc->thunk.t_from32.relay =  /* relative jump */
 200                 (void(*)())((DWORD)WINPROC_CallProc32ATo16 -
 201                                      (DWORD)(&proc->thunk.t_from32.relay + 1));
 202             break;
 203         case WIN_PROC_32A:
 204         case WIN_PROC_32W:
 205             proc->thunk.t_from16.popl_eax    = 0x58;   /* popl  %eax */
 206             proc->thunk.t_from16.pushl_func  = 0x68;   /* pushl $proc */
 207             proc->thunk.t_from16.proc        = (FARPROC32)func;
 208             proc->thunk.t_from16.pushl_eax   = 0x50;   /* pushl %eax */
 209             proc->thunk.t_from16.pushw_bp    = 0x5566; /* pushw %bp */
 210             proc->thunk.t_from16.pushl_thunk = 0x68;   /* pushl $thunkfrom16 */
 211             proc->thunk.t_from16.thunk32     = (type == WIN_PROC_32A) ?
 212                                            (void(*)())WINPROC_CallProc16To32A :
 213                                            (void(*)())WINPROC_CallProc16To32W;
 214             proc->thunk.t_from16.lcall       = 0x9a;   /* lcall cs:relay */
 215             proc->thunk.t_from16.relay       = (void*)Callbacks->CallFrom16WndProc;
 216             GET_CS(proc->thunk.t_from16.cs);
 217             proc->jmp.jmp  = 0xe9;
 218             /* Fixup relative jump */
 219             proc->jmp.proc = (WNDPROC32)((DWORD)func -
 220                                                  (DWORD)(&proc->jmp.proc + 1));
 221             break;
 222         default:
 223             /* Should not happen */
 224             break;
 225         }
 226         proc->magic = WINPROC_MAGIC;
 227         proc->type  = type;
 228         proc->user  = user;
 229     }
 230     proc->next  = NULL;
 231     TRACE(win, "(%08x,%d): returning %08x\n",
 232                  (UINT32)func, type, (UINT32)proc );
 233     return proc;
 234 }
 235
 236
 237 /**********************************************************************
 238  *           WINPROC_GetProc
 239  *
 240  * Get a window procedure pointer that can be passed to the Windows program.
 241  */
 242 WNDPROC16 WINPROC_GetProc( HWINDOWPROC proc, WINDOWPROCTYPE type )
 243 {
 244     if (!proc) return NULL;
 245     if (type == WIN_PROC_16)  /* We want a 16:16 address */
 246     {
 247         if (((WINDOWPROC *)proc)->type == WIN_PROC_16)
 248             return ((WINDOWPROC *)proc)->thunk.t_from32.proc;
 249         else
 250             return (WNDPROC16)HEAP_GetSegptr( WinProcHeap, 0,
 251                                               &((WINDOWPROC *)proc)->thunk );
 252     }
 253     else  /* We want a 32-bit address */
 254     {
 255         if (((WINDOWPROC *)proc)->type == WIN_PROC_16)
 256             return (WNDPROC16)&((WINDOWPROC *)proc)->thunk;
 257         else if (type != ((WINDOWPROC *)proc)->type)
 258             /* Have to return the jmp address if types don't match */
 259             return (WNDPROC16)&((WINDOWPROC *)proc)->jmp;
 260         else
 261             /* Some Win16 programs want to get back the proc they set */
 262             return (WNDPROC16)((WINDOWPROC *)proc)->thunk.t_from16.proc;
 263     }
 264 }
 265
 266
 267 /**********************************************************************
 268  *           WINPROC_SetProc
 269  *
 270  * Set the window procedure for a window or class. There are
 271  * three tree classes of winproc callbacks:
 272  *
 273  * 1) class  -> wp                      -       not subclassed
 274  *    class  -> wp -> wp -> wp -> wp    -       SetClassLong()
 275  *             /           /
 276  * 2) window -'           /             -       not subclassed
 277  *    window -> wp -> wp '              -       SetWindowLong()
 278  *
 279  * 3) timer  -> wp                      -       SetTimer()
 280  *
 281  * Initially, winproc of the window points to the current winproc
 282  * thunk of its class. Subclassing prepends a new thunk to the
 283  * window winproc chain at the head of the list. Thus, window thunk
 284  * list includes class thunks and the latter are preserved when the
 285  * window is destroyed.
 286  *
 287  */
 288 BOOL32 WINPROC_SetProc( HWINDOWPROC *pFirst, WNDPROC16 func,
 289                         WINDOWPROCTYPE type, WINDOWPROCUSER user )
 290 {
 291     BOOL32 bRecycle = FALSE;
 292     WINDOWPROC *proc, **ppPrev;
 293
 294     /* Check if function is already in the list */
 295
 296     ppPrev = (WINDOWPROC **)pFirst;
 297     proc = WINPROC_GetPtr( func );
 298     while (*ppPrev)
 299     {
 300         if (proc)
 301         {
 302             if (*ppPrev == proc)
 303             {
 304                 if ((*ppPrev)->user != user)
 305                 {
 306                     /* terminal thunk is being restored */
 307
 308                     WINPROC_FreeProc( *pFirst, (*ppPrev)->user );
 309                     *(WINDOWPROC **)pFirst = *ppPrev;
 310                     return TRUE;
 311                 }
 312                 bRecycle = TRUE;
 313                 break;
 314             }
 315         }
 316         else
 317         {
 318             if (((*ppPrev)->type == type) &&
 319                 (func == WINPROC_THUNKPROC(*ppPrev)))
 320             {
 321                 bRecycle = TRUE;
 322                 break;
 323             }
 324         }
 325
 326         /* WPF_CLASS thunk terminates window thunk list */
 327         if ((*ppPrev)->user != user) break;
 328         ppPrev = &(*ppPrev)->next;
 329     }
 330
 331     if (bRecycle)
 332     {
 333         /* Extract this thunk from the list */
 334         proc = *ppPrev;
 335         *ppPrev = proc->next;
 336     }
 337     else  /* Allocate a new one */
 338     {
 339         if (proc)  /* Was already a win proc */
 340         {
 341             type = proc->type;
 342             func = WINPROC_THUNKPROC(proc);
 343         }
 344         proc = WINPROC_AllocWinProc( func, type, user );
 345         if (!proc) return FALSE;
 346     }
 347
 348     /* Add the win proc at the head of the list */
 349
 350     TRACE(win, "(%08x,%08x,%d): res=%08x\n",
 351                  (UINT32)*pFirst, (UINT32)func, type, (UINT32)proc );
 352     proc->next  = *(WINDOWPROC **)pFirst;
 353     *(WINDOWPROC **)pFirst = proc;
 354     return TRUE;
 355 }
 356
 357
 358 /**********************************************************************
 359  *           WINPROC_FreeProc
 360  *
 361  * Free a list of win procs.
 362  */
 363 void WINPROC_FreeProc( HWINDOWPROC proc, WINDOWPROCUSER user )
 364 {
 365     while (proc)
 366     {
 367         WINDOWPROC *next = ((WINDOWPROC *)proc)->next;
 368         if (((WINDOWPROC *)proc)->user != user) break;
 369         TRACE(win, "freeing %08x\n", (UINT32)proc);
 370         HeapFree( WinProcHeap, 0, proc );
 371         proc = next;
 372     }
 373 }
 374
 375
 376 /**********************************************************************
 377  *           WINPROC_GetProcType
 378  *
 379  * Return the window procedure type.
 380  */
 381 WINDOWPROCTYPE WINPROC_GetProcType( HWINDOWPROC proc )
 382 {
 383     if (!proc ||
 384         (((WINDOWPROC *)proc)->magic != WINPROC_MAGIC))
 385         return WIN_PROC_INVALID;
 386     return ((WINDOWPROC *)proc)->type;
 387 }
 388 /**********************************************************************
 389  *           WINPROC_TestCBForStr
 390  *
 391  * Return TRUE if the lparam is a string
 392  */
 393 BOOL32 WINPROC_TestCBForStr ( HWND32 hwnd )
 394 {       WND * wnd = WIN_FindWndPtr(hwnd);
 395         return ( !(LOWORD(wnd->dwStyle) & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) ||
 396               (LOWORD(wnd->dwStyle) & CBS_HASSTRINGS) );
 397 }
 398 /**********************************************************************
 399  *           WINPROC_TestLBForStr
 400  *
 401  * Return TRUE if the lparam is a string
 402  */
 403 BOOL32 WINPROC_TestLBForStr ( HWND32 hwnd )
 404 {       WND * wnd = WIN_FindWndPtr(hwnd);
 405         return ( !(LOWORD(wnd->dwStyle) & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) ||
 406             (LOWORD(wnd->dwStyle) & LBS_HASSTRINGS) );
 407 }
 408 /**********************************************************************
 409  *           WINPROC_MapMsg32ATo32W
 410  *
 411  * Map a message from Ansi to Unicode.
 412  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
 413  *
 414  * FIXME:
 415  *  WM_CHAR, WM_CHARTOITEM, WM_DEADCHAR, WM_MENUCHAR, WM_SYSCHAR, WM_SYSDEADCHAR
 416  *
 417  * FIXME:
 418  *  WM_GETTEXT/WM_SETTEXT and static control with SS_ICON style:
 419  *  the first four bytes are the handle of the icon
 420  *  when the WM_SETTEXT message has been used to set the icon
 421  */
 422 INT32 WINPROC_MapMsg32ATo32W( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM *plparam )
 423 {
 424     switch(msg)
 425     {
 426     case WM_GETTEXT:
 427         {
 428             LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0,
 429                                      wParam * sizeof(WCHAR) + sizeof(LPARAM) );
 430             if (!ptr) return -1;
 431             *ptr++ = *plparam;  /* Store previous lParam */
 432             *plparam = (LPARAM)ptr;
 433         }
 434         return 1;
 435
 436     case WM_SETTEXT:
 437     case CB_DIR32:
 438     case CB_FINDSTRING32:
 439     case CB_FINDSTRINGEXACT32:
 440     case CB_SELECTSTRING32:
 441     case LB_DIR32:
 442     case LB_ADDFILE32:
 443     case LB_FINDSTRING32:
 444     case LB_SELECTSTRING32:
 445     case EM_REPLACESEL32:
 446         *plparam = (LPARAM)HEAP_strdupAtoW( SystemHeap, 0, (LPCSTR)*plparam );
 447         return (*plparam ? 1 : -1);
 448
 449     case WM_NCCREATE:
 450     case WM_CREATE:
 451         {
 452             CREATESTRUCT32W *cs = (CREATESTRUCT32W *)HeapAlloc( SystemHeap, 0,
 453                                                                 sizeof(*cs) );
 454             if (!cs) return -1;
 455             *cs = *(CREATESTRUCT32W *)*plparam;
 456             if (HIWORD(cs->lpszName))
 457                 cs->lpszName = HEAP_strdupAtoW( SystemHeap, 0,
 458                                                 (LPCSTR)cs->lpszName );
 459             if (HIWORD(cs->lpszClass))
 460                 cs->lpszClass = HEAP_strdupAtoW( SystemHeap, 0,
 461                                                  (LPCSTR)cs->lpszClass );
 462             *plparam = (LPARAM)cs;
 463         }
 464         return 1;
 465     case WM_MDICREATE:
 466         {
 467             MDICREATESTRUCT32W *cs =
 468                 (MDICREATESTRUCT32W *)HeapAlloc( SystemHeap, 0, sizeof(*cs) );
 469             if (!cs) return -1;
 470             *cs = *(MDICREATESTRUCT32W *)*plparam;
 471             if (HIWORD(cs->szClass))
 472                 cs->szClass = HEAP_strdupAtoW( SystemHeap, 0,
 473                                                (LPCSTR)cs->szClass );
 474             if (HIWORD(cs->szTitle))
 475                 cs->szTitle = HEAP_strdupAtoW( SystemHeap, 0,
 476                                                (LPCSTR)cs->szTitle );
 477             *plparam = (LPARAM)cs;
 478         }
 479         return 1;
 480
 481 /* Listbox */
 482     case LB_ADDSTRING32:
 483     case LB_INSERTSTRING32:
 484         if ( WINPROC_TestLBForStr( hwnd ))
 485           *plparam = (LPARAM)HEAP_strdupAtoW( SystemHeap, 0, (LPCSTR)*plparam );
 486         return (*plparam ? 1 : -1);
 487
 488     case LB_GETTEXT32:              /* fixme: fixed sized buffer */
 489         { if ( WINPROC_TestLBForStr( hwnd ))
 490           { LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0, 256 * sizeof(WCHAR) + sizeof(LPARAM) );
 491             if (!ptr) return -1;
 492             *ptr++ = *plparam;  /* Store previous lParam */
 493             *plparam = (LPARAM)ptr;
 494           }
 495         }
 496         return 1;
 497
 498 /* Combobox */
 499     case CB_ADDSTRING32:
 500     case CB_INSERTSTRING32:
 501         if ( WINPROC_TestCBForStr( hwnd ))
 502           *plparam = (LPARAM)HEAP_strdupAtoW( SystemHeap, 0, (LPCSTR)*plparam );
 503         return (*plparam ? 1 : -1);
 504
 505     case CB_GETLBTEXT32:    /* fixme: fixed sized buffer */
 506         { if ( WINPROC_TestCBForStr( hwnd ))
 507           { LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0, 256 * sizeof(WCHAR) + sizeof(LPARAM) );
 508             if (!ptr) return -1;
 509             *ptr++ = *plparam;  /* Store previous lParam */
 510             *plparam = (LPARAM)ptr;
 511           }
 512         }
 513         return 1;
 514
 515 /* Multiline edit */
 516     case EM_GETLINE32:
 517         { WORD len = (WORD)*plparam;
 518           LPARAM *ptr = (LPARAM *) HEAP_xalloc( SystemHeap, 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(WCHAR) );
 519           if (!ptr) return -1;
 520           *ptr++ = *plparam;  /* Store previous lParam */
 521           (WORD)*ptr = len;   /* Store the lenght */
 522           *plparam = (LPARAM)ptr;
 523         }
 524         return 1;
 525
 526     case WM_ASKCBFORMATNAME:
 527     case WM_DEVMODECHANGE:
 528     case WM_PAINTCLIPBOARD:
 529     case WM_SIZECLIPBOARD:
 530     case WM_WININICHANGE:
 531     case EM_SETPASSWORDCHAR32:
 532         FIXME(msg, "message %s (0x%x) needs translation, please report\n", SPY_GetMsgName(msg), msg );
 533         return -1;
 534     default:  /* No translation needed */
 535         return 0;
 536     }
 537 }
 538
 539
 540 /**********************************************************************
 541  *           WINPROC_UnmapMsg32ATo32W
 542  *
 543  * Unmap a message that was mapped from Ansi to Unicode.
 544  */
 545 void WINPROC_UnmapMsg32ATo32W( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam )
 546 {
 547     switch(msg)
 548     {
 549     case WM_GETTEXT:
 550         {
 551             LPARAM *ptr = (LPARAM *)lParam - 1;
 552             lstrcpynWtoA( (LPSTR)*ptr, (LPWSTR)lParam, wParam );
 553             HeapFree( SystemHeap, 0, ptr );
 554         }
 555         break;
 556
 557     case WM_NCCREATE:
 558     case WM_CREATE:
 559         {
 560             CREATESTRUCT32W *cs = (CREATESTRUCT32W *)lParam;
 561             if (HIWORD(cs->lpszName))
 562                 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszName );
 563             if (HIWORD(cs->lpszClass))
 564                 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszClass );
 565             HeapFree( SystemHeap, 0, cs );
 566         }
 567         break;
 568
 569     case WM_MDICREATE:
 570         {
 571             MDICREATESTRUCT32W *cs = (MDICREATESTRUCT32W *)lParam;
 572             if (HIWORD(cs->szTitle))
 573                 HeapFree( SystemHeap, 0, (LPVOID)cs->szTitle );
 574             if (HIWORD(cs->szClass))
 575                 HeapFree( SystemHeap, 0, (LPVOID)cs->szClass );
 576             HeapFree( SystemHeap, 0, cs );
 577         }
 578         break;
 579
 580     case WM_SETTEXT:
 581     case CB_DIR32:
 582     case CB_FINDSTRING32:
 583     case CB_FINDSTRINGEXACT32:
 584     case CB_SELECTSTRING32:
 585     case LB_DIR32:
 586     case LB_ADDFILE32:
 587     case LB_FINDSTRING32:
 588     case LB_SELECTSTRING32:
 589     case EM_REPLACESEL32:
 590         HeapFree( SystemHeap, 0, (void *)lParam );
 591         break;
 592
 593 /* Listbox */
 594     case LB_ADDSTRING32:
 595     case LB_INSERTSTRING32:
 596         if ( WINPROC_TestLBForStr( hwnd ))
 597           HeapFree( SystemHeap, 0, (void *)lParam );
 598         break;
 599
 600     case LB_GETTEXT32:
 601         { if ( WINPROC_TestLBForStr( hwnd ))
 602           { LPARAM *ptr = (LPARAM *)lParam - 1;
 603             lstrcpyWtoA( (LPSTR)*ptr, (LPWSTR)(lParam) );
 604             HeapFree( SystemHeap, 0, ptr );
 605           }
 606         }
 607         break;
 608
 609 /* Combobox */
 610     case CB_ADDSTRING32:
 611     case CB_INSERTSTRING32:
 612         if ( WINPROC_TestCBForStr( hwnd ))
 613           HeapFree( SystemHeap, 0, (void *)lParam );
 614         break;
 615
 616     case CB_GETLBTEXT32:
 617         { if ( WINPROC_TestCBForStr( hwnd ))
 618           { LPARAM *ptr = (LPARAM *)lParam - 1;
 619             lstrcpyWtoA( (LPSTR)*ptr, (LPWSTR)(lParam) );
 620             HeapFree( SystemHeap, 0, ptr );
 621           }
 622         }
 623         break;
 624
 625 /* Multiline edit */
 626     case EM_GETLINE32:
 627         { LPARAM * ptr = (LPARAM *)lParam - 1;  /* get the old lParam */
 628           WORD len = *(WORD *) lParam;
 629           lstrcpynWtoA( (LPSTR)*ptr , (LPWSTR)lParam, len );
 630           HeapFree( SystemHeap, 0, ptr );
 631         }
 632         break;
 633     }
 634 }
 635
 636
 637 /**********************************************************************
 638  *           WINPROC_MapMsg32WTo32A
 639  *
 640  * Map a message from Unicode to Ansi.
 641  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
 642  */
 643 INT32 WINPROC_MapMsg32WTo32A( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM *plparam )
 644 {   switch(msg)
 645     {
 646     case WM_GETTEXT:
 647         {
 648             LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0,
 649                                                wParam + sizeof(LPARAM) );
 650             if (!ptr) return -1;
 651             *ptr++ = *plparam;  /* Store previous lParam */
 652             *plparam = (LPARAM)ptr;
 653         }
 654         return 1;
 655
 656     case WM_SETTEXT:
 657     case CB_DIR32:
 658     case CB_FINDSTRING32:
 659     case CB_FINDSTRINGEXACT32:
 660     case CB_SELECTSTRING32:
 661     case LB_DIR32:
 662     case LB_ADDFILE32:
 663     case LB_FINDSTRING32:
 664     case LB_SELECTSTRING32:
 665     case EM_REPLACESEL32:
 666         *plparam = (LPARAM)HEAP_strdupWtoA( SystemHeap, 0, (LPCWSTR)*plparam );
 667         return (*plparam ? 1 : -1);
 668
 669     case WM_NCCREATE:
 670     case WM_CREATE:
 671         {
 672             CREATESTRUCT32A *cs = (CREATESTRUCT32A *)HeapAlloc( SystemHeap, 0,
 673                                                                 sizeof(*cs) );
 674             if (!cs) return -1;
 675             *cs = *(CREATESTRUCT32A *)*plparam;
 676             if (HIWORD(cs->lpszName))
 677                 cs->lpszName  = HEAP_strdupWtoA( SystemHeap, 0,
 678                                                  (LPCWSTR)cs->lpszName );
 679             if (HIWORD(cs->lpszClass))
 680                 cs->lpszClass = HEAP_strdupWtoA( SystemHeap, 0,
 681                                                  (LPCWSTR)cs->lpszClass);
 682             *plparam = (LPARAM)cs;
 683         }
 684         return 1;
 685     case WM_MDICREATE:
 686         {
 687             MDICREATESTRUCT32A *cs =
 688                 (MDICREATESTRUCT32A *)HeapAlloc( SystemHeap, 0, sizeof(*cs) );
 689             if (!cs) return -1;
 690             *cs = *(MDICREATESTRUCT32A *)*plparam;
 691             if (HIWORD(cs->szTitle))
 692                 cs->szTitle = HEAP_strdupWtoA( SystemHeap, 0,
 693                                                (LPCWSTR)cs->szTitle );
 694             if (HIWORD(cs->szClass))
 695                 cs->szClass = HEAP_strdupWtoA( SystemHeap, 0,
 696                                                (LPCWSTR)cs->szClass );
 697             *plparam = (LPARAM)cs;
 698         }
 699         return 1;
 700
 701 /* Listbox */
 702     case LB_ADDSTRING32:
 703     case LB_INSERTSTRING32:
 704         if ( WINPROC_TestLBForStr( hwnd ))
 705           *plparam = (LPARAM)HEAP_strdupWtoA( SystemHeap, 0, (LPCWSTR)*plparam );
 706         return (*plparam ? 1 : -1);
 707
 708     case LB_GETTEXT32:                  /* fixme: fixed sized buffer */
 709         { if ( WINPROC_TestLBForStr( hwnd ))
 710           { LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0, 256 + sizeof(LPARAM) );
 711             if (!ptr) return -1;
 712             *ptr++ = *plparam;  /* Store previous lParam */
 713             *plparam = (LPARAM)ptr;
 714           }
 715         }
 716         return 1;
 717
 718 /* Combobox */
 719     case CB_ADDSTRING32:
 720     case CB_INSERTSTRING32:
 721         if ( WINPROC_TestCBForStr( hwnd ))
 722           *plparam = (LPARAM)HEAP_strdupWtoA( SystemHeap, 0, (LPCWSTR)*plparam );
 723         return (*plparam ? 1 : -1);
 724
 725     case CB_GETLBTEXT32:                /* fixme: fixed sized buffer */
 726         { if ( WINPROC_TestCBForStr( hwnd ))
 727           { LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0, 256 + sizeof(LPARAM) );
 728             if (!ptr) return -1;
 729             *ptr++ = *plparam;  /* Store previous lParam */
 730             *plparam = (LPARAM)ptr;
 731           }
 732         }
 733         return 1;
 734
 735 /* Multiline edit */
 736     case EM_GETLINE32:
 737         { WORD len = (WORD)*plparam;
 738           LPARAM *ptr = (LPARAM *) HEAP_xalloc( SystemHeap, 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(CHAR) );
 739           if (!ptr) return -1;
 740           *ptr++ = *plparam;  /* Store previous lParam */
 741           (WORD)*ptr = len;   /* Store the lenght */
 742           *plparam = (LPARAM)ptr;
 743         }
 744         return 1;
 745
 746     case WM_ASKCBFORMATNAME:
 747     case WM_DEVMODECHANGE:
 748     case WM_PAINTCLIPBOARD:
 749     case WM_SIZECLIPBOARD:
 750     case WM_WININICHANGE:
 751     case EM_SETPASSWORDCHAR32:
 752         FIXME(msg, "message %s (%04x) needs translation, please report\n",SPY_GetMsgName(msg),msg );
 753         return -1;
 754     default:  /* No translation needed */
 755         return 0;
 756     }
 757 }
 758
 759
 760 /**********************************************************************
 761  *           WINPROC_UnmapMsg32WTo32A
 762  *
 763  * Unmap a message that was mapped from Unicode to Ansi.
 764  */
 765 void WINPROC_UnmapMsg32WTo32A( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam )
 766 {
 767     switch(msg)
 768     {
 769     case WM_GETTEXT:
 770         {
 771             LPARAM *ptr = (LPARAM *)lParam - 1;
 772             lstrcpynAtoW( (LPWSTR)*ptr, (LPSTR)lParam, wParam );
 773             HeapFree( SystemHeap, 0, ptr );
 774         }
 775         break;
 776
 777     case WM_SETTEXT:
 778     case CB_DIR32:
 779     case CB_FINDSTRING32:
 780     case CB_FINDSTRINGEXACT32:
 781     case CB_SELECTSTRING32:
 782     case LB_DIR32:
 783     case LB_ADDFILE32:
 784     case LB_FINDSTRING32:
 785     case LB_SELECTSTRING32:
 786     case EM_REPLACESEL32:
 787         HeapFree( SystemHeap, 0, (void *)lParam );
 788         break;
 789
 790     case WM_NCCREATE:
 791     case WM_CREATE:
 792         {
 793             CREATESTRUCT32A *cs = (CREATESTRUCT32A *)lParam;
 794             if (HIWORD(cs->lpszName))
 795                 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszName );
 796             if (HIWORD(cs->lpszClass))
 797                 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszClass );
 798             HeapFree( SystemHeap, 0, cs );
 799         }
 800         break;
 801
 802     case WM_MDICREATE:
 803         {
 804             MDICREATESTRUCT32A *cs = (MDICREATESTRUCT32A *)lParam;
 805             if (HIWORD(cs->szTitle))
 806                 HeapFree( SystemHeap, 0, (LPVOID)cs->szTitle );
 807             if (HIWORD(cs->szClass))
 808                 HeapFree( SystemHeap, 0, (LPVOID)cs->szClass );
 809             HeapFree( SystemHeap, 0, cs );
 810         }
 811         break;
 812
 813 /* Listbox */
 814     case LB_ADDSTRING32:
 815     case LB_INSERTSTRING32:
 816         if ( WINPROC_TestLBForStr( hwnd ))
 817           HeapFree( SystemHeap, 0, (void *)lParam );
 818         break;
 819
 820     case LB_GETTEXT32:
 821         { if ( WINPROC_TestLBForStr( hwnd ))
 822           { LPARAM *ptr = (LPARAM *)lParam - 1;
 823             lstrcpyAtoW( (LPWSTR)*ptr, (LPSTR)(lParam) );
 824             HeapFree( SystemHeap, 0, ptr );
 825           }
 826         }
 827         break;
 828
 829 /* Combobox */
 830     case CB_ADDSTRING32:
 831     case CB_INSERTSTRING32:
 832         if ( WINPROC_TestCBForStr( hwnd ))
 833           HeapFree( SystemHeap, 0, (void *)lParam );
 834         break;
 835
 836     case CB_GETLBTEXT32:
 837         { if ( WINPROC_TestCBForStr( hwnd ))
 838           { LPARAM *ptr = (LPARAM *)lParam - 1;
 839             lstrcpyAtoW( (LPWSTR)*ptr, (LPSTR)(lParam) );
 840             HeapFree( SystemHeap, 0, ptr );
 841           }
 842         }
 843         break;
 844
 845 /* Multiline edit */
 846     case EM_GETLINE32:
 847         { LPARAM * ptr = (LPARAM *)lParam - 1;  /* get the old lparam */
 848           WORD len = *(WORD *)ptr;
 849           lstrcpynAtoW( (LPWSTR) *ptr, (LPSTR)lParam, len );
 850           HeapFree( SystemHeap, 0, ptr );
 851         }
 852         break;
 853     }
 854 }
 855
 856
 857 /**********************************************************************
 858  *           WINPROC_MapMsg16To32A
 859  *
 860  * Map a message from 16- to 32-bit Ansi.
 861  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
 862  */
 863 INT32 WINPROC_MapMsg16To32A( UINT16 msg16, WPARAM16 wParam16, UINT32 *pmsg32,
 864                              WPARAM32 *pwparam32, LPARAM *plparam )
 865 {
 866     *pmsg32 = (UINT32)msg16;
 867     *pwparam32 = (WPARAM32)wParam16;
 868     switch(msg16)
 869     {
 870     case WM_ACTIVATE:
 871     case WM_CHARTOITEM:
 872     case WM_COMMAND:
 873     case WM_VKEYTOITEM:
 874         *pwparam32 = MAKEWPARAM( wParam16, HIWORD(*plparam) );
 875         *plparam   = (LPARAM)(HWND32)LOWORD(*plparam);
 876         return 0;
 877     case WM_HSCROLL:
 878     case WM_VSCROLL:
 879         *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
 880         *plparam   = (LPARAM)(HWND32)HIWORD(*plparam);
 881         return 0;
 882     case WM_CTLCOLOR:
 883         if ( HIWORD(*plparam) > CTLCOLOR_STATIC ) return -1;
 884         *pmsg32    = WM_CTLCOLORMSGBOX + HIWORD(*plparam);
 885         *pwparam32 = (WPARAM32)(HDC32)wParam16;
 886         *plparam   = (LPARAM)(HWND32)LOWORD(*plparam);
 887         return 0;
 888     case WM_COMPAREITEM:
 889         {
 890             COMPAREITEMSTRUCT16* cis16 = (COMPAREITEMSTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
 891             COMPAREITEMSTRUCT32 *cis = (COMPAREITEMSTRUCT32 *)
 892                                         HeapAlloc(SystemHeap, 0, sizeof(*cis));
 893             if (!cis) return -1;
 894             cis->CtlType    = cis16->CtlType;
 895             cis->CtlID      = cis16->CtlID;
 896             cis->hwndItem   = cis16->hwndItem;
 897             cis->itemID1    = cis16->itemID1;
 898             cis->itemData1  = cis16->itemData1;
 899             cis->itemID2    = cis16->itemID2;
 900             cis->itemData2  = cis16->itemData2;
 901             cis->dwLocaleId = 0;  /* FIXME */
 902             *plparam = (LPARAM)cis;
 903         }
 904         return 1;
 905     case WM_DELETEITEM:
 906         {
 907             DELETEITEMSTRUCT16* dis16 = (DELETEITEMSTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
 908             DELETEITEMSTRUCT32 *dis = (DELETEITEMSTRUCT32 *)
 909                                         HeapAlloc(SystemHeap, 0, sizeof(*dis));
 910             if (!dis) return -1;
 911             dis->CtlType  = dis16->CtlType;
 912             dis->CtlID    = dis16->CtlID;
 913             dis->hwndItem = dis16->hwndItem;
 914             dis->itemData = dis16->itemData;
 915             *plparam = (LPARAM)dis;
 916         }
 917         return 1;
 918     case WM_MEASUREITEM:
 919         {
 920             MEASUREITEMSTRUCT16* mis16 = (MEASUREITEMSTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
 921             MEASUREITEMSTRUCT32 *mis = (MEASUREITEMSTRUCT32 *)
 922                                         HeapAlloc(SystemHeap, 0,
 923                                                 sizeof(*mis) + sizeof(LPARAM));
 924             if (!mis) return -1;
 925             mis->CtlType    = mis16->CtlType;
 926             mis->CtlID      = mis16->CtlID;
 927             mis->itemID     = mis16->itemID;
 928             mis->itemWidth  = mis16->itemWidth;
 929             mis->itemHeight = mis16->itemHeight;
 930             mis->itemData   = mis16->itemData;
 931             *(LPARAM *)(mis + 1) = *plparam;  /* Store the previous lParam */
 932             *plparam = (LPARAM)mis;
 933         }
 934         return 1;
 935     case WM_DRAWITEM:
 936         {
 937             DRAWITEMSTRUCT16* dis16 = (DRAWITEMSTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
 938             DRAWITEMSTRUCT32 *dis = (DRAWITEMSTRUCT32*)HeapAlloc(SystemHeap, 0,
 939                                                                  sizeof(*dis));
 940             if (!dis) return -1;
 941             dis->CtlType    = dis16->CtlType;
 942             dis->CtlID      = dis16->CtlID;
 943             dis->itemID     = dis16->itemID;
 944             dis->itemAction = dis16->itemAction;
 945             dis->itemState  = dis16->itemState;
 946             dis->hwndItem   = dis16->hwndItem;
 947             dis->hDC        = dis16->hDC;
 948             dis->itemData   = dis16->itemData;
 949             CONV_RECT16TO32( &dis16->rcItem, &dis->rcItem );
 950             *plparam = (LPARAM)dis;
 951         }
 952         return 1;
 953     case WM_GETMINMAXINFO:
 954         {
 955             MINMAXINFO32 *mmi = (MINMAXINFO32 *)HeapAlloc( SystemHeap, 0,
 956                                                 sizeof(*mmi) + sizeof(LPARAM));
 957             if (!mmi) return -1;
 958             STRUCT32_MINMAXINFO16to32( (MINMAXINFO16*)PTR_SEG_TO_LIN(*plparam),
 959                                        mmi );
 960             *(LPARAM *)(mmi + 1) = *plparam;  /* Store the previous lParam */
 961             *plparam = (LPARAM)mmi;
 962         }
 963         return 1;
 964     case WM_GETTEXT:
 965     case WM_SETTEXT:
 966         *plparam = (LPARAM)PTR_SEG_TO_LIN(*plparam);
 967         return 0;
 968     case WM_MDICREATE:
 969         {
 970             MDICREATESTRUCT16 *cs16 =
 971                 (MDICREATESTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
 972             MDICREATESTRUCT32A *cs =
 973                 (MDICREATESTRUCT32A *)HeapAlloc( SystemHeap, 0,
 974                                                 sizeof(*cs) + sizeof(LPARAM) );
 975             if (!cs) return -1;
 976             STRUCT32_MDICREATESTRUCT16to32A( cs16, cs );
 977             cs->szTitle = (LPCSTR)PTR_SEG_TO_LIN(cs16->szTitle);
 978             cs->szClass = (LPCSTR)PTR_SEG_TO_LIN(cs16->szClass);
 979             *(LPARAM *)(cs + 1) = *plparam;  /* Store the previous lParam */
 980             *plparam = (LPARAM)cs;
 981         }
 982         return 1;
 983     case WM_MDIGETACTIVE:
 984         *plparam = (LPARAM)HeapAlloc( SystemHeap, 0, sizeof(BOOL32) );
 985         *(BOOL32*)(*plparam) = 0;
 986         return 1;
 987     case WM_MDISETMENU:
 988         if(wParam16==TRUE)
 989            *pmsg32=WM_MDIREFRESHMENU;
 990         *pwparam32 = (WPARAM32)(HMENU32)LOWORD(*plparam);
 991         *plparam   = (LPARAM)(HMENU32)HIWORD(*plparam);
 992         return 0;
 993     case WM_MENUCHAR:
 994     case WM_MENUSELECT:
 995         *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
 996         *plparam   = (LPARAM)(HMENU32)HIWORD(*plparam);
 997         return 0;
 998     case WM_MDIACTIVATE:
 999         if( *plparam )
1000         {
1001             *pwparam32 = (WPARAM32)(HWND32)HIWORD(*plparam);
1002             *plparam   = (LPARAM)(HWND32)LOWORD(*plparam);
1003         }
1004         else /* message sent to MDI client */
1005             *pwparam32 = wParam16;
1006         return 0;
1007     case WM_NCCALCSIZE:
1008         {
1009             NCCALCSIZE_PARAMS16 *nc16;
1010             NCCALCSIZE_PARAMS32 *nc;
1011
1012             nc = (NCCALCSIZE_PARAMS32 *)HeapAlloc( SystemHeap, 0,
1013                                                 sizeof(*nc) + sizeof(LPARAM) );
1014             if (!nc) return -1;
1015             nc16 = (NCCALCSIZE_PARAMS16 *)PTR_SEG_TO_LIN(*plparam);
1016             CONV_RECT16TO32( &nc16->rgrc[0], &nc->rgrc[0] );
1017             if (wParam16)
1018             {
1019                 nc->lppos = (WINDOWPOS32 *)HeapAlloc( SystemHeap, 0,
1020                                                       sizeof(*nc->lppos) );
1021                 CONV_RECT16TO32( &nc16->rgrc[1], &nc->rgrc[1] );
1022                 CONV_RECT16TO32( &nc16->rgrc[2], &nc->rgrc[2] );
1023                 if (nc->lppos) STRUCT32_WINDOWPOS16to32( (WINDOWPOS16 *)PTR_SEG_TO_LIN(nc16->lppos), nc->lppos );
1024             }
1025             *(LPARAM *)(nc + 1) = *plparam;  /* Store the previous lParam */
1026             *plparam = (LPARAM)nc;
1027         }
1028         return 1;
1029     case WM_NCCREATE:
1030     case WM_CREATE:
1031         {
1032             CREATESTRUCT16 *cs16 = (CREATESTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
1033             CREATESTRUCT32A *cs = (CREATESTRUCT32A *)HeapAlloc( SystemHeap, 0,
1034                                                 sizeof(*cs) + sizeof(LPARAM) );
1035             if (!cs) return -1;
1036             STRUCT32_CREATESTRUCT16to32A( cs16, cs );
1037             cs->lpszName  = (LPCSTR)PTR_SEG_TO_LIN(cs16->lpszName);
1038             cs->lpszClass = (LPCSTR)PTR_SEG_TO_LIN(cs16->lpszClass);
1039             *(LPARAM *)(cs + 1) = *plparam;  /* Store the previous lParam */
1040             *plparam = (LPARAM)cs;
1041         }
1042         return 1;
1043     case WM_PARENTNOTIFY:
1044         if ((wParam16 == WM_CREATE) || (wParam16 == WM_DESTROY))
1045         {
1046             *pwparam32 = MAKEWPARAM( wParam16, HIWORD(*plparam) );
1047             *plparam   = (LPARAM)(HWND32)LOWORD(*plparam);
1048         }
1049         return 0;
1050     case WM_WINDOWPOSCHANGING:
1051     case WM_WINDOWPOSCHANGED:
1052         {
1053             WINDOWPOS32 *wp = (WINDOWPOS32 *)HeapAlloc( SystemHeap, 0,
1054                                                 sizeof(*wp) + sizeof(LPARAM) );
1055             if (!wp) return -1;
1056             STRUCT32_WINDOWPOS16to32( (WINDOWPOS16 *)PTR_SEG_TO_LIN(*plparam),
1057                                       wp );
1058             *(LPARAM *)(wp + 1) = *plparam;  /* Store the previous lParam */
1059             *plparam = (LPARAM)wp;
1060         }
1061         return 1;
1062     case WM_GETDLGCODE:
1063         if (*plparam)
1064         {
1065             LPMSG16 msg16 = (LPMSG16)PTR_SEG_TO_LIN(*plparam);
1066             LPMSG32 msg32 = (LPMSG32)HeapAlloc( SystemHeap, 0, sizeof(MSG32) );
1067
1068             if (!msg32) return -1;
1069             msg32->hwnd = msg16->hwnd;
1070             msg32->lParam = msg16->lParam;
1071             msg32->time = msg16->time;
1072             CONV_POINT16TO32(&msg16->pt,&msg32->pt);
1073             /* this is right, right? */
1074             if (WINPROC_MapMsg16To32A(msg16->message,msg16->wParam,
1075                                      &msg32->message,&msg32->wParam,
1076                                      &msg32->lParam)<0) {
1077                 HeapFree( SystemHeap, 0, msg32 );
1078                 return -1;
1079             }
1080             *plparam = (LPARAM)msg32;
1081             return 1;
1082         }
1083         else return 0;
1084     case WM_NOTIFY:
1085         *plparam = (LPARAM)PTR_SEG_TO_LIN(*plparam);
1086         return 1;
1087     case WM_ACTIVATEAPP:
1088         if (*plparam)
1089         { /* We need this when SetActiveWindow sends a Sendmessage16() to
1090              a 32bit window. Might be superflous with 32bit interprocess
1091              message queues.
1092           */
1093           HTASK16 htask = (HTASK16) *plparam;
1094           DWORD idThread = THDB_TO_THREAD_ID(((TDB*)GlobalLock16(htask))->thdb);
1095           *plparam = (LPARAM) idThread;
1096         }
1097         return 1;
1098     case WM_ASKCBFORMATNAME:
1099     case WM_DEVMODECHANGE:
1100     case WM_PAINTCLIPBOARD:
1101     case WM_SIZECLIPBOARD:
1102     case WM_WININICHANGE:
1103         FIXME( msg, "message %04x needs translation\n",msg16 );
1104         return -1;
1105
1106     default:  /* No translation needed */
1107         return 0;
1108     }
1109 }
1110
1111
1112 /**********************************************************************
1113  *           WINPROC_UnmapMsg16To32A
1114  *
1115  * Unmap a message that was mapped from 16- to 32-bit Ansi.
1116  */
1117 LRESULT WINPROC_UnmapMsg16To32A( HWND16 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam,
1118                                  LRESULT result )
1119 {
1120     switch(msg)
1121     {
1122     case WM_COMPAREITEM:
1123     case WM_DELETEITEM:
1124     case WM_DRAWITEM:
1125         HeapFree( SystemHeap, 0, (LPVOID)lParam );
1126         break;
1127     case WM_MEASUREITEM:
1128         {
1129             MEASUREITEMSTRUCT16 *mis16;
1130             MEASUREITEMSTRUCT32 *mis = (MEASUREITEMSTRUCT32 *)lParam;
1131             lParam = *(LPARAM *)(mis + 1);
1132             mis16 = (MEASUREITEMSTRUCT16 *)PTR_SEG_TO_LIN(lParam);
1133             mis16->itemWidth  = (UINT16)mis->itemWidth;
1134             mis16->itemHeight = (UINT16)mis->itemHeight;
1135             HeapFree( SystemHeap, 0, mis );
1136         }
1137         break;
1138     case WM_GETMINMAXINFO:
1139         {
1140             MINMAXINFO32 *mmi = (MINMAXINFO32 *)lParam;
1141             lParam = *(LPARAM *)(mmi + 1);
1142             STRUCT32_MINMAXINFO32to16( mmi,
1143                                        (MINMAXINFO16 *)PTR_SEG_TO_LIN(lParam));
1144             HeapFree( SystemHeap, 0, mmi );
1145         }
1146         break;
1147     case WM_MDICREATE:
1148         {
1149             MDICREATESTRUCT32A *cs = (MDICREATESTRUCT32A *)lParam;
1150             lParam = *(LPARAM *)(cs + 1);
1151             STRUCT32_MDICREATESTRUCT32Ato16( cs,
1152                                  (MDICREATESTRUCT16 *)PTR_SEG_TO_LIN(lParam) );
1153             HeapFree( SystemHeap, 0, cs );
1154         }
1155         break;
1156     case WM_MDIGETACTIVE:
1157         result = MAKELONG( LOWORD(result), (BOOL16)(*(BOOL32 *)lParam) );
1158         HeapFree( SystemHeap, 0, (BOOL32 *)lParam );
1159         break;
1160     case WM_NCCALCSIZE:
1161         {
1162             NCCALCSIZE_PARAMS16 *nc16;
1163             NCCALCSIZE_PARAMS32 *nc = (NCCALCSIZE_PARAMS32 *)lParam;
1164             lParam = *(LPARAM *)(nc + 1);
1165             nc16 = (NCCALCSIZE_PARAMS16 *)PTR_SEG_TO_LIN(lParam);
1166             CONV_RECT32TO16( &nc->rgrc[0], &nc16->rgrc[0] );
1167             if (wParam)
1168             {
1169                 CONV_RECT32TO16( &nc->rgrc[1], &nc16->rgrc[1] );
1170                 CONV_RECT32TO16( &nc->rgrc[2], &nc16->rgrc[2] );
1171                 if (nc->lppos)
1172                 {
1173                     STRUCT32_WINDOWPOS32to16( nc->lppos,
1174                                    (WINDOWPOS16 *)PTR_SEG_TO_LIN(nc16->lppos));
1175                     HeapFree( SystemHeap, 0, nc->lppos );
1176                 }
1177             }
1178             HeapFree( SystemHeap, 0, nc );
1179         }
1180         break;
1181     case WM_NCCREATE:
1182     case WM_CREATE:
1183         {
1184             CREATESTRUCT32A *cs = (CREATESTRUCT32A *)lParam;
1185             lParam = *(LPARAM *)(cs + 1);
1186             STRUCT32_CREATESTRUCT32Ato16( cs,
1187                                     (CREATESTRUCT16 *)PTR_SEG_TO_LIN(lParam) );
1188             HeapFree( SystemHeap, 0, cs );
1189         }
1190         break;
1191     case WM_WINDOWPOSCHANGING:
1192     case WM_WINDOWPOSCHANGED:
1193         {
1194             WINDOWPOS32 *wp = (WINDOWPOS32 *)lParam;
1195             lParam = *(LPARAM *)(wp + 1);
1196             STRUCT32_WINDOWPOS32to16(wp,(WINDOWPOS16 *)PTR_SEG_TO_LIN(lParam));
1197             HeapFree( SystemHeap, 0, wp );
1198         }
1199         break;
1200     case WM_GETDLGCODE:
1201         if (lParam)
1202         {
1203             LPMSG32 msg32 = (LPMSG32)lParam;
1204
1205             WINPROC_UnmapMsg16To32A( hwnd, msg32->message, msg32->wParam, msg32->lParam,
1206                                      result);
1207             HeapFree( SystemHeap, 0, msg32 );
1208         }
1209         break;
1210     }
1211     return result;
1212 }
1213
1214
1215 /**********************************************************************
1216  *           WINPROC_MapMsg16To32W
1217  *
1218  * Map a message from 16- to 32-bit Unicode.
1219  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1220  */
1221 INT32 WINPROC_MapMsg16To32W( HWND16 hwnd, UINT16 msg16, WPARAM16 wParam16, UINT32 *pmsg32,
1222                              WPARAM32 *pwparam32, LPARAM *plparam )
1223 {
1224     switch(msg16)
1225     {
1226     case WM_GETTEXT:
1227     case WM_SETTEXT:
1228         *plparam = (LPARAM)PTR_SEG_TO_LIN(*plparam);
1229         return WINPROC_MapMsg32ATo32W( hwnd, *pmsg32, *pwparam32, plparam );
1230     case WM_NCCREATE:
1231     case WM_CREATE:
1232         {
1233             CREATESTRUCT16 *cs16 = (CREATESTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
1234             CREATESTRUCT32W *cs = (CREATESTRUCT32W *)HeapAlloc( SystemHeap, 0,
1235                                                 sizeof(*cs) + sizeof(LPARAM) );
1236             if (!cs) return -1;
1237             STRUCT32_CREATESTRUCT16to32A( cs16, (CREATESTRUCT32A *)cs );
1238             cs->lpszName  = (LPCWSTR)PTR_SEG_TO_LIN(cs16->lpszName);
1239             cs->lpszClass = (LPCWSTR)PTR_SEG_TO_LIN(cs16->lpszClass);
1240             if (HIWORD(cs->lpszName))
1241                 cs->lpszName = HEAP_strdupAtoW( SystemHeap, 0,
1242                                                 (LPCSTR)cs->lpszName );
1243             if (HIWORD(cs->lpszClass))
1244                 cs->lpszClass = HEAP_strdupAtoW( SystemHeap, 0,
1245                                                  (LPCSTR)cs->lpszClass );
1246             *(LPARAM *)(cs + 1) = *plparam;  /* Store the previous lParam */
1247             *plparam = (LPARAM)cs;
1248         }
1249         return 1;
1250     case WM_MDICREATE:
1251         {
1252             MDICREATESTRUCT16 *cs16 =
1253                 (MDICREATESTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
1254             MDICREATESTRUCT32W *cs =
1255                 (MDICREATESTRUCT32W *)HeapAlloc( SystemHeap, 0,
1256                                                 sizeof(*cs) + sizeof(LPARAM) );
1257             if (!cs) return -1;
1258             STRUCT32_MDICREATESTRUCT16to32A( cs16, (MDICREATESTRUCT32A *)cs );
1259             cs->szTitle = (LPCWSTR)PTR_SEG_TO_LIN(cs16->szTitle);
1260             cs->szClass = (LPCWSTR)PTR_SEG_TO_LIN(cs16->szClass);
1261             if (HIWORD(cs->szTitle))
1262                 cs->szTitle = HEAP_strdupAtoW( SystemHeap, 0,
1263                                                (LPCSTR)cs->szTitle );
1264             if (HIWORD(cs->szClass))
1265                 cs->szClass = HEAP_strdupAtoW( SystemHeap, 0,
1266                                                (LPCSTR)cs->szClass );
1267             *(LPARAM *)(cs + 1) = *plparam;  /* Store the previous lParam */
1268             *plparam = (LPARAM)cs;
1269         }
1270         return 1;
1271     case WM_GETDLGCODE:
1272         if (*plparam)
1273         {
1274             LPMSG16 msg16 = (LPMSG16)PTR_SEG_TO_LIN(*plparam);
1275             LPMSG32 msg32 = (LPMSG32)HeapAlloc( SystemHeap, 0, sizeof(MSG32) );
1276
1277             if (!msg32) return -1;
1278             msg32->hwnd = msg16->hwnd;
1279             msg32->lParam = msg16->lParam;
1280             msg32->time = msg16->time;
1281             CONV_POINT16TO32(&msg16->pt,&msg32->pt);
1282             /* this is right, right? */
1283             if (WINPROC_MapMsg16To32W(hwnd, msg16->message,msg16->wParam,
1284                                      &msg32->message,&msg32->wParam,
1285                                      &msg32->lParam)<0) {
1286                 HeapFree( SystemHeap, 0, msg32 );
1287                 return -1;
1288             }
1289             *plparam = (LPARAM)msg32;
1290             return 1;
1291         }
1292         else return 0;
1293     default:  /* No Unicode translation needed */
1294         return WINPROC_MapMsg16To32A( msg16, wParam16, pmsg32,
1295                                       pwparam32, plparam );
1296     }
1297 }
1298
1299
1300 /**********************************************************************
1301  *           WINPROC_UnmapMsg16To32W
1302  *
1303  * Unmap a message that was mapped from 16- to 32-bit Unicode.
1304  */
1305 LRESULT WINPROC_UnmapMsg16To32W( HWND16 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam,
1306                                  LRESULT result )
1307 {
1308     switch(msg)
1309     {
1310     case WM_GETTEXT:
1311     case WM_SETTEXT:
1312         WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam );
1313         break;
1314     case WM_NCCREATE:
1315     case WM_CREATE:
1316         {
1317             CREATESTRUCT32W *cs = (CREATESTRUCT32W *)lParam;
1318             lParam = *(LPARAM *)(cs + 1);
1319             STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCT32A *)cs,
1320                                     (CREATESTRUCT16 *)PTR_SEG_TO_LIN(lParam) );
1321             if (HIWORD(cs->lpszName))
1322                 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszName );
1323             if (HIWORD(cs->lpszClass))
1324                 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszClass );
1325             HeapFree( SystemHeap, 0, cs );
1326         }
1327         break;
1328     case WM_MDICREATE:
1329         {
1330             MDICREATESTRUCT32W *cs = (MDICREATESTRUCT32W *)lParam;
1331             lParam = *(LPARAM *)(cs + 1);
1332             STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCT32A *)cs,
1333                                  (MDICREATESTRUCT16 *)PTR_SEG_TO_LIN(lParam) );
1334             if (HIWORD(cs->szTitle))
1335                 HeapFree( SystemHeap, 0, (LPVOID)cs->szTitle );
1336             if (HIWORD(cs->szClass))
1337                 HeapFree( SystemHeap, 0, (LPVOID)cs->szClass );
1338             HeapFree( SystemHeap, 0, cs );
1339         }
1340         break;
1341     case WM_GETDLGCODE:
1342         if (lParam)
1343         {
1344             LPMSG32 msg32 = (LPMSG32)lParam;
1345
1346             WINPROC_UnmapMsg16To32W( hwnd, msg32->message, msg32->wParam, msg32->lParam,
1347                                      result);
1348             HeapFree( SystemHeap, 0, msg32 );
1349         }
1350         break;
1351     default:
1352         return WINPROC_UnmapMsg16To32A( hwnd, msg, wParam, lParam, result );
1353     }
1354     return result;
1355 }
1356
1357
1358 /**********************************************************************
1359  *           WINPROC_MapMsg32ATo16
1360  *
1361  * Map a message from 32-bit Ansi to 16-bit.
1362  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1363  */
1364 INT32 WINPROC_MapMsg32ATo16( HWND32 hwnd, UINT32 msg32, WPARAM32 wParam32,
1365                              UINT16 *pmsg16, WPARAM16 *pwparam16,
1366                              LPARAM *plparam )
1367 {
1368     *pmsg16 = (UINT16)msg32;
1369     *pwparam16 = (WPARAM16)LOWORD(wParam32);
1370     switch(msg32)
1371     {
1372     case BM_GETCHECK32:
1373     case BM_SETCHECK32:
1374     case BM_GETSTATE32:
1375     case BM_SETSTATE32:
1376     case BM_SETSTYLE32:
1377         *pmsg16 = (UINT16)msg32 + (BM_GETCHECK16 - BM_GETCHECK32);
1378         return 0;
1379
1380     case EM_GETSEL32:
1381     case EM_GETRECT32:
1382     case EM_SETRECT32:
1383     case EM_SETRECTNP32:
1384     case EM_SCROLL32:
1385     case EM_LINESCROLL32:
1386     case EM_SCROLLCARET32:
1387     case EM_GETMODIFY32:
1388     case EM_SETMODIFY32:
1389     case EM_GETLINECOUNT32:
1390     case EM_LINEINDEX32:
1391     case EM_SETHANDLE32:
1392     case EM_GETHANDLE32:
1393     case EM_GETTHUMB32:
1394     case EM_LINELENGTH32:
1395     case EM_REPLACESEL32:
1396     case EM_GETLINE32:
1397     case EM_LIMITTEXT32:
1398     case EM_CANUNDO32:
1399     case EM_UNDO32:
1400     case EM_FMTLINES32:
1401     case EM_LINEFROMCHAR32:
1402     case EM_SETTABSTOPS32:
1403     case EM_SETPASSWORDCHAR32:
1404     case EM_EMPTYUNDOBUFFER32:
1405     case EM_GETFIRSTVISIBLELINE32:
1406     case EM_SETREADONLY32:
1407     case EM_SETWORDBREAKPROC32:
1408     case EM_GETWORDBREAKPROC32:
1409     case EM_GETPASSWORDCHAR32:
1410         *pmsg16 = (UINT16)msg32 + (EM_GETSEL16 - EM_GETSEL32);
1411         return 0;
1412
1413     case LB_CARETOFF32:
1414     case LB_CARETON32:
1415     case LB_DELETESTRING32:
1416     case LB_GETANCHORINDEX32:
1417     case LB_GETCARETINDEX32:
1418     case LB_GETCOUNT32:
1419     case LB_GETCURSEL32:
1420     case LB_GETHORIZONTALEXTENT32:
1421     case LB_GETITEMDATA32:
1422     case LB_GETITEMHEIGHT32:
1423     case LB_GETSEL32:
1424     case LB_GETSELCOUNT32:
1425     case LB_GETTEXTLEN32:
1426     case LB_GETTOPINDEX32:
1427     case LB_RESETCONTENT32:
1428     case LB_SELITEMRANGE32:
1429     case LB_SELITEMRANGEEX32:
1430     case LB_SETANCHORINDEX32:
1431     case LB_SETCARETINDEX32:
1432     case LB_SETCOLUMNWIDTH32:
1433     case LB_SETCURSEL32:
1434     case LB_SETHORIZONTALEXTENT32:
1435     case LB_SETITEMDATA32:
1436     case LB_SETITEMHEIGHT32:
1437     case LB_SETSEL32:
1438     case LB_SETTOPINDEX32:
1439         *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING32);
1440         return 0;
1441     case CB_DELETESTRING32:
1442     case CB_GETCOUNT32:
1443     case CB_GETLBTEXTLEN32:
1444     case CB_LIMITTEXT32:
1445     case CB_RESETCONTENT32:
1446     case CB_SETEDITSEL32:
1447     case CB_GETCURSEL32:
1448     case CB_SETCURSEL32:
1449     case CB_SHOWDROPDOWN32:
1450     case CB_SETITEMDATA32:
1451     case CB_SETITEMHEIGHT32:
1452     case CB_GETITEMHEIGHT32:
1453     case CB_SETEXTENDEDUI32:
1454     case CB_GETEXTENDEDUI32:
1455     case CB_GETDROPPEDSTATE32:
1456         *pmsg16 = (UINT16)msg32 + (CB_GETEDITSEL16 - CB_GETEDITSEL32);
1457         return 0;
1458     case CB_GETEDITSEL32:
1459         *pmsg16 = CB_GETEDITSEL16;
1460         return 1;
1461
1462     case LB_ADDSTRING32:
1463     case LB_FINDSTRING32:
1464     case LB_FINDSTRINGEXACT32:
1465     case LB_INSERTSTRING32:
1466     case LB_SELECTSTRING32:
1467     case LB_DIR32:
1468     case LB_ADDFILE32:
1469         {
1470             LPSTR str = SEGPTR_STRDUP( (LPSTR)*plparam );
1471             if (!str) return -1;
1472             *plparam = (LPARAM)SEGPTR_GET(str);
1473         }
1474         *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING32);
1475         return 1;
1476
1477     case CB_ADDSTRING32:
1478     case CB_FINDSTRING32:
1479     case CB_FINDSTRINGEXACT32:
1480     case CB_INSERTSTRING32:
1481     case CB_SELECTSTRING32:
1482     case CB_DIR32:
1483         {
1484             LPSTR str = SEGPTR_STRDUP( (LPSTR)*plparam );
1485             if (!str) return -1;
1486             *plparam = (LPARAM)SEGPTR_GET(str);
1487         }
1488         *pmsg16 = (UINT16)msg32 + (CB_GETEDITSEL16 - CB_GETEDITSEL32);
1489         return 1;
1490
1491     case LB_GETITEMRECT32:
1492         {
1493             RECT16 *rect;
1494             rect = (RECT16 *)SEGPTR_ALLOC( sizeof(RECT16) + sizeof(LPARAM) );
1495             if (!rect) return -1;
1496             *(LPARAM *)(rect + 1) = *plparam;  /* Store the previous lParam */
1497             *plparam = (LPARAM)SEGPTR_GET(rect);
1498         }
1499         *pmsg16 = LB_GETITEMRECT16;
1500         return 1;
1501     case LB_GETSELITEMS32:
1502         {
1503             LPINT16 items;
1504             *pwparam16 = (WPARAM16)MIN( wParam32, 0x7f80 ); /* Must be < 64K */
1505             if (!(items = SEGPTR_ALLOC( *pwparam16 * sizeof(INT16)
1506                                         + sizeof(LPARAM)))) return -1;
1507             *((LPARAM *)items)++ = *plparam;  /* Store the previous lParam */
1508             *plparam = (LPARAM)SEGPTR_GET(items);
1509         }
1510         *pmsg16 = LB_GETSELITEMS16;
1511         return 1;
1512     case LB_SETTABSTOPS32:
1513         if (wParam32)
1514         {
1515             INT32 i;
1516             LPINT16 stops;
1517             *pwparam16 = (WPARAM16)MIN( wParam32, 0x7f80 ); /* Must be < 64K */
1518             if (!(stops = SEGPTR_ALLOC( *pwparam16 * sizeof(INT16)
1519                                         + sizeof(LPARAM)))) return -1;
1520             for (i = 0; i < *pwparam16; i++) stops[i] = *((LPINT32)*plparam+i);
1521             *plparam = (LPARAM)SEGPTR_GET(stops);
1522             return 1;
1523         }
1524         *pmsg16 = LB_SETTABSTOPS16;
1525         return 0;
1526
1527     case CB_GETDROPPEDCONTROLRECT32:
1528         {
1529             RECT16 *rect;
1530             rect = (RECT16 *)SEGPTR_ALLOC( sizeof(RECT16) + sizeof(LPARAM) );
1531             if (!rect) return -1;
1532             *(LPARAM *)(rect + 1) = *plparam;  /* Store the previous lParam */
1533             *plparam = (LPARAM)SEGPTR_GET(rect);
1534         }
1535         *pmsg16 = CB_GETDROPPEDCONTROLRECT16;
1536         return 1;
1537
1538     case LB_GETTEXT32:
1539         *plparam = (LPARAM)MapLS( (LPVOID)(*plparam) );
1540         *pmsg16 = LB_GETTEXT16;
1541         return 1;
1542
1543     case CB_GETLBTEXT32:
1544         *plparam = (LPARAM)MapLS( (LPVOID)(*plparam) );
1545         *pmsg16 = CB_GETLBTEXT16;
1546         return 1;
1547
1548     case EM_SETSEL32:
1549         *pwparam16 = 0;
1550         *plparam = MAKELONG( (INT16)(INT32)wParam32, (INT16)*plparam );
1551         *pmsg16 = EM_SETSEL16;
1552         return 0;
1553
1554     case WM_ACTIVATE:
1555     case WM_CHARTOITEM:
1556     case WM_COMMAND:
1557     case WM_VKEYTOITEM:
1558         *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32) );
1559         return 0;
1560     case WM_HSCROLL:
1561     case WM_VSCROLL:
1562         *plparam = MAKELPARAM( HIWORD(wParam32), (HWND16)*plparam );
1563         return 0;
1564     case WM_CTLCOLORMSGBOX:
1565     case WM_CTLCOLOREDIT:
1566     case WM_CTLCOLORLISTBOX:
1567     case WM_CTLCOLORBTN:
1568     case WM_CTLCOLORDLG:
1569     case WM_CTLCOLORSCROLLBAR:
1570     case WM_CTLCOLORSTATIC:
1571         *pmsg16  = WM_CTLCOLOR;
1572         *plparam = MAKELPARAM( (HWND16)*plparam,
1573                                (WORD)msg32 - WM_CTLCOLORMSGBOX );
1574         return 0;
1575     case WM_COMPAREITEM:
1576         {
1577             COMPAREITEMSTRUCT32 *cis32 = (COMPAREITEMSTRUCT32 *)*plparam;
1578             COMPAREITEMSTRUCT16 *cis = SEGPTR_NEW(COMPAREITEMSTRUCT16);
1579             if (!cis) return -1;
1580             cis->CtlType    = (UINT16)cis32->CtlType;
1581             cis->CtlID      = (UINT16)cis32->CtlID;
1582             cis->hwndItem   = (HWND16)cis32->hwndItem;
1583             cis->itemID1    = (UINT16)cis32->itemID1;
1584             cis->itemData1  = cis32->itemData1;
1585             cis->itemID2    = (UINT16)cis32->itemID2;
1586             cis->itemData2  = cis32->itemData2;
1587             *plparam = (LPARAM)SEGPTR_GET(cis);
1588         }
1589         return 1;
1590     case WM_DELETEITEM:
1591         {
1592             DELETEITEMSTRUCT32 *dis32 = (DELETEITEMSTRUCT32 *)*plparam;
1593             DELETEITEMSTRUCT16 *dis = SEGPTR_NEW(DELETEITEMSTRUCT16);
1594             if (!dis) return -1;
1595             dis->CtlType  = (UINT16)dis32->CtlType;
1596             dis->CtlID    = (UINT16)dis32->CtlID;
1597             dis->itemID   = (UINT16)dis32->itemID;
1598             dis->hwndItem = (HWND16)dis32->hwndItem;
1599             dis->itemData = dis32->itemData;
1600             *plparam = (LPARAM)SEGPTR_GET(dis);
1601         }
1602         return 1;
1603     case WM_DRAWITEM:
1604         {
1605             DRAWITEMSTRUCT32 *dis32 = (DRAWITEMSTRUCT32 *)*plparam;
1606             DRAWITEMSTRUCT16 *dis = SEGPTR_NEW(DRAWITEMSTRUCT16);
1607             if (!dis) return -1;
1608             dis->CtlType    = (UINT16)dis32->CtlType;
1609             dis->CtlID      = (UINT16)dis32->CtlID;
1610             dis->itemID     = (UINT16)dis32->itemID;
1611             dis->itemAction = (UINT16)dis32->itemAction;
1612             dis->itemState  = (UINT16)dis32->itemState;
1613             dis->hwndItem   = (HWND16)dis32->hwndItem;
1614             dis->hDC        = (HDC16)dis32->hDC;
1615             dis->itemData   = dis32->itemData;
1616             CONV_RECT32TO16( &dis32->rcItem, &dis->rcItem );
1617             *plparam = (LPARAM)SEGPTR_GET(dis);
1618         }
1619         return 1;
1620     case WM_MEASUREITEM:
1621         {
1622             MEASUREITEMSTRUCT32 *mis32 = (MEASUREITEMSTRUCT32 *)*plparam;
1623             MEASUREITEMSTRUCT16 *mis = (MEASUREITEMSTRUCT16 *)
1624                                      SEGPTR_ALLOC(sizeof(*mis)+sizeof(LPARAM));
1625             if (!mis) return -1;
1626             mis->CtlType    = (UINT16)mis32->CtlType;
1627             mis->CtlID      = (UINT16)mis32->CtlID;
1628             mis->itemID     = (UINT16)mis32->itemID;
1629             mis->itemWidth  = (UINT16)mis32->itemWidth;
1630             mis->itemHeight = (UINT16)mis32->itemHeight;
1631             mis->itemData   = mis32->itemData;
1632             *(LPARAM *)(mis + 1) = *plparam;  /* Store the previous lParam */
1633             *plparam = (LPARAM)SEGPTR_GET(mis);
1634         }
1635         return 1;
1636     case WM_GETMINMAXINFO:
1637         {
1638             MINMAXINFO16 *mmi = (MINMAXINFO16 *)SEGPTR_ALLOC( sizeof(*mmi) +
1639                                                               sizeof(LPARAM) );
1640             if (!mmi) return -1;
1641             STRUCT32_MINMAXINFO32to16( (MINMAXINFO32 *)*plparam, mmi );
1642             *(LPARAM *)(mmi + 1) = *plparam;  /* Store the previous lParam */
1643             *plparam = (LPARAM)SEGPTR_GET(mmi);
1644         }
1645         return 1;
1646     case WM_GETTEXT:
1647         {
1648             LPSTR str;
1649             *pwparam16 = (WPARAM16)MIN( wParam32, 0xff80 ); /* Must be < 64K */
1650             if (!(str = SEGPTR_ALLOC(*pwparam16 + sizeof(LPARAM)))) return -1;
1651             *((LPARAM *)str)++ = *plparam;  /* Store the previous lParam */
1652             *plparam = (LPARAM)SEGPTR_GET(str);
1653         }
1654         return 1;
1655     case WM_MDICREATE:
1656         {
1657             MDICREATESTRUCT16 *cs;
1658             MDICREATESTRUCT32A *cs32 = (MDICREATESTRUCT32A *)*plparam;
1659             LPSTR name, cls;
1660
1661             if (!(cs = SEGPTR_NEW(MDICREATESTRUCT16))) return -1;
1662             STRUCT32_MDICREATESTRUCT32Ato16( cs32, cs );
1663             name = SEGPTR_STRDUP( cs32->szTitle );
1664             cls  = SEGPTR_STRDUP( cs32->szClass );
1665             cs->szTitle = SEGPTR_GET(name);
1666             cs->szClass = SEGPTR_GET(cls);
1667             *plparam = (LPARAM)SEGPTR_GET(cs);
1668         }
1669         return 1;
1670     case WM_MDIGETACTIVE:
1671         return 1;
1672     case WM_MDISETMENU:
1673         *plparam   = MAKELPARAM( (HMENU16)LOWORD(wParam32),
1674                                  (HMENU16)LOWORD(*plparam) );
1675         *pwparam16 = (*plparam == 0);
1676         return 0;
1677     case WM_MENUCHAR:
1678     case WM_MENUSELECT:
1679         *plparam = MAKELPARAM( HIWORD(wParam32), (HMENU16)*plparam );
1680         return 0;
1681     case WM_MDIACTIVATE:
1682         if( WIDGETS_IsControl32(WIN_FindWndPtr(hwnd), BIC32_MDICLIENT) )
1683         {
1684             *pwparam16 = (HWND32)wParam32;
1685             *plparam = 0;
1686         }
1687         else
1688         {
1689             *pwparam16 = ((HWND32)*plparam == hwnd);
1690             *plparam = MAKELPARAM( (HWND16)LOWORD(*plparam),
1691                                    (HWND16)LOWORD(wParam32) );
1692         }
1693         return 0;
1694     case WM_NCCALCSIZE:
1695         {
1696             NCCALCSIZE_PARAMS32 *nc32 = (NCCALCSIZE_PARAMS32 *)*plparam;
1697             NCCALCSIZE_PARAMS16 *nc = (NCCALCSIZE_PARAMS16 *)SEGPTR_ALLOC( sizeof(*nc) + sizeof(LPARAM) );
1698             if (!nc) return -1;
1699
1700             CONV_RECT32TO16( &nc32->rgrc[0], &nc->rgrc[0] );
1701             if (wParam32)
1702             {
1703                 WINDOWPOS16 *wp;
1704                 CONV_RECT32TO16( &nc32->rgrc[1], &nc->rgrc[1] );
1705                 CONV_RECT32TO16( &nc32->rgrc[2], &nc->rgrc[2] );
1706                 if (!(wp = SEGPTR_NEW(WINDOWPOS16)))
1707                 {
1708                     SEGPTR_FREE(nc);
1709                     return -1;
1710                 }
1711                 STRUCT32_WINDOWPOS32to16( nc32->lppos, wp );
1712                 nc->lppos = SEGPTR_GET(wp);
1713             }
1714             *(LPARAM *)(nc + 1) = *plparam;  /* Store the previous lParam */
1715             *plparam = (LPARAM)SEGPTR_GET(nc);
1716         }
1717         return 1;
1718     case WM_NCCREATE:
1719     case WM_CREATE:
1720         {
1721             CREATESTRUCT16 *cs;
1722             CREATESTRUCT32A *cs32 = (CREATESTRUCT32A *)*plparam;
1723             LPSTR name, cls;
1724
1725             if (!(cs = SEGPTR_NEW(CREATESTRUCT16))) return -1;
1726             STRUCT32_CREATESTRUCT32Ato16( cs32, cs );
1727             name = SEGPTR_STRDUP( cs32->lpszName );
1728             cls  = SEGPTR_STRDUP( cs32->lpszClass );
1729             cs->lpszName  = SEGPTR_GET(name);
1730             cs->lpszClass = SEGPTR_GET(cls);
1731             *plparam = (LPARAM)SEGPTR_GET(cs);
1732         }
1733         return 1;
1734     case WM_PARENTNOTIFY:
1735         if ((LOWORD(wParam32)==WM_CREATE) || (LOWORD(wParam32)==WM_DESTROY))
1736             *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32));
1737         /* else nothing to do */
1738         return 0;
1739     case WM_NOTIFY:
1740         *plparam = MapLS( (NMHDR *)*plparam ); /* NMHDR is already 32-bit */
1741         return 1;
1742     case WM_SETTEXT:
1743         {
1744             LPSTR str = SEGPTR_STRDUP( (LPSTR)*plparam );
1745             if (!str) return -1;
1746             *plparam = (LPARAM)SEGPTR_GET(str);
1747         }
1748         return 1;
1749     case WM_WINDOWPOSCHANGING:
1750     case WM_WINDOWPOSCHANGED:
1751         {
1752             WINDOWPOS16 *wp = (WINDOWPOS16 *)SEGPTR_ALLOC( sizeof(*wp) +
1753                                                            sizeof(LPARAM) );
1754             if (!wp) return -1;
1755             STRUCT32_WINDOWPOS32to16( (WINDOWPOS32 *)*plparam, wp );
1756             *(LPARAM *)(wp + 1) = *plparam;  /* Store the previous lParam */
1757             *plparam = (LPARAM)SEGPTR_GET(wp);
1758         }
1759         return 1;
1760     case WM_GETDLGCODE:
1761          if (*plparam) {
1762             LPMSG32 msg32 = (LPMSG32) *plparam;
1763             LPMSG16 msg16 = (LPMSG16) SEGPTR_NEW( MSG16 );
1764
1765             if (!msg16) return -1;
1766             msg16->hwnd = msg32->hwnd;
1767             msg16->lParam = msg32->lParam;
1768             msg16->time = msg32->time;
1769             CONV_POINT32TO16(&msg32->pt,&msg16->pt);
1770             /* this is right, right? */
1771             if (WINPROC_MapMsg32ATo16(msg32->hwnd,msg32->message,msg32->wParam,
1772                          &msg16->message,&msg16->wParam, &msg16->lParam)<0) {
1773                 SEGPTR_FREE( msg16 );
1774                 return -1;
1775             }
1776             *plparam = (LPARAM)SEGPTR_GET(msg16);
1777             return 1;
1778         }
1779         return 0;
1780
1781     case WM_ACTIVATEAPP:
1782         if (*plparam) {
1783         *plparam = (LPARAM) THREAD_ID_TO_THDB((DWORD) *plparam)->teb.htask16;
1784         }
1785         return 1;
1786     case WM_ASKCBFORMATNAME:
1787     case WM_DEVMODECHANGE:
1788     case WM_PAINTCLIPBOARD:
1789     case WM_SIZECLIPBOARD:
1790     case WM_WININICHANGE:
1791         FIXME( msg, "message %04x needs translation\n", msg32 );
1792         return -1;
1793     default:  /* No translation needed */
1794         return 0;
1795     }
1796 }
1797
1798
1799 /**********************************************************************
1800  *           WINPROC_UnmapMsg32ATo16
1801  *
1802  * Unmap a message that was mapped from 32-bit Ansi to 16-bit.
1803  */
1804 void WINPROC_UnmapMsg32ATo16( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam,
1805                               MSGPARAM16* p16 )
1806 {
1807     switch(msg)
1808     {
1809     case LB_ADDFILE32:
1810     case LB_ADDSTRING32:
1811     case LB_DIR32:
1812     case LB_FINDSTRING32:
1813     case LB_FINDSTRINGEXACT32:
1814     case LB_INSERTSTRING32:
1815     case LB_SELECTSTRING32:
1816     case LB_SETTABSTOPS32:
1817     case CB_ADDSTRING32:
1818     case CB_FINDSTRING32:
1819     case CB_FINDSTRINGEXACT32:
1820     case CB_INSERTSTRING32:
1821     case CB_SELECTSTRING32:
1822     case CB_DIR32:
1823     case WM_COMPAREITEM:
1824     case WM_DELETEITEM:
1825     case WM_DRAWITEM:
1826     case WM_SETTEXT:
1827         SEGPTR_FREE( PTR_SEG_TO_LIN(p16->lParam) );
1828         break;
1829
1830     case CB_GETDROPPEDCONTROLRECT32:
1831     case LB_GETITEMRECT32:
1832         {
1833             RECT16 *rect = (RECT16 *)PTR_SEG_TO_LIN(p16->lParam);
1834             p16->lParam = *(LPARAM *)(rect + 1);
1835             CONV_RECT16TO32( rect, (RECT32 *)(p16->lParam));
1836             SEGPTR_FREE( rect );
1837         }
1838         break;
1839     case LB_GETSELITEMS32:
1840         {
1841             INT32 i;
1842             LPINT16 items = (LPINT16)PTR_SEG_TO_LIN(lParam);
1843             p16->lParam = *((LPARAM *)items - 1);
1844             for (i = 0; i < p16->wParam; i++) *((LPINT32)(p16->lParam) + i) = items[i];
1845             SEGPTR_FREE( (LPARAM *)items - 1 );
1846         }
1847         break;
1848
1849     case CB_GETEDITSEL32:
1850         if( wParam )
1851             *((LPUINT32)(wParam)) = LOWORD(p16->lResult);
1852         if( lParam )
1853             *((LPUINT32)(lParam)) = HIWORD(p16->lResult);       /* FIXME: substract 1? */
1854         break;
1855
1856     case LB_GETTEXT32:
1857     case CB_GETLBTEXT32:
1858         UnMapLS( (SEGPTR)(p16->lParam) );
1859         break;
1860
1861     case WM_MEASUREITEM:
1862         {
1863             MEASUREITEMSTRUCT16 *mis = (MEASUREITEMSTRUCT16 *)PTR_SEG_TO_LIN(p16->lParam);
1864             MEASUREITEMSTRUCT32 *mis32 = *(MEASUREITEMSTRUCT32 **)(mis + 1);
1865             mis32->itemWidth  = mis->itemWidth;
1866             mis32->itemHeight = mis->itemHeight;
1867             SEGPTR_FREE(mis);
1868         }
1869         break;
1870     case WM_GETMINMAXINFO:
1871         {
1872             MINMAXINFO16 *mmi = (MINMAXINFO16 *)PTR_SEG_TO_LIN(p16->lParam);
1873             p16->lParam = *(LPARAM *)(mmi + 1);
1874             STRUCT32_MINMAXINFO16to32( mmi, (MINMAXINFO32 *)(p16->lParam) );
1875             SEGPTR_FREE(mmi);
1876         }
1877         break;
1878     case WM_GETTEXT:
1879         {
1880             LPSTR str = (LPSTR)PTR_SEG_TO_LIN(p16->lParam);
1881             p16->lParam = *((LPARAM *)str - 1);
1882             lstrcpyn32A( (LPSTR)(p16->lParam), str, p16->wParam );
1883             SEGPTR_FREE( (LPARAM *)str - 1 );
1884         }
1885         break;
1886     case WM_MDICREATE:
1887         {
1888             MDICREATESTRUCT16 *cs = (MDICREATESTRUCT16*)PTR_SEG_TO_LIN(p16->lParam);
1889             SEGPTR_FREE( PTR_SEG_TO_LIN(cs->szTitle) );
1890             SEGPTR_FREE( PTR_SEG_TO_LIN(cs->szClass) );
1891             SEGPTR_FREE( cs );
1892         }
1893         break;
1894     case WM_MDIGETACTIVE:
1895         if (lParam) *(BOOL32 *)lParam = (BOOL16)HIWORD(p16->lResult);
1896         p16->lResult = (HWND32)LOWORD(p16->lResult);
1897         break;
1898     case WM_NCCALCSIZE:
1899         {
1900             NCCALCSIZE_PARAMS32 *nc32;
1901             NCCALCSIZE_PARAMS16 *nc = (NCCALCSIZE_PARAMS16 *)PTR_SEG_TO_LIN(p16->lParam);
1902             p16->lParam = *(LPARAM *)(nc + 1);
1903             nc32 = (NCCALCSIZE_PARAMS32 *)(p16->lParam);
1904             CONV_RECT16TO32( &nc->rgrc[0], &nc32->rgrc[0] );
1905             if (p16->wParam)
1906             {
1907                 CONV_RECT16TO32( &nc->rgrc[1], &nc32->rgrc[1] );
1908                 CONV_RECT16TO32( &nc->rgrc[2], &nc32->rgrc[2] );
1909                 STRUCT32_WINDOWPOS16to32( (WINDOWPOS16 *)PTR_SEG_TO_LIN(nc->lppos),
1910                                           nc32->lppos );
1911                 SEGPTR_FREE( PTR_SEG_TO_LIN(nc->lppos) );
1912             }
1913             SEGPTR_FREE(nc);
1914         }
1915         break;
1916     case WM_NCCREATE:
1917     case WM_CREATE:
1918         {
1919             CREATESTRUCT16 *cs = (CREATESTRUCT16 *)PTR_SEG_TO_LIN(p16->lParam);
1920             SEGPTR_FREE( PTR_SEG_TO_LIN(cs->lpszName) );
1921             SEGPTR_FREE( PTR_SEG_TO_LIN(cs->lpszClass) );
1922             SEGPTR_FREE( cs );
1923         }
1924         break;
1925     case WM_WINDOWPOSCHANGING:
1926     case WM_WINDOWPOSCHANGED:
1927         {
1928             WINDOWPOS16 *wp = (WINDOWPOS16 *)PTR_SEG_TO_LIN(p16->lParam);
1929             p16->lParam = *(LPARAM *)(wp + 1);
1930             STRUCT32_WINDOWPOS16to32( wp, (WINDOWPOS32 *)p16->lParam );
1931             SEGPTR_FREE(wp);
1932         }
1933         break;
1934     case WM_NOTIFY:
1935         UnMapLS(p16->lParam);
1936         break;
1937     case WM_GETDLGCODE:
1938         if (p16->lParam)
1939         {
1940             LPMSG16 msg16 = (LPMSG16)PTR_SEG_TO_LIN(p16->lParam);
1941             MSGPARAM16 msgp16;
1942             msgp16.wParam=msg16->wParam;
1943             msgp16.lParam=msg16->lParam;
1944             WINPROC_UnmapMsg32ATo16(((LPMSG32)lParam)->hwnd, ((LPMSG32)lParam)->message,
1945                     ((LPMSG32)lParam)->wParam, ((LPMSG32)lParam)->lParam,
1946                     &msgp16 );
1947             SEGPTR_FREE(msg16);
1948         }
1949         break;
1950     }
1951 }
1952
1953
1954 /**********************************************************************
1955  *           WINPROC_MapMsg32WTo16
1956  *
1957  * Map a message from 32-bit Unicode to 16-bit.
1958  * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1959  */
1960 INT32 WINPROC_MapMsg32WTo16( HWND32 hwnd, UINT32 msg32, WPARAM32 wParam32,
1961                              UINT16 *pmsg16, WPARAM16 *pwparam16,
1962                              LPARAM *plparam )
1963 {
1964     switch(msg32)
1965     {
1966     case LB_ADDSTRING32:
1967     case LB_FINDSTRING32:
1968     case LB_FINDSTRINGEXACT32:
1969     case LB_INSERTSTRING32:
1970     case LB_SELECTSTRING32:
1971     case LB_DIR32:
1972     case LB_ADDFILE32:
1973         {
1974             LPSTR str = SEGPTR_STRDUP_WtoA( (LPWSTR)*plparam );
1975             if (!str) return -1;
1976             *pwparam16 = (WPARAM16)LOWORD(wParam32);
1977             *plparam   = (LPARAM)SEGPTR_GET(str);
1978         }
1979         *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING32);
1980         return 1;
1981
1982     case CB_ADDSTRING32:
1983     case CB_FINDSTRING32:
1984     case CB_FINDSTRINGEXACT32:
1985     case CB_INSERTSTRING32:
1986     case CB_SELECTSTRING32:
1987     case CB_DIR32:
1988         {
1989             LPSTR str = SEGPTR_STRDUP_WtoA( (LPWSTR)*plparam );
1990             if (!str) return -1;
1991             *pwparam16 = (WPARAM16)LOWORD(wParam32);
1992             *plparam   = (LPARAM)SEGPTR_GET(str);
1993         }
1994         *pmsg16 = (UINT16)msg32 + (CB_ADDSTRING16 - CB_ADDSTRING32);
1995         return 1;
1996
1997     case WM_NCCREATE:
1998     case WM_CREATE:
1999         {
2000             CREATESTRUCT16 *cs;
2001             CREATESTRUCT32W *cs32 = (CREATESTRUCT32W *)*plparam;
2002             LPSTR name, cls;
2003
2004             if (!(cs = SEGPTR_NEW(CREATESTRUCT16))) return -1;
2005             STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCT32A *)cs32, cs );
2006             name = SEGPTR_STRDUP_WtoA( cs32->lpszName );
2007             cls  = SEGPTR_STRDUP_WtoA( cs32->lpszClass );
2008             cs->lpszName  = SEGPTR_GET(name);
2009             cs->lpszClass = SEGPTR_GET(cls);
2010             *pmsg16    = (UINT16)msg32;
2011             *pwparam16 = (WPARAM16)LOWORD(wParam32);
2012             *plparam   = (LPARAM)SEGPTR_GET(cs);
2013         }
2014         return 1;
2015     case WM_MDICREATE:
2016         {
2017             MDICREATESTRUCT16 *cs;
2018             MDICREATESTRUCT32W *cs32 = (MDICREATESTRUCT32W *)*plparam;
2019             LPSTR name, cls;
2020
2021             if (!(cs = SEGPTR_NEW(MDICREATESTRUCT16))) return -1;
2022             STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCT32A *)cs32, cs );
2023             name = SEGPTR_STRDUP_WtoA( cs32->szTitle );
2024             cls  = SEGPTR_STRDUP_WtoA( cs32->szClass );
2025             cs->szTitle = SEGPTR_GET(name);
2026             cs->szClass = SEGPTR_GET(cls);
2027             *pmsg16    = (UINT16)msg32;
2028             *pwparam16 = (WPARAM16)LOWORD(wParam32);
2029             *plparam   = (LPARAM)SEGPTR_GET(cs);
2030         }
2031         return 1;
2032     case WM_SETTEXT:
2033         {
2034             LPSTR str = SEGPTR_STRDUP_WtoA( (LPWSTR)*plparam );
2035             if (!str) return -1;
2036             *pmsg16    = (UINT16)msg32;
2037             *pwparam16 = (WPARAM16)LOWORD(wParam32);
2038             *plparam   = (LPARAM)SEGPTR_GET(str);
2039         }
2040         return 1;
2041     default:  /* No Unicode translation needed */
2042         return WINPROC_MapMsg32ATo16( hwnd, msg32, wParam32, pmsg16,
2043                                       pwparam16, plparam );
2044     }
2045 }
2046
2047
2048 /**********************************************************************
2049  *           WINPROC_UnmapMsg32WTo16
2050  *
2051  * Unmap a message that was mapped from 32-bit Unicode to 16-bit.
2052  */
2053 void WINPROC_UnmapMsg32WTo16( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam,
2054                               MSGPARAM16* p16 )
2055 {
2056     switch(msg)
2057     {
2058     case WM_GETTEXT:
2059         {
2060             LPSTR str = (LPSTR)PTR_SEG_TO_LIN(p16->lParam);
2061             p16->lParam = *((LPARAM *)str - 1);
2062             lstrcpyAtoW( (LPWSTR)(p16->lParam), str );
2063             SEGPTR_FREE( (LPARAM *)str - 1 );
2064         }
2065         break;
2066     default:
2067         WINPROC_UnmapMsg32ATo16( hwnd, msg, wParam, lParam, p16 );
2068         break;
2069     }
2070 }
2071
2072
2073 /**********************************************************************
2074  *           WINPROC_CallProc32ATo32W
2075  *
2076  * Call a window procedure, translating args from Ansi to Unicode.
2077  */
2078 static LRESULT WINPROC_CallProc32ATo32W( WNDPROC32 func, HWND32 hwnd,
2079                                          UINT32 msg, WPARAM32 wParam,
2080                                          LPARAM lParam )
2081 {
2082     LRESULT result;
2083
2084     if (WINPROC_MapMsg32ATo32W( hwnd, msg, wParam, &lParam ) == -1) return 0;
2085     result = WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2086     WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam );
2087     return result;
2088 }
2089
2090
2091 /**********************************************************************
2092  *           WINPROC_CallProc32WTo32A
2093  *
2094  * Call a window procedure, translating args from Unicode to Ansi.
2095  */
2096 static LRESULT WINPROC_CallProc32WTo32A( WNDPROC32 func, HWND32 hwnd,
2097                                          UINT32 msg, WPARAM32 wParam,
2098                                          LPARAM lParam )
2099 {
2100     LRESULT result;
2101
2102     if (WINPROC_MapMsg32WTo32A( hwnd, msg, wParam, &lParam ) == -1) return 0;
2103     result = WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2104     WINPROC_UnmapMsg32WTo32A( hwnd, msg, wParam, lParam );
2105     return result;
2106 }
2107
2108
2109 /**********************************************************************
2110  *           WINPROC_CallProc16To32A
2111  *
2112  * Call a 32-bit window procedure, translating the 16-bit args.
2113  */
2114 LRESULT WINPROC_CallProc16To32A( HWND16 hwnd, UINT16 msg,
2115                                  WPARAM16 wParam, LPARAM lParam,
2116                                  WNDPROC32 func )
2117 {
2118     LRESULT result;
2119     UINT32 msg32;
2120     WPARAM32 wParam32;
2121
2122     if (WINPROC_MapMsg16To32A( msg, wParam, &msg32, &wParam32, &lParam ) == -1)
2123         return 0;
2124     result = WINPROC_CallWndProc32( func, hwnd, msg32, wParam32, lParam );
2125     return WINPROC_UnmapMsg16To32A( hwnd, msg32, wParam32, lParam, result );
2126 }
2127
2128
2129 /**********************************************************************
2130  *           WINPROC_CallProc16To32W
2131  *
2132  * Call a 32-bit window procedure, translating the 16-bit args.
2133  */
2134 LRESULT WINPROC_CallProc16To32W( HWND16 hwnd, UINT16 msg,
2135                                  WPARAM16 wParam, LPARAM lParam,
2136                                  WNDPROC32 func )
2137 {
2138     LRESULT result;
2139     UINT32 msg32;
2140     WPARAM32 wParam32;
2141
2142     if (WINPROC_MapMsg16To32W( hwnd, msg, wParam, &msg32, &wParam32, &lParam ) == -1)
2143         return 0;
2144     result = WINPROC_CallWndProc32( func, hwnd, msg32, wParam32, lParam );
2145     return WINPROC_UnmapMsg16To32W( hwnd, msg32, wParam32, lParam, result );
2146 }
2147
2148
2149 /**********************************************************************
2150  *           WINPROC_CallProc32ATo16
2151  *
2152  * Call a 16-bit window procedure, translating the 32-bit args.
2153  */
2154 static LRESULT WINAPI WINPROC_CallProc32ATo16( WNDPROC16 func, HWND32 hwnd,
2155                                                UINT32 msg, WPARAM32 wParam,
2156                                                LPARAM lParam )
2157 {
2158     UINT16 msg16;
2159     MSGPARAM16 mp16;
2160
2161     mp16.lParam = lParam;
2162     if (WINPROC_MapMsg32ATo16( hwnd, msg, wParam,
2163                                &msg16, &mp16.wParam, &mp16.lParam ) == -1)
2164         return 0;
2165     mp16.lResult = Callbacks->CallWndProc( func, hwnd, msg16,
2166                                            mp16.wParam, mp16.lParam );
2167     WINPROC_UnmapMsg32ATo16( hwnd, msg, wParam, lParam, &mp16 );
2168     return mp16.lResult;
2169 }
2170
2171
2172 /**********************************************************************
2173  *           WINPROC_CallProc32WTo16
2174  *
2175  * Call a 16-bit window procedure, translating the 32-bit args.
2176  */
2177 static LRESULT WINAPI WINPROC_CallProc32WTo16( WNDPROC16 func, HWND32 hwnd,
2178                                                UINT32 msg, WPARAM32 wParam,
2179                                                LPARAM lParam )
2180 {
2181     UINT16 msg16;
2182     MSGPARAM16 mp16;
2183
2184     mp16.lParam = lParam;
2185     if (WINPROC_MapMsg32WTo16( hwnd, msg, wParam, &msg16, &mp16.wParam,
2186                                &mp16.lParam ) == -1)
2187         return 0;
2188     mp16.lResult = Callbacks->CallWndProc( func, hwnd, msg16,
2189                                            mp16.wParam, mp16.lParam );
2190     WINPROC_UnmapMsg32WTo16( hwnd, msg, wParam, lParam, &mp16 );
2191     return mp16.lResult;
2192 }
2193
2194
2195 /**********************************************************************
2196  *           CallWindowProc16    (USER.122)
2197  */
2198 LRESULT WINAPI CallWindowProc16( WNDPROC16 func, HWND16 hwnd, UINT16 msg,
2199                                  WPARAM16 wParam, LPARAM lParam )
2200 {
2201     WINDOWPROC *proc = WINPROC_GetPtr( func );
2202
2203     if (!proc)
2204         return Callbacks->CallWndProc( func, hwnd, msg, wParam, lParam );
2205
2206 #if testing
2207     func = WINPROC_GetProc( (HWINDOWPROC)proc, WIN_PROC_16 );
2208     return Callbacks->CallWndProc( func, hwnd, msg, wParam, lParam );
2209 #endif
2210
2211     switch(proc->type)
2212     {
2213     case WIN_PROC_16:
2214         if (!proc->thunk.t_from32.proc) return 0;
2215         return Callbacks->CallWndProc( proc->thunk.t_from32.proc,
2216                                        hwnd, msg, wParam, lParam );
2217     case WIN_PROC_32A:
2218         if (!proc->thunk.t_from16.proc) return 0;
2219         return WINPROC_CallProc16To32A( hwnd, msg, wParam, lParam,
2220                                         proc->thunk.t_from16.proc );
2221     case WIN_PROC_32W:
2222         if (!proc->thunk.t_from16.proc) return 0;
2223         return WINPROC_CallProc16To32W( hwnd, msg, wParam, lParam,
2224                                         proc->thunk.t_from16.proc );
2225     default:
2226         WARN( relay, "Invalid proc %p\n", proc );
2227         return 0;
2228     }
2229 }
2230
2231
2232 /**********************************************************************
2233  *           CallWindowProc32A    (USER32.18)
2234  *
2235  * The CallWindowProc() function invokes the windows procedure _func_,
2236  * with _hwnd_ as the target window, the message specified by _msg_, and
2237  * the message parameters _wParam_ and _lParam_.
2238  *
2239  * Some kinds of argument conversion may be done, I'm not sure what.
2240  *
2241  * CallWindowProc() may be used for windows subclassing. Use
2242  * SetWindowLong() to set a new windows procedure for windows of the
2243  * subclass, and handle subclassed messages in the new windows
2244  * procedure. The new windows procedure may then use CallWindowProc()
2245  * with _func_ set to the parent class's windows procedure to dispatch
2246  * the message to the superclass.
2247  *
2248  * RETURNS
2249  *
2250  *    The return value is message dependent.
2251  *
2252  * CONFORMANCE
2253  *
2254  *   ECMA-234, Win32
2255  */
2256 LRESULT WINAPI CallWindowProc32A(
2257     WNDPROC32 func, /* window procedure */
2258     HWND32 hwnd, /* target window */
2259     UINT32 msg,  /* message */
2260     WPARAM32 wParam, /* message dependent parameter */
2261     LPARAM lParam    /* message dependent parameter */
2262 ) {
2263     WINDOWPROC *proc = WINPROC_GetPtr( (WNDPROC16)func );
2264
2265     if (!proc) return WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2266
2267 #if testing
2268     func = WINPROC_GetProc( (HWINDOWPROC)proc, WIN_PROC_32A );
2269     return WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2270 #endif
2271
2272     switch(proc->type)
2273     {
2274     case WIN_PROC_16:
2275         if (!proc->thunk.t_from32.proc) return 0;
2276         return WINPROC_CallProc32ATo16( proc->thunk.t_from32.proc,
2277                                         hwnd, msg, wParam, lParam );
2278     case WIN_PROC_32A:
2279         if (!proc->thunk.t_from16.proc) return 0;
2280         return WINPROC_CallWndProc32( proc->thunk.t_from16.proc,
2281                                       hwnd, msg, wParam, lParam );
2282     case WIN_PROC_32W:
2283         if (!proc->thunk.t_from16.proc) return 0;
2284         return WINPROC_CallProc32ATo32W( proc->thunk.t_from16.proc,
2285                                          hwnd, msg, wParam, lParam );
2286     default:
2287         WARN( relay, "Invalid proc %p\n", proc );
2288         return 0;
2289     }
2290 }
2291
2292
2293 /**********************************************************************
2294  *           CallWindowProc32W    (USER32.19)
2295  */
2296 LRESULT WINAPI CallWindowProc32W( WNDPROC32 func, HWND32 hwnd, UINT32 msg,
2297                                   WPARAM32 wParam, LPARAM lParam )
2298 {
2299     WINDOWPROC *proc = WINPROC_GetPtr( (WNDPROC16)func );
2300
2301     if (!proc) return WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2302
2303 #if testing
2304     func = WINPROC_GetProc( (HWINDOWPROC)proc, WIN_PROC_32W );
2305     return WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2306 #endif
2307
2308     switch(proc->type)
2309     {
2310     case WIN_PROC_16:
2311         if (!proc->thunk.t_from32.proc) return 0;
2312         return WINPROC_CallProc32WTo16( proc->thunk.t_from32.proc,
2313                                         hwnd, msg, wParam, lParam );
2314     case WIN_PROC_32A:
2315         if (!proc->thunk.t_from16.proc) return 0;
2316         return WINPROC_CallProc32WTo32A( proc->thunk.t_from16.proc,
2317                                          hwnd, msg, wParam, lParam );
2318     case WIN_PROC_32W:
2319         if (!proc->thunk.t_from16.proc) return 0;
2320         return WINPROC_CallWndProc32( proc->thunk.t_from16.proc,
2321                                       hwnd, msg, wParam, lParam );
2322     default:
2323         WARN( relay, "Invalid proc %p\n", proc );
2324         return 0;
2325     }
2326 }