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