dlls/user32/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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "wine/winuser16.h"
  22 #include "wownt32.h"
  23 #include "win.h"
  24 #include "controls.h"
  25 #include "user_private.h"
  26 #include "wine/list.h"
  27 #include "wine/server.h"
  28
  29 /* size of buffer needed to store an atom string */
  30 #define ATOM_BUFFER_SIZE 256
  31
  32 /* handle <--> handle16 conversions */
  33 #define HANDLE_16(h32)          (LOWORD(h32))
  34 #define HANDLE_32(h16)          ((HANDLE)(ULONG_PTR)(h16))
  35
  36 static HWND16 hwndSysModal;
  37
  38 struct class_entry
  39 {
  40     struct list entry;
  41     ATOM        atom;
  42     HINSTANCE16 inst;
  43 };
  44
  45 static struct list class_list = LIST_INIT( class_list );
  46
  47 struct wnd_enum_info
  48 {
  49     WNDENUMPROC16 proc;
  50     LPARAM        param;
  51 };
  52
  53 /* callback for 16-bit window enumeration functions */
  54 static BOOL CALLBACK wnd_enum_callback( HWND hwnd, LPARAM param )
  55 {
  56     const struct wnd_enum_info *info = (struct wnd_enum_info *)param;
  57     WORD args[3];
  58     DWORD ret;
  59
  60     args[2] = HWND_16(hwnd);
  61     args[1] = HIWORD(info->param);
  62     args[0] = LOWORD(info->param);
  63     WOWCallback16Ex( (DWORD)info->proc, WCB16_PASCAL, sizeof(args), args, &ret );
  64     return LOWORD(ret);
  65 }
  66
  67 /* convert insert after window handle to 32-bit */
  68 static inline HWND full_insert_after_hwnd( HWND16 hwnd )
  69 {
  70     HWND ret = WIN_Handle32( hwnd );
  71     if (ret == (HWND)0xffff) ret = HWND_TOPMOST;
  72     return ret;
  73 }
  74
  75 void free_module_classes( HINSTANCE16 inst )
  76 {
  77     struct class_entry *class, *next;
  78
  79     LIST_FOR_EACH_ENTRY_SAFE( class, next, &class_list, struct class_entry, entry )
  80     {
  81         if (class->inst != inst) continue;
  82         list_remove( &class->entry );
  83         UnregisterClassA( (LPCSTR)MAKEINTATOM(class->atom), HINSTANCE_32(class->inst) );
  84         HeapFree( GetProcessHeap(), 0, class );
  85     }
  86 }
  87
  88 /**************************************************************************
  89  *              MessageBox   (USER.1)
  90  */
  91 INT16 WINAPI MessageBox16( HWND16 hwnd, LPCSTR text, LPCSTR title, UINT16 type )
  92 {
  93     return MessageBoxA( WIN_Handle32(hwnd), text, title, type );
  94 }
  95
  96
  97 /***********************************************************************
  98  *              SetTimer (USER.10)
  99  */
 100 UINT16 WINAPI SetTimer16( HWND16 hwnd, UINT16 id, UINT16 timeout, TIMERPROC16 proc )
 101 {
 102     TIMERPROC proc32 = (TIMERPROC)WINPROC_AllocProc16( (WNDPROC16)proc );
 103     return SetTimer( WIN_Handle32(hwnd), id, timeout, proc32 );
 104 }
 105
 106
 107 /***********************************************************************
 108  *              SetSystemTimer (USER.11)
 109  */
 110 UINT16 WINAPI SetSystemTimer16( HWND16 hwnd, UINT16 id, UINT16 timeout, TIMERPROC16 proc )
 111 {
 112     TIMERPROC proc32 = (TIMERPROC)WINPROC_AllocProc16( (WNDPROC16)proc );
 113     return SetSystemTimer( WIN_Handle32(hwnd), id, timeout, proc32 );
 114 }
 115
 116
 117 /**************************************************************************
 118  *              KillTimer   (USER.12)
 119  */
 120 BOOL16 WINAPI KillTimer16( HWND16 hwnd, UINT16 id )
 121 {
 122     return KillTimer( WIN_Handle32(hwnd), id );
 123 }
 124
 125
 126 /**************************************************************************
 127  *              SetCapture   (USER.18)
 128  */
 129 HWND16 WINAPI SetCapture16( HWND16 hwnd )
 130 {
 131     return HWND_16( SetCapture( WIN_Handle32(hwnd) ));
 132 }
 133
 134
 135 /**************************************************************************
 136  *              ReleaseCapture   (USER.19)
 137  */
 138 BOOL16 WINAPI ReleaseCapture16(void)
 139 {
 140     return ReleaseCapture();
 141 }
 142
 143
 144 /**************************************************************************
 145  *              SetFocus   (USER.22)
 146  */
 147 HWND16 WINAPI SetFocus16( HWND16 hwnd )
 148 {
 149     return HWND_16( SetFocus( WIN_Handle32(hwnd) ));
 150 }
 151
 152
 153 /**************************************************************************
 154  *              GetFocus   (USER.23)
 155  */
 156 HWND16 WINAPI GetFocus16(void)
 157 {
 158     return HWND_16( GetFocus() );
 159 }
 160
 161
 162 /**************************************************************************
 163  *              RemoveProp   (USER.24)
 164  */
 165 HANDLE16 WINAPI RemoveProp16( HWND16 hwnd, LPCSTR str )
 166 {
 167     return HANDLE_16(RemovePropA( WIN_Handle32(hwnd), str ));
 168 }
 169
 170
 171 /**************************************************************************
 172  *              GetProp   (USER.25)
 173  */
 174 HANDLE16 WINAPI GetProp16( HWND16 hwnd, LPCSTR str )
 175 {
 176     return HANDLE_16(GetPropA( WIN_Handle32(hwnd), str ));
 177 }
 178
 179
 180 /**************************************************************************
 181  *              SetProp   (USER.26)
 182  */
 183 BOOL16 WINAPI SetProp16( HWND16 hwnd, LPCSTR str, HANDLE16 handle )
 184 {
 185     return SetPropA( WIN_Handle32(hwnd), str, HANDLE_32(handle) );
 186 }
 187
 188
 189 /***********************************************************************
 190  *              EnumProps   (USER.27)
 191  */
 192 INT16 WINAPI EnumProps16( HWND16 hwnd, PROPENUMPROC16 func )
 193 {
 194     int ret = -1, i, count, total = 32;
 195     property_data_t *list;
 196
 197     while (total)
 198     {
 199         if (!(list = HeapAlloc( GetProcessHeap(), 0, total * sizeof(*list) ))) break;
 200         count = 0;
 201         SERVER_START_REQ( get_window_properties )
 202         {
 203             req->window = wine_server_user_handle( HWND_32(hwnd) );
 204             wine_server_set_reply( req, list, total * sizeof(*list) );
 205             if (!wine_server_call( req )) count = reply->total;
 206         }
 207         SERVER_END_REQ;
 208
 209         if (count && count <= total)
 210         {
 211             char string[ATOM_BUFFER_SIZE];
 212             SEGPTR segptr = MapLS( string );
 213             WORD args[4];
 214             DWORD result;
 215
 216             for (i = 0; i < count; i++)
 217             {
 218                 if (list[i].string)  /* it was a string originally */
 219                 {
 220                     if (!GlobalGetAtomNameA( list[i].atom, string, ATOM_BUFFER_SIZE )) continue;
 221                     args[3] = hwnd;
 222                     args[2] = SELECTOROF(segptr);
 223                     args[1] = OFFSETOF(segptr);
 224                     args[0] = LOWORD(list[i].data);
 225                 }
 226                 else
 227                 {
 228                     args[3] = hwnd;
 229                     args[2] = 0;
 230                     args[1] = list[i].atom;
 231                     args[0] = LOWORD(list[i].data);
 232                 }
 233                 WOWCallback16Ex( (DWORD)func, WCB16_PASCAL, sizeof(args), args, &result );
 234                 if (!(ret = LOWORD(result))) break;
 235             }
 236             UnMapLS( segptr );
 237             HeapFree( GetProcessHeap(), 0, list );
 238             break;
 239         }
 240         HeapFree( GetProcessHeap(), 0, list );
 241         total = count;  /* restart with larger buffer */
 242     }
 243     return ret;
 244 }
 245
 246
 247 /**************************************************************************
 248  *              ClientToScreen   (USER.28)
 249  */
 250 void WINAPI ClientToScreen16( HWND16 hwnd, LPPOINT16 lppnt )
 251 {
 252     MapWindowPoints16( hwnd, 0, lppnt, 1 );
 253 }
 254
 255
 256 /**************************************************************************
 257  *              ScreenToClient   (USER.29)
 258  */
 259 void WINAPI ScreenToClient16( HWND16 hwnd, LPPOINT16 lppnt )
 260 {
 261     MapWindowPoints16( 0, hwnd, lppnt, 1 );
 262 }
 263
 264
 265 /**************************************************************************
 266  *              WindowFromPoint   (USER.30)
 267  */
 268 HWND16 WINAPI WindowFromPoint16( POINT16 pt )
 269 {
 270     POINT pt32;
 271
 272     pt32.x = pt.x;
 273     pt32.y = pt.y;
 274     return HWND_16( WindowFromPoint( pt32 ) );
 275 }
 276
 277
 278 /**************************************************************************
 279  *              IsIconic   (USER.31)
 280  */
 281 BOOL16 WINAPI IsIconic16(HWND16 hwnd)
 282 {
 283     return IsIconic( WIN_Handle32(hwnd) );
 284 }
 285
 286
 287 /**************************************************************************
 288  *              GetWindowRect   (USER.32)
 289  */
 290 void WINAPI GetWindowRect16( HWND16 hwnd, LPRECT16 rect )
 291 {
 292     RECT rect32;
 293
 294     GetWindowRect( WIN_Handle32(hwnd), &rect32 );
 295     rect->left   = rect32.left;
 296     rect->top    = rect32.top;
 297     rect->right  = rect32.right;
 298     rect->bottom = rect32.bottom;
 299 }
 300
 301
 302 /**************************************************************************
 303  *              GetClientRect   (USER.33)
 304  */
 305 void WINAPI GetClientRect16( HWND16 hwnd, LPRECT16 rect )
 306 {
 307     RECT rect32;
 308
 309     GetClientRect( WIN_Handle32(hwnd), &rect32 );
 310     rect->left   = rect32.left;
 311     rect->top    = rect32.top;
 312     rect->right  = rect32.right;
 313     rect->bottom = rect32.bottom;
 314 }
 315
 316
 317 /**************************************************************************
 318  *              EnableWindow   (USER.34)
 319  */
 320 BOOL16 WINAPI EnableWindow16( HWND16 hwnd, BOOL16 enable )
 321 {
 322     return EnableWindow( WIN_Handle32(hwnd), enable );
 323 }
 324
 325
 326 /**************************************************************************
 327  *              IsWindowEnabled   (USER.35)
 328  */
 329 BOOL16 WINAPI IsWindowEnabled16(HWND16 hwnd)
 330 {
 331     return IsWindowEnabled( WIN_Handle32(hwnd) );
 332 }
 333
 334
 335 /**************************************************************************
 336  *              GetWindowText   (USER.36)
 337  */
 338 INT16 WINAPI GetWindowText16( HWND16 hwnd, SEGPTR lpString, INT16 nMaxCount )
 339 {
 340     return SendMessage16( hwnd, WM_GETTEXT, nMaxCount, lpString );
 341 }
 342
 343
 344 /**************************************************************************
 345  *              SetWindowText   (USER.37)
 346  */
 347 BOOL16 WINAPI SetWindowText16( HWND16 hwnd, SEGPTR lpString )
 348 {
 349     return SendMessage16( hwnd, WM_SETTEXT, 0, (LPARAM)lpString );
 350 }
 351
 352
 353 /**************************************************************************
 354  *              GetWindowTextLength   (USER.38)
 355  */
 356 INT16 WINAPI GetWindowTextLength16( HWND16 hwnd )
 357 {
 358     return SendMessage16( hwnd, WM_GETTEXTLENGTH, 0, 0 );
 359 }
 360
 361
 362 /***********************************************************************
 363  *              BeginPaint (USER.39)
 364  */
 365 HDC16 WINAPI BeginPaint16( HWND16 hwnd, LPPAINTSTRUCT16 lps )
 366 {
 367     PAINTSTRUCT ps;
 368
 369     BeginPaint( WIN_Handle32(hwnd), &ps );
 370     lps->hdc            = HDC_16(ps.hdc);
 371     lps->fErase         = ps.fErase;
 372     lps->rcPaint.top    = ps.rcPaint.top;
 373     lps->rcPaint.left   = ps.rcPaint.left;
 374     lps->rcPaint.right  = ps.rcPaint.right;
 375     lps->rcPaint.bottom = ps.rcPaint.bottom;
 376     lps->fRestore       = ps.fRestore;
 377     lps->fIncUpdate     = ps.fIncUpdate;
 378     return lps->hdc;
 379 }
 380
 381
 382 /***********************************************************************
 383  *              EndPaint (USER.40)
 384  */
 385 BOOL16 WINAPI EndPaint16( HWND16 hwnd, const PAINTSTRUCT16* lps )
 386 {
 387     PAINTSTRUCT ps;
 388
 389     ps.hdc = HDC_32(lps->hdc);
 390     return EndPaint( WIN_Handle32(hwnd), &ps );
 391 }
 392
 393
 394 /***********************************************************************
 395  *              CreateWindow (USER.41)
 396  */
 397 HWND16 WINAPI CreateWindow16( LPCSTR className, LPCSTR windowName,
 398                               DWORD style, INT16 x, INT16 y, INT16 width,
 399                               INT16 height, HWND16 parent, HMENU16 menu,
 400                               HINSTANCE16 instance, LPVOID data )
 401 {
 402     return CreateWindowEx16( 0, className, windowName, style,
 403                              x, y, width, height, parent, menu, instance, data );
 404 }
 405
 406
 407 /**************************************************************************
 408  *              ShowWindow   (USER.42)
 409  */
 410 BOOL16 WINAPI ShowWindow16( HWND16 hwnd, INT16 cmd )
 411 {
 412     return ShowWindow( WIN_Handle32(hwnd), cmd );
 413 }
 414
 415
 416 /**************************************************************************
 417  *              CloseWindow   (USER.43)
 418  */
 419 BOOL16 WINAPI CloseWindow16( HWND16 hwnd )
 420 {
 421     return CloseWindow( WIN_Handle32(hwnd) );
 422 }
 423
 424
 425 /**************************************************************************
 426  *              OpenIcon   (USER.44)
 427  */
 428 BOOL16 WINAPI OpenIcon16( HWND16 hwnd )
 429 {
 430     return OpenIcon( WIN_Handle32(hwnd) );
 431 }
 432
 433
 434 /**************************************************************************
 435  *              BringWindowToTop   (USER.45)
 436  */
 437 BOOL16 WINAPI BringWindowToTop16( HWND16 hwnd )
 438 {
 439     return BringWindowToTop( WIN_Handle32(hwnd) );
 440 }
 441
 442
 443 /**************************************************************************
 444  *              GetParent   (USER.46)
 445  */
 446 HWND16 WINAPI GetParent16( HWND16 hwnd )
 447 {
 448     return HWND_16( GetParent( WIN_Handle32(hwnd) ));
 449 }
 450
 451
 452 /**************************************************************************
 453  *              IsWindow   (USER.47)
 454  */
 455 BOOL16 WINAPI IsWindow16( HWND16 hwnd )
 456 {
 457     STACK16FRAME *frame = MapSL( (SEGPTR)NtCurrentTeb()->WOW32Reserved );
 458     frame->es = USER_HeapSel;
 459     /* don't use WIN_Handle32 here, we don't care about the full handle */
 460     return IsWindow( HWND_32(hwnd) );
 461 }
 462
 463
 464 /**************************************************************************
 465  *              IsChild   (USER.48)
 466  */
 467 BOOL16 WINAPI IsChild16( HWND16 parent, HWND16 child )
 468 {
 469     return IsChild( WIN_Handle32(parent), WIN_Handle32(child) );
 470 }
 471
 472
 473 /**************************************************************************
 474  *              IsWindowVisible   (USER.49)
 475  */
 476 BOOL16 WINAPI IsWindowVisible16( HWND16 hwnd )
 477 {
 478     return IsWindowVisible( WIN_Handle32(hwnd) );
 479 }
 480
 481
 482 /**************************************************************************
 483  *              FindWindow   (USER.50)
 484  */
 485 HWND16 WINAPI FindWindow16( LPCSTR className, LPCSTR title )
 486 {
 487     return HWND_16( FindWindowA( className, title ));
 488 }
 489
 490
 491 /**************************************************************************
 492  *              DestroyWindow   (USER.53)
 493  */
 494 BOOL16 WINAPI DestroyWindow16( HWND16 hwnd )
 495 {
 496     return DestroyWindow( WIN_Handle32(hwnd) );
 497 }
 498
 499
 500 /*******************************************************************
 501  *           EnumWindows   (USER.54)
 502  */
 503 BOOL16 WINAPI EnumWindows16( WNDENUMPROC16 func, LPARAM lParam )
 504 {
 505     struct wnd_enum_info info;
 506
 507     info.proc  = func;
 508     info.param = lParam;
 509     return EnumWindows( wnd_enum_callback, (LPARAM)&info );
 510 }
 511
 512
 513 /**********************************************************************
 514  *           EnumChildWindows   (USER.55)
 515  */
 516 BOOL16 WINAPI EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func, LPARAM lParam )
 517 {
 518     struct wnd_enum_info info;
 519
 520     info.proc  = func;
 521     info.param = lParam;
 522     return EnumChildWindows( WIN_Handle32(parent), wnd_enum_callback, (LPARAM)&info );
 523 }
 524
 525
 526 /**************************************************************************
 527  *              MoveWindow   (USER.56)
 528  */
 529 BOOL16 WINAPI MoveWindow16( HWND16 hwnd, INT16 x, INT16 y, INT16 cx, INT16 cy, BOOL16 repaint )
 530 {
 531     return MoveWindow( WIN_Handle32(hwnd), x, y, cx, cy, repaint );
 532 }
 533
 534
 535 /***********************************************************************
 536  *              RegisterClass (USER.57)
 537  */
 538 ATOM WINAPI RegisterClass16( const WNDCLASS16 *wc )
 539 {
 540     WNDCLASSEX16 wcex;
 541
 542     wcex.cbSize        = sizeof(wcex);
 543     wcex.style         = wc->style;
 544     wcex.lpfnWndProc   = wc->lpfnWndProc;
 545     wcex.cbClsExtra    = wc->cbClsExtra;
 546     wcex.cbWndExtra    = wc->cbWndExtra;
 547     wcex.hInstance     = wc->hInstance;
 548     wcex.hIcon         = wc->hIcon;
 549     wcex.hCursor       = wc->hCursor;
 550     wcex.hbrBackground = wc->hbrBackground;
 551     wcex.lpszMenuName  = wc->lpszMenuName;
 552     wcex.lpszClassName = wc->lpszClassName;
 553     wcex.hIconSm       = 0;
 554     return RegisterClassEx16( &wcex );
 555 }
 556
 557
 558 /**************************************************************************
 559  *              GetClassName   (USER.58)
 560  */
 561 INT16 WINAPI GetClassName16( HWND16 hwnd, LPSTR buffer, INT16 count )
 562 {
 563     return GetClassNameA( WIN_Handle32(hwnd), buffer, count );
 564 }
 565
 566
 567 /**************************************************************************
 568  *              SetActiveWindow   (USER.59)
 569  */
 570 HWND16 WINAPI SetActiveWindow16( HWND16 hwnd )
 571 {
 572     return HWND_16( SetActiveWindow( WIN_Handle32(hwnd) ));
 573 }
 574
 575
 576 /**************************************************************************
 577  *              GetActiveWindow   (USER.60)
 578  */
 579 HWND16 WINAPI GetActiveWindow16(void)
 580 {
 581     return HWND_16( GetActiveWindow() );
 582 }
 583
 584
 585 /**************************************************************************
 586  *              ScrollWindow   (USER.61)
 587  */
 588 void WINAPI ScrollWindow16( HWND16 hwnd, INT16 dx, INT16 dy, const RECT16 *rect,
 589                             const RECT16 *clipRect )
 590 {
 591     RECT rect32, clipRect32;
 592
 593     if (rect)
 594     {
 595         rect32.left   = rect->left;
 596         rect32.top    = rect->top;
 597         rect32.right  = rect->right;
 598         rect32.bottom = rect->bottom;
 599     }
 600     if (clipRect)
 601     {
 602         clipRect32.left   = clipRect->left;
 603         clipRect32.top    = clipRect->top;
 604         clipRect32.right  = clipRect->right;
 605         clipRect32.bottom = clipRect->bottom;
 606     }
 607     ScrollWindow( WIN_Handle32(hwnd), dx, dy, rect ? &rect32 : NULL,
 608                   clipRect ? &clipRect32 : NULL );
 609 }
 610
 611
 612 /**************************************************************************
 613  *              SetScrollPos   (USER.62)
 614  */
 615 INT16 WINAPI SetScrollPos16( HWND16 hwnd, INT16 nBar, INT16 nPos, BOOL16 redraw )
 616 {
 617     return SetScrollPos( WIN_Handle32(hwnd), nBar, nPos, redraw );
 618 }
 619
 620
 621 /**************************************************************************
 622  *              GetScrollPos   (USER.63)
 623  */
 624 INT16 WINAPI GetScrollPos16( HWND16 hwnd, INT16 nBar )
 625 {
 626     return GetScrollPos( WIN_Handle32(hwnd), nBar );
 627 }
 628
 629
 630 /**************************************************************************
 631  *              SetScrollRange   (USER.64)
 632  */
 633 void WINAPI SetScrollRange16( HWND16 hwnd, INT16 nBar, INT16 MinVal, INT16 MaxVal, BOOL16 redraw )
 634 {
 635     /* Invalid range -> range is set to (0,0) */
 636     if ((INT)MaxVal - (INT)MinVal > 0x7fff) MinVal = MaxVal = 0;
 637     SetScrollRange( WIN_Handle32(hwnd), nBar, MinVal, MaxVal, redraw );
 638 }
 639
 640
 641 /**************************************************************************
 642  *              GetScrollRange   (USER.65)
 643  */
 644 BOOL16 WINAPI GetScrollRange16( HWND16 hwnd, INT16 nBar, LPINT16 lpMin, LPINT16 lpMax)
 645 {
 646     INT min, max;
 647     BOOL ret = GetScrollRange( WIN_Handle32(hwnd), nBar, &min, &max );
 648     if (lpMin) *lpMin = min;
 649     if (lpMax) *lpMax = max;
 650     return ret;
 651 }
 652
 653
 654 /**************************************************************************
 655  *              GetDC   (USER.66)
 656  */
 657 HDC16 WINAPI GetDC16( HWND16 hwnd )
 658 {
 659     return HDC_16(GetDC( WIN_Handle32(hwnd) ));
 660 }
 661
 662
 663 /**************************************************************************
 664  *              GetWindowDC   (USER.67)
 665  */
 666 HDC16 WINAPI GetWindowDC16( HWND16 hwnd )
 667 {
 668     return GetDCEx16( hwnd, 0, DCX_USESTYLE | DCX_WINDOW );
 669 }
 670
 671
 672 /**************************************************************************
 673  *              ReleaseDC   (USER.68)
 674  */
 675 INT16 WINAPI ReleaseDC16( HWND16 hwnd, HDC16 hdc )
 676 {
 677     return (INT16)ReleaseDC( WIN_Handle32(hwnd), HDC_32(hdc) );
 678 }
 679
 680
 681 /**************************************************************************
 682  *              FlashWindow   (USER.105)
 683  */
 684 BOOL16 WINAPI FlashWindow16( HWND16 hwnd, BOOL16 bInvert )
 685 {
 686     return FlashWindow( WIN_Handle32(hwnd), bInvert );
 687 }
 688
 689
 690 /**************************************************************************
 691  *              WindowFromDC   (USER.117)
 692  */
 693 HWND16 WINAPI WindowFromDC16( HDC16 hDC )
 694 {
 695     return HWND_16( WindowFromDC( HDC_32(hDC) ) );
 696 }
 697
 698
 699 /**************************************************************************
 700  *              UpdateWindow   (USER.124)
 701  */
 702 void WINAPI UpdateWindow16( HWND16 hwnd )
 703 {
 704     RedrawWindow16( hwnd, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN );
 705 }
 706
 707
 708 /**************************************************************************
 709  *              InvalidateRect   (USER.125)
 710  */
 711 void WINAPI InvalidateRect16( HWND16 hwnd, const RECT16 *rect, BOOL16 erase )
 712 {
 713     RedrawWindow16( hwnd, rect, 0, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
 714 }
 715
 716
 717 /**************************************************************************
 718  *              InvalidateRgn   (USER.126)
 719  */
 720 void WINAPI InvalidateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
 721 {
 722     RedrawWindow16( hwnd, NULL, hrgn, RDW_INVALIDATE | (erase ? RDW_ERASE : 0) );
 723 }
 724
 725
 726 /**************************************************************************
 727  *              ValidateRect   (USER.127)
 728  */
 729 void WINAPI ValidateRect16( HWND16 hwnd, const RECT16 *rect )
 730 {
 731     RedrawWindow16( hwnd, rect, 0, RDW_VALIDATE | RDW_NOCHILDREN );
 732 }
 733
 734
 735 /**************************************************************************
 736  *              ValidateRgn   (USER.128)
 737  */
 738 void WINAPI ValidateRgn16( HWND16 hwnd, HRGN16 hrgn )
 739 {
 740     RedrawWindow16( hwnd, NULL, hrgn, RDW_VALIDATE | RDW_NOCHILDREN );
 741 }
 742
 743
 744 /**************************************************************************
 745  *              GetClassWord   (USER.129)
 746  */
 747 WORD WINAPI GetClassWord16( HWND16 hwnd, INT16 offset )
 748 {
 749     return GetClassWord( WIN_Handle32(hwnd), offset );
 750 }
 751
 752
 753 /**************************************************************************
 754  *              SetClassWord   (USER.130)
 755  */
 756 WORD WINAPI SetClassWord16( HWND16 hwnd, INT16 offset, WORD newval )
 757 {
 758     return SetClassWord( WIN_Handle32(hwnd), offset, newval );
 759 }
 760
 761
 762 /***********************************************************************
 763  *              GetClassLong (USER.131)
 764  */
 765 LONG WINAPI GetClassLong16( HWND16 hwnd16, INT16 offset )
 766 {
 767     LONG_PTR ret = GetClassLongA( WIN_Handle32(hwnd16), offset );
 768
 769     switch( offset )
 770     {
 771     case GCLP_WNDPROC:
 772         return (LONG_PTR)WINPROC_GetProc16( (WNDPROC)ret, FALSE );
 773     case GCLP_MENUNAME:
 774         return MapLS( (void *)ret );  /* leak */
 775     default:
 776         return ret;
 777     }
 778 }
 779
 780
 781 /***********************************************************************
 782  *              SetClassLong (USER.132)
 783  */
 784 LONG WINAPI SetClassLong16( HWND16 hwnd16, INT16 offset, LONG newval )
 785 {
 786     switch( offset )
 787     {
 788     case GCLP_WNDPROC:
 789         {
 790             WNDPROC new_proc = WINPROC_AllocProc16( (WNDPROC16)newval );
 791             WNDPROC old_proc = (WNDPROC)SetClassLongA( WIN_Handle32(hwnd16), offset, (LONG_PTR)new_proc );
 792             return (LONG)WINPROC_GetProc16( old_proc, FALSE );
 793         }
 794     case GCLP_MENUNAME:
 795         newval = (LONG)MapSL( newval );
 796         /* fall through */
 797     default:
 798         return SetClassLongA( WIN_Handle32(hwnd16), offset, newval );
 799     }
 800 }
 801
 802
 803 /**************************************************************************
 804  *              GetWindowWord   (USER.133)
 805  */
 806 WORD WINAPI GetWindowWord16( HWND16 hwnd, INT16 offset )
 807 {
 808     return GetWindowWord( WIN_Handle32(hwnd), offset );
 809 }
 810
 811
 812 /**************************************************************************
 813  *              SetWindowWord   (USER.134)
 814  */
 815 WORD WINAPI SetWindowWord16( HWND16 hwnd, INT16 offset, WORD newval )
 816 {
 817     return SetWindowWord( WIN_Handle32(hwnd), offset, newval );
 818 }
 819
 820
 821 /**********************************************************************
 822  *              GetWindowLong (USER.135)
 823  */
 824 LONG WINAPI GetWindowLong16( HWND16 hwnd16, INT16 offset )
 825 {
 826     HWND hwnd = WIN_Handle32( hwnd16 );
 827     LONG_PTR retvalue;
 828     BOOL is_winproc = (offset == GWLP_WNDPROC);
 829
 830     if (offset >= 0)
 831     {
 832         int cbWndExtra = GetClassLongA( hwnd, GCL_CBWNDEXTRA );
 833
 834         if (offset > (int)(cbWndExtra - sizeof(LONG)))
 835         {
 836             /*
 837              * Some programs try to access last element from 16 bit
 838              * code using illegal offset value. Hopefully this is
 839              * what those programs really expect.
 840              */
 841             if (cbWndExtra >= 4 && offset == cbWndExtra - sizeof(WORD))
 842             {
 843                 offset = cbWndExtra - sizeof(LONG);
 844             }
 845             else
 846             {
 847                 SetLastError( ERROR_INVALID_INDEX );
 848                 return 0;
 849             }
 850         }
 851         else if (offset == DWLP_DLGPROC)
 852             is_winproc = (wow_handlers32.get_dialog_info( hwnd, FALSE ) != NULL);
 853     }
 854     retvalue = GetWindowLongA( hwnd, offset );
 855     if (is_winproc) retvalue = (LONG_PTR)WINPROC_GetProc16( (WNDPROC)retvalue, FALSE );
 856     return retvalue;
 857 }
 858
 859
 860 /**********************************************************************
 861  *              SetWindowLong (USER.136)
 862  */
 863 LONG WINAPI SetWindowLong16( HWND16 hwnd16, INT16 offset, LONG newval )
 864 {
 865     HWND hwnd = WIN_Handle32( hwnd16 );
 866     BOOL is_winproc = (offset == GWLP_WNDPROC);
 867
 868     if (offset == DWLP_DLGPROC)
 869         is_winproc = (wow_handlers32.get_dialog_info( hwnd, FALSE ) != NULL);
 870
 871     if (is_winproc)
 872     {
 873         WNDPROC new_proc = WINPROC_AllocProc16( (WNDPROC16)newval );
 874         WNDPROC old_proc = (WNDPROC)SetWindowLongPtrA( hwnd, offset, (LONG_PTR)new_proc );
 875         return (LONG)WINPROC_GetProc16( old_proc, FALSE );
 876     }
 877     else return SetWindowLongA( hwnd, offset, newval );
 878 }
 879
 880
 881 /**************************************************************************
 882  *              OpenClipboard   (USER.137)
 883  */
 884 BOOL16 WINAPI OpenClipboard16( HWND16 hwnd )
 885 {
 886     return OpenClipboard( WIN_Handle32(hwnd) );
 887 }
 888
 889
 890 /**************************************************************************
 891  *              GetClipboardOwner   (USER.140)
 892  */
 893 HWND16 WINAPI GetClipboardOwner16(void)
 894 {
 895     return HWND_16( GetClipboardOwner() );
 896 }
 897
 898
 899 /**************************************************************************
 900  *              SetClipboardViewer   (USER.147)
 901  */
 902 HWND16 WINAPI SetClipboardViewer16( HWND16 hwnd )
 903 {
 904     return HWND_16( SetClipboardViewer( WIN_Handle32(hwnd) ));
 905 }
 906
 907
 908 /**************************************************************************
 909  *              GetClipboardViewer   (USER.148)
 910  */
 911 HWND16 WINAPI GetClipboardViewer16(void)
 912 {
 913     return HWND_16( GetClipboardViewer() );
 914 }
 915
 916
 917 /**************************************************************************
 918  *              ChangeClipboardChain   (USER.149)
 919  */
 920 BOOL16 WINAPI ChangeClipboardChain16(HWND16 hwnd, HWND16 hwndNext)
 921 {
 922     return ChangeClipboardChain( WIN_Handle32(hwnd), WIN_Handle32(hwndNext) );
 923 }
 924
 925
 926 /**************************************************************************
 927  *              GetSystemMenu   (USER.156)
 928  */
 929 HMENU16 WINAPI GetSystemMenu16( HWND16 hwnd, BOOL16 revert )
 930 {
 931     return HMENU_16(GetSystemMenu( WIN_Handle32(hwnd), revert ));
 932 }
 933
 934
 935 /**************************************************************************
 936  *              GetMenu   (USER.157)
 937  */
 938 HMENU16 WINAPI GetMenu16( HWND16 hwnd )
 939 {
 940     return HMENU_16(GetMenu( WIN_Handle32(hwnd) ));
 941 }
 942
 943
 944 /**************************************************************************
 945  *              SetMenu   (USER.158)
 946  */
 947 BOOL16 WINAPI SetMenu16( HWND16 hwnd, HMENU16 hMenu )
 948 {
 949     return SetMenu( WIN_Handle32(hwnd), HMENU_32(hMenu) );
 950 }
 951
 952
 953 /**************************************************************************
 954  *              DrawMenuBar   (USER.160)
 955  */
 956 void WINAPI DrawMenuBar16( HWND16 hwnd )
 957 {
 958     DrawMenuBar( WIN_Handle32(hwnd) );
 959 }
 960
 961
 962 /**************************************************************************
 963  *              HiliteMenuItem   (USER.162)
 964  */
 965 BOOL16 WINAPI HiliteMenuItem16( HWND16 hwnd, HMENU16 hMenu, UINT16 id, UINT16 wHilite )
 966 {
 967     return HiliteMenuItem( WIN_Handle32(hwnd), HMENU_32(hMenu), id, wHilite );
 968 }
 969
 970
 971 /**************************************************************************
 972  *              CreateCaret   (USER.163)
 973  */
 974 void WINAPI CreateCaret16( HWND16 hwnd, HBITMAP16 bitmap, INT16 width, INT16 height )
 975 {
 976     CreateCaret( WIN_Handle32(hwnd), HBITMAP_32(bitmap), width, height );
 977 }
 978
 979
 980 /*****************************************************************
 981  *              DestroyCaret (USER.164)
 982  */
 983 void WINAPI DestroyCaret16(void)
 984 {
 985     DestroyCaret();
 986 }
 987
 988
 989 /*****************************************************************
 990  *              SetCaretPos (USER.165)
 991  */
 992 void WINAPI SetCaretPos16( INT16 x, INT16 y )
 993 {
 994     SetCaretPos( x, y );
 995 }
 996
 997
 998 /**************************************************************************
 999  *              HideCaret   (USER.166)
1000  */
1001 void WINAPI HideCaret16( HWND16 hwnd )
1002 {
1003     HideCaret( WIN_Handle32(hwnd) );
1004 }
1005
1006
1007 /**************************************************************************
1008  *              ShowCaret   (USER.167)
1009  */
1010 void WINAPI ShowCaret16( HWND16 hwnd )
1011 {
1012     ShowCaret( WIN_Handle32(hwnd) );
1013 }
1014
1015
1016 /*****************************************************************
1017  *              SetCaretBlinkTime (USER.168)
1018  */
1019 void WINAPI SetCaretBlinkTime16( UINT16 msecs )
1020 {
1021     SetCaretBlinkTime( msecs );
1022 }
1023
1024
1025 /*****************************************************************
1026  *              GetCaretBlinkTime (USER.169)
1027  */
1028 UINT16 WINAPI GetCaretBlinkTime16(void)
1029 {
1030     return GetCaretBlinkTime();
1031 }
1032
1033
1034 /**************************************************************************
1035  *              ArrangeIconicWindows   (USER.170)
1036  */
1037 UINT16 WINAPI ArrangeIconicWindows16( HWND16 parent)
1038 {
1039     return ArrangeIconicWindows( WIN_Handle32(parent) );
1040 }
1041
1042
1043 /**************************************************************************
1044  *              SwitchToThisWindow   (USER.172)
1045  */
1046 void WINAPI SwitchToThisWindow16( HWND16 hwnd, BOOL16 restore )
1047 {
1048     SwitchToThisWindow( WIN_Handle32(hwnd), restore );
1049 }
1050
1051
1052 /**************************************************************************
1053  *              KillSystemTimer   (USER.182)
1054  */
1055 BOOL16 WINAPI KillSystemTimer16( HWND16 hwnd, UINT16 id )
1056 {
1057     return KillSystemTimer( WIN_Handle32(hwnd), id );
1058 }
1059
1060
1061 /*****************************************************************
1062  *              GetCaretPos (USER.183)
1063  */
1064 void WINAPI GetCaretPos16( LPPOINT16 pt16 )
1065 {
1066     POINT pt;
1067     if (GetCaretPos( &pt ))
1068     {
1069         pt16->x = pt.x;
1070         pt16->y = pt.y;
1071     }
1072 }
1073
1074
1075 /**************************************************************************
1076  *              SetSysModalWindow   (USER.188)
1077  */
1078 HWND16 WINAPI SetSysModalWindow16( HWND16 hwnd )
1079 {
1080     HWND16 old = hwndSysModal;
1081     hwndSysModal = hwnd;
1082     return old;
1083 }
1084
1085
1086 /**************************************************************************
1087  *              GetSysModalWindow   (USER.189)
1088  */
1089 HWND16 WINAPI GetSysModalWindow16(void)
1090 {
1091     return hwndSysModal;
1092 }
1093
1094
1095 /**************************************************************************
1096  *              GetUpdateRect   (USER.190)
1097  */
1098 BOOL16 WINAPI GetUpdateRect16( HWND16 hwnd, LPRECT16 rect, BOOL16 erase )
1099 {
1100     RECT r;
1101     BOOL16 ret;
1102
1103     if (!rect) return GetUpdateRect( WIN_Handle32(hwnd), NULL, erase );
1104     ret = GetUpdateRect( WIN_Handle32(hwnd), &r, erase );
1105     rect->left   = r.left;
1106     rect->top    = r.top;
1107     rect->right  = r.right;
1108     rect->bottom = r.bottom;
1109     return ret;
1110 }
1111
1112
1113 /**************************************************************************
1114  *              ChildWindowFromPoint   (USER.191)
1115  */
1116 HWND16 WINAPI ChildWindowFromPoint16( HWND16 hwndParent, POINT16 pt )
1117 {
1118     POINT pt32;
1119
1120     pt32.x = pt.x;
1121     pt32.y = pt.y;
1122     return HWND_16( ChildWindowFromPoint( WIN_Handle32(hwndParent), pt32 ));
1123 }
1124
1125
1126 /***********************************************************************
1127  *              CascadeChildWindows (USER.198)
1128  */
1129 void WINAPI CascadeChildWindows16( HWND16 parent, WORD action )
1130 {
1131     CascadeWindows( WIN_Handle32(parent), action, NULL, 0, NULL );
1132 }
1133
1134
1135 /***********************************************************************
1136  *              TileChildWindows (USER.199)
1137  */
1138 void WINAPI TileChildWindows16( HWND16 parent, WORD action )
1139 {
1140     TileWindows( WIN_Handle32(parent), action, NULL, 0, NULL );
1141 }
1142
1143
1144 /***********************************************************************
1145  *              GetWindowTask   (USER.224)
1146  */
1147 HTASK16 WINAPI GetWindowTask16( HWND16 hwnd )
1148 {
1149     DWORD tid = GetWindowThreadProcessId( HWND_32(hwnd), NULL );
1150     if (!tid) return 0;
1151     return HTASK_16(tid);
1152 }
1153
1154 /**********************************************************************
1155  *              EnumTaskWindows   (USER.225)
1156  */
1157 BOOL16 WINAPI EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func, LPARAM lParam )
1158 {
1159     struct wnd_enum_info info;
1160     DWORD tid = HTASK_32( hTask );
1161
1162     if (!tid) return FALSE;
1163     info.proc  = func;
1164     info.param = lParam;
1165     return EnumThreadWindows( tid, wnd_enum_callback, (LPARAM)&info );
1166 }
1167
1168
1169 /**************************************************************************
1170  *              GetTopWindow   (USER.229)
1171  */
1172 HWND16 WINAPI GetTopWindow16( HWND16 hwnd )
1173 {
1174     return HWND_16( GetTopWindow( WIN_Handle32(hwnd) ));
1175 }
1176
1177
1178 /**************************************************************************
1179  *              GetNextWindow   (USER.230)
1180  */
1181 HWND16 WINAPI GetNextWindow16( HWND16 hwnd, WORD flag )
1182 {
1183     if ((flag != GW_HWNDNEXT) && (flag != GW_HWNDPREV)) return 0;
1184     return GetWindow16( hwnd, flag );
1185 }
1186
1187
1188 /**************************************************************************
1189  *              SetWindowPos   (USER.232)
1190  */
1191 BOOL16 WINAPI SetWindowPos16( HWND16 hwnd, HWND16 hwndInsertAfter,
1192                               INT16 x, INT16 y, INT16 cx, INT16 cy, WORD flags)
1193 {
1194     return SetWindowPos( WIN_Handle32(hwnd), full_insert_after_hwnd(hwndInsertAfter),
1195                          x, y, cx, cy, flags );
1196 }
1197
1198
1199 /**************************************************************************
1200  *              SetParent   (USER.233)
1201  */
1202 HWND16 WINAPI SetParent16( HWND16 hwndChild, HWND16 hwndNewParent )
1203 {
1204     return HWND_16( SetParent( WIN_Handle32(hwndChild), WIN_Handle32(hwndNewParent) ));
1205 }
1206
1207
1208 /**************************************************************************
1209  *              GetCapture   (USER.236)
1210  */
1211 HWND16 WINAPI GetCapture16(void)
1212 {
1213     return HWND_16( GetCapture() );
1214 }
1215
1216
1217 /**************************************************************************
1218  *              GetUpdateRgn   (USER.237)
1219  */
1220 INT16 WINAPI GetUpdateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
1221 {
1222     return GetUpdateRgn( WIN_Handle32(hwnd), HRGN_32(hrgn), erase );
1223 }
1224
1225
1226 /**************************************************************************
1227  *              ExcludeUpdateRgn   (USER.238)
1228  */
1229 INT16 WINAPI ExcludeUpdateRgn16( HDC16 hdc, HWND16 hwnd )
1230 {
1231     return ExcludeUpdateRgn( HDC_32(hdc), WIN_Handle32(hwnd) );
1232 }
1233
1234
1235 /**************************************************************************
1236  *              GetOpenClipboardWindow   (USER.248)
1237  */
1238 HWND16 WINAPI GetOpenClipboardWindow16(void)
1239 {
1240     return HWND_16( GetOpenClipboardWindow() );
1241 }
1242
1243
1244 /*******************************************************************
1245  *              MapWindowPoints (USER.258)
1246  */
1247 void WINAPI MapWindowPoints16( HWND16 hwndFrom, HWND16 hwndTo, LPPOINT16 lppt, UINT16 count )
1248 {
1249     POINT buffer[8], *ppt = buffer;
1250     UINT i;
1251
1252     if (count > 8) ppt = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*ppt) );
1253     for (i = 0; i < count; i++)
1254     {
1255         ppt[i].x = lppt[i].x;
1256         ppt[i].y = lppt[i].y;
1257     }
1258     MapWindowPoints( WIN_Handle32(hwndFrom), WIN_Handle32(hwndTo), ppt, count );
1259     for (i = 0; i < count; i++)
1260     {
1261         lppt[i].x = ppt[i].x;
1262         lppt[i].y = ppt[i].y;
1263     }
1264     if (ppt != buffer) HeapFree( GetProcessHeap(), 0, ppt );
1265 }
1266
1267
1268 /**************************************************************************
1269  *              BeginDeferWindowPos   (USER.259)
1270  */
1271 HDWP16 WINAPI BeginDeferWindowPos16( INT16 count )
1272 {
1273     return HDWP_16(BeginDeferWindowPos( count ));
1274 }
1275
1276
1277 /**************************************************************************
1278  *              DeferWindowPos   (USER.260)
1279  */
1280 HDWP16 WINAPI DeferWindowPos16( HDWP16 hdwp, HWND16 hwnd, HWND16 hwndAfter,
1281                                 INT16 x, INT16 y, INT16 cx, INT16 cy,
1282                                 UINT16 flags )
1283 {
1284     return HDWP_16(DeferWindowPos( HDWP_32(hdwp), WIN_Handle32(hwnd),
1285                    full_insert_after_hwnd(hwndAfter), x, y, cx, cy, flags ));
1286 }
1287
1288
1289 /**************************************************************************
1290  *              EndDeferWindowPos   (USER.261)
1291  */
1292 BOOL16 WINAPI EndDeferWindowPos16( HDWP16 hdwp )
1293 {
1294     return EndDeferWindowPos(HDWP_32(hdwp));
1295 }
1296
1297
1298 /**************************************************************************
1299  *              GetWindow   (USER.262)
1300  */
1301 HWND16 WINAPI GetWindow16( HWND16 hwnd, WORD rel )
1302 {
1303     return HWND_16( GetWindow( WIN_Handle32(hwnd), rel ) );
1304 }
1305
1306
1307 /**************************************************************************
1308  *              ShowOwnedPopups   (USER.265)
1309  */
1310 void WINAPI ShowOwnedPopups16( HWND16 owner, BOOL16 fShow )
1311 {
1312     ShowOwnedPopups( WIN_Handle32(owner), fShow );
1313 }
1314
1315
1316 /**************************************************************************
1317  *              ShowScrollBar   (USER.267)
1318  */
1319 void WINAPI ShowScrollBar16( HWND16 hwnd, INT16 nBar, BOOL16 fShow )
1320 {
1321     ShowScrollBar( WIN_Handle32(hwnd), nBar, fShow );
1322 }
1323
1324
1325 /**************************************************************************
1326  *              IsZoomed   (USER.272)
1327  */
1328 BOOL16 WINAPI IsZoomed16(HWND16 hwnd)
1329 {
1330     return IsZoomed( WIN_Handle32(hwnd) );
1331 }
1332
1333
1334 /**************************************************************************
1335  *              GetDlgCtrlID   (USER.277)
1336  */
1337 INT16 WINAPI GetDlgCtrlID16( HWND16 hwnd )
1338 {
1339     return GetDlgCtrlID( WIN_Handle32(hwnd) );
1340 }
1341
1342
1343 /**************************************************************************
1344  *              GetDesktopHwnd   (USER.278)
1345  *
1346  * Exactly the same thing as GetDesktopWindow(), but not documented.
1347  * Don't ask me why...
1348  */
1349 HWND16 WINAPI GetDesktopHwnd16(void)
1350 {
1351     return GetDesktopWindow16();
1352 }
1353
1354
1355 /**************************************************************************
1356  *              SetSystemMenu   (USER.280)
1357  */
1358 BOOL16 WINAPI SetSystemMenu16( HWND16 hwnd, HMENU16 hMenu )
1359 {
1360     return SetSystemMenu( WIN_Handle32(hwnd), HMENU_32(hMenu) );
1361 }
1362
1363
1364 /**************************************************************************
1365  *              GetDesktopWindow   (USER.286)
1366  */
1367 HWND16 WINAPI GetDesktopWindow16(void)
1368 {
1369     return HWND_16( GetDesktopWindow() );
1370 }
1371
1372
1373 /**************************************************************************
1374  *              GetLastActivePopup   (USER.287)
1375  */
1376 HWND16 WINAPI GetLastActivePopup16( HWND16 hwnd )
1377 {
1378     return HWND_16( GetLastActivePopup( WIN_Handle32(hwnd) ));
1379 }
1380
1381
1382 /**************************************************************************
1383  *              RedrawWindow   (USER.290)
1384  */
1385 BOOL16 WINAPI RedrawWindow16( HWND16 hwnd, const RECT16 *rectUpdate,
1386                               HRGN16 hrgnUpdate, UINT16 flags )
1387 {
1388     if (rectUpdate)
1389     {
1390         RECT r;
1391         r.left   = rectUpdate->left;
1392         r.top    = rectUpdate->top;
1393         r.right  = rectUpdate->right;
1394         r.bottom = rectUpdate->bottom;
1395         return RedrawWindow(WIN_Handle32(hwnd), &r, HRGN_32(hrgnUpdate), flags);
1396     }
1397     return RedrawWindow(WIN_Handle32(hwnd), NULL, HRGN_32(hrgnUpdate), flags);
1398 }
1399
1400
1401 /**************************************************************************
1402  *              LockWindowUpdate   (USER.294)
1403  */
1404 BOOL16 WINAPI LockWindowUpdate16( HWND16 hwnd )
1405 {
1406     return LockWindowUpdate( WIN_Handle32(hwnd) );
1407 }
1408
1409
1410 /**************************************************************************
1411  *              ScrollWindowEx   (USER.319)
1412  */
1413 INT16 WINAPI ScrollWindowEx16( HWND16 hwnd, INT16 dx, INT16 dy,
1414                                const RECT16 *rect, const RECT16 *clipRect,
1415                                HRGN16 hrgnUpdate, LPRECT16 rcUpdate,
1416                                UINT16 flags )
1417 {
1418     RECT rect32, clipRect32, rcUpdate32;
1419     BOOL16 ret;
1420
1421     if (rect)
1422     {
1423         rect32.left   = rect->left;
1424         rect32.top    = rect->top;
1425         rect32.right  = rect->right;
1426         rect32.bottom = rect->bottom;
1427     }
1428     if (clipRect)
1429     {
1430         clipRect32.left   = clipRect->left;
1431         clipRect32.top    = clipRect->top;
1432         clipRect32.right  = clipRect->right;
1433         clipRect32.bottom = clipRect->bottom;
1434     }
1435     ret = ScrollWindowEx( WIN_Handle32(hwnd), dx, dy, rect ? &rect32 : NULL,
1436                           clipRect ? &clipRect32 : NULL, HRGN_32(hrgnUpdate),
1437                           (rcUpdate) ? &rcUpdate32 : NULL, flags );
1438     if (rcUpdate)
1439     {
1440         rcUpdate->left   = rcUpdate32.left;
1441         rcUpdate->top    = rcUpdate32.top;
1442         rcUpdate->right  = rcUpdate32.right;
1443         rcUpdate->bottom = rcUpdate32.bottom;
1444     }
1445     return ret;
1446 }
1447
1448
1449 /**************************************************************************
1450  *              FillWindow   (USER.324)
1451  */
1452 void WINAPI FillWindow16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc, HBRUSH16 hbrush )
1453 {
1454     RECT rect;
1455     RECT16 rc16;
1456     GetClientRect( WIN_Handle32(hwnd), &rect );
1457     DPtoLP( HDC_32(hdc), (LPPOINT)&rect, 2 );
1458     rc16.left   = rect.left;
1459     rc16.top    = rect.top;
1460     rc16.right  = rect.right;
1461     rc16.bottom = rect.bottom;
1462     PaintRect16( hwndParent, hwnd, hdc, hbrush, &rc16 );
1463 }
1464
1465
1466 /**************************************************************************
1467  *              PaintRect   (USER.325)
1468  */
1469 void WINAPI PaintRect16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc,
1470                          HBRUSH16 hbrush, const RECT16 *rect)
1471 {
1472     if (hbrush <= CTLCOLOR_STATIC)
1473     {
1474         HWND parent = WIN_Handle32(hwndParent), hwnd32 = WIN_Handle32(hwnd);
1475
1476         if (!parent) return;
1477         hbrush = SendMessageW( parent, WM_CTLCOLORMSGBOX + hbrush, (WPARAM)hdc, (LPARAM)hwnd32 );
1478         if (!hbrush) hbrush = DefWindowProcW( parent, WM_CTLCOLORMSGBOX + hbrush,
1479                                               (WPARAM)hdc, (LPARAM)hwnd32 );
1480     }
1481     if (hbrush) FillRect16( hdc, rect, hbrush );
1482 }
1483
1484
1485 /**************************************************************************
1486  *              GetControlBrush   (USER.326)
1487  */
1488 HBRUSH16 WINAPI GetControlBrush16( HWND16 hwnd, HDC16 hdc, UINT16 ctlType )
1489 {
1490     HBRUSH16 ret;
1491     HWND hwnd32 = WIN_Handle32(hwnd);
1492     HWND parent = GetParent( hwnd32 );
1493
1494     if (!parent) parent = hwnd32;
1495     ret = SendMessageW( parent, WM_CTLCOLORMSGBOX + ctlType, (WPARAM)hdc, (LPARAM)hwnd32 );
1496     if (!ret) ret = DefWindowProcW( parent, WM_CTLCOLORMSGBOX + ctlType,
1497                                     (WPARAM)hdc, (LPARAM)hwnd32 );
1498     return ret;
1499 }
1500
1501
1502 /**************************************************************************
1503  *              GetDCEx   (USER.359)
1504  */
1505 HDC16 WINAPI GetDCEx16( HWND16 hwnd, HRGN16 hrgnClip, DWORD flags )
1506 {
1507     return HDC_16(GetDCEx(WIN_Handle32(hwnd), HRGN_32(hrgnClip), flags));
1508 }
1509
1510
1511 /**************************************************************************
1512  *              GetWindowPlacement   (USER.370)
1513  */
1514 BOOL16 WINAPI GetWindowPlacement16( HWND16 hwnd, WINDOWPLACEMENT16 *wp16 )
1515 {
1516     WINDOWPLACEMENT wpl;
1517
1518     wpl.length = sizeof(wpl);
1519     if (!GetWindowPlacement( WIN_Handle32(hwnd), &wpl )) return FALSE;
1520     wp16->length  = sizeof(*wp16);
1521     wp16->flags   = wpl.flags;
1522     wp16->showCmd = wpl.showCmd;
1523     wp16->ptMinPosition.x = wpl.ptMinPosition.x;
1524     wp16->ptMinPosition.y = wpl.ptMinPosition.y;
1525     wp16->ptMaxPosition.x = wpl.ptMaxPosition.x;
1526     wp16->ptMaxPosition.y = wpl.ptMaxPosition.y;
1527     wp16->rcNormalPosition.left   = wpl.rcNormalPosition.left;
1528     wp16->rcNormalPosition.top    = wpl.rcNormalPosition.top;
1529     wp16->rcNormalPosition.right  = wpl.rcNormalPosition.right;
1530     wp16->rcNormalPosition.bottom = wpl.rcNormalPosition.bottom;
1531     return TRUE;
1532 }
1533
1534
1535 /**************************************************************************
1536  *              SetWindowPlacement   (USER.371)
1537  */
1538 BOOL16 WINAPI SetWindowPlacement16( HWND16 hwnd, const WINDOWPLACEMENT16 *wp16 )
1539 {
1540     WINDOWPLACEMENT wpl;
1541
1542     if (!wp16) return FALSE;
1543     wpl.length  = sizeof(wpl);
1544     wpl.flags   = wp16->flags;
1545     wpl.showCmd = wp16->showCmd;
1546     wpl.ptMinPosition.x = wp16->ptMinPosition.x;
1547     wpl.ptMinPosition.y = wp16->ptMinPosition.y;
1548     wpl.ptMaxPosition.x = wp16->ptMaxPosition.x;
1549     wpl.ptMaxPosition.y = wp16->ptMaxPosition.y;
1550     wpl.rcNormalPosition.left   = wp16->rcNormalPosition.left;
1551     wpl.rcNormalPosition.top    = wp16->rcNormalPosition.top;
1552     wpl.rcNormalPosition.right  = wp16->rcNormalPosition.right;
1553     wpl.rcNormalPosition.bottom = wp16->rcNormalPosition.bottom;
1554     return SetWindowPlacement( WIN_Handle32(hwnd), &wpl );
1555 }
1556
1557
1558 /***********************************************************************
1559  *              RegisterClassEx (USER.397)
1560  */
1561 ATOM WINAPI RegisterClassEx16( const WNDCLASSEX16 *wc )
1562 {
1563     struct class_entry *class;
1564     WNDCLASSEXA wc32;
1565     HINSTANCE16 inst;
1566     ATOM atom;
1567
1568     inst = GetExePtr( wc->hInstance );
1569     if (!inst) inst = GetModuleHandle16( NULL );
1570
1571     wc32.cbSize        = sizeof(wc32);
1572     wc32.style         = wc->style;
1573     wc32.lpfnWndProc   = WINPROC_AllocProc16( wc->lpfnWndProc );
1574     wc32.cbClsExtra    = wc->cbClsExtra;
1575     wc32.cbWndExtra    = wc->cbWndExtra;
1576     wc32.hInstance     = HINSTANCE_32(inst);
1577     wc32.hIcon         = HICON_32(wc->hIcon);
1578     wc32.hCursor       = HCURSOR_32(wc->hCursor);
1579     wc32.hbrBackground = HBRUSH_32(wc->hbrBackground);
1580     wc32.lpszMenuName  = MapSL(wc->lpszMenuName);
1581     wc32.lpszClassName = MapSL(wc->lpszClassName);
1582     wc32.hIconSm       = HICON_32(wc->hIconSm);
1583     atom = RegisterClassExA( &wc32 );
1584     if ((class = HeapAlloc( GetProcessHeap(), 0, sizeof(*class) )))
1585     {
1586         class->atom = atom;
1587         class->inst = inst;
1588         list_add_tail( &class_list, &class->entry );
1589     }
1590     return atom;
1591 }
1592
1593
1594 /***********************************************************************
1595  *              GetClassInfoEx (USER.398)
1596  *
1597  * FIXME: this is just a guess, I have no idea if GetClassInfoEx() is the
1598  * same in Win16 as in Win32. --AJ
1599  */
1600 BOOL16 WINAPI GetClassInfoEx16( HINSTANCE16 hInst16, SEGPTR name, WNDCLASSEX16 *wc )
1601 {
1602     WNDCLASSEXA wc32;
1603     HINSTANCE hInstance;
1604     BOOL ret;
1605
1606     if (hInst16 == GetModuleHandle16("user")) hInstance = user32_module;
1607     else hInstance = HINSTANCE_32(GetExePtr( hInst16 ));
1608
1609     ret = GetClassInfoExA( hInstance, MapSL(name), &wc32 );
1610
1611     if (ret)
1612     {
1613         wc->lpfnWndProc   = WINPROC_GetProc16( wc32.lpfnWndProc, FALSE );
1614         wc->style         = wc32.style;
1615         wc->cbClsExtra    = wc32.cbClsExtra;
1616         wc->cbWndExtra    = wc32.cbWndExtra;
1617         wc->hInstance     = (wc32.hInstance == user32_module) ? GetModuleHandle16("user") : HINSTANCE_16(wc32.hInstance);
1618         wc->hIcon         = HICON_16(wc32.hIcon);
1619         wc->hIconSm       = HICON_16(wc32.hIconSm);
1620         wc->hCursor       = HCURSOR_16(wc32.hCursor);
1621         wc->hbrBackground = HBRUSH_16(wc32.hbrBackground);
1622         wc->lpszClassName = 0;
1623         wc->lpszMenuName  = MapLS(wc32.lpszMenuName);  /* FIXME: leak */
1624     }
1625     return ret;
1626 }
1627
1628
1629 /**************************************************************************
1630  *              ChildWindowFromPointEx   (USER.399)
1631  */
1632 HWND16 WINAPI ChildWindowFromPointEx16( HWND16 hwndParent, POINT16 pt, UINT16 uFlags)
1633 {
1634     POINT pt32;
1635
1636     pt32.x = pt.x;
1637     pt32.y = pt.y;
1638     return HWND_16( ChildWindowFromPointEx( WIN_Handle32(hwndParent), pt32, uFlags ));
1639 }
1640
1641
1642 /**************************************************************************
1643  *              GetPriorityClipboardFormat   (USER.402)
1644  */
1645 INT16 WINAPI GetPriorityClipboardFormat16( UINT16 *list, INT16 count )
1646 {
1647     int i;
1648
1649     for (i = 0; i < count; i++)
1650         if (IsClipboardFormatAvailable( list[i] )) return list[i];
1651     return -1;
1652 }
1653
1654
1655 /***********************************************************************
1656  *              UnregisterClass (USER.403)
1657  */
1658 BOOL16 WINAPI UnregisterClass16( LPCSTR className, HINSTANCE16 hInstance )
1659 {
1660     ATOM atom;
1661
1662     if (hInstance == GetModuleHandle16("user")) hInstance = 0;
1663     else hInstance = GetExePtr( hInstance );
1664
1665     if ((atom = GlobalFindAtomA( className )))
1666     {
1667         struct class_entry *class;
1668         LIST_FOR_EACH_ENTRY( class, &class_list, struct class_entry, entry )
1669         {
1670             if (class->inst != hInstance) continue;
1671             if (class->atom != atom) continue;
1672             list_remove( &class->entry );
1673             HeapFree( GetProcessHeap(), 0, class );
1674             break;
1675         }
1676     }
1677     return UnregisterClassA( className, HINSTANCE_32(hInstance) );
1678 }
1679
1680
1681 /***********************************************************************
1682  *              GetClassInfo (USER.404)
1683  */
1684 BOOL16 WINAPI GetClassInfo16( HINSTANCE16 hInst16, SEGPTR name, WNDCLASS16 *wc )
1685 {
1686     WNDCLASSEX16 wcex;
1687     UINT16 ret = GetClassInfoEx16( hInst16, name, &wcex );
1688
1689     if (ret)
1690     {
1691         wc->style         = wcex.style;
1692         wc->lpfnWndProc   = wcex.lpfnWndProc;
1693         wc->cbClsExtra    = wcex.cbClsExtra;
1694         wc->cbWndExtra    = wcex.cbWndExtra;
1695         wc->hInstance     = wcex.hInstance;
1696         wc->hIcon         = wcex.hIcon;
1697         wc->hCursor       = wcex.hCursor;
1698         wc->hbrBackground = wcex.hbrBackground;
1699         wc->lpszMenuName  = wcex.lpszMenuName;
1700         wc->lpszClassName = wcex.lpszClassName;
1701     }
1702     return ret;
1703 }
1704
1705
1706 /**************************************************************************
1707  *              TrackPopupMenu   (USER.416)
1708  */
1709 BOOL16 WINAPI TrackPopupMenu16( HMENU16 hMenu, UINT16 wFlags, INT16 x, INT16 y,
1710                                 INT16 nReserved, HWND16 hwnd, const RECT16 *lpRect )
1711 {
1712     RECT r;
1713     if (lpRect)
1714     {
1715         r.left   = lpRect->left;
1716         r.top    = lpRect->top;
1717         r.right  = lpRect->right;
1718         r.bottom = lpRect->bottom;
1719     }
1720     return TrackPopupMenu( HMENU_32(hMenu), wFlags, x, y, nReserved,
1721                            WIN_Handle32(hwnd), lpRect ? &r : NULL );
1722 }
1723
1724
1725 /**************************************************************************
1726  *              FindWindowEx   (USER.427)
1727  */
1728 HWND16 WINAPI FindWindowEx16( HWND16 parent, HWND16 child, LPCSTR className, LPCSTR title )
1729 {
1730     return HWND_16( FindWindowExA( WIN_Handle32(parent), WIN_Handle32(child),
1731                                         className, title ));
1732 }
1733
1734
1735 /***********************************************************************
1736  *              DefFrameProc (USER.445)
1737  */
1738 LRESULT WINAPI DefFrameProc16( HWND16 hwnd, HWND16 hwndMDIClient,
1739                                UINT16 message, WPARAM16 wParam, LPARAM lParam )
1740 {
1741     switch (message)
1742     {
1743     case WM_SETTEXT:
1744         lParam = (LPARAM)MapSL(lParam);
1745         /* fall through */
1746     case WM_COMMAND:
1747     case WM_NCACTIVATE:
1748     case WM_SETFOCUS:
1749     case WM_SIZE:
1750         return DefFrameProcA( WIN_Handle32(hwnd), WIN_Handle32(hwndMDIClient),
1751                               message, wParam, lParam );
1752
1753     case WM_NEXTMENU:
1754         {
1755             MDINEXTMENU next_menu;
1756             DefFrameProcW( WIN_Handle32(hwnd), WIN_Handle32(hwndMDIClient),
1757                            message, wParam, (LPARAM)&next_menu );
1758             return MAKELONG( HMENU_16(next_menu.hmenuNext), HWND_16(next_menu.hwndNext) );
1759         }
1760     default:
1761         return DefWindowProc16(hwnd, message, wParam, lParam);
1762     }
1763 }
1764
1765
1766 /***********************************************************************
1767  *              DefMDIChildProc (USER.447)
1768  */
1769 LRESULT WINAPI DefMDIChildProc16( HWND16 hwnd, UINT16 message,
1770                                   WPARAM16 wParam, LPARAM lParam )
1771 {
1772     switch (message)
1773     {
1774     case WM_SETTEXT:
1775         return DefMDIChildProcA( WIN_Handle32(hwnd), message, wParam, (LPARAM)MapSL(lParam) );
1776
1777     case WM_MENUCHAR:
1778     case WM_CLOSE:
1779     case WM_SETFOCUS:
1780     case WM_CHILDACTIVATE:
1781     case WM_SYSCOMMAND:
1782     case WM_SETVISIBLE:
1783     case WM_SIZE:
1784     case WM_SYSCHAR:
1785         return DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, lParam );
1786
1787     case WM_GETMINMAXINFO:
1788         {
1789             MINMAXINFO16 *mmi16 = MapSL(lParam);
1790             MINMAXINFO mmi;
1791
1792             mmi.ptReserved.x     = mmi16->ptReserved.x;
1793             mmi.ptReserved.y     = mmi16->ptReserved.y;
1794             mmi.ptMaxSize.x      = mmi16->ptMaxSize.x;
1795             mmi.ptMaxSize.y      = mmi16->ptMaxSize.y;
1796             mmi.ptMaxPosition.x  = mmi16->ptMaxPosition.x;
1797             mmi.ptMaxPosition.y  = mmi16->ptMaxPosition.y;
1798             mmi.ptMinTrackSize.x = mmi16->ptMinTrackSize.x;
1799             mmi.ptMinTrackSize.y = mmi16->ptMinTrackSize.y;
1800             mmi.ptMaxTrackSize.x = mmi16->ptMaxTrackSize.x;
1801             mmi.ptMaxTrackSize.y = mmi16->ptMaxTrackSize.y;
1802
1803             DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, (LPARAM)&mmi );
1804
1805             mmi16->ptReserved.x     = mmi.ptReserved.x;
1806             mmi16->ptReserved.y     = mmi.ptReserved.y;
1807             mmi16->ptMaxSize.x      = mmi.ptMaxSize.x;
1808             mmi16->ptMaxSize.y      = mmi.ptMaxSize.y;
1809             mmi16->ptMaxPosition.x  = mmi.ptMaxPosition.x;
1810             mmi16->ptMaxPosition.y  = mmi.ptMaxPosition.y;
1811             mmi16->ptMinTrackSize.x = mmi.ptMinTrackSize.x;
1812             mmi16->ptMinTrackSize.y = mmi.ptMinTrackSize.y;
1813             mmi16->ptMaxTrackSize.x = mmi.ptMaxTrackSize.x;
1814             mmi16->ptMaxTrackSize.y = mmi.ptMaxTrackSize.y;
1815             return 0;
1816         }
1817     case WM_NEXTMENU:
1818         {
1819             MDINEXTMENU next_menu;
1820             DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, (LPARAM)&next_menu );
1821             return MAKELONG( HMENU_16(next_menu.hmenuNext), HWND_16(next_menu.hwndNext) );
1822         }
1823     default:
1824         return DefWindowProc16(hwnd, message, wParam, lParam);
1825     }
1826 }
1827
1828
1829 /**************************************************************************
1830  *              DrawAnimatedRects   (USER.448)
1831  */
1832 BOOL16 WINAPI DrawAnimatedRects16( HWND16 hwnd, INT16 idAni,
1833                                    const RECT16* lprcFrom, const RECT16* lprcTo )
1834 {
1835     RECT rcFrom32, rcTo32;
1836     rcFrom32.left   = lprcFrom->left;
1837     rcFrom32.top    = lprcFrom->top;
1838     rcFrom32.right  = lprcFrom->right;
1839     rcFrom32.bottom = lprcFrom->bottom;
1840     rcTo32.left     = lprcTo->left;
1841     rcTo32.top      = lprcTo->top;
1842     rcTo32.right    = lprcTo->right;
1843     rcTo32.bottom   = lprcTo->bottom;
1844     return DrawAnimatedRects( WIN_Handle32(hwnd), idAni, &rcFrom32, &rcTo32 );
1845 }
1846
1847
1848 /***********************************************************************
1849  *              CreateWindowEx (USER.452)
1850  */
1851 HWND16 WINAPI CreateWindowEx16( DWORD exStyle, LPCSTR className,
1852                                 LPCSTR windowName, DWORD style, INT16 x,
1853                                 INT16 y, INT16 width, INT16 height,
1854                                 HWND16 parent, HMENU16 menu,
1855                                 HINSTANCE16 instance, LPVOID data )
1856 {
1857     CREATESTRUCTA cs;
1858     char buffer[256];
1859     HWND hwnd;
1860
1861     /* Fix the coordinates */
1862
1863     cs.x  = (x == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)x;
1864     cs.y  = (y == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)y;
1865     cs.cx = (width == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)width;
1866     cs.cy = (height == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)height;
1867
1868     /* Create the window */
1869
1870     cs.lpCreateParams = data;
1871     cs.hInstance      = HINSTANCE_32(instance);
1872     cs.hMenu          = HMENU_32(menu);
1873     cs.hwndParent     = WIN_Handle32( parent );
1874     cs.style          = style;
1875     cs.lpszName       = windowName;
1876     cs.lpszClass      = className;
1877     cs.dwExStyle      = exStyle;
1878
1879     /* load the menu */
1880     if (!menu && (style & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1881     {
1882         WNDCLASSA class;
1883         HINSTANCE16 module = GetExePtr( instance );
1884
1885         if (GetClassInfoA( HINSTANCE_32(module), className, &class ))
1886             cs.hMenu = HMENU_32( LoadMenu16( module, class.lpszMenuName ));
1887     }
1888
1889     if (!IS_INTRESOURCE(className))
1890     {
1891         WCHAR bufferW[256];
1892
1893         if (!MultiByteToWideChar( CP_ACP, 0, className, -1, bufferW, sizeof(bufferW)/sizeof(WCHAR) ))
1894             return 0;
1895         hwnd = create_window16( (CREATESTRUCTW *)&cs, bufferW, HINSTANCE_32(instance), FALSE );
1896     }
1897     else
1898     {
1899         if (!GlobalGetAtomNameA( LOWORD(className), buffer, sizeof(buffer) )) return 0;
1900         cs.lpszClass = buffer;
1901         hwnd = create_window16( (CREATESTRUCTW *)&cs, (LPCWSTR)className, HINSTANCE_32(instance), FALSE );
1902     }
1903     return HWND_16( hwnd );
1904 }
1905
1906
1907 /***********************************************************************
1908  *              GetInternalWindowPos (USER.460)
1909  */
1910 UINT16 WINAPI GetInternalWindowPos16( HWND16 hwnd, LPRECT16 rectWnd, LPPOINT16 ptIcon )
1911 {
1912     WINDOWPLACEMENT16 wndpl;
1913
1914     if (!GetWindowPlacement16( hwnd, &wndpl )) return 0;
1915     if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
1916     if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
1917     return wndpl.showCmd;
1918 }
1919
1920
1921 /**************************************************************************
1922  *              SetInternalWindowPos   (USER.461)
1923  */
1924 void WINAPI SetInternalWindowPos16( HWND16 hwnd, UINT16 showCmd, LPRECT16 rect, LPPOINT16 pt )
1925 {
1926     RECT rc32;
1927     POINT pt32;
1928
1929     if (rect)
1930     {
1931         rc32.left   = rect->left;
1932         rc32.top    = rect->top;
1933         rc32.right  = rect->right;
1934         rc32.bottom = rect->bottom;
1935     }
1936     if (pt)
1937     {
1938         pt32.x = pt->x;
1939         pt32.y = pt->y;
1940     }
1941     SetInternalWindowPos( WIN_Handle32(hwnd), showCmd,
1942                           rect ? &rc32 : NULL, pt ? &pt32 : NULL );
1943 }
1944
1945
1946 /**************************************************************************
1947  *              CalcChildScroll   (USER.462)
1948  */
1949 void WINAPI CalcChildScroll16( HWND16 hwnd, WORD scroll )
1950 {
1951     CalcChildScroll( WIN_Handle32(hwnd), scroll );
1952 }
1953
1954
1955 /**************************************************************************
1956  *              ScrollChildren   (USER.463)
1957  */
1958 void WINAPI ScrollChildren16(HWND16 hwnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam)
1959 {
1960     ScrollChildren( WIN_Handle32(hwnd), uMsg, wParam, lParam );
1961 }
1962
1963
1964 /**************************************************************************
1965  *              DragDetect   (USER.465)
1966  */
1967 BOOL16 WINAPI DragDetect16( HWND16 hwnd, POINT16 pt )
1968 {
1969     POINT pt32;
1970
1971     pt32.x = pt.x;
1972     pt32.y = pt.y;
1973     return DragDetect( WIN_Handle32(hwnd), pt32 );
1974 }
1975
1976
1977 /**************************************************************************
1978  *              SetScrollInfo   (USER.475)
1979  */
1980 INT16 WINAPI SetScrollInfo16( HWND16 hwnd, INT16 nBar, const SCROLLINFO *info, BOOL16 redraw )
1981 {
1982     return SetScrollInfo( WIN_Handle32(hwnd), nBar, info, redraw );
1983 }
1984
1985
1986 /**************************************************************************
1987  *              GetScrollInfo   (USER.476)
1988  */
1989 BOOL16 WINAPI GetScrollInfo16( HWND16 hwnd, INT16 nBar, LPSCROLLINFO info )
1990 {
1991     return GetScrollInfo( WIN_Handle32(hwnd), nBar, info );
1992 }
1993
1994
1995 /**************************************************************************
1996  *              EnableScrollBar   (USER.482)
1997  */
1998 BOOL16 WINAPI EnableScrollBar16( HWND16 hwnd, INT16 nBar, UINT16 flags )
1999 {
2000     return EnableScrollBar( WIN_Handle32(hwnd), nBar, flags );
2001 }
2002
2003
2004 /**************************************************************************
2005  *              GetShellWindow   (USER.600)
2006  */
2007 HWND16 WINAPI GetShellWindow16(void)
2008 {
2009     return HWND_16( GetShellWindow() );
2010 }
2011
2012
2013 /**************************************************************************
2014  *              GetForegroundWindow   (USER.608)
2015  */
2016 HWND16 WINAPI GetForegroundWindow16(void)
2017 {
2018     return HWND_16( GetForegroundWindow() );
2019 }
2020
2021
2022 /**************************************************************************
2023  *              SetForegroundWindow   (USER.609)
2024  */
2025 BOOL16 WINAPI SetForegroundWindow16( HWND16 hwnd )
2026 {
2027     return SetForegroundWindow( WIN_Handle32(hwnd) );
2028 }
2029
2030
2031 /**************************************************************************
2032  *              DrawCaptionTemp   (USER.657)
2033  */
2034 BOOL16 WINAPI DrawCaptionTemp16( HWND16 hwnd, HDC16 hdc, const RECT16 *rect,
2035                                  HFONT16 hFont, HICON16 hIcon, LPCSTR str, UINT16 uFlags )
2036 {
2037     RECT rect32;
2038
2039     if (rect)
2040     {
2041         rect32.left   = rect->left;
2042         rect32.top    = rect->top;
2043         rect32.right  = rect->right;
2044         rect32.bottom = rect->bottom;
2045     }
2046     return DrawCaptionTempA( WIN_Handle32(hwnd), HDC_32(hdc),
2047                              rect ? &rect32 : NULL, HFONT_32(hFont),
2048                              HICON_32(hIcon), str, uFlags & 0x1f );
2049 }
2050
2051
2052 /**************************************************************************
2053  *              DrawCaption   (USER.660)
2054  */
2055 BOOL16 WINAPI DrawCaption16( HWND16 hwnd, HDC16 hdc, const RECT16 *rect, UINT16 flags )
2056 {
2057     RECT rect32;
2058
2059     if (rect)
2060     {
2061         rect32.left   = rect->left;
2062         rect32.top    = rect->top;
2063         rect32.right  = rect->right;
2064         rect32.bottom = rect->bottom;
2065     }
2066     return DrawCaption(WIN_Handle32(hwnd), HDC_32(hdc), rect ? &rect32 : NULL, flags);
2067 }
2068
2069
2070 /**************************************************************************
2071  *              GetMenuItemRect   (USER.665)
2072  */
2073 BOOL16 WINAPI GetMenuItemRect16( HWND16 hwnd, HMENU16 hMenu, UINT16 uItem,
2074                                  LPRECT16 rect)
2075 {
2076      RECT r32;
2077      BOOL res;
2078      if (!rect) return FALSE;
2079      res = GetMenuItemRect( WIN_Handle32(hwnd), HMENU_32(hMenu), uItem, &r32 );
2080      rect->left   = r32.left;
2081      rect->top    = r32.top;
2082      rect->right  = r32.right;
2083      rect->bottom = r32.bottom;
2084      return res;
2085 }
2086
2087
2088 /**************************************************************************
2089  *              SetWindowRgn   (USER.668)
2090  */
2091 INT16 WINAPI SetWindowRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 redraw )
2092 {
2093     return SetWindowRgn( WIN_Handle32(hwnd), HRGN_32(hrgn), redraw );
2094 }
2095
2096
2097 /**************************************************************************
2098  *              MessageBoxIndirect   (USER.827)
2099  */
2100 INT16 WINAPI MessageBoxIndirect16( LPMSGBOXPARAMS16 msgbox )
2101 {
2102     MSGBOXPARAMSA msgbox32;
2103
2104     msgbox32.cbSize             = msgbox->cbSize;
2105     msgbox32.hwndOwner          = WIN_Handle32( msgbox->hwndOwner );
2106     msgbox32.hInstance          = HINSTANCE_32(msgbox->hInstance);
2107     msgbox32.lpszText           = MapSL(msgbox->lpszText);
2108     msgbox32.lpszCaption        = MapSL(msgbox->lpszCaption);
2109     msgbox32.dwStyle            = msgbox->dwStyle;
2110     msgbox32.lpszIcon           = MapSL(msgbox->lpszIcon);
2111     msgbox32.dwContextHelpId    = msgbox->dwContextHelpId;
2112     msgbox32.lpfnMsgBoxCallback = msgbox->lpfnMsgBoxCallback;
2113     msgbox32.dwLanguageId       = msgbox->dwLanguageId;
2114     return MessageBoxIndirectA( &msgbox32 );
2115 }