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