git.oblomov.eu Git - wine/blob - dlls/user/wnd16.c

   1 /*
   2  * 16-bit windowing functions
   3  *
   4  * Copyright 2001 Alexandre Julliard
   5  */
   6
   7 #include "wine/winuser16.h"
   8 #include "user.h"
   9 #include "win.h"
  10 #include "stackframe.h"
  11
  12 static HWND16 hwndSysModal;
  13
  14 /* convert insert after window handle to 32-bit */
  15 inline static HWND full_insert_after_hwnd( HWND16 hwnd )
  16 {
  17     HWND ret = WIN_Handle32( hwnd );
  18     if (ret == (HWND)0xffff) ret = HWND_TOPMOST;
  19     return ret;
  20 }
  21
  22 /**************************************************************************
  23  *              MessageBox   (USER.1)
  24  */
  25 INT16 WINAPI MessageBox16( HWND16 hwnd, LPCSTR text, LPCSTR title, UINT16 type )
  26 {
  27     return MessageBoxA( WIN_Handle32(hwnd), text, title, type );
  28 }
  29
  30
  31 /**************************************************************************
  32  *              KillTimer   (USER.12)
  33  */
  34 BOOL16 WINAPI KillTimer16( HWND16 hwnd, UINT16 id )
  35 {
  36     return KillTimer( WIN_Handle32(hwnd), id );
  37 }
  38
  39
  40 /**************************************************************************
  41  *              SetCapture   (USER.18)
  42  */
  43 HWND16 WINAPI SetCapture16( HWND16 hwnd )
  44 {
  45     return WIN_Handle16( SetCapture( WIN_Handle32(hwnd) ));
  46 }
  47
  48
  49 /**************************************************************************
  50  *              ReleaseCapture   (USER.19)
  51  */
  52 BOOL16 WINAPI ReleaseCapture16(void)
  53 {
  54     return ReleaseCapture();
  55 }
  56
  57
  58 /**************************************************************************
  59  *              SetFocus   (USER.22)
  60  */
  61 HWND16 WINAPI SetFocus16( HWND16 hwnd )
  62 {
  63     return WIN_Handle16( SetFocus( WIN_Handle32(hwnd) ));
  64 }
  65
  66
  67 /**************************************************************************
  68  *              GetFocus   (USER.23)
  69  */
  70 HWND16 WINAPI GetFocus16(void)
  71 {
  72     return WIN_Handle16( GetFocus() );
  73 }
  74
  75
  76 /**************************************************************************
  77  *              RemoveProp   (USER.24)
  78  */
  79 HANDLE16 WINAPI RemoveProp16( HWND16 hwnd, LPCSTR str )
  80 {
  81     return (HANDLE16)RemovePropA( WIN_Handle32(hwnd), str );
  82 }
  83
  84
  85 /**************************************************************************
  86  *              GetProp   (USER.25)
  87  */
  88 HANDLE16 WINAPI GetProp16( HWND16 hwnd, LPCSTR str )
  89 {
  90     return (HANDLE16)GetPropA( WIN_Handle32(hwnd), str );
  91 }
  92
  93
  94 /**************************************************************************
  95  *              SetProp   (USER.26)
  96  */
  97 BOOL16 WINAPI SetProp16( HWND16 hwnd, LPCSTR str, HANDLE16 handle )
  98 {
  99     return SetPropA( WIN_Handle32(hwnd), str, handle );
 100 }
 101
 102
 103 /**************************************************************************
 104  *              ClientToScreen   (USER.28)
 105  */
 106 void WINAPI ClientToScreen16( HWND16 hwnd, LPPOINT16 lppnt )
 107 {
 108     MapWindowPoints16( hwnd, 0, lppnt, 1 );
 109 }
 110
 111
 112 /**************************************************************************
 113  *              ScreenToClient   (USER.29)
 114  */
 115 void WINAPI ScreenToClient16( HWND16 hwnd, LPPOINT16 lppnt )
 116 {
 117     MapWindowPoints16( 0, hwnd, lppnt, 1 );
 118 }
 119
 120
 121 /**************************************************************************
 122  *              WindowFromPoint   (USER.30)
 123  */
 124 HWND16 WINAPI WindowFromPoint16( POINT16 pt )
 125 {
 126     POINT pt32;
 127
 128     CONV_POINT16TO32( &pt, &pt32 );
 129     return WIN_Handle16( WindowFromPoint( pt32 ) );
 130 }
 131
 132
 133 /**************************************************************************
 134  *              IsIconic   (USER.31)
 135  */
 136 BOOL16 WINAPI IsIconic16(HWND16 hwnd)
 137 {
 138     return IsIconic( WIN_Handle32(hwnd) );
 139 }
 140
 141
 142 /**************************************************************************
 143  *              GetWindowRect   (USER.32)
 144  */
 145 void WINAPI GetWindowRect16( HWND16 hwnd, LPRECT16 rect )
 146 {
 147     RECT rect32;
 148
 149     GetWindowRect( WIN_Handle32(hwnd), &rect32 );
 150     rect->left   = rect32.left;
 151     rect->top    = rect32.top;
 152     rect->right  = rect32.right;
 153     rect->bottom = rect32.bottom;
 154 }
 155
 156
 157 /**************************************************************************
 158  *              GetClientRect   (USER.33)
 159  */
 160 void WINAPI GetClientRect16( HWND16 hwnd, LPRECT16 rect )
 161 {
 162     RECT rect32;
 163
 164     GetClientRect( WIN_Handle32(hwnd), &rect32 );
 165     rect->left   = rect32.left;
 166     rect->top    = rect32.top;
 167     rect->right  = rect32.right;
 168     rect->bottom = rect32.bottom;
 169 }
 170
 171
 172 /**************************************************************************
 173  *              EnableWindow   (USER.34)
 174  */
 175 BOOL16 WINAPI EnableWindow16( HWND16 hwnd, BOOL16 enable )
 176 {
 177     return EnableWindow( WIN_Handle32(hwnd), enable );
 178 }
 179
 180
 181 /**************************************************************************
 182  *              IsWindowEnabled   (USER.35)
 183  */
 184 BOOL16 WINAPI IsWindowEnabled16(HWND16 hwnd)
 185 {
 186     return IsWindowEnabled( WIN_Handle32(hwnd) );
 187 }
 188
 189
 190 /**************************************************************************
 191  *              GetWindowText   (USER.36)
 192  */
 193 INT16 WINAPI GetWindowText16( HWND16 hwnd, SEGPTR lpString, INT16 nMaxCount )
 194 {
 195     return SendMessage16( hwnd, WM_GETTEXT, nMaxCount, lpString );
 196 }
 197
 198
 199 /**************************************************************************
 200  *              SetWindowText   (USER.37)
 201  */
 202 BOOL16 WINAPI SetWindowText16( HWND16 hwnd, SEGPTR lpString )
 203 {
 204     return SendMessage16( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
 205 }
 206
 207
 208 /**************************************************************************
 209  *              GetWindowTextLength   (USER.38)
 210  */
 211 INT16 WINAPI GetWindowTextLength16( HWND16 hwnd )
 212 {
 213     return SendMessage16( hwnd, WM_GETTEXTLENGTH, 0, 0 );
 214 }
 215
 216
 217 /***********************************************************************
 218  *              BeginPaint (USER.39)
 219  */
 220 HDC16 WINAPI BeginPaint16( HWND16 hwnd, LPPAINTSTRUCT16 lps )
 221 {
 222     PAINTSTRUCT ps;
 223
 224     BeginPaint( WIN_Handle32(hwnd), &ps );
 225     lps->hdc            = ps.hdc;
 226     lps->fErase         = ps.fErase;
 227     lps->rcPaint.top    = ps.rcPaint.top;
 228     lps->rcPaint.left   = ps.rcPaint.left;
 229     lps->rcPaint.right  = ps.rcPaint.right;
 230     lps->rcPaint.bottom = ps.rcPaint.bottom;
 231     lps->fRestore       = ps.fRestore;
 232     lps->fIncUpdate     = ps.fIncUpdate;
 233     return lps->hdc;
 234 }
 235
 236
 237 /***********************************************************************
 238  *              EndPaint (USER.40)
 239  */
 240 BOOL16 WINAPI EndPaint16( HWND16 hwnd, const PAINTSTRUCT16* lps )
 241 {
 242     PAINTSTRUCT ps;
 243
 244     ps.hdc = lps->hdc;
 245     return EndPaint( WIN_Handle32(hwnd), &ps );
 246 }
 247
 248
 249 /**************************************************************************
 250  *              ShowWindow   (USER.42)
 251  */
 252 BOOL16 WINAPI ShowWindow16( HWND16 hwnd, INT16 cmd )
 253 {
 254     return ShowWindow( WIN_Handle32(hwnd), cmd );
 255 }
 256
 257
 258 /**************************************************************************
 259  *              CloseWindow   (USER.43)
 260  */
 261 BOOL16 WINAPI CloseWindow16( HWND16 hwnd )
 262 {
 263     return CloseWindow( WIN_Handle32(hwnd) );
 264 }
 265
 266
 267 /**************************************************************************
 268  *              OpenIcon   (USER.44)
 269  */
 270 BOOL16 WINAPI OpenIcon16( HWND16 hwnd )
 271 {
 272     return OpenIcon( WIN_Handle32(hwnd) );
 273 }
 274
 275
 276 /**************************************************************************
 277  *              BringWindowToTop   (USER.45)
 278  */
 279 BOOL16 WINAPI BringWindowToTop16( HWND16 hwnd )
 280 {
 281     return BringWindowToTop( WIN_Handle32(hwnd) );
 282 }
 283
 284
 285 /**************************************************************************
 286  *              GetParent   (USER.46)
 287  */
 288 HWND16 WINAPI GetParent16( HWND16 hwnd )
 289 {
 290     return WIN_Handle16( GetParent( WIN_Handle32(hwnd) ));
 291 }
 292
 293
 294 /**************************************************************************
 295  *              IsWindow   (USER.47)
 296  */
 297 BOOL16 WINAPI IsWindow16( HWND16 hwnd )
 298 {
 299     CURRENT_STACK16->es = USER_HeapSel;
 300     /* don't use WIN_Handle32 here, we don't care about the full handle */
 301     return IsWindow( (HWND)(ULONG_PTR)hwnd );
 302 }
 303
 304
 305 /**************************************************************************
 306  *              IsChild   (USER.48)
 307  */
 308 BOOL16 WINAPI IsChild16( HWND16 parent, HWND16 child )
 309 {
 310     return IsChild( WIN_Handle32(parent), WIN_Handle32(child) );
 311 }
 312
 313
 314 /**************************************************************************
 315  *              IsWindowVisible   (USER.49)
 316  */
 317 BOOL16 WINAPI IsWindowVisible16( HWND16 hwnd )
 318 {
 319     return IsWindowVisible( WIN_Handle32(hwnd) );
 320 }
 321
 322
 323 /**************************************************************************
 324  *              FindWindow   (USER.50)
 325  */
 326 HWND16 WINAPI FindWindow16( LPCSTR className, LPCSTR title )
 327 {
 328     return WIN_Handle16( FindWindowA( className, title ));
 329 }
 330
 331
 332 /**************************************************************************
 333  *              DestroyWindow   (USER.53)
 334  */
 335 BOOL16 WINAPI DestroyWindow16( HWND16 hwnd )
 336 {
 337     return DestroyWindow( WIN_Handle32(hwnd) );
 338 }
 339
 340
 341 /**************************************************************************
 342  *              MoveWindow   (USER.56)
 343  */
 344 BOOL16 WINAPI MoveWindow16( HWND16 hwnd, INT16 x, INT16 y, INT16 cx, INT16 cy, BOOL16 repaint )
 345 {
 346     return MoveWindow( WIN_Handle32(hwnd), x, y, cx, cy, repaint );
 347 }
 348
 349
 350 /**************************************************************************
 351  *              GetClassName   (USER.58)
 352  */
 353 INT16 WINAPI GetClassName16( HWND16 hwnd, LPSTR buffer, INT16 count )
 354 {
 355     return GetClassNameA( WIN_Handle32(hwnd), buffer, count );
 356 }
 357
 358
 359 /**************************************************************************
 360  *              SetActiveWindow   (USER.59)
 361  */
 362 HWND16 WINAPI SetActiveWindow16( HWND16 hwnd )
 363 {
 364     return WIN_Handle16( SetActiveWindow( WIN_Handle32(hwnd) ));
 365 }
 366
 367
 368 /**************************************************************************
 369  *              GetActiveWindow   (USER.60)
 370  */
 371 HWND16 WINAPI GetActiveWindow16(void)
 372 {
 373     return WIN_Handle16( GetActiveWindow() );
 374 }
 375
 376
 377 /**************************************************************************
 378  *              ScrollWindow   (USER.61)
 379  */
 380 void WINAPI ScrollWindow16( HWND16 hwnd, INT16 dx, INT16 dy, const RECT16 *rect,
 381                             const RECT16 *clipRect )
 382 {
 383     RECT rect32, clipRect32;
 384
 385     if (rect) CONV_RECT16TO32( rect, &rect32 );
 386     if (clipRect) CONV_RECT16TO32( clipRect, &clipRect32 );
 387     ScrollWindow( WIN_Handle32(hwnd), dx, dy, rect ? &rect32 : NULL,
 388                   clipRect ? &clipRect32 : NULL );
 389 }
 390
 391
 392 /**************************************************************************
 393  *              SetScrollPos   (USER.62)
 394  */
 395 INT16 WINAPI SetScrollPos16( HWND16 hwnd, INT16 nBar, INT16 nPos, BOOL16 redraw )
 396 {
 397     return SetScrollPos( WIN_Handle32(hwnd), nBar, nPos, redraw );
 398 }
 399
 400
 401 /**************************************************************************
 402  *              GetScrollPos   (USER.63)
 403  */
 404 INT16 WINAPI GetScrollPos16( HWND16 hwnd, INT16 nBar )
 405 {
 406     return GetScrollPos( WIN_Handle32(hwnd), nBar );
 407 }
 408
 409
 410 /**************************************************************************
 411  *              SetScrollRange   (USER.64)
 412  */
 413 void WINAPI SetScrollRange16( HWND16 hwnd, INT16 nBar, INT16 MinVal, INT16 MaxVal, BOOL16 redraw )
 414 {
 415     /* Invalid range -> range is set to (0,0) */
 416     if ((INT)MaxVal - (INT)MinVal > 0x7fff) MinVal = MaxVal = 0;
 417     SetScrollRange( WIN_Handle32(hwnd), nBar, MinVal, MaxVal, redraw );
 418 }
 419
 420
 421 /**************************************************************************
 422  *              GetScrollRange   (USER.65)
 423  */
 424 BOOL16 WINAPI GetScrollRange16( HWND16 hwnd, INT16 nBar, LPINT16 lpMin, LPINT16 lpMax)
 425 {
 426     INT min, max;
 427     BOOL ret = GetScrollRange( WIN_Handle32(hwnd), nBar, &min, &max );
 428     if (lpMin) *lpMin = min;
 429     if (lpMax) *lpMax = max;
 430     return ret;
 431 }
 432
 433
 434 /**************************************************************************
 435  *              GetDC   (USER.66)
 436  */
 437 HDC16 WINAPI GetDC16( HWND16 hwnd )
 438 {
 439     return (HDC16)GetDC( WIN_Handle32(hwnd) );
 440 }
 441
 442
 443 /**************************************************************************
 444  *              GetWindowDC   (USER.67)
 445  */
 446 HDC16 WINAPI GetWindowDC16( HWND16 hwnd )
 447 {
 448     return GetDCEx16( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 449 }
 450
 451
 452 /**************************************************************************
 453  *              ReleaseDC   (USER.68)
 454  */
 455 INT16 WINAPI ReleaseDC16( HWND16 hwnd, HDC16 hdc )
 456 {
 457     return (INT16)ReleaseDC( WIN_Handle32(hwnd), hdc );
 458 }
 459
 460
 461 /**************************************************************************
 462  *              EndDialog   (USER.88)
 463  */
 464 BOOL16 WINAPI EndDialog16( HWND16 hwnd, INT16 retval )
 465 {
 466     return EndDialog( WIN_Handle32(hwnd), retval );
 467 }
 468
 469
 470 /**************************************************************************
 471  *              GetDlgItem   (USER.91)
 472  */
 473 HWND16 WINAPI GetDlgItem16( HWND16 hwndDlg, INT16 id )
 474 {
 475     return WIN_Handle16( GetDlgItem( WIN_Handle32(hwndDlg), (UINT16) id ));
 476 }
 477
 478
 479 /**************************************************************************
 480  *              SetDlgItemText   (USER.92)
 481  */
 482 void WINAPI SetDlgItemText16( HWND16 hwnd, INT16 id, SEGPTR lpString )
 483 {
 484     SendDlgItemMessage16( hwnd, id, WM_SETTEXT, 0, (LPARAM)lpString );
 485 }
 486
 487
 488 /**************************************************************************
 489  *              GetDlgItemText   (USER.93)
 490  */
 491 INT16 WINAPI GetDlgItemText16( HWND16 hwnd, INT16 id, SEGPTR str, UINT16 len )
 492 {
 493     return (INT16)SendDlgItemMessage16( hwnd, id, WM_GETTEXT, len, (LPARAM)str );
 494 }
 495
 496
 497 /**************************************************************************
 498  *              SetDlgItemInt   (USER.94)
 499  */
 500 void WINAPI SetDlgItemInt16( HWND16 hwnd, INT16 id, UINT16 value, BOOL16 fSigned )
 501 {
 502     SetDlgItemInt( WIN_Handle32(hwnd), (UINT)(UINT16)id,
 503              (UINT)(fSigned ? (INT16) value : (UINT16) value), fSigned );
 504 }
 505
 506
 507 /**************************************************************************
 508  *              GetDlgItemInt   (USER.95)
 509  */
 510 UINT16 WINAPI GetDlgItemInt16( HWND16 hwnd, INT16 id, BOOL16 *translated, BOOL16 fSigned )
 511 {
 512     UINT result;
 513     BOOL ok;
 514
 515     if (translated) *translated = FALSE;
 516     result = GetDlgItemInt( WIN_Handle32(hwnd), (UINT)(UINT16)id, &ok, fSigned );
 517     if (!ok) return 0;
 518     if (fSigned)
 519     {
 520         if (((INT)result < -32767) || ((INT)result > 32767)) return 0;
 521     }
 522     else
 523     {
 524         if (result > 65535) return 0;
 525     }
 526     if (translated) *translated = TRUE;
 527     return (UINT16)result;
 528 }
 529
 530
 531 /**************************************************************************
 532  *              CheckRadioButton   (USER.96)
 533  */
 534 BOOL16 WINAPI CheckRadioButton16( HWND16 hwndDlg, UINT16 firstID,
 535                                   UINT16 lastID, UINT16 checkID )
 536 {
 537     return CheckRadioButton( WIN_Handle32(hwndDlg), firstID, lastID, checkID );
 538 }
 539
 540
 541 /**************************************************************************
 542  *              CheckDlgButton   (USER.97)
 543  */
 544 BOOL16 WINAPI CheckDlgButton16( HWND16 hwnd, INT16 id, UINT16 check )
 545 {
 546     SendDlgItemMessage16( hwnd, id, BM_SETCHECK16, check, 0 );
 547     return TRUE;
 548 }
 549
 550
 551 /**************************************************************************
 552  *              IsDlgButtonChecked   (USER.98)
 553  */
 554 UINT16 WINAPI IsDlgButtonChecked16( HWND16 hwnd, UINT16 id )
 555 {
 556     return (UINT16)SendDlgItemMessage16( hwnd, id, BM_GETCHECK16, 0, 0 );
 557 }
 558
 559
 560 /**************************************************************************
 561  *              DlgDirSelect   (USER.99)
 562  */
 563 BOOL16 WINAPI DlgDirSelect16( HWND16 hwnd, LPSTR str, INT16 id )
 564 {
 565     return DlgDirSelectEx16( hwnd, str, 128, id );
 566 }
 567
 568
 569 /**************************************************************************
 570  *              DlgDirList   (USER.100)
 571  */
 572 INT16 WINAPI DlgDirList16( HWND16 hDlg, LPSTR spec, INT16 idLBox,
 573                            INT16 idStatic, UINT16 attrib )
 574 {
 575     /* according to Win16 docs, DDL_DRIVES should make DDL_EXCLUSIVE
 576      * be set automatically (this is different in Win32, and
 577      * DIALOG_DlgDirList sends Win32 messages to the control,
 578      * so do it here) */
 579     if (attrib & DDL_DRIVES) attrib |= DDL_EXCLUSIVE;
 580     return DlgDirListA( WIN_Handle32(hDlg), spec, idLBox, idStatic, attrib );
 581 }
 582
 583
 584 /**************************************************************************
 585  *              SendDlgItemMessage   (USER.101)
 586  */
 587 LRESULT WINAPI SendDlgItemMessage16( HWND16 hwnd, INT16 id, UINT16 msg,
 588                                      WPARAM16 wParam, LPARAM lParam )
 589 {
 590     HWND16 hwndCtrl = GetDlgItem16( hwnd, id );
 591     if (hwndCtrl) return SendMessage16( hwndCtrl, msg, wParam, lParam );
 592     else return 0;
 593 }
 594
 595
 596 /**************************************************************************
 597  *              MapDialogRect   (USER.103)
 598  */
 599 void WINAPI MapDialogRect16( HWND16 hwnd, LPRECT16 rect )
 600 {
 601     RECT rect32;
 602     MapDialogRect( WIN_Handle32(hwnd), &rect32 );
 603     rect->left   = rect32.left;
 604     rect->right  = rect32.right;
 605     rect->top    = rect32.top;
 606     rect->bottom = rect32.bottom;
 607 }
 608
 609
 610 /**************************************************************************
 611  *              FlashWindow   (USER.105)
 612  */
 613 BOOL16 WINAPI FlashWindow16( HWND16 hwnd, BOOL16 bInvert )
 614 {
 615     return FlashWindow( WIN_Handle32(hwnd), bInvert );
 616 }
 617
 618
 619 /**************************************************************************
 620  *              WindowFromDC   (USER.117)
 621  */
 622 HWND16 WINAPI WindowFromDC16( HDC16 hDC )
 623 {
 624     return WIN_Handle16( WindowFromDC( hDC ) );
 625 }
 626
 627
 628 /**************************************************************************
 629  *              UpdateWindow   (USER.124)
 630  */
 631 void WINAPI UpdateWindow16( HWND16 hwnd )
 632 {
 633     RedrawWindow16( hwnd, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN );
 634 }
 635
 636
 637 /**************************************************************************
 638  *              InvalidateRect   (USER.125)
 639  */
 640 void WINAPI InvalidateRect16( HWND16 hwnd, const RECT16 *rect, BOOL16 erase )
 641 {
 642     RedrawWindow16( hwnd, rect, 0, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
 643 }
 644
 645
 646 /**************************************************************************
 647  *              InvalidateRgn   (USER.126)
 648  */
 649 void WINAPI InvalidateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
 650 {
 651     RedrawWindow16( hwnd, NULL, hrgn, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
 652 }
 653
 654
 655 /**************************************************************************
 656  *              ValidateRect   (USER.127)
 657  */
 658 void WINAPI ValidateRect16( HWND16 hwnd, const RECT16 *rect )
 659 {
 660     RedrawWindow16( hwnd, rect, 0, RDW_VALIDATE | RDW_NOCHILDREN );
 661 }
 662
 663
 664 /**************************************************************************
 665  *              ValidateRgn   (USER.128)
 666  */
 667 void WINAPI ValidateRgn16( HWND16 hwnd, HRGN16 hrgn )
 668 {
 669     RedrawWindow16( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOCHILDREN );
 670 }
 671
 672
 673 /**************************************************************************
 674  *              GetClassWord   (USER.129)
 675  */
 676 WORD WINAPI GetClassWord16( HWND16 hwnd, INT16 offset )
 677 {
 678     return GetClassWord( WIN_Handle32(hwnd), offset );
 679 }
 680
 681
 682 /**************************************************************************
 683  *              SetClassWord   (USER.130)
 684  */
 685 WORD WINAPI SetClassWord16( HWND16 hwnd, INT16 offset, WORD newval )
 686 {
 687     return SetClassWord( WIN_Handle32(hwnd), offset, newval );
 688 }
 689
 690
 691 /**************************************************************************
 692  *              GetWindowWord   (USER.133)
 693  */
 694 WORD WINAPI GetWindowWord16( HWND16 hwnd, INT16 offset )
 695 {
 696     return GetWindowWord( WIN_Handle32(hwnd), offset );
 697 }
 698
 699
 700 /**************************************************************************
 701  *              SetWindowWord   (USER.134)
 702  */
 703 WORD WINAPI SetWindowWord16( HWND16 hwnd, INT16 offset, WORD newval )
 704 {
 705     return SetWindowWord( WIN_Handle32(hwnd), offset, newval );
 706 }
 707
 708
 709 /**************************************************************************
 710  *              OpenClipboard   (USER.137)
 711  */
 712 BOOL16 WINAPI OpenClipboard16( HWND16 hwnd )
 713 {
 714     return OpenClipboard( WIN_Handle32(hwnd) );
 715 }
 716
 717
 718 /**************************************************************************
 719  *              GetClipboardOwner   (USER.140)
 720  */
 721 HWND16 WINAPI GetClipboardOwner16(void)
 722 {
 723     return WIN_Handle16( GetClipboardOwner() );
 724 }
 725
 726
 727 /**************************************************************************
 728  *              SetClipboardViewer   (USER.147)
 729  */
 730 HWND16 WINAPI SetClipboardViewer16( HWND16 hwnd )
 731 {
 732     return WIN_Handle16( SetClipboardViewer( WIN_Handle32(hwnd) ));
 733 }
 734
 735
 736 /**************************************************************************
 737  *              GetClipboardViewer   (USER.148)
 738  */
 739 HWND16 WINAPI GetClipboardViewer16(void)
 740 {
 741     return WIN_Handle16( GetClipboardViewer() );
 742 }
 743
 744
 745 /**************************************************************************
 746  *              ChangeClipboardChain   (USER.149)
 747  */
 748 BOOL16 WINAPI ChangeClipboardChain16(HWND16 hwnd, HWND16 hwndNext)
 749 {
 750     return ChangeClipboardChain( WIN_Handle32(hwnd), WIN_Handle32(hwndNext) );
 751 }
 752
 753
 754 /**************************************************************************
 755  *              GetSystemMenu   (USER.156)
 756  */
 757 HMENU16 WINAPI GetSystemMenu16( HWND16 hwnd, BOOL16 revert )
 758 {
 759     return GetSystemMenu( WIN_Handle32(hwnd), revert );
 760 }
 761
 762
 763 /**************************************************************************
 764  *              GetMenu   (USER.157)
 765  */
 766 HMENU16 WINAPI GetMenu16( HWND16 hwnd )
 767 {
 768     return GetMenu( WIN_Handle32(hwnd) );
 769 }
 770
 771
 772 /**************************************************************************
 773  *              SetMenu   (USER.158)
 774  */
 775 BOOL16 WINAPI SetMenu16( HWND16 hwnd, HMENU16 hMenu )
 776 {
 777     return SetMenu( WIN_Handle32(hwnd), hMenu );
 778 }
 779
 780
 781 /**************************************************************************
 782  *              DrawMenuBar   (USER.160)
 783  */
 784 void WINAPI DrawMenuBar16( HWND16 hwnd )
 785 {
 786     DrawMenuBar( WIN_Handle32(hwnd) );
 787 }
 788
 789
 790 /**************************************************************************
 791  *              HiliteMenuItem   (USER.162)
 792  */
 793 BOOL16 WINAPI HiliteMenuItem16( HWND16 hwnd, HMENU16 hMenu, UINT16 id, UINT16 wHilite )
 794 {
 795     return HiliteMenuItem( WIN_Handle32(hwnd), hMenu, id, wHilite );
 796 }
 797
 798
 799 /**************************************************************************
 800  *              CreateCaret   (USER.163)
 801  */
 802 void WINAPI CreateCaret16( HWND16 hwnd, HBITMAP16 bitmap, INT16 width, INT16 height )
 803 {
 804     CreateCaret( WIN_Handle32(hwnd), bitmap, width, height );
 805 }
 806
 807
 808 /**************************************************************************
 809  *              HideCaret   (USER.166)
 810  */
 811 void WINAPI HideCaret16( HWND16 hwnd )
 812 {
 813     HideCaret( WIN_Handle32(hwnd) );
 814 }
 815
 816
 817 /**************************************************************************
 818  *              ShowCaret   (USER.167)
 819  */
 820 void WINAPI ShowCaret16( HWND16 hwnd )
 821 {
 822     ShowCaret( WIN_Handle32(hwnd) );
 823 }
 824
 825
 826 /**************************************************************************
 827  *              ArrangeIconicWindows   (USER.170)
 828  */
 829 UINT16 WINAPI ArrangeIconicWindows16( HWND16 parent)
 830 {
 831     return ArrangeIconicWindows( WIN_Handle32(parent) );
 832 }
 833
 834
 835 /**************************************************************************
 836  *              SwitchToThisWindow   (USER.172)
 837  */
 838 void WINAPI SwitchToThisWindow16( HWND16 hwnd, BOOL16 restore )
 839 {
 840     SwitchToThisWindow( WIN_Handle32(hwnd), restore );
 841 }
 842
 843
 844 /**************************************************************************
 845  *              KillSystemTimer   (USER.182)
 846  */
 847 BOOL16 WINAPI KillSystemTimer16( HWND16 hwnd, UINT16 id )
 848 {
 849     return KillSystemTimer( WIN_Handle32(hwnd), id );
 850 }
 851
 852
 853 /**************************************************************************
 854  *              SetSysModalWindow   (USER.188)
 855  */
 856 HWND16 WINAPI SetSysModalWindow16( HWND16 hwnd )
 857 {
 858     HWND16 old = hwndSysModal;
 859     hwndSysModal = hwnd;
 860     return old;
 861 }
 862
 863
 864 /**************************************************************************
 865  *              GetSysModalWindow   (USER.189)
 866  */
 867 HWND16 WINAPI GetSysModalWindow16(void)
 868 {
 869     return hwndSysModal;
 870 }
 871
 872
 873 /**************************************************************************
 874  *              GetUpdateRect   (USER.190)
 875  */
 876 BOOL16 WINAPI GetUpdateRect16( HWND16 hwnd, LPRECT16 rect, BOOL16 erase )
 877 {
 878     RECT r;
 879     BOOL16 ret;
 880
 881     if (!rect) return GetUpdateRect( WIN_Handle32(hwnd), NULL, erase );
 882     ret = GetUpdateRect( WIN_Handle32(hwnd), &r, erase );
 883     CONV_RECT32TO16( &r, rect );
 884     return ret;
 885 }
 886
 887
 888 /**************************************************************************
 889  *              ChildWindowFromPoint   (USER.191)
 890  */
 891 HWND16 WINAPI ChildWindowFromPoint16( HWND16 hwndParent, POINT16 pt )
 892 {
 893     POINT pt32;
 894     CONV_POINT16TO32( &pt, &pt32 );
 895     return WIN_Handle16( ChildWindowFromPoint( WIN_Handle32(hwndParent), pt32 ));
 896 }
 897
 898
 899 /**************************************************************************
 900  *              DlgDirSelectComboBox   (USER.194)
 901  */
 902 BOOL16 WINAPI DlgDirSelectComboBox16( HWND16 hwnd, LPSTR str, INT16 id )
 903 {
 904     return DlgDirSelectComboBoxEx16( hwnd, str, 128, id );
 905 }
 906
 907
 908 /**************************************************************************
 909  *              DlgDirListComboBox   (USER.195)
 910  */
 911 INT16 WINAPI DlgDirListComboBox16( HWND16 hDlg, LPSTR spec, INT16 idCBox,
 912                                    INT16 idStatic, UINT16 attrib )
 913 {
 914     return DlgDirListComboBoxA( WIN_Handle32(hDlg), spec, idCBox, idStatic, attrib );
 915 }
 916
 917
 918 /**************************************************************************
 919  *              GetNextDlgGroupItem   (USER.227)
 920  */
 921 HWND16 WINAPI GetNextDlgGroupItem16( HWND16 hwndDlg, HWND16 hwndCtrl,
 922                                      BOOL16 fPrevious )
 923 {
 924     return WIN_Handle16( GetNextDlgGroupItem( WIN_Handle32(hwndDlg),
 925                                               WIN_Handle32(hwndCtrl), fPrevious ));
 926 }
 927
 928
 929 /**************************************************************************
 930  *              GetNextDlgTabItem   (USER.228)
 931  */
 932 HWND16 WINAPI GetNextDlgTabItem16( HWND16 hwndDlg, HWND16 hwndCtrl,
 933                                    BOOL16 fPrevious )
 934 {
 935     return WIN_Handle16( GetNextDlgTabItem( WIN_Handle32(hwndDlg),
 936                                             WIN_Handle32(hwndCtrl), fPrevious ));
 937 }
 938
 939
 940 /**************************************************************************
 941  *              GetTopWindow   (USER.229)
 942  */
 943 HWND16 WINAPI GetTopWindow16( HWND16 hwnd )
 944 {
 945     return WIN_Handle16( GetTopWindow( WIN_Handle32(hwnd) ));
 946 }
 947
 948
 949 /**************************************************************************
 950  *              GetNextWindow   (USER.230)
 951  */
 952 HWND16 WINAPI GetNextWindow16( HWND16 hwnd, WORD flag )
 953 {
 954     if ((flag != GW_HWNDNEXT) && (flag != GW_HWNDPREV)) return 0;
 955     return GetWindow16( hwnd, flag );
 956 }
 957
 958
 959 /**************************************************************************
 960  *              SetWindowPos   (USER.232)
 961  */
 962 BOOL16 WINAPI SetWindowPos16( HWND16 hwnd, HWND16 hwndInsertAfter,
 963                               INT16 x, INT16 y, INT16 cx, INT16 cy, WORD flags)
 964 {
 965     return SetWindowPos( WIN_Handle32(hwnd), full_insert_after_hwnd(hwndInsertAfter),
 966                          x, y, cx, cy, flags );
 967 }
 968
 969
 970 /**************************************************************************
 971  *              SetParent   (USER.233)
 972  */
 973 HWND16 WINAPI SetParent16( HWND16 hwndChild, HWND16 hwndNewParent )
 974 {
 975     return WIN_Handle16( SetParent( WIN_Handle32(hwndChild), WIN_Handle32(hwndNewParent) ));
 976 }
 977
 978
 979 /**************************************************************************
 980  *              GetCapture   (USER.236)
 981  */
 982 HWND16 WINAPI GetCapture16(void)
 983 {
 984     return WIN_Handle16( GetCapture() );
 985 }
 986
 987
 988 /**************************************************************************
 989  *              GetUpdateRgn   (USER.237)
 990  */
 991 INT16 WINAPI GetUpdateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
 992 {
 993     return GetUpdateRgn( WIN_Handle32(hwnd), hrgn, erase );
 994 }
 995
 996
 997 /**************************************************************************
 998  *              ExcludeUpdateRgn   (USER.238)
 999  */
1000 INT16 WINAPI ExcludeUpdateRgn16( HDC16 hdc, HWND16 hwnd )
1001 {
1002     return ExcludeUpdateRgn( hdc, WIN_Handle32(hwnd) );
1003 }
1004
1005
1006 /**************************************************************************
1007  *              GetOpenClipboardWindow   (USER.248)
1008  */
1009 HWND16 WINAPI GetOpenClipboardWindow16(void)
1010 {
1011     return WIN_Handle16( GetOpenClipboardWindow() );
1012 }
1013
1014
1015 /**************************************************************************
1016  *              BeginDeferWindowPos   (USER.259)
1017  */
1018 HDWP16 WINAPI BeginDeferWindowPos16( INT16 count )
1019 {
1020     return BeginDeferWindowPos( count );
1021 }
1022
1023
1024 /**************************************************************************
1025  *              DeferWindowPos   (USER.260)
1026  */
1027 HDWP16 WINAPI DeferWindowPos16( HDWP16 hdwp, HWND16 hwnd, HWND16 hwndAfter,
1028                                 INT16 x, INT16 y, INT16 cx, INT16 cy,
1029                                 UINT16 flags )
1030 {
1031     return DeferWindowPos( hdwp, WIN_Handle32(hwnd), full_insert_after_hwnd(hwndAfter),
1032                            x, y, cx, cy, flags );
1033 }
1034
1035
1036 /**************************************************************************
1037  *              EndDeferWindowPos   (USER.261)
1038  */
1039 BOOL16 WINAPI EndDeferWindowPos16( HDWP16 hdwp )
1040 {
1041     return EndDeferWindowPos( hdwp );
1042 }
1043
1044
1045 /**************************************************************************
1046  *              GetWindow   (USER.262)
1047  */
1048 HWND16 WINAPI GetWindow16( HWND16 hwnd, WORD rel )
1049 {
1050     return WIN_Handle16( GetWindow( WIN_Handle32(hwnd), rel ) );
1051 }
1052
1053
1054 /**************************************************************************
1055  *              ShowOwnedPopups   (USER.265)
1056  */
1057 void WINAPI ShowOwnedPopups16( HWND16 owner, BOOL16 fShow )
1058 {
1059     ShowOwnedPopups( WIN_Handle32(owner), fShow );
1060 }
1061
1062
1063 /**************************************************************************
1064  *              ShowScrollBar   (USER.267)
1065  */
1066 void WINAPI ShowScrollBar16( HWND16 hwnd, INT16 nBar, BOOL16 fShow )
1067 {
1068     ShowScrollBar( WIN_Handle32(hwnd), nBar, fShow );
1069 }
1070
1071
1072 /**************************************************************************
1073  *              IsZoomed   (USER.272)
1074  */
1075 BOOL16 WINAPI IsZoomed16(HWND16 hwnd)
1076 {
1077     return IsZoomed( WIN_Handle32(hwnd) );
1078 }
1079
1080
1081 /**************************************************************************
1082  *              GetDlgCtrlID   (USER.277)
1083  */
1084 INT16 WINAPI GetDlgCtrlID16( HWND16 hwnd )
1085 {
1086     return GetDlgCtrlID( WIN_Handle32(hwnd) );
1087 }
1088
1089
1090 /**************************************************************************
1091  *              GetDesktopHwnd   (USER.278)
1092  *
1093  * Exactly the same thing as GetDesktopWindow(), but not documented.
1094  * Don't ask me why...
1095  */
1096 HWND16 WINAPI GetDesktopHwnd16(void)
1097 {
1098     return GetDesktopWindow16();
1099 }
1100
1101
1102 /**************************************************************************
1103  *              SetSystemMenu   (USER.280)
1104  */
1105 BOOL16 WINAPI SetSystemMenu16( HWND16 hwnd, HMENU16 hMenu )
1106 {
1107     return SetSystemMenu( WIN_Handle32(hwnd), hMenu );
1108 }
1109
1110
1111 /**************************************************************************
1112  *              GetDesktopWindow   (USER.286)
1113  */
1114 HWND16 WINAPI GetDesktopWindow16(void)
1115 {
1116     return WIN_Handle16( GetDesktopWindow() );
1117 }
1118
1119
1120 /**************************************************************************
1121  *              GetLastActivePopup   (USER.287)
1122  */
1123 HWND16 WINAPI GetLastActivePopup16( HWND16 hwnd )
1124 {
1125     return WIN_Handle16( GetLastActivePopup( WIN_Handle32(hwnd) ));
1126 }
1127
1128
1129 /**************************************************************************
1130  *              RedrawWindow   (USER.290)
1131  */
1132 BOOL16 WINAPI RedrawWindow16( HWND16 hwnd, const RECT16 *rectUpdate,
1133                               HRGN16 hrgnUpdate, UINT16 flags )
1134 {
1135     if (rectUpdate)
1136     {
1137         RECT r;
1138         CONV_RECT16TO32( rectUpdate, &r );
1139         return RedrawWindow( WIN_Handle32(hwnd), &r, hrgnUpdate, flags );
1140     }
1141     return RedrawWindow( WIN_Handle32(hwnd), NULL, hrgnUpdate, flags );
1142 }
1143
1144
1145 /**************************************************************************
1146  *              LockWindowUpdate   (USER.294)
1147  */
1148 BOOL16 WINAPI LockWindowUpdate16( HWND16 hwnd )
1149 {
1150     return LockWindowUpdate( WIN_Handle32(hwnd) );
1151 }
1152
1153
1154 /**************************************************************************
1155  *              ScrollWindowEx   (USER.319)
1156  */
1157 INT16 WINAPI ScrollWindowEx16( HWND16 hwnd, INT16 dx, INT16 dy,
1158                                const RECT16 *rect, const RECT16 *clipRect,
1159                                HRGN16 hrgnUpdate, LPRECT16 rcUpdate,
1160                                UINT16 flags )
1161 {
1162     RECT rect32, clipRect32, rcUpdate32;
1163     BOOL16 ret;
1164
1165     if (rect) CONV_RECT16TO32( rect, &rect32 );
1166     if (clipRect) CONV_RECT16TO32( clipRect, &clipRect32 );
1167     ret = ScrollWindowEx( WIN_Handle32(hwnd), dx, dy, rect ? &rect32 : NULL,
1168                           clipRect ? &clipRect32 : NULL, hrgnUpdate,
1169                           (rcUpdate) ? &rcUpdate32 : NULL, flags );
1170     if (rcUpdate) CONV_RECT32TO16( &rcUpdate32, rcUpdate );
1171     return ret;
1172 }
1173
1174
1175 /**************************************************************************
1176  *              FillWindow   (USER.324)
1177  */
1178 void WINAPI FillWindow16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc, HBRUSH16 hbrush )
1179 {
1180     RECT rect;
1181     RECT16 rc16;
1182     GetClientRect( WIN_Handle32(hwnd), &rect );
1183     DPtoLP( hdc, (LPPOINT)&rect, 2 );
1184     CONV_RECT32TO16( &rect, &rc16 );
1185     PaintRect16( hwndParent, hwnd, hdc, hbrush, &rc16 );
1186 }
1187
1188
1189 /**************************************************************************
1190  *              PaintRect   (USER.325)
1191  */
1192 void WINAPI PaintRect16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc,
1193                          HBRUSH16 hbrush, const RECT16 *rect)
1194 {
1195     if (hbrush <= CTLCOLOR_STATIC)
1196     {
1197         HWND parent = WIN_Handle32(hwndParent), hwnd32 = WIN_Handle32(hwnd);
1198
1199         if (!parent) return;
1200         hbrush = SendMessageW( parent, WM_CTLCOLORMSGBOX + hbrush, (WPARAM)hdc, (LPARAM)hwnd32 );
1201         if (!hbrush) hbrush = DefWindowProcW( parent, WM_CTLCOLORMSGBOX + hbrush,
1202                                               (WPARAM)hdc, (LPARAM)hwnd32 );
1203     }
1204     if (hbrush) FillRect16( hdc, rect, hbrush );
1205 }
1206
1207
1208 /**************************************************************************
1209  *              GetControlBrush   (USER.326)
1210  */
1211 HBRUSH16 WINAPI GetControlBrush16( HWND16 hwnd, HDC16 hdc, UINT16 ctlType )
1212 {
1213     HBRUSH16 ret;
1214     HWND hwnd32 = WIN_Handle32(hwnd);
1215     HWND parent = GetParent( hwnd32 );
1216
1217     if (!parent) parent = hwnd32;
1218     ret = SendMessageW( parent, WM_CTLCOLORMSGBOX + ctlType, (WPARAM)hdc, (LPARAM)hwnd32 );
1219     if (!ret) ret = DefWindowProcW( parent, WM_CTLCOLORMSGBOX + ctlType,
1220                                     (WPARAM)hdc, (LPARAM)hwnd32 );
1221     return ret;
1222 }
1223
1224
1225 /**************************************************************************
1226  *              GetDCEx   (USER.359)
1227  */
1228 HDC16 WINAPI GetDCEx16( HWND16 hwnd, HRGN16 hrgnClip, DWORD flags )
1229 {
1230     return (HDC16)GetDCEx( WIN_Handle32(hwnd), hrgnClip, flags );
1231 }
1232
1233
1234 /**************************************************************************
1235  *              GetWindowPlacement   (USER.370)
1236  */
1237 BOOL16 WINAPI GetWindowPlacement16( HWND16 hwnd, WINDOWPLACEMENT16 *wp16 )
1238 {
1239     WINDOWPLACEMENT wpl;
1240
1241     wpl.length = sizeof(wpl);
1242     if (!GetWindowPlacement( WIN_Handle32(hwnd), &wpl )) return FALSE;
1243     wp16->length  = sizeof(*wp16);
1244     wp16->flags   = wpl.flags;
1245     wp16->showCmd = wpl.showCmd;
1246     CONV_POINT32TO16( &wpl.ptMinPosition, &wp16->ptMinPosition );
1247     CONV_POINT32TO16( &wpl.ptMaxPosition, &wp16->ptMaxPosition );
1248     CONV_RECT32TO16( &wpl.rcNormalPosition, &wp16->rcNormalPosition );
1249     return TRUE;
1250 }
1251
1252
1253 /**************************************************************************
1254  *              SetWindowPlacement   (USER.371)
1255  */
1256 BOOL16 WINAPI SetWindowPlacement16( HWND16 hwnd, const WINDOWPLACEMENT16 *wp16 )
1257 {
1258     WINDOWPLACEMENT wpl;
1259
1260     if (!wp16) return FALSE;
1261     wpl.length  = sizeof(wpl);
1262     wpl.flags   = wp16->flags;
1263     wpl.showCmd = wp16->showCmd;
1264     wpl.ptMinPosition.x = wp16->ptMinPosition.x;
1265     wpl.ptMinPosition.y = wp16->ptMinPosition.y;
1266     wpl.ptMaxPosition.x = wp16->ptMaxPosition.x;
1267     wpl.ptMaxPosition.y = wp16->ptMaxPosition.y;
1268     wpl.rcNormalPosition.left   = wp16->rcNormalPosition.left;
1269     wpl.rcNormalPosition.top    = wp16->rcNormalPosition.top;
1270     wpl.rcNormalPosition.right  = wp16->rcNormalPosition.right;
1271     wpl.rcNormalPosition.bottom = wp16->rcNormalPosition.bottom;
1272     return SetWindowPlacement( WIN_Handle32(hwnd), &wpl );
1273 }
1274
1275
1276 /**************************************************************************
1277  *              ChildWindowFromPointEx   (USER.399)
1278  */
1279 HWND16 WINAPI ChildWindowFromPointEx16( HWND16 hwndParent, POINT16 pt, UINT16 uFlags)
1280 {
1281     POINT pt32;
1282     CONV_POINT16TO32( &pt, &pt32 );
1283     return WIN_Handle16( ChildWindowFromPointEx( WIN_Handle32(hwndParent), pt32, uFlags ));
1284 }
1285
1286
1287 /**************************************************************************
1288  *              GetPriorityClipboardFormat   (USER.402)
1289  */
1290 INT16 WINAPI GetPriorityClipboardFormat16( UINT16 *list, INT16 count )
1291 {
1292     int i;
1293
1294     for (i = 0; i < count; i++)
1295         if (IsClipboardFormatAvailable( list[i] )) return list[i];
1296     return -1;
1297 }
1298
1299
1300 /**************************************************************************
1301  *              TrackPopupMenu   (USER.416)
1302  */
1303 BOOL16 WINAPI TrackPopupMenu16( HMENU16 hMenu, UINT16 wFlags, INT16 x, INT16 y,
1304                                 INT16 nReserved, HWND16 hwnd, const RECT16 *lpRect )
1305 {
1306     RECT r;
1307     if (lpRect) CONV_RECT16TO32( lpRect, &r );
1308     return TrackPopupMenu( hMenu, wFlags, x, y, nReserved,
1309                            WIN_Handle32(hwnd), lpRect ? &r : NULL );
1310 }
1311
1312
1313 /**************************************************************************
1314  *              DlgDirSelectEx   (USER.422)
1315  */
1316 BOOL16 WINAPI DlgDirSelectEx16( HWND16 hwnd, LPSTR str, INT16 len, INT16 id )
1317 {
1318     return DlgDirSelectExA( WIN_Handle32(hwnd), str, len, id );
1319 }
1320
1321
1322 /**************************************************************************
1323  *              DlgDirSelectComboBoxEx   (USER.423)
1324  */
1325 BOOL16 WINAPI DlgDirSelectComboBoxEx16( HWND16 hwnd, LPSTR str, INT16 len,
1326                                         INT16 id )
1327 {
1328     return DlgDirSelectComboBoxExA( WIN_Handle32(hwnd), str, len, id );
1329 }
1330
1331
1332 /**************************************************************************
1333  *              FindWindowEx   (USER.427)
1334  */
1335 HWND16 WINAPI FindWindowEx16( HWND16 parent, HWND16 child, LPCSTR className, LPCSTR title )
1336 {
1337     return WIN_Handle16( FindWindowExA( WIN_Handle32(parent), WIN_Handle32(child),
1338                                         className, title ));
1339 }
1340
1341
1342 /**************************************************************************
1343  *              DrawAnimatedRects   (USER.448)
1344  */
1345 BOOL16 WINAPI DrawAnimatedRects16( HWND16 hwnd, INT16 idAni,
1346                                    const RECT16* lprcFrom, const RECT16* lprcTo )
1347 {
1348     RECT rcFrom32, rcTo32;
1349     rcFrom32.left   = lprcFrom->left;
1350     rcFrom32.top    = lprcFrom->top;
1351     rcFrom32.right  = lprcFrom->right;
1352     rcFrom32.bottom = lprcFrom->bottom;
1353     rcTo32.left     = lprcTo->left;
1354     rcTo32.top      = lprcTo->top;
1355     rcTo32.right    = lprcTo->right;
1356     rcTo32.bottom   = lprcTo->bottom;
1357     return DrawAnimatedRects( WIN_Handle32(hwnd), idAni, &rcFrom32, &rcTo32 );
1358 }
1359
1360
1361 /**************************************************************************
1362  *              SetInternalWindowPos   (USER.461)
1363  */
1364 void WINAPI SetInternalWindowPos16( HWND16 hwnd, UINT16 showCmd, LPRECT16 rect, LPPOINT16 pt )
1365 {
1366     RECT rc32;
1367     POINT pt32;
1368
1369     if (rect)
1370     {
1371         rc32.left   = rect->left;
1372         rc32.top    = rect->top;
1373         rc32.right  = rect->right;
1374         rc32.bottom = rect->bottom;
1375     }
1376     if (pt)
1377     {
1378         pt32.x = pt->x;
1379         pt32.y = pt->y;
1380     }
1381     SetInternalWindowPos( WIN_Handle32(hwnd), showCmd,
1382                           rect ? &rc32 : NULL, pt ? &pt32 : NULL );
1383 }
1384
1385
1386 /**************************************************************************
1387  *              CalcChildScroll   (USER.462)
1388  */
1389 void WINAPI CalcChildScroll16( HWND16 hwnd, WORD scroll )
1390 {
1391     return CalcChildScroll( WIN_Handle32(hwnd), scroll );
1392 }
1393
1394
1395 /**************************************************************************
1396  *              ScrollChildren   (USER.463)
1397  */
1398 void WINAPI ScrollChildren16(HWND16 hwnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam)
1399 {
1400     ScrollChildren( WIN_Handle32(hwnd), uMsg, wParam, lParam );
1401 }
1402
1403
1404 /**************************************************************************
1405  *              DragDetect   (USER.465)
1406  */
1407 BOOL16 WINAPI DragDetect16( HWND16 hwnd, POINT16 pt )
1408 {
1409     POINT pt32;
1410     CONV_POINT16TO32( &pt, &pt32 );
1411     return DragDetect( WIN_Handle32(hwnd), pt32 );
1412 }
1413
1414
1415 /**************************************************************************
1416  *              SetScrollInfo   (USER.475)
1417  */
1418 INT16 WINAPI SetScrollInfo16( HWND16 hwnd, INT16 nBar, const SCROLLINFO *info, BOOL16 redraw )
1419 {
1420     return SetScrollInfo( WIN_Handle32(hwnd), nBar, info, redraw );
1421 }
1422
1423
1424 /**************************************************************************
1425  *              GetScrollInfo   (USER.476)
1426  */
1427 BOOL16 WINAPI GetScrollInfo16( HWND16 hwnd, INT16 nBar, LPSCROLLINFO info )
1428 {
1429     return GetScrollInfo( WIN_Handle32(hwnd), nBar, info );
1430 }
1431
1432
1433 /**************************************************************************
1434  *              EnableScrollBar   (USER.482)
1435  */
1436 BOOL16 WINAPI EnableScrollBar16( HWND16 hwnd, INT16 nBar, UINT16 flags )
1437 {
1438     return EnableScrollBar( WIN_Handle32(hwnd), nBar, flags );
1439 }
1440
1441
1442 /**************************************************************************
1443  *              GetShellWindow   (USER.600)
1444  */
1445 HWND16 WINAPI GetShellWindow16(void)
1446 {
1447     return WIN_Handle16( GetShellWindow() );
1448 }
1449
1450
1451 /**************************************************************************
1452  *              GetForegroundWindow   (USER.608)
1453  */
1454 HWND16 WINAPI GetForegroundWindow16(void)
1455 {
1456     return WIN_Handle16( GetForegroundWindow() );
1457 }
1458
1459
1460 /**************************************************************************
1461  *              SetForegroundWindow   (USER.609)
1462  */
1463 BOOL16 WINAPI SetForegroundWindow16( HWND16 hwnd )
1464 {
1465     return SetForegroundWindow( WIN_Handle32(hwnd) );
1466 }
1467
1468
1469 /**************************************************************************
1470  *              DrawCaptionTemp   (USER.657)
1471  */
1472 BOOL16 WINAPI DrawCaptionTemp16( HWND16 hwnd, HDC16 hdc, const RECT16 *rect,
1473                                  HFONT16 hFont, HICON16 hIcon, LPCSTR str, UINT16 uFlags )
1474 {
1475     RECT rect32;
1476
1477     if (rect) CONV_RECT16TO32(rect,&rect32);
1478
1479     return DrawCaptionTempA( WIN_Handle32(hwnd), hdc, rect ? &rect32 : NULL,
1480                              hFont, hIcon, str, uFlags & 0x1f );
1481 }
1482
1483
1484 /**************************************************************************
1485  *              DrawCaption   (USER.660)
1486  */
1487 BOOL16 WINAPI DrawCaption16( HWND16 hwnd, HDC16 hdc, const RECT16 *rect, UINT16 flags )
1488 {
1489     RECT rect32;
1490
1491     if (rect) CONV_RECT16TO32( rect, &rect32 );
1492
1493     return DrawCaption( WIN_Handle32(hwnd), hdc, rect ? &rect32 : NULL, flags );
1494 }
1495
1496
1497 /**************************************************************************
1498  *              GetMenuItemRect   (USER.665)
1499  */
1500 BOOL16 WINAPI GetMenuItemRect16( HWND16 hwnd, HMENU16 hMenu, UINT16 uItem,
1501                                  LPRECT16 rect)
1502 {
1503      RECT r32;
1504      BOOL res;
1505      if (!rect) return FALSE;
1506      res = GetMenuItemRect( WIN_Handle32(hwnd), hMenu, uItem, &r32 );
1507      CONV_RECT32TO16( &r32, rect );
1508      return res;
1509 }
1510
1511
1512 /**************************************************************************
1513  *              SetWindowRgn   (USER.668)
1514  */
1515 INT16 WINAPI SetWindowRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 redraw )
1516 {
1517     return SetWindowRgn( WIN_Handle32(hwnd), hrgn, redraw );
1518 }
1519
1520
1521 /**************************************************************************
1522  *              MessageBoxIndirect   (USER.827)
1523  */
1524 INT16 WINAPI MessageBoxIndirect16( LPMSGBOXPARAMS16 msgbox )
1525 {
1526     MSGBOXPARAMSA msgbox32;
1527
1528     msgbox32.cbSize             = msgbox->cbSize;
1529     msgbox32.hwndOwner          = WIN_Handle32( msgbox->hwndOwner );
1530     msgbox32.hInstance          = msgbox->hInstance;
1531     msgbox32.lpszText           = MapSL(msgbox->lpszText);
1532     msgbox32.lpszCaption        = MapSL(msgbox->lpszCaption);
1533     msgbox32.dwStyle            = msgbox->dwStyle;
1534     msgbox32.lpszIcon           = MapSL(msgbox->lpszIcon);
1535     msgbox32.dwContextHelpId    = msgbox->dwContextHelpId;
1536     msgbox32.lpfnMsgBoxCallback = msgbox->lpfnMsgBoxCallback;
1537     msgbox32.dwLanguageId       = msgbox->dwLanguageId;
1538     return MessageBoxIndirectA( &msgbox32 );
1539 }