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