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