dlls/user.exe16/window.c

   1 /*
   2  * 16-bit windowing functions
   3  *
   4  * Copyright 2001 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "wine/winuser16.h"
  22 #include "wownt32.h"
  23 #include "user_private.h"
  24 #include "wine/list.h"
  25 #include "wine/server.h"
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(win);
  29
  30 /* size of buffer needed to store an atom string */
  31 #define ATOM_BUFFER_SIZE 256
  32
  33 /* handle <--> handle16 conversions */
  34 #define HANDLE_16(h32)          (LOWORD(h32))
  35 #define HANDLE_32(h16)          ((HANDLE)(ULONG_PTR)(h16))
  36
  37 static HWND16 hwndSysModal;
  38
  39 struct class_entry
  40 {
  41     struct list entry;
  42     ATOM        atom;
  43     HINSTANCE16 inst;
  44 };
  45
  46 static struct list class_list = LIST_INIT( class_list );
  47
  48 struct wnd_enum_info
  49 {
  50     WNDENUMPROC16 proc;
  51     LPARAM        param;
  52 };
  53
  54 /* callback for 16-bit window enumeration functions */
  55 static BOOL CALLBACK wnd_enum_callback( HWND hwnd, LPARAM param )
  56 {
  57     const struct wnd_enum_info *info = (struct wnd_enum_info *)param;
  58     WORD args[3];
  59     DWORD ret;
  60
  61     args[2] = HWND_16(hwnd);
  62     args[1] = HIWORD(info->param);
  63     args[0] = LOWORD(info->param);
  64     WOWCallback16Ex( (DWORD)info->proc, WCB16_PASCAL, sizeof(args), args, &ret );
  65     return LOWORD(ret);
  66 }
  67
  68 /* convert insert after window handle to 32-bit */
  69 static inline HWND full_insert_after_hwnd( HWND16 hwnd )
  70 {
  71     HWND ret = WIN_Handle32( hwnd );
  72     if (ret == (HWND)0xffff) ret = HWND_TOPMOST;
  73     return ret;
  74 }
  75
  76 void free_module_classes( HINSTANCE16 inst )
  77 {
  78     struct class_entry *class, *next;
  79
  80     LIST_FOR_EACH_ENTRY_SAFE( class, next, &class_list, struct class_entry, entry )
  81     {
  82         if (class->inst != inst) continue;
  83         list_remove( &class->entry );
  84         UnregisterClassA( (LPCSTR)MAKEINTATOM(class->atom), HINSTANCE_32(class->inst) );
  85         HeapFree( GetProcessHeap(), 0, class );
  86     }
  87 }
  88
  89 /**************************************************************************
  90  *              MessageBox   (USER.1)
  91  */
  92 INT16 WINAPI MessageBox16( HWND16 hwnd, LPCSTR text, LPCSTR title, UINT16 type )
  93 {
  94     return MessageBoxA( WIN_Handle32(hwnd), text, title, type );
  95 }
  96
  97
  98 /***********************************************************************
  99  *              SetTimer (USER.10)
 100  */
 101 UINT16 WINAPI SetTimer16( HWND16 hwnd, UINT16 id, UINT16 timeout, TIMERPROC16 proc )
 102 {
 103     TIMERPROC proc32 = (TIMERPROC)WINPROC_AllocProc16( (WNDPROC16)proc );
 104     return SetTimer( WIN_Handle32(hwnd), id, timeout, proc32 );
 105 }
 106
 107
 108 /***********************************************************************
 109  *              SetSystemTimer (USER.11)
 110  */
 111 UINT16 WINAPI SetSystemTimer16( HWND16 hwnd, UINT16 id, UINT16 timeout, TIMERPROC16 proc )
 112 {
 113     TIMERPROC proc32 = (TIMERPROC)WINPROC_AllocProc16( (WNDPROC16)proc );
 114     return SetTimer( WIN_Handle32(hwnd), (UINT_PTR)id | SYSTEM_TIMER_FLAG, timeout, proc32 );
 115 }
 116
 117
 118 /**************************************************************************
 119  *              KillTimer   (USER.12)
 120  */
 121 BOOL16 WINAPI KillTimer16( HWND16 hwnd, UINT16 id )
 122 {
 123     return KillTimer( WIN_Handle32(hwnd), id );
 124 }
 125
 126
 127 /**************************************************************************
 128  *              SetCapture   (USER.18)
 129  */
 130 HWND16 WINAPI SetCapture16( HWND16 hwnd )
 131 {
 132     return HWND_16( SetCapture( WIN_Handle32(hwnd) ));
 133 }
 134
 135
 136 /**************************************************************************
 137  *              ReleaseCapture   (USER.19)
 138  */
 139 BOOL16 WINAPI ReleaseCapture16(void)
 140 {
 141     return ReleaseCapture();
 142 }
 143
 144
 145 /**************************************************************************
 146  *              SetFocus   (USER.22)
 147  */
 148 HWND16 WINAPI SetFocus16( HWND16 hwnd )
 149 {
 150     return HWND_16( SetFocus( WIN_Handle32(hwnd) ));
 151 }
 152
 153
 154 /**************************************************************************
 155  *              GetFocus   (USER.23)
 156  */
 157 HWND16 WINAPI GetFocus16(void)
 158 {
 159     return HWND_16( GetFocus() );
 160 }
 161
 162
 163 /**************************************************************************
 164  *              RemoveProp   (USER.24)
 165  */
 166 HANDLE16 WINAPI RemoveProp16( HWND16 hwnd, LPCSTR str )
 167 {
 168     return HANDLE_16(RemovePropA( WIN_Handle32(hwnd), str ));
 169 }
 170
 171
 172 /**************************************************************************
 173  *              GetProp   (USER.25)
 174  */
 175 HANDLE16 WINAPI GetProp16( HWND16 hwnd, LPCSTR str )
 176 {
 177     return HANDLE_16(GetPropA( WIN_Handle32(hwnd), str ));
 178 }
 179
 180
 181 /**************************************************************************
 182  *              SetProp   (USER.26)
 183  */
 184 BOOL16 WINAPI SetProp16( HWND16 hwnd, LPCSTR str, HANDLE16 handle )
 185 {
 186     return SetPropA( WIN_Handle32(hwnd), str, HANDLE_32(handle) );
 187 }
 188
 189
 190 /***********************************************************************
 191  *              EnumProps   (USER.27)
 192  */
 193 INT16 WINAPI EnumProps16( HWND16 hwnd, PROPENUMPROC16 func )
 194 {
 195     int ret = -1, i, count, total = 32;
 196     property_data_t *list;
 197
 198     while (total)
 199     {
 200         if (!(list = HeapAlloc( GetProcessHeap(), 0, total * sizeof(*list) ))) break;
 201         count = 0;
 202         SERVER_START_REQ( get_window_properties )
 203         {
 204             req->window = wine_server_user_handle( HWND_32(hwnd) );
 205             wine_server_set_reply( req, list, total * sizeof(*list) );
 206             if (!wine_server_call( req )) count = reply->total;
 207         }
 208         SERVER_END_REQ;
 209
 210         if (count && count <= total)
 211         {
 212             char string[ATOM_BUFFER_SIZE];
 213             SEGPTR segptr = MapLS( string );
 214             WORD args[4];
 215             DWORD result;
 216
 217             for (i = 0; i < count; i++)
 218             {
 219                 if (list[i].string)  /* it was a string originally */
 220                 {
 221                     if (!GlobalGetAtomNameA( list[i].atom, string, ATOM_BUFFER_SIZE )) continue;
 222                     args[3] = hwnd;
 223                     args[2] = SELECTOROF(segptr);
 224                     args[1] = OFFSETOF(segptr);
 225                     args[0] = LOWORD(list[i].data);
 226                 }
 227                 else
 228                 {
 229                     args[3] = hwnd;
 230                     args[2] = 0;
 231                     args[1] = list[i].atom;
 232                     args[0] = LOWORD(list[i].data);
 233                 }
 234                 WOWCallback16Ex( (DWORD)func, WCB16_PASCAL, sizeof(args), args, &result );
 235                 if (!(ret = LOWORD(result))) break;
 236             }
 237             UnMapLS( segptr );
 238             HeapFree( GetProcessHeap(), 0, list );
 239             break;
 240         }
 241         HeapFree( GetProcessHeap(), 0, list );
 242         total = count;  /* restart with larger buffer */
 243     }
 244     return ret;
 245 }
 246
 247
 248 /**************************************************************************
 249  *              ClientToScreen   (USER.28)
 250  */
 251 void WINAPI ClientToScreen16( HWND16 hwnd, LPPOINT16 lppnt )
 252 {
 253     MapWindowPoints16( hwnd, 0, lppnt, 1 );
 254 }
 255
 256
 257 /**************************************************************************
 258  *              ScreenToClient   (USER.29)
 259  */
 260 void WINAPI ScreenToClient16( HWND16 hwnd, LPPOINT16 lppnt )
 261 {
 262     MapWindowPoints16( 0, hwnd, lppnt, 1 );
 263 }
 264
 265
 266 /**************************************************************************
 267  *              WindowFromPoint   (USER.30)
 268  */
 269 HWND16 WINAPI WindowFromPoint16( POINT16 pt )
 270 {
 271     POINT pt32;
 272
 273     pt32.x = pt.x;
 274     pt32.y = pt.y;
 275     return HWND_16( WindowFromPoint( pt32 ) );
 276 }
 277
 278
 279 /**************************************************************************
 280  *              IsIconic   (USER.31)
 281  */
 282 BOOL16 WINAPI IsIconic16(HWND16 hwnd)
 283 {
 284     return IsIconic( WIN_Handle32(hwnd) );
 285 }
 286
 287
 288 /**************************************************************************
 289  *              GetWindowRect   (USER.32)
 290  */
 291 void WINAPI GetWindowRect16( HWND16 hwnd, LPRECT16 rect )
 292 {
 293     RECT rect32;
 294
 295     GetWindowRect( WIN_Handle32(hwnd), &rect32 );
 296     rect->left   = rect32.left;
 297     rect->top    = rect32.top;
 298     rect->right  = rect32.right;
 299     rect->bottom = rect32.bottom;
 300 }
 301
 302
 303 /**************************************************************************
 304  *              GetClientRect   (USER.33)
 305  */
 306 void WINAPI GetClientRect16( HWND16 hwnd, LPRECT16 rect )
 307 {
 308     RECT rect32;
 309
 310     GetClientRect( WIN_Handle32(hwnd), &rect32 );
 311     rect->left   = rect32.left;
 312     rect->top    = rect32.top;
 313     rect->right  = rect32.right;
 314     rect->bottom = rect32.bottom;
 315 }
 316
 317
 318 /**************************************************************************
 319  *              EnableWindow   (USER.34)
 320  */
 321 BOOL16 WINAPI EnableWindow16( HWND16 hwnd, BOOL16 enable )
 322 {
 323     return EnableWindow( WIN_Handle32(hwnd), enable );
 324 }
 325
 326
 327 /**************************************************************************
 328  *              IsWindowEnabled   (USER.35)
 329  */
 330 BOOL16 WINAPI IsWindowEnabled16(HWND16 hwnd)
 331 {
 332     return IsWindowEnabled( WIN_Handle32(hwnd) );
 333 }
 334
 335
 336 /**************************************************************************
 337  *              GetWindowText   (USER.36)
 338  */
 339 INT16 WINAPI GetWindowText16( HWND16 hwnd, SEGPTR lpString, INT16 nMaxCount )
 340 {
 341     return SendMessage16( hwnd, WM_GETTEXT, nMaxCount, lpString );
 342 }
 343
 344
 345 /**************************************************************************
 346  *              SetWindowText   (USER.37)
 347  */
 348 BOOL16 WINAPI SetWindowText16( HWND16 hwnd, SEGPTR lpString )
 349 {
 350     return SendMessage16( hwnd, WM_SETTEXT, 0, lpString );
 351 }
 352
 353
 354 /**************************************************************************
 355  *              GetWindowTextLength   (USER.38)
 356  */
 357 INT16 WINAPI GetWindowTextLength16( HWND16 hwnd )
 358 {
 359     return SendMessage16( hwnd, WM_GETTEXTLENGTH, 0, 0 );
 360 }
 361
 362
 363 /***********************************************************************
 364  *              BeginPaint (USER.39)
 365  */
 366 HDC16 WINAPI BeginPaint16( HWND16 hwnd, LPPAINTSTRUCT16 lps )
 367 {
 368     PAINTSTRUCT ps;
 369
 370     BeginPaint( WIN_Handle32(hwnd), &ps );
 371     lps->hdc            = HDC_16(ps.hdc);
 372     lps->fErase         = ps.fErase;
 373     lps->rcPaint.top    = ps.rcPaint.top;
 374     lps->rcPaint.left   = ps.rcPaint.left;
 375     lps->rcPaint.right  = ps.rcPaint.right;
 376     lps->rcPaint.bottom = ps.rcPaint.bottom;
 377     lps->fRestore       = ps.fRestore;
 378     lps->fIncUpdate     = ps.fIncUpdate;
 379     return lps->hdc;
 380 }
 381
 382
 383 /***********************************************************************
 384  *              EndPaint (USER.40)
 385  */
 386 BOOL16 WINAPI EndPaint16( HWND16 hwnd, const PAINTSTRUCT16* lps )
 387 {
 388     PAINTSTRUCT ps;
 389
 390     ps.hdc = HDC_32(lps->hdc);
 391     return EndPaint( WIN_Handle32(hwnd), &ps );
 392 }
 393
 394
 395 /***********************************************************************
 396  *              CreateWindow (USER.41)
 397  */
 398 HWND16 WINAPI CreateWindow16( LPCSTR className, LPCSTR windowName,
 399                               DWORD style, INT16 x, INT16 y, INT16 width,
 400                               INT16 height, HWND16 parent, HMENU16 menu,
 401                               HINSTANCE16 instance, LPVOID data )
 402 {
 403     return CreateWindowEx16( 0, className, windowName, style,
 404                              x, y, width, height, parent, menu, instance, data );
 405 }
 406
 407
 408 /**************************************************************************
 409  *              ShowWindow   (USER.42)
 410  */
 411 BOOL16 WINAPI ShowWindow16( HWND16 hwnd, INT16 cmd )
 412 {
 413     return ShowWindow( WIN_Handle32(hwnd), cmd );
 414 }
 415
 416
 417 /**************************************************************************
 418  *              CloseWindow   (USER.43)
 419  */
 420 BOOL16 WINAPI CloseWindow16( HWND16 hwnd )
 421 {
 422     return CloseWindow( WIN_Handle32(hwnd) );
 423 }
 424
 425
 426 /**************************************************************************
 427  *              OpenIcon   (USER.44)
 428  */
 429 BOOL16 WINAPI OpenIcon16( HWND16 hwnd )
 430 {
 431     return OpenIcon( WIN_Handle32(hwnd) );
 432 }
 433
 434
 435 /**************************************************************************
 436  *              BringWindowToTop   (USER.45)
 437  */
 438 BOOL16 WINAPI BringWindowToTop16( HWND16 hwnd )
 439 {
 440     return BringWindowToTop( WIN_Handle32(hwnd) );
 441 }
 442
 443
 444 /**************************************************************************
 445  *              GetParent   (USER.46)
 446  */
 447 HWND16 WINAPI GetParent16( HWND16 hwnd )
 448 {
 449     return HWND_16( GetParent( WIN_Handle32(hwnd) ));
 450 }
 451
 452
 453 /**************************************************************************
 454  *              IsWindow   (USER.47)
 455  */
 456 BOOL16 WINAPI IsWindow16( HWND16 hwnd )
 457 {
 458     CURRENT_STACK16->es = USER_HeapSel;
 459     /* don't use WIN_Handle32 here, we don't care about the full handle */
 460     return IsWindow( HWND_32(hwnd) );
 461 }
 462
 463
 464 /**************************************************************************
 465  *              IsChild   (USER.48)
 466  */
 467 BOOL16 WINAPI IsChild16( HWND16 parent, HWND16 child )
 468 {
 469     return IsChild( WIN_Handle32(parent), WIN_Handle32(child) );
 470 }
 471
 472
 473 /**************************************************************************
 474  *              IsWindowVisible   (USER.49)
 475  */
 476 BOOL16 WINAPI IsWindowVisible16( HWND16 hwnd )
 477 {
 478     return IsWindowVisible( WIN_Handle32(hwnd) );
 479 }
 480
 481
 482 /**************************************************************************
 483  *              FindWindow   (USER.50)
 484  */
 485 HWND16 WINAPI FindWindow16( LPCSTR className, LPCSTR title )
 486 {
 487     return HWND_16( FindWindowA( className, title ));
 488 }
 489
 490
 491 /**************************************************************************
 492  *              DestroyWindow   (USER.53)
 493  */
 494 BOOL16 WINAPI DestroyWindow16( HWND16 hwnd )
 495 {
 496     return DestroyWindow( WIN_Handle32(hwnd) );
 497 }
 498
 499
 500 /*******************************************************************
 501  *           EnumWindows   (USER.54)
 502  */
 503 BOOL16 WINAPI EnumWindows16( WNDENUMPROC16 func, LPARAM lParam )
 504 {
 505     struct wnd_enum_info info;
 506
 507     info.proc  = func;
 508     info.param = lParam;
 509     return EnumWindows( wnd_enum_callback, (LPARAM)&info );
 510 }
 511
 512
 513 /**********************************************************************
 514  *           EnumChildWindows   (USER.55)
 515  */
 516 BOOL16 WINAPI EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func, LPARAM lParam )
 517 {
 518     struct wnd_enum_info info;
 519
 520     info.proc  = func;
 521     info.param = lParam;
 522     return EnumChildWindows( WIN_Handle32(parent), wnd_enum_callback, (LPARAM)&info );
 523 }
 524
 525
 526 /**************************************************************************
 527  *              MoveWindow   (USER.56)
 528  */
 529 BOOL16 WINAPI MoveWindow16( HWND16 hwnd, INT16 x, INT16 y, INT16 cx, INT16 cy, BOOL16 repaint )
 530 {
 531     return MoveWindow( WIN_Handle32(hwnd), x, y, cx, cy, repaint );
 532 }
 533
 534
 535 /***********************************************************************
 536  *              RegisterClass (USER.57)
 537  */
 538 ATOM WINAPI RegisterClass16( const WNDCLASS16 *wc )
 539 {
 540     WNDCLASSEX16 wcex;
 541
 542     wcex.cbSize        = sizeof(wcex);
 543     wcex.style         = wc->style;
 544     wcex.lpfnWndProc   = wc->lpfnWndProc;
 545     wcex.cbClsExtra    = wc->cbClsExtra;
 546     wcex.cbWndExtra    = wc->cbWndExtra;
 547     wcex.hInstance     = wc->hInstance;
 548     wcex.hIcon         = wc->hIcon;
 549     wcex.hCursor       = wc->hCursor;
 550     wcex.hbrBackground = wc->hbrBackground;
 551     wcex.lpszMenuName  = wc->lpszMenuName;
 552     wcex.lpszClassName = wc->lpszClassName;
 553     wcex.hIconSm       = 0;
 554     return RegisterClassEx16( &wcex );
 555 }
 556
 557
 558 /**************************************************************************
 559  *              GetClassName   (USER.58)
 560  */
 561 INT16 WINAPI GetClassName16( HWND16 hwnd, LPSTR buffer, INT16 count )
 562 {
 563     return GetClassNameA( WIN_Handle32(hwnd), buffer, count );
 564 }
 565
 566
 567 /**************************************************************************
 568  *              SetActiveWindow   (USER.59)
 569  */
 570 HWND16 WINAPI SetActiveWindow16( HWND16 hwnd )
 571 {
 572     return HWND_16( SetActiveWindow( WIN_Handle32(hwnd) ));
 573 }
 574
 575
 576 /**************************************************************************
 577  *              GetActiveWindow   (USER.60)
 578  */
 579 HWND16 WINAPI GetActiveWindow16(void)
 580 {
 581     return HWND_16( GetActiveWindow() );
 582 }
 583
 584
 585 /**************************************************************************
 586  *              ScrollWindow   (USER.61)
 587  */
 588 void WINAPI ScrollWindow16( HWND16 hwnd, INT16 dx, INT16 dy, const RECT16 *rect,
 589                             const RECT16 *clipRect )
 590 {
 591     RECT rect32, clipRect32;
 592
 593     if (rect)
 594     {
 595         rect32.left   = rect->left;
 596         rect32.top    = rect->top;
 597         rect32.right  = rect->right;
 598         rect32.bottom = rect->bottom;
 599     }
 600     if (clipRect)
 601     {
 602         clipRect32.left   = clipRect->left;
 603         clipRect32.top    = clipRect->top;
 604         clipRect32.right  = clipRect->right;
 605         clipRect32.bottom = clipRect->bottom;
 606     }
 607     ScrollWindow( WIN_Handle32(hwnd), dx, dy, rect ? &rect32 : NULL,
 608                   clipRect ? &clipRect32 : NULL );
 609 }
 610
 611
 612 /**************************************************************************
 613  *              SetScrollPos   (USER.62)
 614  */
 615 INT16 WINAPI SetScrollPos16( HWND16 hwnd, INT16 nBar, INT16 nPos, BOOL16 redraw )
 616 {
 617     return SetScrollPos( WIN_Handle32(hwnd), nBar, nPos, redraw );
 618 }
 619
 620
 621 /**************************************************************************
 622  *              GetScrollPos   (USER.63)
 623  */
 624 INT16 WINAPI GetScrollPos16( HWND16 hwnd, INT16 nBar )
 625 {
 626     return GetScrollPos( WIN_Handle32(hwnd), nBar );
 627 }
 628
 629
 630 /**************************************************************************
 631  *              SetScrollRange   (USER.64)
 632  */
 633 void WINAPI SetScrollRange16( HWND16 hwnd, INT16 nBar, INT16 MinVal, INT16 MaxVal, BOOL16 redraw )
 634 {
 635     /* Invalid range -> range is set to (0,0) */
 636     if ((INT)MaxVal - (INT)MinVal > 0x7fff) MinVal = MaxVal = 0;
 637     SetScrollRange( WIN_Handle32(hwnd), nBar, MinVal, MaxVal, redraw );
 638 }
 639
 640
 641 /**************************************************************************
 642  *              GetScrollRange   (USER.65)
 643  */
 644 BOOL16 WINAPI GetScrollRange16( HWND16 hwnd, INT16 nBar, LPINT16 lpMin, LPINT16 lpMax)
 645 {
 646     INT min, max;
 647     BOOL ret = GetScrollRange( WIN_Handle32(hwnd), nBar, &min, &max );
 648     if (lpMin) *lpMin = min;
 649     if (lpMax) *lpMax = max;
 650     return ret;
 651 }
 652
 653
 654 /**************************************************************************
 655  *              GetDC   (USER.66)
 656  */
 657 HDC16 WINAPI GetDC16( HWND16 hwnd )
 658 {
 659     return HDC_16(GetDC( WIN_Handle32(hwnd) ));
 660 }
 661
 662
 663 /**************************************************************************
 664  *              GetWindowDC   (USER.67)
 665  */
 666 HDC16 WINAPI GetWindowDC16( HWND16 hwnd )
 667 {
 668     return GetDCEx16( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 669 }
 670
 671
 672 /**************************************************************************
 673  *              ReleaseDC   (USER.68)
 674  */
 675 INT16 WINAPI ReleaseDC16( HWND16 hwnd, HDC16 hdc )
 676 {
 677     INT16 ret = (INT16)ReleaseDC( WIN_Handle32(hwnd), HDC_32(hdc) );
 678     NtUserEnableDC( HDC_32(hdc) );
 679     return ret;
 680 }
 681
 682
 683 /**************************************************************************
 684  *              FlashWindow   (USER.105)
 685  */
 686 BOOL16 WINAPI FlashWindow16( HWND16 hwnd, BOOL16 bInvert )
 687 {
 688     return FlashWindow( WIN_Handle32(hwnd), bInvert );
 689 }
 690
 691
 692 /**************************************************************************
 693  *              WindowFromDC   (USER.117)
 694  */
 695 HWND16 WINAPI WindowFromDC16( HDC16 hDC )
 696 {
 697     return HWND_16( WindowFromDC( HDC_32(hDC) ) );
 698 }
 699
 700
 701 /**************************************************************************
 702  *              UpdateWindow   (USER.124)
 703  */
 704 void WINAPI UpdateWindow16( HWND16 hwnd )
 705 {
 706     RedrawWindow16( hwnd, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN );
 707 }
 708
 709
 710 /**************************************************************************
 711  *              InvalidateRect   (USER.125)
 712  */
 713 void WINAPI InvalidateRect16( HWND16 hwnd, const RECT16 *rect, BOOL16 erase )
 714 {
 715     RedrawWindow16( hwnd, rect, 0, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
 716 }
 717
 718
 719 /**************************************************************************
 720  *              InvalidateRgn   (USER.126)
 721  */
 722 void WINAPI InvalidateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
 723 {
 724     RedrawWindow16( hwnd, NULL, hrgn, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
 725 }
 726
 727
 728 /**************************************************************************
 729  *              ValidateRect   (USER.127)
 730  */
 731 void WINAPI ValidateRect16( HWND16 hwnd, const RECT16 *rect )
 732 {
 733     RedrawWindow16( hwnd, rect, 0, RDW_VALIDATE | RDW_NOCHILDREN );
 734 }
 735
 736
 737 /**************************************************************************
 738  *              ValidateRgn   (USER.128)
 739  */
 740 void WINAPI ValidateRgn16( HWND16 hwnd, HRGN16 hrgn )
 741 {
 742     RedrawWindow16( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOCHILDREN );
 743 }
 744
 745
 746 /**************************************************************************
 747  *              GetClassWord   (USER.129)
 748  */
 749 WORD WINAPI GetClassWord16( HWND16 hwnd, INT16 offset )
 750 {
 751     HICON icon;
 752
 753     switch (offset)
 754     {
 755     case GCLP_HCURSOR:
 756     case GCLP_HICON:
 757     case GCLP_HICONSM:
 758         icon = (HICON)GetClassLongPtrW( WIN_Handle32(hwnd), offset );
 759         return get_icon_16( icon );
 760     }
 761     return GetClassWord( WIN_Handle32(hwnd), offset );
 762 }
 763
 764
 765 /**************************************************************************
 766  *              SetClassWord   (USER.130)
 767  */
 768 WORD WINAPI SetClassWord16( HWND16 hwnd, INT16 offset, WORD newval )
 769 {
 770     HICON icon;
 771
 772     switch (offset)
 773     {
 774     case GCLP_HCURSOR:
 775     case GCLP_HICON:
 776     case GCLP_HICONSM:
 777         icon = (HICON)SetClassLongPtrW( WIN_Handle32(hwnd), offset, (ULONG_PTR)get_icon_32(newval) );
 778         return get_icon_16( icon );
 779     }
 780     return SetClassWord( WIN_Handle32(hwnd), offset, newval );
 781 }
 782
 783
 784 /***********************************************************************
 785  *              GetClassLong (USER.131)
 786  */
 787 LONG WINAPI GetClassLong16( HWND16 hwnd16, INT16 offset )
 788 {
 789     LONG_PTR ret = GetClassLongA( WIN_Handle32(hwnd16), offset );
 790
 791     switch( offset )
 792     {
 793     case GCLP_WNDPROC:
 794         return (LONG_PTR)WINPROC_GetProc16( (WNDPROC)ret, FALSE );
 795     case GCLP_MENUNAME:
 796         return MapLS( (void *)ret );  /* leak */
 797     case GCLP_HCURSOR:
 798     case GCLP_HICON:
 799     case GCLP_HICONSM:
 800         return get_icon_16( (HICON)ret );
 801     default:
 802         return ret;
 803     }
 804 }
 805
 806
 807 /***********************************************************************
 808  *              SetClassLong (USER.132)
 809  */
 810 LONG WINAPI SetClassLong16( HWND16 hwnd16, INT16 offset, LONG newval )
 811 {
 812     HICON icon;
 813
 814     switch( offset )
 815     {
 816     case GCLP_HCURSOR:
 817     case GCLP_HICON:
 818     case GCLP_HICONSM:
 819         icon = (HICON)SetClassLongPtrW( WIN_Handle32(hwnd16), offset, (ULONG_PTR)get_icon_32(newval) );
 820         return get_icon_16( icon );
 821     case GCLP_WNDPROC:
 822         {
 823             WNDPROC new_proc = WINPROC_AllocProc16( (WNDPROC16)newval );
 824             WNDPROC old_proc = (WNDPROC)SetClassLongA( WIN_Handle32(hwnd16), offset, (LONG_PTR)new_proc );
 825             return (LONG)WINPROC_GetProc16( old_proc, FALSE );
 826         }
 827     case GCLP_MENUNAME:
 828         newval = (LONG)MapSL( newval );
 829         /* fall through */
 830     default:
 831         return SetClassLongA( WIN_Handle32(hwnd16), offset, newval );
 832     }
 833 }
 834
 835
 836 /**************************************************************************
 837  *              GetWindowWord   (USER.133)
 838  */
 839 WORD WINAPI GetWindowWord16( HWND16 hwnd, INT16 offset )
 840 {
 841     switch(offset)
 842     {
 843     case GWLP_ID:
 844     case GWLP_HINSTANCE:
 845     case GWLP_HWNDPARENT:
 846         return GetWindowLongA( WIN_Handle32(hwnd), offset );
 847     default:
 848         return GetWindowWord( WIN_Handle32(hwnd), offset );
 849     }
 850 }
 851
 852
 853 /**************************************************************************
 854  *              SetWindowWord   (USER.134)
 855  */
 856 WORD WINAPI SetWindowWord16( HWND16 hwnd, INT16 offset, WORD newval )
 857 {
 858     switch(offset)
 859     {
 860     case GWLP_ID:
 861     case GWLP_HINSTANCE:
 862     case GWLP_HWNDPARENT:
 863         return SetWindowLongA( WIN_Handle32(hwnd), offset, newval );
 864     default:
 865         return SetWindowWord( WIN_Handle32(hwnd), offset, newval );
 866     }
 867 }
 868
 869
 870 /**********************************************************************
 871  *              GetWindowLong (USER.135)
 872  */
 873 LONG WINAPI GetWindowLong16( HWND16 hwnd16, INT16 offset )
 874 {
 875     HWND hwnd = WIN_Handle32( hwnd16 );
 876     LONG_PTR retvalue;
 877     BOOL is_winproc = (offset == GWLP_WNDPROC);
 878
 879     if (offset >= 0)
 880     {
 881         int cbWndExtra = GetClassLongA( hwnd, GCL_CBWNDEXTRA );
 882
 883         if (offset > (int)(cbWndExtra - sizeof(LONG)))
 884         {
 885             /*
 886              * Some programs try to access last element from 16 bit
 887              * code using illegal offset value. Hopefully this is
 888              * what those programs really expect.
 889              */
 890             if (cbWndExtra >= 4 && offset == cbWndExtra - sizeof(WORD))
 891             {
 892                 offset = cbWndExtra - sizeof(LONG);
 893             }
 894             else
 895             {
 896                 SetLastError( ERROR_INVALID_INDEX );
 897                 return 0;
 898             }
 899         }
 900         else if (offset == DWLP_DLGPROC)
 901             is_winproc = (wow_handlers32.get_dialog_info( hwnd, FALSE ) != NULL);
 902     }
 903     retvalue = GetWindowLongA( hwnd, offset );
 904     if (is_winproc) retvalue = (LONG_PTR)WINPROC_GetProc16( (WNDPROC)retvalue, FALSE );
 905     return retvalue;
 906 }
 907
 908
 909 /**********************************************************************
 910  *              SetWindowLong (USER.136)
 911  */
 912 LONG WINAPI SetWindowLong16( HWND16 hwnd16, INT16 offset, LONG newval )
 913 {
 914     HWND hwnd = WIN_Handle32( hwnd16 );
 915     BOOL is_winproc = (offset == GWLP_WNDPROC);
 916
 917     if (offset == DWLP_DLGPROC)
 918         is_winproc = (wow_handlers32.get_dialog_info( hwnd, FALSE ) != NULL);
 919
 920     if (is_winproc)
 921     {
 922         WNDPROC new_proc = WINPROC_AllocProc16( (WNDPROC16)newval );
 923         WNDPROC old_proc = (WNDPROC)SetWindowLongPtrA( hwnd, offset, (LONG_PTR)new_proc );
 924         return (LONG)WINPROC_GetProc16( old_proc, FALSE );
 925     }
 926     else return SetWindowLongA( hwnd, offset, newval );
 927 }
 928
 929
 930 /**************************************************************************
 931  *              OpenClipboard   (USER.137)
 932  */
 933 BOOL16 WINAPI OpenClipboard16( HWND16 hwnd )
 934 {
 935     return OpenClipboard( WIN_Handle32(hwnd) );
 936 }
 937
 938
 939 /**************************************************************************
 940  *              GetClipboardOwner   (USER.140)
 941  */
 942 HWND16 WINAPI GetClipboardOwner16(void)
 943 {
 944     return HWND_16( GetClipboardOwner() );
 945 }
 946
 947
 948 /**************************************************************************
 949  *              SetClipboardViewer   (USER.147)
 950  */
 951 HWND16 WINAPI SetClipboardViewer16( HWND16 hwnd )
 952 {
 953     return HWND_16( SetClipboardViewer( WIN_Handle32(hwnd) ));
 954 }
 955
 956
 957 /**************************************************************************
 958  *              GetClipboardViewer   (USER.148)
 959  */
 960 HWND16 WINAPI GetClipboardViewer16(void)
 961 {
 962     return HWND_16( GetClipboardViewer() );
 963 }
 964
 965
 966 /**************************************************************************
 967  *              ChangeClipboardChain   (USER.149)
 968  */
 969 BOOL16 WINAPI ChangeClipboardChain16(HWND16 hwnd, HWND16 hwndNext)
 970 {
 971     return ChangeClipboardChain( WIN_Handle32(hwnd), WIN_Handle32(hwndNext) );
 972 }
 973
 974
 975 /**************************************************************************
 976  *              GetSystemMenu   (USER.156)
 977  */
 978 HMENU16 WINAPI GetSystemMenu16( HWND16 hwnd, BOOL16 revert )
 979 {
 980     return HMENU_16(GetSystemMenu( WIN_Handle32(hwnd), revert ));
 981 }
 982
 983
 984 /**************************************************************************
 985  *              GetMenu   (USER.157)
 986  */
 987 HMENU16 WINAPI GetMenu16( HWND16 hwnd )
 988 {
 989     return HMENU_16(GetMenu( WIN_Handle32(hwnd) ));
 990 }
 991
 992
 993 /**************************************************************************
 994  *              SetMenu   (USER.158)
 995  */
 996 BOOL16 WINAPI SetMenu16( HWND16 hwnd, HMENU16 hMenu )
 997 {
 998     return SetMenu( WIN_Handle32(hwnd), HMENU_32(hMenu) );
 999 }
1000
1001
1002 /**************************************************************************
1003  *              DrawMenuBar   (USER.160)
1004  */
1005 void WINAPI DrawMenuBar16( HWND16 hwnd )
1006 {
1007     DrawMenuBar( WIN_Handle32(hwnd) );
1008 }
1009
1010
1011 /**************************************************************************
1012  *              HiliteMenuItem   (USER.162)
1013  */
1014 BOOL16 WINAPI HiliteMenuItem16( HWND16 hwnd, HMENU16 hMenu, UINT16 id, UINT16 wHilite )
1015 {
1016     return HiliteMenuItem( WIN_Handle32(hwnd), HMENU_32(hMenu), id, wHilite );
1017 }
1018
1019
1020 /**************************************************************************
1021  *              CreateCaret   (USER.163)
1022  */
1023 void WINAPI CreateCaret16( HWND16 hwnd, HBITMAP16 bitmap, INT16 width, INT16 height )
1024 {
1025     CreateCaret( WIN_Handle32(hwnd), HBITMAP_32(bitmap), width, height );
1026 }
1027
1028
1029 /*****************************************************************
1030  *              DestroyCaret (USER.164)
1031  */
1032 void WINAPI DestroyCaret16(void)
1033 {
1034     DestroyCaret();
1035 }
1036
1037
1038 /*****************************************************************
1039  *              SetCaretPos (USER.165)
1040  */
1041 void WINAPI SetCaretPos16( INT16 x, INT16 y )
1042 {
1043     SetCaretPos( x, y );
1044 }
1045
1046
1047 /**************************************************************************
1048  *              HideCaret   (USER.166)
1049  */
1050 void WINAPI HideCaret16( HWND16 hwnd )
1051 {
1052     HideCaret( WIN_Handle32(hwnd) );
1053 }
1054
1055
1056 /**************************************************************************
1057  *              ShowCaret   (USER.167)
1058  */
1059 void WINAPI ShowCaret16( HWND16 hwnd )
1060 {
1061     ShowCaret( WIN_Handle32(hwnd) );
1062 }
1063
1064
1065 /*****************************************************************
1066  *              SetCaretBlinkTime (USER.168)
1067  */
1068 void WINAPI SetCaretBlinkTime16( UINT16 msecs )
1069 {
1070     SetCaretBlinkTime( msecs );
1071 }
1072
1073
1074 /*****************************************************************
1075  *              GetCaretBlinkTime (USER.169)
1076  */
1077 UINT16 WINAPI GetCaretBlinkTime16(void)
1078 {
1079     return GetCaretBlinkTime();
1080 }
1081
1082
1083 /**************************************************************************
1084  *              ArrangeIconicWindows   (USER.170)
1085  */
1086 UINT16 WINAPI ArrangeIconicWindows16( HWND16 parent)
1087 {
1088     return ArrangeIconicWindows( WIN_Handle32(parent) );
1089 }
1090
1091
1092 /**************************************************************************
1093  *              SwitchToThisWindow   (USER.172)
1094  */
1095 void WINAPI SwitchToThisWindow16( HWND16 hwnd, BOOL16 restore )
1096 {
1097     SwitchToThisWindow( WIN_Handle32(hwnd), restore );
1098 }
1099
1100
1101 /**************************************************************************
1102  *              KillSystemTimer   (USER.182)
1103  */
1104 BOOL16 WINAPI KillSystemTimer16( HWND16 hwnd, UINT16 id )
1105 {
1106     return KillTimer( WIN_Handle32(hwnd), (UINT_PTR)id | SYSTEM_TIMER_FLAG );
1107 }
1108
1109
1110 /*****************************************************************
1111  *              GetCaretPos (USER.183)
1112  */
1113 void WINAPI GetCaretPos16( LPPOINT16 pt16 )
1114 {
1115     POINT pt;
1116     if (GetCaretPos( &pt ))
1117     {
1118         pt16->x = pt.x;
1119         pt16->y = pt.y;
1120     }
1121 }
1122
1123
1124 /**************************************************************************
1125  *              SetSysModalWindow   (USER.188)
1126  */
1127 HWND16 WINAPI SetSysModalWindow16( HWND16 hwnd )
1128 {
1129     HWND16 old = hwndSysModal;
1130     hwndSysModal = hwnd;
1131     return old;
1132 }
1133
1134
1135 /**************************************************************************
1136  *              GetSysModalWindow   (USER.189)
1137  */
1138 HWND16 WINAPI GetSysModalWindow16(void)
1139 {
1140     return hwndSysModal;
1141 }
1142
1143
1144 /**************************************************************************
1145  *              GetUpdateRect   (USER.190)
1146  */
1147 BOOL16 WINAPI GetUpdateRect16( HWND16 hwnd, LPRECT16 rect, BOOL16 erase )
1148 {
1149     RECT r;
1150     BOOL16 ret;
1151
1152     if (!rect) return GetUpdateRect( WIN_Handle32(hwnd), NULL, erase );
1153     ret = GetUpdateRect( WIN_Handle32(hwnd), &r, erase );
1154     rect->left   = r.left;
1155     rect->top    = r.top;
1156     rect->right  = r.right;
1157     rect->bottom = r.bottom;
1158     return ret;
1159 }
1160
1161
1162 /**************************************************************************
1163  *              ChildWindowFromPoint   (USER.191)
1164  */
1165 HWND16 WINAPI ChildWindowFromPoint16( HWND16 hwndParent, POINT16 pt )
1166 {
1167     POINT pt32;
1168
1169     pt32.x = pt.x;
1170     pt32.y = pt.y;
1171     return HWND_16( ChildWindowFromPoint( WIN_Handle32(hwndParent), pt32 ));
1172 }
1173
1174
1175 /***********************************************************************
1176  *              CascadeChildWindows (USER.198)
1177  */
1178 void WINAPI CascadeChildWindows16( HWND16 parent, WORD action )
1179 {
1180     CascadeWindows( WIN_Handle32(parent), action, NULL, 0, NULL );
1181 }
1182
1183
1184 /***********************************************************************
1185  *              TileChildWindows (USER.199)
1186  */
1187 void WINAPI TileChildWindows16( HWND16 parent, WORD action )
1188 {
1189     TileWindows( WIN_Handle32(parent), action, NULL, 0, NULL );
1190 }
1191
1192
1193 /***********************************************************************
1194  *              GetWindowTask   (USER.224)
1195  */
1196 HTASK16 WINAPI GetWindowTask16( HWND16 hwnd )
1197 {
1198     DWORD tid = GetWindowThreadProcessId( HWND_32(hwnd), NULL );
1199     if (!tid) return 0;
1200     return HTASK_16(tid);
1201 }
1202
1203 /**********************************************************************
1204  *              EnumTaskWindows   (USER.225)
1205  */
1206 BOOL16 WINAPI EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func, LPARAM lParam )
1207 {
1208     struct wnd_enum_info info;
1209     DWORD tid = HTASK_32( hTask );
1210
1211     if (!tid) return FALSE;
1212     info.proc  = func;
1213     info.param = lParam;
1214     return EnumThreadWindows( tid, wnd_enum_callback, (LPARAM)&info );
1215 }
1216
1217
1218 /**************************************************************************
1219  *              GetTopWindow   (USER.229)
1220  */
1221 HWND16 WINAPI GetTopWindow16( HWND16 hwnd )
1222 {
1223     return HWND_16( GetTopWindow( WIN_Handle32(hwnd) ));
1224 }
1225
1226
1227 /**************************************************************************
1228  *              GetNextWindow   (USER.230)
1229  */
1230 HWND16 WINAPI GetNextWindow16( HWND16 hwnd, WORD flag )
1231 {
1232     if ((flag != GW_HWNDNEXT) && (flag != GW_HWNDPREV)) return 0;
1233     return GetWindow16( hwnd, flag );
1234 }
1235
1236
1237 /**************************************************************************
1238  *              SetWindowPos   (USER.232)
1239  */
1240 BOOL16 WINAPI SetWindowPos16( HWND16 hwnd, HWND16 hwndInsertAfter,
1241                               INT16 x, INT16 y, INT16 cx, INT16 cy, WORD flags)
1242 {
1243     return SetWindowPos( WIN_Handle32(hwnd), full_insert_after_hwnd(hwndInsertAfter),
1244                          x, y, cx, cy, flags );
1245 }
1246
1247
1248 /**************************************************************************
1249  *              SetParent   (USER.233)
1250  */
1251 HWND16 WINAPI SetParent16( HWND16 hwndChild, HWND16 hwndNewParent )
1252 {
1253     return HWND_16( SetParent( WIN_Handle32(hwndChild), WIN_Handle32(hwndNewParent) ));
1254 }
1255
1256
1257 /**************************************************************************
1258  *              GetCapture   (USER.236)
1259  */
1260 HWND16 WINAPI GetCapture16(void)
1261 {
1262     return HWND_16( GetCapture() );
1263 }
1264
1265
1266 /**************************************************************************
1267  *              GetUpdateRgn   (USER.237)
1268  */
1269 INT16 WINAPI GetUpdateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
1270 {
1271     return GetUpdateRgn( WIN_Handle32(hwnd), HRGN_32(hrgn), erase );
1272 }
1273
1274
1275 /**************************************************************************
1276  *              ExcludeUpdateRgn   (USER.238)
1277  */
1278 INT16 WINAPI ExcludeUpdateRgn16( HDC16 hdc, HWND16 hwnd )
1279 {
1280     return ExcludeUpdateRgn( HDC_32(hdc), WIN_Handle32(hwnd) );
1281 }
1282
1283
1284 /**************************************************************************
1285  *              GetOpenClipboardWindow   (USER.248)
1286  */
1287 HWND16 WINAPI GetOpenClipboardWindow16(void)
1288 {
1289     return HWND_16( GetOpenClipboardWindow() );
1290 }
1291
1292
1293 /*******************************************************************
1294  *              MapWindowPoints (USER.258)
1295  */
1296 void WINAPI MapWindowPoints16( HWND16 hwndFrom, HWND16 hwndTo, LPPOINT16 lppt, UINT16 count )
1297 {
1298     POINT buffer[8], *ppt = buffer;
1299     UINT i;
1300
1301     if (count > 8) ppt = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*ppt) );
1302     for (i = 0; i < count; i++)
1303     {
1304         ppt[i].x = lppt[i].x;
1305         ppt[i].y = lppt[i].y;
1306     }
1307     MapWindowPoints( WIN_Handle32(hwndFrom), WIN_Handle32(hwndTo), ppt, count );
1308     for (i = 0; i < count; i++)
1309     {
1310         lppt[i].x = ppt[i].x;
1311         lppt[i].y = ppt[i].y;
1312     }
1313     if (ppt != buffer) HeapFree( GetProcessHeap(), 0, ppt );
1314 }
1315
1316
1317 /**************************************************************************
1318  *              BeginDeferWindowPos   (USER.259)
1319  */
1320 HDWP16 WINAPI BeginDeferWindowPos16( INT16 count )
1321 {
1322     return HDWP_16(BeginDeferWindowPos( count ));
1323 }
1324
1325
1326 /**************************************************************************
1327  *              DeferWindowPos   (USER.260)
1328  */
1329 HDWP16 WINAPI DeferWindowPos16( HDWP16 hdwp, HWND16 hwnd, HWND16 hwndAfter,
1330                                 INT16 x, INT16 y, INT16 cx, INT16 cy,
1331                                 UINT16 flags )
1332 {
1333     return HDWP_16(DeferWindowPos( HDWP_32(hdwp), WIN_Handle32(hwnd),
1334                    full_insert_after_hwnd(hwndAfter), x, y, cx, cy, flags ));
1335 }
1336
1337
1338 /**************************************************************************
1339  *              EndDeferWindowPos   (USER.261)
1340  */
1341 BOOL16 WINAPI EndDeferWindowPos16( HDWP16 hdwp )
1342 {
1343     return EndDeferWindowPos(HDWP_32(hdwp));
1344 }
1345
1346
1347 /**************************************************************************
1348  *              GetWindow   (USER.262)
1349  */
1350 HWND16 WINAPI GetWindow16( HWND16 hwnd, WORD rel )
1351 {
1352     return HWND_16( GetWindow( WIN_Handle32(hwnd), rel ) );
1353 }
1354
1355
1356 /**************************************************************************
1357  *              ShowOwnedPopups   (USER.265)
1358  */
1359 void WINAPI ShowOwnedPopups16( HWND16 owner, BOOL16 fShow )
1360 {
1361     ShowOwnedPopups( WIN_Handle32(owner), fShow );
1362 }
1363
1364
1365 /**************************************************************************
1366  *              ShowScrollBar   (USER.267)
1367  */
1368 void WINAPI ShowScrollBar16( HWND16 hwnd, INT16 nBar, BOOL16 fShow )
1369 {
1370     ShowScrollBar( WIN_Handle32(hwnd), nBar, fShow );
1371 }
1372
1373
1374 /**************************************************************************
1375  *              IsZoomed   (USER.272)
1376  */
1377 BOOL16 WINAPI IsZoomed16(HWND16 hwnd)
1378 {
1379     return IsZoomed( WIN_Handle32(hwnd) );
1380 }
1381
1382
1383 /**************************************************************************
1384  *              GetDlgCtrlID   (USER.277)
1385  */
1386 INT16 WINAPI GetDlgCtrlID16( HWND16 hwnd )
1387 {
1388     return GetDlgCtrlID( WIN_Handle32(hwnd) );
1389 }
1390
1391
1392 /**************************************************************************
1393  *              GetDesktopHwnd   (USER.278)
1394  *
1395  * Exactly the same thing as GetDesktopWindow(), but not documented.
1396  * Don't ask me why...
1397  */
1398 HWND16 WINAPI GetDesktopHwnd16(void)
1399 {
1400     return GetDesktopWindow16();
1401 }
1402
1403
1404 /**************************************************************************
1405  *              SetSystemMenu   (USER.280)
1406  */
1407 BOOL16 WINAPI SetSystemMenu16( HWND16 hwnd, HMENU16 hMenu )
1408 {
1409     return SetSystemMenu( WIN_Handle32(hwnd), HMENU_32(hMenu) );
1410 }
1411
1412
1413 /**************************************************************************
1414  *              GetDesktopWindow   (USER.286)
1415  */
1416 HWND16 WINAPI GetDesktopWindow16(void)
1417 {
1418     return HWND_16( GetDesktopWindow() );
1419 }
1420
1421
1422 /**************************************************************************
1423  *              GetLastActivePopup   (USER.287)
1424  */
1425 HWND16 WINAPI GetLastActivePopup16( HWND16 hwnd )
1426 {
1427     return HWND_16( GetLastActivePopup( WIN_Handle32(hwnd) ));
1428 }
1429
1430
1431 /**************************************************************************
1432  *              RedrawWindow   (USER.290)
1433  */
1434 BOOL16 WINAPI RedrawWindow16( HWND16 hwnd, const RECT16 *rectUpdate,
1435                               HRGN16 hrgnUpdate, UINT16 flags )
1436 {
1437     if (rectUpdate)
1438     {
1439         RECT r;
1440         r.left   = rectUpdate->left;
1441         r.top    = rectUpdate->top;
1442         r.right  = rectUpdate->right;
1443         r.bottom = rectUpdate->bottom;
1444         return RedrawWindow(WIN_Handle32(hwnd), &r, HRGN_32(hrgnUpdate), flags);
1445     }
1446     return RedrawWindow(WIN_Handle32(hwnd), NULL, HRGN_32(hrgnUpdate), flags);
1447 }
1448
1449
1450 /**************************************************************************
1451  *              LockWindowUpdate   (USER.294)
1452  */
1453 BOOL16 WINAPI LockWindowUpdate16( HWND16 hwnd )
1454 {
1455     return LockWindowUpdate( WIN_Handle32(hwnd) );
1456 }
1457
1458
1459 /**************************************************************************
1460  *              ScrollWindowEx   (USER.319)
1461  */
1462 INT16 WINAPI ScrollWindowEx16( HWND16 hwnd, INT16 dx, INT16 dy,
1463                                const RECT16 *rect, const RECT16 *clipRect,
1464                                HRGN16 hrgnUpdate, LPRECT16 rcUpdate,
1465                                UINT16 flags )
1466 {
1467     RECT rect32, clipRect32, rcUpdate32;
1468     BOOL16 ret;
1469
1470     if (rect)
1471     {
1472         rect32.left   = rect->left;
1473         rect32.top    = rect->top;
1474         rect32.right  = rect->right;
1475         rect32.bottom = rect->bottom;
1476     }
1477     if (clipRect)
1478     {
1479         clipRect32.left   = clipRect->left;
1480         clipRect32.top    = clipRect->top;
1481         clipRect32.right  = clipRect->right;
1482         clipRect32.bottom = clipRect->bottom;
1483     }
1484     ret = ScrollWindowEx( WIN_Handle32(hwnd), dx, dy, rect ? &rect32 : NULL,
1485                           clipRect ? &clipRect32 : NULL, HRGN_32(hrgnUpdate),
1486                           (rcUpdate) ? &rcUpdate32 : NULL, flags );
1487     if (rcUpdate)
1488     {
1489         rcUpdate->left   = rcUpdate32.left;
1490         rcUpdate->top    = rcUpdate32.top;
1491         rcUpdate->right  = rcUpdate32.right;
1492         rcUpdate->bottom = rcUpdate32.bottom;
1493     }
1494     return ret;
1495 }
1496
1497
1498 /**************************************************************************
1499  *              FillWindow   (USER.324)
1500  */
1501 void WINAPI FillWindow16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc, HBRUSH16 hbrush )
1502 {
1503     RECT rect;
1504     RECT16 rc16;
1505     GetClientRect( WIN_Handle32(hwnd), &rect );
1506     DPtoLP( HDC_32(hdc), (LPPOINT)&rect, 2 );
1507     rc16.left   = rect.left;
1508     rc16.top    = rect.top;
1509     rc16.right  = rect.right;
1510     rc16.bottom = rect.bottom;
1511     PaintRect16( hwndParent, hwnd, hdc, hbrush, &rc16 );
1512 }
1513
1514
1515 /**************************************************************************
1516  *              PaintRect   (USER.325)
1517  */
1518 void WINAPI PaintRect16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc,
1519                          HBRUSH16 hbrush, const RECT16 *rect)
1520 {
1521     if (hbrush <= CTLCOLOR_STATIC)
1522     {
1523         HWND parent = WIN_Handle32(hwndParent), hwnd32 = WIN_Handle32(hwnd);
1524
1525         if (!parent) return;
1526         hbrush = SendMessageW( parent, WM_CTLCOLORMSGBOX + hbrush, hdc, (LPARAM)hwnd32 );
1527         if (!hbrush) hbrush = DefWindowProcW( parent, WM_CTLCOLORMSGBOX + hbrush,
1528                                               hdc, (LPARAM)hwnd32 );
1529     }
1530     if (hbrush) FillRect16( hdc, rect, hbrush );
1531 }
1532
1533
1534 /**************************************************************************
1535  *              GetControlBrush   (USER.326)
1536  */
1537 HBRUSH16 WINAPI GetControlBrush16( HWND16 hwnd, HDC16 hdc, UINT16 ctlType )
1538 {
1539     HBRUSH16 ret;
1540     HWND hwnd32 = WIN_Handle32(hwnd);
1541     HWND parent = GetParent( hwnd32 );
1542
1543     if (!parent) parent = hwnd32;
1544     ret = SendMessageW( parent, WM_CTLCOLORMSGBOX + ctlType, hdc, (LPARAM)hwnd32 );
1545     if (!ret) ret = DefWindowProcW( parent, WM_CTLCOLORMSGBOX + ctlType,
1546                                     hdc, (LPARAM)hwnd32 );
1547     return ret;
1548 }
1549
1550
1551 /**************************************************************************
1552  *              GetDCEx   (USER.359)
1553  */
1554 HDC16 WINAPI GetDCEx16( HWND16 hwnd, HRGN16 hrgnClip, DWORD flags )
1555 {
1556     return HDC_16(GetDCEx(WIN_Handle32(hwnd), HRGN_32(hrgnClip), flags));
1557 }
1558
1559
1560 /**************************************************************************
1561  *              GetWindowPlacement   (USER.370)
1562  */
1563 BOOL16 WINAPI GetWindowPlacement16( HWND16 hwnd, WINDOWPLACEMENT16 *wp16 )
1564 {
1565     WINDOWPLACEMENT wpl;
1566
1567     wpl.length = sizeof(wpl);
1568     if (!GetWindowPlacement( WIN_Handle32(hwnd), &wpl )) return FALSE;
1569     wp16->length  = sizeof(*wp16);
1570     wp16->flags   = wpl.flags;
1571     wp16->showCmd = wpl.showCmd;
1572     wp16->ptMinPosition.x = wpl.ptMinPosition.x;
1573     wp16->ptMinPosition.y = wpl.ptMinPosition.y;
1574     wp16->ptMaxPosition.x = wpl.ptMaxPosition.x;
1575     wp16->ptMaxPosition.y = wpl.ptMaxPosition.y;
1576     wp16->rcNormalPosition.left   = wpl.rcNormalPosition.left;
1577     wp16->rcNormalPosition.top    = wpl.rcNormalPosition.top;
1578     wp16->rcNormalPosition.right  = wpl.rcNormalPosition.right;
1579     wp16->rcNormalPosition.bottom = wpl.rcNormalPosition.bottom;
1580     return TRUE;
1581 }
1582
1583
1584 /**************************************************************************
1585  *              SetWindowPlacement   (USER.371)
1586  */
1587 BOOL16 WINAPI SetWindowPlacement16( HWND16 hwnd, const WINDOWPLACEMENT16 *wp16 )
1588 {
1589     WINDOWPLACEMENT wpl;
1590
1591     if (!wp16) return FALSE;
1592     wpl.length  = sizeof(wpl);
1593     wpl.flags   = wp16->flags;
1594     wpl.showCmd = wp16->showCmd;
1595     wpl.ptMinPosition.x = wp16->ptMinPosition.x;
1596     wpl.ptMinPosition.y = wp16->ptMinPosition.y;
1597     wpl.ptMaxPosition.x = wp16->ptMaxPosition.x;
1598     wpl.ptMaxPosition.y = wp16->ptMaxPosition.y;
1599     wpl.rcNormalPosition.left   = wp16->rcNormalPosition.left;
1600     wpl.rcNormalPosition.top    = wp16->rcNormalPosition.top;
1601     wpl.rcNormalPosition.right  = wp16->rcNormalPosition.right;
1602     wpl.rcNormalPosition.bottom = wp16->rcNormalPosition.bottom;
1603     return SetWindowPlacement( WIN_Handle32(hwnd), &wpl );
1604 }
1605
1606
1607 /***********************************************************************
1608  *              RegisterClassEx (USER.397)
1609  */
1610 ATOM WINAPI RegisterClassEx16( const WNDCLASSEX16 *wc )
1611 {
1612     struct class_entry *class;
1613     WNDCLASSEXA wc32;
1614     HINSTANCE16 inst;
1615     ATOM atom;
1616
1617     inst = GetExePtr( wc->hInstance );
1618     if (!inst) inst = GetModuleHandle16( NULL );
1619
1620     wc32.cbSize        = sizeof(wc32);
1621     wc32.style         = wc->style;
1622     wc32.lpfnWndProc   = WINPROC_AllocProc16( wc->lpfnWndProc );
1623     wc32.cbClsExtra    = wc->cbClsExtra;
1624     wc32.cbWndExtra    = wc->cbWndExtra;
1625     wc32.hInstance     = HINSTANCE_32(inst);
1626     wc32.hIcon         = get_icon_32(wc->hIcon);
1627     wc32.hCursor       = get_icon_32( wc->hCursor );
1628     wc32.hbrBackground = HBRUSH_32(wc->hbrBackground);
1629     wc32.lpszMenuName  = MapSL(wc->lpszMenuName);
1630     wc32.lpszClassName = MapSL(wc->lpszClassName);
1631     wc32.hIconSm       = get_icon_32(wc->hIconSm);
1632     atom = RegisterClassExA( &wc32 );
1633     if ((class = HeapAlloc( GetProcessHeap(), 0, sizeof(*class) )))
1634     {
1635         class->atom = atom;
1636         class->inst = inst;
1637         list_add_tail( &class_list, &class->entry );
1638     }
1639     return atom;
1640 }
1641
1642
1643 /***********************************************************************
1644  *              GetClassInfoEx (USER.398)
1645  *
1646  * FIXME: this is just a guess, I have no idea if GetClassInfoEx() is the
1647  * same in Win16 as in Win32. --AJ
1648  */
1649 BOOL16 WINAPI GetClassInfoEx16( HINSTANCE16 hInst16, SEGPTR name, WNDCLASSEX16 *wc )
1650 {
1651     static HMODULE user32_module;
1652     WNDCLASSEXA wc32;
1653     HINSTANCE hInstance;
1654     BOOL ret;
1655
1656     if (!user32_module) user32_module = GetModuleHandleA( "user32.dll" );
1657     if (hInst16 == GetModuleHandle16("user")) hInstance = user32_module;
1658     else hInstance = HINSTANCE_32(GetExePtr( hInst16 ));
1659
1660     ret = GetClassInfoExA( hInstance, MapSL(name), &wc32 );
1661
1662     if (ret)
1663     {
1664         wc->lpfnWndProc   = WINPROC_GetProc16( wc32.lpfnWndProc, FALSE );
1665         wc->style         = wc32.style;
1666         wc->cbClsExtra    = wc32.cbClsExtra;
1667         wc->cbWndExtra    = wc32.cbWndExtra;
1668         wc->hInstance     = (wc32.hInstance == user32_module) ? GetModuleHandle16("user") : HINSTANCE_16(wc32.hInstance);
1669         wc->hIcon         = get_icon_16( wc32.hIcon );
1670         wc->hIconSm       = get_icon_16( wc32.hIconSm );
1671         wc->hCursor       = get_icon_16( wc32.hCursor );
1672         wc->hbrBackground = HBRUSH_16(wc32.hbrBackground);
1673         wc->lpszClassName = 0;
1674         wc->lpszMenuName  = MapLS((void *)wc32.lpszMenuName);  /* FIXME: leak */
1675     }
1676     return ret;
1677 }
1678
1679
1680 /**************************************************************************
1681  *              ChildWindowFromPointEx   (USER.399)
1682  */
1683 HWND16 WINAPI ChildWindowFromPointEx16( HWND16 hwndParent, POINT16 pt, UINT16 uFlags)
1684 {
1685     POINT pt32;
1686
1687     pt32.x = pt.x;
1688     pt32.y = pt.y;
1689     return HWND_16( ChildWindowFromPointEx( WIN_Handle32(hwndParent), pt32, uFlags ));
1690 }
1691
1692
1693 /**************************************************************************
1694  *              GetPriorityClipboardFormat   (USER.402)
1695  */
1696 INT16 WINAPI GetPriorityClipboardFormat16( UINT16 *list, INT16 count )
1697 {
1698     int i;
1699
1700     for (i = 0; i < count; i++)
1701         if (IsClipboardFormatAvailable( list[i] )) return list[i];
1702     return -1;
1703 }
1704
1705
1706 /***********************************************************************
1707  *              UnregisterClass (USER.403)
1708  */
1709 BOOL16 WINAPI UnregisterClass16( LPCSTR className, HINSTANCE16 hInstance )
1710 {
1711     ATOM atom;
1712
1713     if (hInstance == GetModuleHandle16("user")) hInstance = 0;
1714     else hInstance = GetExePtr( hInstance );
1715
1716     if ((atom = GlobalFindAtomA( className )))
1717     {
1718         struct class_entry *class;
1719         LIST_FOR_EACH_ENTRY( class, &class_list, struct class_entry, entry )
1720         {
1721             if (class->inst != hInstance) continue;
1722             if (class->atom != atom) continue;
1723             list_remove( &class->entry );
1724             HeapFree( GetProcessHeap(), 0, class );
1725             break;
1726         }
1727     }
1728     return UnregisterClassA( className, HINSTANCE_32(hInstance) );
1729 }
1730
1731
1732 /***********************************************************************
1733  *              GetClassInfo (USER.404)
1734  */
1735 BOOL16 WINAPI GetClassInfo16( HINSTANCE16 hInst16, SEGPTR name, WNDCLASS16 *wc )
1736 {
1737     WNDCLASSEX16 wcex;
1738     UINT16 ret = GetClassInfoEx16( hInst16, name, &wcex );
1739
1740     if (ret)
1741     {
1742         wc->style         = wcex.style;
1743         wc->lpfnWndProc   = wcex.lpfnWndProc;
1744         wc->cbClsExtra    = wcex.cbClsExtra;
1745         wc->cbWndExtra    = wcex.cbWndExtra;
1746         wc->hInstance     = wcex.hInstance;
1747         wc->hIcon         = wcex.hIcon;
1748         wc->hCursor       = wcex.hCursor;
1749         wc->hbrBackground = wcex.hbrBackground;
1750         wc->lpszMenuName  = wcex.lpszMenuName;
1751         wc->lpszClassName = wcex.lpszClassName;
1752     }
1753     return ret;
1754 }
1755
1756
1757 /**************************************************************************
1758  *              TrackPopupMenu   (USER.416)
1759  */
1760 BOOL16 WINAPI TrackPopupMenu16( HMENU16 hMenu, UINT16 wFlags, INT16 x, INT16 y,
1761                                 INT16 nReserved, HWND16 hwnd, const RECT16 *lpRect )
1762 {
1763     RECT r;
1764     if (lpRect)
1765     {
1766         r.left   = lpRect->left;
1767         r.top    = lpRect->top;
1768         r.right  = lpRect->right;
1769         r.bottom = lpRect->bottom;
1770     }
1771     return TrackPopupMenu( HMENU_32(hMenu), wFlags, x, y, nReserved,
1772                            WIN_Handle32(hwnd), lpRect ? &r : NULL );
1773 }
1774
1775
1776 /**************************************************************************
1777  *              FindWindowEx   (USER.427)
1778  */
1779 HWND16 WINAPI FindWindowEx16( HWND16 parent, HWND16 child, LPCSTR className, LPCSTR title )
1780 {
1781     return HWND_16( FindWindowExA( WIN_Handle32(parent), WIN_Handle32(child),
1782                                         className, title ));
1783 }
1784
1785
1786 /***********************************************************************
1787  *              DefFrameProc (USER.445)
1788  */
1789 LRESULT WINAPI DefFrameProc16( HWND16 hwnd, HWND16 hwndMDIClient,
1790                                UINT16 message, WPARAM16 wParam, LPARAM lParam )
1791 {
1792     switch (message)
1793     {
1794     case WM_SETTEXT:
1795         lParam = (LPARAM)MapSL(lParam);
1796         /* fall through */
1797     case WM_COMMAND:
1798     case WM_NCACTIVATE:
1799     case WM_SETFOCUS:
1800     case WM_SIZE:
1801         return DefFrameProcA( WIN_Handle32(hwnd), WIN_Handle32(hwndMDIClient),
1802                               message, wParam, lParam );
1803
1804     case WM_NEXTMENU:
1805         {
1806             MDINEXTMENU next_menu;
1807             DefFrameProcW( WIN_Handle32(hwnd), WIN_Handle32(hwndMDIClient),
1808                            message, wParam, (LPARAM)&next_menu );
1809             return MAKELONG( HMENU_16(next_menu.hmenuNext), HWND_16(next_menu.hwndNext) );
1810         }
1811     default:
1812         return DefWindowProc16(hwnd, message, wParam, lParam);
1813     }
1814 }
1815
1816
1817 /***********************************************************************
1818  *              DefMDIChildProc (USER.447)
1819  */
1820 LRESULT WINAPI DefMDIChildProc16( HWND16 hwnd, UINT16 message,
1821                                   WPARAM16 wParam, LPARAM lParam )
1822 {
1823     switch (message)
1824     {
1825     case WM_SETTEXT:
1826         return DefMDIChildProcA( WIN_Handle32(hwnd), message, wParam, (LPARAM)MapSL(lParam) );
1827
1828     case WM_MENUCHAR:
1829     case WM_CLOSE:
1830     case WM_SETFOCUS:
1831     case WM_CHILDACTIVATE:
1832     case WM_SYSCOMMAND:
1833     case WM_SETVISIBLE:
1834     case WM_SIZE:
1835     case WM_SYSCHAR:
1836         return DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, lParam );
1837
1838     case WM_GETMINMAXINFO:
1839         {
1840             MINMAXINFO16 *mmi16 = MapSL(lParam);
1841             MINMAXINFO mmi;
1842
1843             mmi.ptReserved.x     = mmi16->ptReserved.x;
1844             mmi.ptReserved.y     = mmi16->ptReserved.y;
1845             mmi.ptMaxSize.x      = mmi16->ptMaxSize.x;
1846             mmi.ptMaxSize.y      = mmi16->ptMaxSize.y;
1847             mmi.ptMaxPosition.x  = mmi16->ptMaxPosition.x;
1848             mmi.ptMaxPosition.y  = mmi16->ptMaxPosition.y;
1849             mmi.ptMinTrackSize.x = mmi16->ptMinTrackSize.x;
1850             mmi.ptMinTrackSize.y = mmi16->ptMinTrackSize.y;
1851             mmi.ptMaxTrackSize.x = mmi16->ptMaxTrackSize.x;
1852             mmi.ptMaxTrackSize.y = mmi16->ptMaxTrackSize.y;
1853
1854             DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, (LPARAM)&mmi );
1855
1856             mmi16->ptReserved.x     = mmi.ptReserved.x;
1857             mmi16->ptReserved.y     = mmi.ptReserved.y;
1858             mmi16->ptMaxSize.x      = mmi.ptMaxSize.x;
1859             mmi16->ptMaxSize.y      = mmi.ptMaxSize.y;
1860             mmi16->ptMaxPosition.x  = mmi.ptMaxPosition.x;
1861             mmi16->ptMaxPosition.y  = mmi.ptMaxPosition.y;
1862             mmi16->ptMinTrackSize.x = mmi.ptMinTrackSize.x;
1863             mmi16->ptMinTrackSize.y = mmi.ptMinTrackSize.y;
1864             mmi16->ptMaxTrackSize.x = mmi.ptMaxTrackSize.x;
1865             mmi16->ptMaxTrackSize.y = mmi.ptMaxTrackSize.y;
1866             return 0;
1867         }
1868     case WM_NEXTMENU:
1869         {
1870             MDINEXTMENU next_menu;
1871             DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, (LPARAM)&next_menu );
1872             return MAKELONG( HMENU_16(next_menu.hmenuNext), HWND_16(next_menu.hwndNext) );
1873         }
1874     default:
1875         return DefWindowProc16(hwnd, message, wParam, lParam);
1876     }
1877 }
1878
1879
1880 /**************************************************************************
1881  *              DrawAnimatedRects   (USER.448)
1882  */
1883 BOOL16 WINAPI DrawAnimatedRects16( HWND16 hwnd, INT16 idAni,
1884                                    const RECT16* lprcFrom, const RECT16* lprcTo )
1885 {
1886     RECT rcFrom32, rcTo32;
1887     rcFrom32.left   = lprcFrom->left;
1888     rcFrom32.top    = lprcFrom->top;
1889     rcFrom32.right  = lprcFrom->right;
1890     rcFrom32.bottom = lprcFrom->bottom;
1891     rcTo32.left     = lprcTo->left;
1892     rcTo32.top      = lprcTo->top;
1893     rcTo32.right    = lprcTo->right;
1894     rcTo32.bottom   = lprcTo->bottom;
1895     return DrawAnimatedRects( WIN_Handle32(hwnd), idAni, &rcFrom32, &rcTo32 );
1896 }
1897
1898
1899 /***********************************************************************
1900  *              CreateWindowEx (USER.452)
1901  */
1902 HWND16 WINAPI CreateWindowEx16( DWORD exStyle, LPCSTR className,
1903                                 LPCSTR windowName, DWORD style, INT16 x,
1904                                 INT16 y, INT16 width, INT16 height,
1905                                 HWND16 parent, HMENU16 menu,
1906                                 HINSTANCE16 instance, LPVOID data )
1907 {
1908     CREATESTRUCTA cs;
1909     char buffer[256];
1910     HWND hwnd;
1911
1912     /* Fix the coordinates */
1913
1914     cs.x  = (x == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)x;
1915     cs.y  = (y == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)y;
1916     cs.cx = (width == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)width;
1917     cs.cy = (height == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)height;
1918
1919     /* Create the window */
1920
1921     cs.lpCreateParams = data;
1922     cs.hInstance      = HINSTANCE_32(instance);
1923     cs.hMenu          = HMENU_32(menu);
1924     cs.hwndParent     = WIN_Handle32( parent );
1925     cs.style          = style;
1926     cs.lpszName       = windowName;
1927     cs.lpszClass      = className;
1928     cs.dwExStyle      = exStyle;
1929
1930     /* load the menu */
1931     if (!menu && (style & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1932     {
1933         WNDCLASSA class;
1934         HINSTANCE16 module = GetExePtr( instance );
1935
1936         if (GetClassInfoA( HINSTANCE_32(module), className, &class ))
1937             cs.hMenu = HMENU_32( LoadMenu16( module, class.lpszMenuName ));
1938     }
1939
1940     if (!IS_INTRESOURCE(className))
1941     {
1942         WCHAR bufferW[256];
1943
1944         if (!MultiByteToWideChar( CP_ACP, 0, className, -1, bufferW, ARRAY_SIZE(bufferW)))
1945             return 0;
1946         hwnd = create_window16( (CREATESTRUCTW *)&cs, bufferW, HINSTANCE_32(instance), FALSE );
1947     }
1948     else
1949     {
1950         if (!GlobalGetAtomNameA( LOWORD(className), buffer, sizeof(buffer) )) return 0;
1951         cs.lpszClass = buffer;
1952         hwnd = create_window16( (CREATESTRUCTW *)&cs, (LPCWSTR)className, HINSTANCE_32(instance), FALSE );
1953     }
1954     return HWND_16( hwnd );
1955 }
1956
1957
1958 /***********************************************************************
1959  *              GetInternalWindowPos (USER.460)
1960  */
1961 UINT16 WINAPI GetInternalWindowPos16( HWND16 hwnd, LPRECT16 rectWnd, LPPOINT16 ptIcon )
1962 {
1963     WINDOWPLACEMENT16 wndpl;
1964
1965     if (!GetWindowPlacement16( hwnd, &wndpl )) return 0;
1966     if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
1967     if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
1968     return wndpl.showCmd;
1969 }
1970
1971
1972 /**************************************************************************
1973  *              SetInternalWindowPos   (USER.461)
1974  */
1975 void WINAPI SetInternalWindowPos16( HWND16 hwnd, UINT16 showCmd, LPRECT16 rect, LPPOINT16 pt )
1976 {
1977     RECT rc32;
1978     POINT pt32;
1979
1980     if (rect)
1981     {
1982         rc32.left   = rect->left;
1983         rc32.top    = rect->top;
1984         rc32.right  = rect->right;
1985         rc32.bottom = rect->bottom;
1986     }
1987     if (pt)
1988     {
1989         pt32.x = pt->x;
1990         pt32.y = pt->y;
1991     }
1992     SetInternalWindowPos( WIN_Handle32(hwnd), showCmd,
1993                           rect ? &rc32 : NULL, pt ? &pt32 : NULL );
1994 }
1995
1996
1997 /**************************************************************************
1998  *              CalcChildScroll   (USER.462)
1999  */
2000 void WINAPI CalcChildScroll16( HWND16 hwnd, WORD scroll )
2001 {
2002     CalcChildScroll( WIN_Handle32(hwnd), scroll );
2003 }
2004
2005
2006 /**************************************************************************
2007  *              ScrollChildren   (USER.463)
2008  */
2009 void WINAPI ScrollChildren16(HWND16 hwnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam)
2010 {
2011     ScrollChildren( WIN_Handle32(hwnd), uMsg, wParam, lParam );
2012 }
2013
2014
2015 /**************************************************************************
2016  *              DragDetect   (USER.465)
2017  */
2018 BOOL16 WINAPI DragDetect16( HWND16 hwnd, POINT16 pt )
2019 {
2020     POINT pt32;
2021
2022     pt32.x = pt.x;
2023     pt32.y = pt.y;
2024     return DragDetect( WIN_Handle32(hwnd), pt32 );
2025 }
2026
2027
2028 /**************************************************************************
2029  *              SetScrollInfo   (USER.475)
2030  */
2031 INT16 WINAPI SetScrollInfo16( HWND16 hwnd, INT16 nBar, const SCROLLINFO *info, BOOL16 redraw )
2032 {
2033     return SetScrollInfo( WIN_Handle32(hwnd), nBar, info, redraw );
2034 }
2035
2036
2037 /**************************************************************************
2038  *              GetScrollInfo   (USER.476)
2039  */
2040 BOOL16 WINAPI GetScrollInfo16( HWND16 hwnd, INT16 nBar, LPSCROLLINFO info )
2041 {
2042     return GetScrollInfo( WIN_Handle32(hwnd), nBar, info );
2043 }
2044
2045
2046 /**************************************************************************
2047  *              EnableScrollBar   (USER.482)
2048  */
2049 BOOL16 WINAPI EnableScrollBar16( HWND16 hwnd, INT16 nBar, UINT16 flags )
2050 {
2051     return EnableScrollBar( WIN_Handle32(hwnd), nBar, flags );
2052 }
2053
2054
2055 /**************************************************************************
2056  *              GetShellWindow   (USER.600)
2057  */
2058 HWND16 WINAPI GetShellWindow16(void)
2059 {
2060     return HWND_16( GetShellWindow() );
2061 }
2062
2063
2064 /**************************************************************************
2065  *              GetForegroundWindow   (USER.608)
2066  */
2067 HWND16 WINAPI GetForegroundWindow16(void)
2068 {
2069     return HWND_16( GetForegroundWindow() );
2070 }
2071
2072
2073 /**************************************************************************
2074  *              SetForegroundWindow   (USER.609)
2075  */
2076 BOOL16 WINAPI SetForegroundWindow16( HWND16 hwnd )
2077 {
2078     return SetForegroundWindow( WIN_Handle32(hwnd) );
2079 }
2080
2081
2082 /**************************************************************************
2083  *              DrawCaptionTemp   (USER.657)
2084  */
2085 BOOL16 WINAPI DrawCaptionTemp16( HWND16 hwnd, HDC16 hdc, const RECT16 *rect,
2086                                  HFONT16 hFont, HICON16 hIcon, LPCSTR str, UINT16 uFlags )
2087 {
2088     RECT rect32;
2089
2090     if (rect)
2091     {
2092         rect32.left   = rect->left;
2093         rect32.top    = rect->top;
2094         rect32.right  = rect->right;
2095         rect32.bottom = rect->bottom;
2096     }
2097     return DrawCaptionTempA( WIN_Handle32(hwnd), HDC_32(hdc),
2098                              rect ? &rect32 : NULL, HFONT_32(hFont),
2099                              get_icon_32(hIcon), str, uFlags & 0x1f );
2100 }
2101
2102
2103 /**************************************************************************
2104  *              DrawCaption   (USER.660)
2105  */
2106 BOOL16 WINAPI DrawCaption16( HWND16 hwnd, HDC16 hdc, const RECT16 *rect, UINT16 flags )
2107 {
2108     RECT rect32;
2109
2110     if (rect)
2111     {
2112         rect32.left   = rect->left;
2113         rect32.top    = rect->top;
2114         rect32.right  = rect->right;
2115         rect32.bottom = rect->bottom;
2116     }
2117     return DrawCaption(WIN_Handle32(hwnd), HDC_32(hdc), rect ? &rect32 : NULL, flags);
2118 }
2119
2120
2121 /**************************************************************************
2122  *              GetMenuItemRect   (USER.665)
2123  */
2124 BOOL16 WINAPI GetMenuItemRect16( HWND16 hwnd, HMENU16 hMenu, UINT16 uItem,
2125                                  LPRECT16 rect)
2126 {
2127      RECT r32;
2128      BOOL res;
2129      if (!rect) return FALSE;
2130      res = GetMenuItemRect( WIN_Handle32(hwnd), HMENU_32(hMenu), uItem, &r32 );
2131      rect->left   = r32.left;
2132      rect->top    = r32.top;
2133      rect->right  = r32.right;
2134      rect->bottom = r32.bottom;
2135      return res;
2136 }
2137
2138
2139 /**************************************************************************
2140  *              SetWindowRgn   (USER.668)
2141  */
2142 INT16 WINAPI SetWindowRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 redraw )
2143 {
2144     return SetWindowRgn( WIN_Handle32(hwnd), HRGN_32(hrgn), redraw );
2145 }
2146
2147
2148 /**************************************************************************
2149  *              MessageBoxIndirect   (USER.827)
2150  */
2151 INT16 WINAPI MessageBoxIndirect16( LPMSGBOXPARAMS16 msgbox )
2152 {
2153     char caption[256], text[256];
2154     MSGBOXPARAMSA msgbox32;
2155
2156     msgbox32.cbSize             = msgbox->cbSize;
2157     msgbox32.hwndOwner          = WIN_Handle32( msgbox->hwndOwner );
2158     msgbox32.hInstance          = 0;
2159     msgbox32.dwStyle            = msgbox->dwStyle;
2160     msgbox32.lpszIcon           = NULL;
2161     msgbox32.dwContextHelpId    = msgbox->dwContextHelpId;
2162     msgbox32.lpfnMsgBoxCallback = msgbox->lpfnMsgBoxCallback;
2163     msgbox32.dwLanguageId       = msgbox->dwLanguageId;
2164
2165     if (!HIWORD(msgbox->lpszCaption))
2166     {
2167         LoadString16( msgbox->hInstance, LOWORD(msgbox->lpszCaption), caption, sizeof(caption) );
2168         msgbox32.lpszCaption = caption;
2169     }
2170     else msgbox32.lpszCaption = MapSL(msgbox->lpszCaption);
2171
2172     if (!HIWORD(msgbox->lpszText))
2173     {
2174         LoadString16( msgbox->hInstance, LOWORD(msgbox->lpszText), text, sizeof(text) );
2175         msgbox32.lpszText = text;
2176     }
2177     else msgbox32.lpszText = MapSL(msgbox->lpszText);
2178
2179     if ((msgbox->dwStyle & MB_ICONMASK) == MB_USERICON)
2180     {
2181         FIXME( "user icon %s not supported\n", debugstr_a( MapSL(msgbox->lpszIcon) ));
2182         msgbox32.dwStyle &= ~MB_USERICON;
2183     }
2184
2185     return MessageBoxIndirectA( &msgbox32 );
2186 }