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