dlls/user/wnd16.c

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