git.oblomov.eu Git - wine/blob - 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 hwnd, INT16 offset )
 825 {
 826     WND *wndPtr;
 827     LONG_PTR retvalue;
 828     BOOL is_winproc = (offset == GWLP_WNDPROC);
 829
 830     if (offset >= 0)
 831     {
 832         if (!(wndPtr = WIN_GetPtr( WIN_Handle32(hwnd) )))
 833         {
 834             SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 835             return 0;
 836         }
 837         if (wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
 838         {
 839             if (offset > (int)(wndPtr->cbWndExtra - sizeof(LONG)))
 840             {
 841                 /*
 842                  * Some programs try to access last element from 16 bit
 843                  * code using illegal offset value. Hopefully this is
 844                  * what those programs really expect.
 845                  */
 846                 if (wndPtr->cbWndExtra >= 4 && offset == wndPtr->cbWndExtra - sizeof(WORD))
 847                 {
 848                     offset = wndPtr->cbWndExtra - sizeof(LONG);
 849                 }
 850                 else
 851                 {
 852                     WIN_ReleasePtr( wndPtr );
 853                     SetLastError( ERROR_INVALID_INDEX );
 854                     return 0;
 855                 }
 856             }
 857             is_winproc = ((offset == DWLP_DLGPROC) && (wndPtr->flags & WIN_ISDIALOG));
 858             WIN_ReleasePtr( wndPtr );
 859         }
 860     }
 861     retvalue = GetWindowLongA( WIN_Handle32(hwnd), offset );
 862     if (is_winproc) retvalue = (LONG_PTR)WINPROC_GetProc16( (WNDPROC)retvalue, FALSE );
 863     return retvalue;
 864 }
 865
 866
 867 /**********************************************************************
 868  *              SetWindowLong (USER.136)
 869  */
 870 LONG WINAPI SetWindowLong16( HWND16 hwnd, INT16 offset, LONG newval )
 871 {
 872     WND *wndPtr;
 873     BOOL is_winproc = (offset == GWLP_WNDPROC);
 874
 875     if (offset == DWLP_DLGPROC)
 876     {
 877         if (!(wndPtr = WIN_GetPtr( WIN_Handle32(hwnd) )))
 878         {
 879             SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 880             return 0;
 881         }
 882         if (wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
 883         {
 884             is_winproc = ((wndPtr->cbWndExtra - sizeof(LONG_PTR) >= DWLP_DLGPROC) &&
 885                           (wndPtr->flags & WIN_ISDIALOG));
 886             WIN_ReleasePtr( wndPtr );
 887         }
 888     }
 889
 890     if (is_winproc)
 891     {
 892         WNDPROC new_proc = WINPROC_AllocProc16( (WNDPROC16)newval );
 893         WNDPROC old_proc = (WNDPROC)SetWindowLongPtrA( WIN_Handle32(hwnd), offset, (LONG_PTR)new_proc );
 894         return (LONG)WINPROC_GetProc16( old_proc, FALSE );
 895     }
 896     else return SetWindowLongA( WIN_Handle32(hwnd), offset, newval );
 897 }
 898
 899
 900 /**************************************************************************
 901  *              OpenClipboard   (USER.137)
 902  */
 903 BOOL16 WINAPI OpenClipboard16( HWND16 hwnd )
 904 {
 905     return OpenClipboard( WIN_Handle32(hwnd) );
 906 }
 907
 908
 909 /**************************************************************************
 910  *              GetClipboardOwner   (USER.140)
 911  */
 912 HWND16 WINAPI GetClipboardOwner16(void)
 913 {
 914     return HWND_16( GetClipboardOwner() );
 915 }
 916
 917
 918 /**************************************************************************
 919  *              SetClipboardViewer   (USER.147)
 920  */
 921 HWND16 WINAPI SetClipboardViewer16( HWND16 hwnd )
 922 {
 923     return HWND_16( SetClipboardViewer( WIN_Handle32(hwnd) ));
 924 }
 925
 926
 927 /**************************************************************************
 928  *              GetClipboardViewer   (USER.148)
 929  */
 930 HWND16 WINAPI GetClipboardViewer16(void)
 931 {
 932     return HWND_16( GetClipboardViewer() );
 933 }
 934
 935
 936 /**************************************************************************
 937  *              ChangeClipboardChain   (USER.149)
 938  */
 939 BOOL16 WINAPI ChangeClipboardChain16(HWND16 hwnd, HWND16 hwndNext)
 940 {
 941     return ChangeClipboardChain( WIN_Handle32(hwnd), WIN_Handle32(hwndNext) );
 942 }
 943
 944
 945 /**************************************************************************
 946  *              GetSystemMenu   (USER.156)
 947  */
 948 HMENU16 WINAPI GetSystemMenu16( HWND16 hwnd, BOOL16 revert )
 949 {
 950     return HMENU_16(GetSystemMenu( WIN_Handle32(hwnd), revert ));
 951 }
 952
 953
 954 /**************************************************************************
 955  *              GetMenu   (USER.157)
 956  */
 957 HMENU16 WINAPI GetMenu16( HWND16 hwnd )
 958 {
 959     return HMENU_16(GetMenu( WIN_Handle32(hwnd) ));
 960 }
 961
 962
 963 /**************************************************************************
 964  *              SetMenu   (USER.158)
 965  */
 966 BOOL16 WINAPI SetMenu16( HWND16 hwnd, HMENU16 hMenu )
 967 {
 968     return SetMenu( WIN_Handle32(hwnd), HMENU_32(hMenu) );
 969 }
 970
 971
 972 /**************************************************************************
 973  *              DrawMenuBar   (USER.160)
 974  */
 975 void WINAPI DrawMenuBar16( HWND16 hwnd )
 976 {
 977     DrawMenuBar( WIN_Handle32(hwnd) );
 978 }
 979
 980
 981 /**************************************************************************
 982  *              HiliteMenuItem   (USER.162)
 983  */
 984 BOOL16 WINAPI HiliteMenuItem16( HWND16 hwnd, HMENU16 hMenu, UINT16 id, UINT16 wHilite )
 985 {
 986     return HiliteMenuItem( WIN_Handle32(hwnd), HMENU_32(hMenu), id, wHilite );
 987 }
 988
 989
 990 /**************************************************************************
 991  *              CreateCaret   (USER.163)
 992  */
 993 void WINAPI CreateCaret16( HWND16 hwnd, HBITMAP16 bitmap, INT16 width, INT16 height )
 994 {
 995     CreateCaret( WIN_Handle32(hwnd), HBITMAP_32(bitmap), width, height );
 996 }
 997
 998
 999 /*****************************************************************
1000  *              DestroyCaret (USER.164)
1001  */
1002 void WINAPI DestroyCaret16(void)
1003 {
1004     DestroyCaret();
1005 }
1006
1007
1008 /*****************************************************************
1009  *              SetCaretPos (USER.165)
1010  */
1011 void WINAPI SetCaretPos16( INT16 x, INT16 y )
1012 {
1013     SetCaretPos( x, y );
1014 }
1015
1016
1017 /**************************************************************************
1018  *              HideCaret   (USER.166)
1019  */
1020 void WINAPI HideCaret16( HWND16 hwnd )
1021 {
1022     HideCaret( WIN_Handle32(hwnd) );
1023 }
1024
1025
1026 /**************************************************************************
1027  *              ShowCaret   (USER.167)
1028  */
1029 void WINAPI ShowCaret16( HWND16 hwnd )
1030 {
1031     ShowCaret( WIN_Handle32(hwnd) );
1032 }
1033
1034
1035 /*****************************************************************
1036  *              SetCaretBlinkTime (USER.168)
1037  */
1038 void WINAPI SetCaretBlinkTime16( UINT16 msecs )
1039 {
1040     SetCaretBlinkTime( msecs );
1041 }
1042
1043
1044 /*****************************************************************
1045  *              GetCaretBlinkTime (USER.169)
1046  */
1047 UINT16 WINAPI GetCaretBlinkTime16(void)
1048 {
1049     return GetCaretBlinkTime();
1050 }
1051
1052
1053 /**************************************************************************
1054  *              ArrangeIconicWindows   (USER.170)
1055  */
1056 UINT16 WINAPI ArrangeIconicWindows16( HWND16 parent)
1057 {
1058     return ArrangeIconicWindows( WIN_Handle32(parent) );
1059 }
1060
1061
1062 /**************************************************************************
1063  *              SwitchToThisWindow   (USER.172)
1064  */
1065 void WINAPI SwitchToThisWindow16( HWND16 hwnd, BOOL16 restore )
1066 {
1067     SwitchToThisWindow( WIN_Handle32(hwnd), restore );
1068 }
1069
1070
1071 /**************************************************************************
1072  *              KillSystemTimer   (USER.182)
1073  */
1074 BOOL16 WINAPI KillSystemTimer16( HWND16 hwnd, UINT16 id )
1075 {
1076     return KillSystemTimer( WIN_Handle32(hwnd), id );
1077 }
1078
1079
1080 /*****************************************************************
1081  *              GetCaretPos (USER.183)
1082  */
1083 void WINAPI GetCaretPos16( LPPOINT16 pt16 )
1084 {
1085     POINT pt;
1086     if (GetCaretPos( &pt ))
1087     {
1088         pt16->x = pt.x;
1089         pt16->y = pt.y;
1090     }
1091 }
1092
1093
1094 /**************************************************************************
1095  *              SetSysModalWindow   (USER.188)
1096  */
1097 HWND16 WINAPI SetSysModalWindow16( HWND16 hwnd )
1098 {
1099     HWND16 old = hwndSysModal;
1100     hwndSysModal = hwnd;
1101     return old;
1102 }
1103
1104
1105 /**************************************************************************
1106  *              GetSysModalWindow   (USER.189)
1107  */
1108 HWND16 WINAPI GetSysModalWindow16(void)
1109 {
1110     return hwndSysModal;
1111 }
1112
1113
1114 /**************************************************************************
1115  *              GetUpdateRect   (USER.190)
1116  */
1117 BOOL16 WINAPI GetUpdateRect16( HWND16 hwnd, LPRECT16 rect, BOOL16 erase )
1118 {
1119     RECT r;
1120     BOOL16 ret;
1121
1122     if (!rect) return GetUpdateRect( WIN_Handle32(hwnd), NULL, erase );
1123     ret = GetUpdateRect( WIN_Handle32(hwnd), &r, erase );
1124     rect->left   = r.left;
1125     rect->top    = r.top;
1126     rect->right  = r.right;
1127     rect->bottom = r.bottom;
1128     return ret;
1129 }
1130
1131
1132 /**************************************************************************
1133  *              ChildWindowFromPoint   (USER.191)
1134  */
1135 HWND16 WINAPI ChildWindowFromPoint16( HWND16 hwndParent, POINT16 pt )
1136 {
1137     POINT pt32;
1138
1139     pt32.x = pt.x;
1140     pt32.y = pt.y;
1141     return HWND_16( ChildWindowFromPoint( WIN_Handle32(hwndParent), pt32 ));
1142 }
1143
1144
1145 /***********************************************************************
1146  *              CascadeChildWindows (USER.198)
1147  */
1148 void WINAPI CascadeChildWindows16( HWND16 parent, WORD action )
1149 {
1150     CascadeWindows( WIN_Handle32(parent), action, NULL, 0, NULL );
1151 }
1152
1153
1154 /***********************************************************************
1155  *              TileChildWindows (USER.199)
1156  */
1157 void WINAPI TileChildWindows16( HWND16 parent, WORD action )
1158 {
1159     TileWindows( WIN_Handle32(parent), action, NULL, 0, NULL );
1160 }
1161
1162
1163 /***********************************************************************
1164  *              GetWindowTask   (USER.224)
1165  */
1166 HTASK16 WINAPI GetWindowTask16( HWND16 hwnd )
1167 {
1168     DWORD tid = GetWindowThreadProcessId( HWND_32(hwnd), NULL );
1169     if (!tid) return 0;
1170     return HTASK_16(tid);
1171 }
1172
1173 /**********************************************************************
1174  *              EnumTaskWindows   (USER.225)
1175  */
1176 BOOL16 WINAPI EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func, LPARAM lParam )
1177 {
1178     struct wnd_enum_info info;
1179     DWORD tid = HTASK_32( hTask );
1180
1181     if (!tid) return FALSE;
1182     info.proc  = func;
1183     info.param = lParam;
1184     return EnumThreadWindows( tid, wnd_enum_callback, (LPARAM)&info );
1185 }
1186
1187
1188 /**************************************************************************
1189  *              GetTopWindow   (USER.229)
1190  */
1191 HWND16 WINAPI GetTopWindow16( HWND16 hwnd )
1192 {
1193     return HWND_16( GetTopWindow( WIN_Handle32(hwnd) ));
1194 }
1195
1196
1197 /**************************************************************************
1198  *              GetNextWindow   (USER.230)
1199  */
1200 HWND16 WINAPI GetNextWindow16( HWND16 hwnd, WORD flag )
1201 {
1202     if ((flag != GW_HWNDNEXT) && (flag != GW_HWNDPREV)) return 0;
1203     return GetWindow16( hwnd, flag );
1204 }
1205
1206
1207 /**************************************************************************
1208  *              SetWindowPos   (USER.232)
1209  */
1210 BOOL16 WINAPI SetWindowPos16( HWND16 hwnd, HWND16 hwndInsertAfter,
1211                               INT16 x, INT16 y, INT16 cx, INT16 cy, WORD flags)
1212 {
1213     return SetWindowPos( WIN_Handle32(hwnd), full_insert_after_hwnd(hwndInsertAfter),
1214                          x, y, cx, cy, flags );
1215 }
1216
1217
1218 /**************************************************************************
1219  *              SetParent   (USER.233)
1220  */
1221 HWND16 WINAPI SetParent16( HWND16 hwndChild, HWND16 hwndNewParent )
1222 {
1223     return HWND_16( SetParent( WIN_Handle32(hwndChild), WIN_Handle32(hwndNewParent) ));
1224 }
1225
1226
1227 /**************************************************************************
1228  *              GetCapture   (USER.236)
1229  */
1230 HWND16 WINAPI GetCapture16(void)
1231 {
1232     return HWND_16( GetCapture() );
1233 }
1234
1235
1236 /**************************************************************************
1237  *              GetUpdateRgn   (USER.237)
1238  */
1239 INT16 WINAPI GetUpdateRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 erase )
1240 {
1241     return GetUpdateRgn( WIN_Handle32(hwnd), HRGN_32(hrgn), erase );
1242 }
1243
1244
1245 /**************************************************************************
1246  *              ExcludeUpdateRgn   (USER.238)
1247  */
1248 INT16 WINAPI ExcludeUpdateRgn16( HDC16 hdc, HWND16 hwnd )
1249 {
1250     return ExcludeUpdateRgn( HDC_32(hdc), WIN_Handle32(hwnd) );
1251 }
1252
1253
1254 /**************************************************************************
1255  *              GetOpenClipboardWindow   (USER.248)
1256  */
1257 HWND16 WINAPI GetOpenClipboardWindow16(void)
1258 {
1259     return HWND_16( GetOpenClipboardWindow() );
1260 }
1261
1262
1263 /*******************************************************************
1264  *              MapWindowPoints (USER.258)
1265  */
1266 void WINAPI MapWindowPoints16( HWND16 hwndFrom, HWND16 hwndTo, LPPOINT16 lppt, UINT16 count )
1267 {
1268     POINT buffer[8], *ppt = buffer;
1269     UINT i;
1270
1271     if (count > 8) ppt = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*ppt) );
1272     for (i = 0; i < count; i++)
1273     {
1274         ppt[i].x = lppt[i].x;
1275         ppt[i].y = lppt[i].y;
1276     }
1277     MapWindowPoints( WIN_Handle32(hwndFrom), WIN_Handle32(hwndTo), ppt, count );
1278     for (i = 0; i < count; i++)
1279     {
1280         lppt[i].x = ppt[i].x;
1281         lppt[i].y = ppt[i].y;
1282     }
1283     if (ppt != buffer) HeapFree( GetProcessHeap(), 0, ppt );
1284 }
1285
1286
1287 /**************************************************************************
1288  *              BeginDeferWindowPos   (USER.259)
1289  */
1290 HDWP16 WINAPI BeginDeferWindowPos16( INT16 count )
1291 {
1292     return HDWP_16(BeginDeferWindowPos( count ));
1293 }
1294
1295
1296 /**************************************************************************
1297  *              DeferWindowPos   (USER.260)
1298  */
1299 HDWP16 WINAPI DeferWindowPos16( HDWP16 hdwp, HWND16 hwnd, HWND16 hwndAfter,
1300                                 INT16 x, INT16 y, INT16 cx, INT16 cy,
1301                                 UINT16 flags )
1302 {
1303     return HDWP_16(DeferWindowPos( HDWP_32(hdwp), WIN_Handle32(hwnd),
1304                    full_insert_after_hwnd(hwndAfter), x, y, cx, cy, flags ));
1305 }
1306
1307
1308 /**************************************************************************
1309  *              EndDeferWindowPos   (USER.261)
1310  */
1311 BOOL16 WINAPI EndDeferWindowPos16( HDWP16 hdwp )
1312 {
1313     return EndDeferWindowPos(HDWP_32(hdwp));
1314 }
1315
1316
1317 /**************************************************************************
1318  *              GetWindow   (USER.262)
1319  */
1320 HWND16 WINAPI GetWindow16( HWND16 hwnd, WORD rel )
1321 {
1322     return HWND_16( GetWindow( WIN_Handle32(hwnd), rel ) );
1323 }
1324
1325
1326 /**************************************************************************
1327  *              ShowOwnedPopups   (USER.265)
1328  */
1329 void WINAPI ShowOwnedPopups16( HWND16 owner, BOOL16 fShow )
1330 {
1331     ShowOwnedPopups( WIN_Handle32(owner), fShow );
1332 }
1333
1334
1335 /**************************************************************************
1336  *              ShowScrollBar   (USER.267)
1337  */
1338 void WINAPI ShowScrollBar16( HWND16 hwnd, INT16 nBar, BOOL16 fShow )
1339 {
1340     ShowScrollBar( WIN_Handle32(hwnd), nBar, fShow );
1341 }
1342
1343
1344 /**************************************************************************
1345  *              IsZoomed   (USER.272)
1346  */
1347 BOOL16 WINAPI IsZoomed16(HWND16 hwnd)
1348 {
1349     return IsZoomed( WIN_Handle32(hwnd) );
1350 }
1351
1352
1353 /**************************************************************************
1354  *              GetDlgCtrlID   (USER.277)
1355  */
1356 INT16 WINAPI GetDlgCtrlID16( HWND16 hwnd )
1357 {
1358     return GetDlgCtrlID( WIN_Handle32(hwnd) );
1359 }
1360
1361
1362 /**************************************************************************
1363  *              GetDesktopHwnd   (USER.278)
1364  *
1365  * Exactly the same thing as GetDesktopWindow(), but not documented.
1366  * Don't ask me why...
1367  */
1368 HWND16 WINAPI GetDesktopHwnd16(void)
1369 {
1370     return GetDesktopWindow16();
1371 }
1372
1373
1374 /**************************************************************************
1375  *              SetSystemMenu   (USER.280)
1376  */
1377 BOOL16 WINAPI SetSystemMenu16( HWND16 hwnd, HMENU16 hMenu )
1378 {
1379     return SetSystemMenu( WIN_Handle32(hwnd), HMENU_32(hMenu) );
1380 }
1381
1382
1383 /**************************************************************************
1384  *              GetDesktopWindow   (USER.286)
1385  */
1386 HWND16 WINAPI GetDesktopWindow16(void)
1387 {
1388     return HWND_16( GetDesktopWindow() );
1389 }
1390
1391
1392 /**************************************************************************
1393  *              GetLastActivePopup   (USER.287)
1394  */
1395 HWND16 WINAPI GetLastActivePopup16( HWND16 hwnd )
1396 {
1397     return HWND_16( GetLastActivePopup( WIN_Handle32(hwnd) ));
1398 }
1399
1400
1401 /**************************************************************************
1402  *              RedrawWindow   (USER.290)
1403  */
1404 BOOL16 WINAPI RedrawWindow16( HWND16 hwnd, const RECT16 *rectUpdate,
1405                               HRGN16 hrgnUpdate, UINT16 flags )
1406 {
1407     if (rectUpdate)
1408     {
1409         RECT r;
1410         r.left   = rectUpdate->left;
1411         r.top    = rectUpdate->top;
1412         r.right  = rectUpdate->right;
1413         r.bottom = rectUpdate->bottom;
1414         return RedrawWindow(WIN_Handle32(hwnd), &r, HRGN_32(hrgnUpdate), flags);
1415     }
1416     return RedrawWindow(WIN_Handle32(hwnd), NULL, HRGN_32(hrgnUpdate), flags);
1417 }
1418
1419
1420 /**************************************************************************
1421  *              LockWindowUpdate   (USER.294)
1422  */
1423 BOOL16 WINAPI LockWindowUpdate16( HWND16 hwnd )
1424 {
1425     return LockWindowUpdate( WIN_Handle32(hwnd) );
1426 }
1427
1428
1429 /**************************************************************************
1430  *              ScrollWindowEx   (USER.319)
1431  */
1432 INT16 WINAPI ScrollWindowEx16( HWND16 hwnd, INT16 dx, INT16 dy,
1433                                const RECT16 *rect, const RECT16 *clipRect,
1434                                HRGN16 hrgnUpdate, LPRECT16 rcUpdate,
1435                                UINT16 flags )
1436 {
1437     RECT rect32, clipRect32, rcUpdate32;
1438     BOOL16 ret;
1439
1440     if (rect)
1441     {
1442         rect32.left   = rect->left;
1443         rect32.top    = rect->top;
1444         rect32.right  = rect->right;
1445         rect32.bottom = rect->bottom;
1446     }
1447     if (clipRect)
1448     {
1449         clipRect32.left   = clipRect->left;
1450         clipRect32.top    = clipRect->top;
1451         clipRect32.right  = clipRect->right;
1452         clipRect32.bottom = clipRect->bottom;
1453     }
1454     ret = ScrollWindowEx( WIN_Handle32(hwnd), dx, dy, rect ? &rect32 : NULL,
1455                           clipRect ? &clipRect32 : NULL, HRGN_32(hrgnUpdate),
1456                           (rcUpdate) ? &rcUpdate32 : NULL, flags );
1457     if (rcUpdate)
1458     {
1459         rcUpdate->left   = rcUpdate32.left;
1460         rcUpdate->top    = rcUpdate32.top;
1461         rcUpdate->right  = rcUpdate32.right;
1462         rcUpdate->bottom = rcUpdate32.bottom;
1463     }
1464     return ret;
1465 }
1466
1467
1468 /**************************************************************************
1469  *              FillWindow   (USER.324)
1470  */
1471 void WINAPI FillWindow16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc, HBRUSH16 hbrush )
1472 {
1473     RECT rect;
1474     RECT16 rc16;
1475     GetClientRect( WIN_Handle32(hwnd), &rect );
1476     DPtoLP( HDC_32(hdc), (LPPOINT)&rect, 2 );
1477     rc16.left   = rect.left;
1478     rc16.top    = rect.top;
1479     rc16.right  = rect.right;
1480     rc16.bottom = rect.bottom;
1481     PaintRect16( hwndParent, hwnd, hdc, hbrush, &rc16 );
1482 }
1483
1484
1485 /**************************************************************************
1486  *              PaintRect   (USER.325)
1487  */
1488 void WINAPI PaintRect16( HWND16 hwndParent, HWND16 hwnd, HDC16 hdc,
1489                          HBRUSH16 hbrush, const RECT16 *rect)
1490 {
1491     if (hbrush <= CTLCOLOR_STATIC)
1492     {
1493         HWND parent = WIN_Handle32(hwndParent), hwnd32 = WIN_Handle32(hwnd);
1494
1495         if (!parent) return;
1496         hbrush = SendMessageW( parent, WM_CTLCOLORMSGBOX + hbrush, (WPARAM)hdc, (LPARAM)hwnd32 );
1497         if (!hbrush) hbrush = DefWindowProcW( parent, WM_CTLCOLORMSGBOX + hbrush,
1498                                               (WPARAM)hdc, (LPARAM)hwnd32 );
1499     }
1500     if (hbrush) FillRect16( hdc, rect, hbrush );
1501 }
1502
1503
1504 /**************************************************************************
1505  *              GetControlBrush   (USER.326)
1506  */
1507 HBRUSH16 WINAPI GetControlBrush16( HWND16 hwnd, HDC16 hdc, UINT16 ctlType )
1508 {
1509     HBRUSH16 ret;
1510     HWND hwnd32 = WIN_Handle32(hwnd);
1511     HWND parent = GetParent( hwnd32 );
1512
1513     if (!parent) parent = hwnd32;
1514     ret = SendMessageW( parent, WM_CTLCOLORMSGBOX + ctlType, (WPARAM)hdc, (LPARAM)hwnd32 );
1515     if (!ret) ret = DefWindowProcW( parent, WM_CTLCOLORMSGBOX + ctlType,
1516                                     (WPARAM)hdc, (LPARAM)hwnd32 );
1517     return ret;
1518 }
1519
1520
1521 /**************************************************************************
1522  *              GetDCEx   (USER.359)
1523  */
1524 HDC16 WINAPI GetDCEx16( HWND16 hwnd, HRGN16 hrgnClip, DWORD flags )
1525 {
1526     return HDC_16(GetDCEx(WIN_Handle32(hwnd), HRGN_32(hrgnClip), flags));
1527 }
1528
1529
1530 /**************************************************************************
1531  *              GetWindowPlacement   (USER.370)
1532  */
1533 BOOL16 WINAPI GetWindowPlacement16( HWND16 hwnd, WINDOWPLACEMENT16 *wp16 )
1534 {
1535     WINDOWPLACEMENT wpl;
1536
1537     wpl.length = sizeof(wpl);
1538     if (!GetWindowPlacement( WIN_Handle32(hwnd), &wpl )) return FALSE;
1539     wp16->length  = sizeof(*wp16);
1540     wp16->flags   = wpl.flags;
1541     wp16->showCmd = wpl.showCmd;
1542     wp16->ptMinPosition.x = wpl.ptMinPosition.x;
1543     wp16->ptMinPosition.y = wpl.ptMinPosition.y;
1544     wp16->ptMaxPosition.x = wpl.ptMaxPosition.x;
1545     wp16->ptMaxPosition.y = wpl.ptMaxPosition.y;
1546     wp16->rcNormalPosition.left   = wpl.rcNormalPosition.left;
1547     wp16->rcNormalPosition.top    = wpl.rcNormalPosition.top;
1548     wp16->rcNormalPosition.right  = wpl.rcNormalPosition.right;
1549     wp16->rcNormalPosition.bottom = wpl.rcNormalPosition.bottom;
1550     return TRUE;
1551 }
1552
1553
1554 /**************************************************************************
1555  *              SetWindowPlacement   (USER.371)
1556  */
1557 BOOL16 WINAPI SetWindowPlacement16( HWND16 hwnd, const WINDOWPLACEMENT16 *wp16 )
1558 {
1559     WINDOWPLACEMENT wpl;
1560
1561     if (!wp16) return FALSE;
1562     wpl.length  = sizeof(wpl);
1563     wpl.flags   = wp16->flags;
1564     wpl.showCmd = wp16->showCmd;
1565     wpl.ptMinPosition.x = wp16->ptMinPosition.x;
1566     wpl.ptMinPosition.y = wp16->ptMinPosition.y;
1567     wpl.ptMaxPosition.x = wp16->ptMaxPosition.x;
1568     wpl.ptMaxPosition.y = wp16->ptMaxPosition.y;
1569     wpl.rcNormalPosition.left   = wp16->rcNormalPosition.left;
1570     wpl.rcNormalPosition.top    = wp16->rcNormalPosition.top;
1571     wpl.rcNormalPosition.right  = wp16->rcNormalPosition.right;
1572     wpl.rcNormalPosition.bottom = wp16->rcNormalPosition.bottom;
1573     return SetWindowPlacement( WIN_Handle32(hwnd), &wpl );
1574 }
1575
1576
1577 /***********************************************************************
1578  *              RegisterClassEx (USER.397)
1579  */
1580 ATOM WINAPI RegisterClassEx16( const WNDCLASSEX16 *wc )
1581 {
1582     struct class_entry *class;
1583     WNDCLASSEXA wc32;
1584     HINSTANCE16 inst;
1585     ATOM atom;
1586
1587     inst = GetExePtr( wc->hInstance );
1588     if (!inst) inst = GetModuleHandle16( NULL );
1589
1590     wc32.cbSize        = sizeof(wc32);
1591     wc32.style         = wc->style;
1592     wc32.lpfnWndProc   = WINPROC_AllocProc16( wc->lpfnWndProc );
1593     wc32.cbClsExtra    = wc->cbClsExtra;
1594     wc32.cbWndExtra    = wc->cbWndExtra;
1595     wc32.hInstance     = HINSTANCE_32(inst);
1596     wc32.hIcon         = HICON_32(wc->hIcon);
1597     wc32.hCursor       = HCURSOR_32(wc->hCursor);
1598     wc32.hbrBackground = HBRUSH_32(wc->hbrBackground);
1599     wc32.lpszMenuName  = MapSL(wc->lpszMenuName);
1600     wc32.lpszClassName = MapSL(wc->lpszClassName);
1601     wc32.hIconSm       = HICON_32(wc->hIconSm);
1602     atom = RegisterClassExA( &wc32 );
1603     if ((class = HeapAlloc( GetProcessHeap(), 0, sizeof(*class) )))
1604     {
1605         class->atom = atom;
1606         class->inst = inst;
1607         list_add_tail( &class_list, &class->entry );
1608     }
1609     return atom;
1610 }
1611
1612
1613 /***********************************************************************
1614  *              GetClassInfoEx (USER.398)
1615  *
1616  * FIXME: this is just a guess, I have no idea if GetClassInfoEx() is the
1617  * same in Win16 as in Win32. --AJ
1618  */
1619 BOOL16 WINAPI GetClassInfoEx16( HINSTANCE16 hInst16, SEGPTR name, WNDCLASSEX16 *wc )
1620 {
1621     WNDCLASSEXA wc32;
1622     HINSTANCE hInstance;
1623     BOOL ret;
1624
1625     if (hInst16 == GetModuleHandle16("user")) hInstance = user32_module;
1626     else hInstance = HINSTANCE_32(GetExePtr( hInst16 ));
1627
1628     ret = GetClassInfoExA( hInstance, MapSL(name), &wc32 );
1629
1630     if (ret)
1631     {
1632         wc->lpfnWndProc   = WINPROC_GetProc16( wc32.lpfnWndProc, FALSE );
1633         wc->style         = wc32.style;
1634         wc->cbClsExtra    = wc32.cbClsExtra;
1635         wc->cbWndExtra    = wc32.cbWndExtra;
1636         wc->hInstance     = (wc32.hInstance == user32_module) ? GetModuleHandle16("user") : HINSTANCE_16(wc32.hInstance);
1637         wc->hIcon         = HICON_16(wc32.hIcon);
1638         wc->hIconSm       = HICON_16(wc32.hIconSm);
1639         wc->hCursor       = HCURSOR_16(wc32.hCursor);
1640         wc->hbrBackground = HBRUSH_16(wc32.hbrBackground);
1641         wc->lpszClassName = 0;
1642         wc->lpszMenuName  = MapLS(wc32.lpszMenuName);  /* FIXME: leak */
1643     }
1644     return ret;
1645 }
1646
1647
1648 /**************************************************************************
1649  *              ChildWindowFromPointEx   (USER.399)
1650  */
1651 HWND16 WINAPI ChildWindowFromPointEx16( HWND16 hwndParent, POINT16 pt, UINT16 uFlags)
1652 {
1653     POINT pt32;
1654
1655     pt32.x = pt.x;
1656     pt32.y = pt.y;
1657     return HWND_16( ChildWindowFromPointEx( WIN_Handle32(hwndParent), pt32, uFlags ));
1658 }
1659
1660
1661 /**************************************************************************
1662  *              GetPriorityClipboardFormat   (USER.402)
1663  */
1664 INT16 WINAPI GetPriorityClipboardFormat16( UINT16 *list, INT16 count )
1665 {
1666     int i;
1667
1668     for (i = 0; i < count; i++)
1669         if (IsClipboardFormatAvailable( list[i] )) return list[i];
1670     return -1;
1671 }
1672
1673
1674 /***********************************************************************
1675  *              UnregisterClass (USER.403)
1676  */
1677 BOOL16 WINAPI UnregisterClass16( LPCSTR className, HINSTANCE16 hInstance )
1678 {
1679     ATOM atom;
1680
1681     if (hInstance == GetModuleHandle16("user")) hInstance = 0;
1682     else hInstance = GetExePtr( hInstance );
1683
1684     if ((atom = GlobalFindAtomA( className )))
1685     {
1686         struct class_entry *class;
1687         LIST_FOR_EACH_ENTRY( class, &class_list, struct class_entry, entry )
1688         {
1689             if (class->inst != hInstance) continue;
1690             if (class->atom != atom) continue;
1691             list_remove( &class->entry );
1692             HeapFree( GetProcessHeap(), 0, class );
1693             break;
1694         }
1695     }
1696     return UnregisterClassA( className, HINSTANCE_32(hInstance) );
1697 }
1698
1699
1700 /***********************************************************************
1701  *              GetClassInfo (USER.404)
1702  */
1703 BOOL16 WINAPI GetClassInfo16( HINSTANCE16 hInst16, SEGPTR name, WNDCLASS16 *wc )
1704 {
1705     WNDCLASSEX16 wcex;
1706     UINT16 ret = GetClassInfoEx16( hInst16, name, &wcex );
1707
1708     if (ret)
1709     {
1710         wc->style         = wcex.style;
1711         wc->lpfnWndProc   = wcex.lpfnWndProc;
1712         wc->cbClsExtra    = wcex.cbClsExtra;
1713         wc->cbWndExtra    = wcex.cbWndExtra;
1714         wc->hInstance     = wcex.hInstance;
1715         wc->hIcon         = wcex.hIcon;
1716         wc->hCursor       = wcex.hCursor;
1717         wc->hbrBackground = wcex.hbrBackground;
1718         wc->lpszMenuName  = wcex.lpszMenuName;
1719         wc->lpszClassName = wcex.lpszClassName;
1720     }
1721     return ret;
1722 }
1723
1724
1725 /**************************************************************************
1726  *              TrackPopupMenu   (USER.416)
1727  */
1728 BOOL16 WINAPI TrackPopupMenu16( HMENU16 hMenu, UINT16 wFlags, INT16 x, INT16 y,
1729                                 INT16 nReserved, HWND16 hwnd, const RECT16 *lpRect )
1730 {
1731     RECT r;
1732     if (lpRect)
1733     {
1734         r.left   = lpRect->left;
1735         r.top    = lpRect->top;
1736         r.right  = lpRect->right;
1737         r.bottom = lpRect->bottom;
1738     }
1739     return TrackPopupMenu( HMENU_32(hMenu), wFlags, x, y, nReserved,
1740                            WIN_Handle32(hwnd), lpRect ? &r : NULL );
1741 }
1742
1743
1744 /**************************************************************************
1745  *              FindWindowEx   (USER.427)
1746  */
1747 HWND16 WINAPI FindWindowEx16( HWND16 parent, HWND16 child, LPCSTR className, LPCSTR title )
1748 {
1749     return HWND_16( FindWindowExA( WIN_Handle32(parent), WIN_Handle32(child),
1750                                         className, title ));
1751 }
1752
1753
1754 /***********************************************************************
1755  *              DefFrameProc (USER.445)
1756  */
1757 LRESULT WINAPI DefFrameProc16( HWND16 hwnd, HWND16 hwndMDIClient,
1758                                UINT16 message, WPARAM16 wParam, LPARAM lParam )
1759 {
1760     switch (message)
1761     {
1762     case WM_SETTEXT:
1763         lParam = (LPARAM)MapSL(lParam);
1764         /* fall through */
1765     case WM_COMMAND:
1766     case WM_NCACTIVATE:
1767     case WM_SETFOCUS:
1768     case WM_SIZE:
1769         return DefFrameProcA( WIN_Handle32(hwnd), WIN_Handle32(hwndMDIClient),
1770                               message, wParam, lParam );
1771
1772     case WM_NEXTMENU:
1773         {
1774             MDINEXTMENU next_menu;
1775             DefFrameProcW( WIN_Handle32(hwnd), WIN_Handle32(hwndMDIClient),
1776                            message, wParam, (LPARAM)&next_menu );
1777             return MAKELONG( HMENU_16(next_menu.hmenuNext), HWND_16(next_menu.hwndNext) );
1778         }
1779     default:
1780         return DefWindowProc16(hwnd, message, wParam, lParam);
1781     }
1782 }
1783
1784
1785 /***********************************************************************
1786  *              DefMDIChildProc (USER.447)
1787  */
1788 LRESULT WINAPI DefMDIChildProc16( HWND16 hwnd, UINT16 message,
1789                                   WPARAM16 wParam, LPARAM lParam )
1790 {
1791     switch (message)
1792     {
1793     case WM_SETTEXT:
1794         return DefMDIChildProcA( WIN_Handle32(hwnd), message, wParam, (LPARAM)MapSL(lParam) );
1795
1796     case WM_MENUCHAR:
1797     case WM_CLOSE:
1798     case WM_SETFOCUS:
1799     case WM_CHILDACTIVATE:
1800     case WM_SYSCOMMAND:
1801     case WM_SETVISIBLE:
1802     case WM_SIZE:
1803     case WM_SYSCHAR:
1804         return DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, lParam );
1805
1806     case WM_GETMINMAXINFO:
1807         {
1808             MINMAXINFO16 *mmi16 = MapSL(lParam);
1809             MINMAXINFO mmi;
1810
1811             mmi.ptReserved.x     = mmi16->ptReserved.x;
1812             mmi.ptReserved.y     = mmi16->ptReserved.y;
1813             mmi.ptMaxSize.x      = mmi16->ptMaxSize.x;
1814             mmi.ptMaxSize.y      = mmi16->ptMaxSize.y;
1815             mmi.ptMaxPosition.x  = mmi16->ptMaxPosition.x;
1816             mmi.ptMaxPosition.y  = mmi16->ptMaxPosition.y;
1817             mmi.ptMinTrackSize.x = mmi16->ptMinTrackSize.x;
1818             mmi.ptMinTrackSize.y = mmi16->ptMinTrackSize.y;
1819             mmi.ptMaxTrackSize.x = mmi16->ptMaxTrackSize.x;
1820             mmi.ptMaxTrackSize.y = mmi16->ptMaxTrackSize.y;
1821
1822             DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, (LPARAM)&mmi );
1823
1824             mmi16->ptReserved.x     = mmi.ptReserved.x;
1825             mmi16->ptReserved.y     = mmi.ptReserved.y;
1826             mmi16->ptMaxSize.x      = mmi.ptMaxSize.x;
1827             mmi16->ptMaxSize.y      = mmi.ptMaxSize.y;
1828             mmi16->ptMaxPosition.x  = mmi.ptMaxPosition.x;
1829             mmi16->ptMaxPosition.y  = mmi.ptMaxPosition.y;
1830             mmi16->ptMinTrackSize.x = mmi.ptMinTrackSize.x;
1831             mmi16->ptMinTrackSize.y = mmi.ptMinTrackSize.y;
1832             mmi16->ptMaxTrackSize.x = mmi.ptMaxTrackSize.x;
1833             mmi16->ptMaxTrackSize.y = mmi.ptMaxTrackSize.y;
1834             return 0;
1835         }
1836     case WM_NEXTMENU:
1837         {
1838             MDINEXTMENU next_menu;
1839             DefMDIChildProcW( WIN_Handle32(hwnd), message, wParam, (LPARAM)&next_menu );
1840             return MAKELONG( HMENU_16(next_menu.hmenuNext), HWND_16(next_menu.hwndNext) );
1841         }
1842     default:
1843         return DefWindowProc16(hwnd, message, wParam, lParam);
1844     }
1845 }
1846
1847
1848 /**************************************************************************
1849  *              DrawAnimatedRects   (USER.448)
1850  */
1851 BOOL16 WINAPI DrawAnimatedRects16( HWND16 hwnd, INT16 idAni,
1852                                    const RECT16* lprcFrom, const RECT16* lprcTo )
1853 {
1854     RECT rcFrom32, rcTo32;
1855     rcFrom32.left   = lprcFrom->left;
1856     rcFrom32.top    = lprcFrom->top;
1857     rcFrom32.right  = lprcFrom->right;
1858     rcFrom32.bottom = lprcFrom->bottom;
1859     rcTo32.left     = lprcTo->left;
1860     rcTo32.top      = lprcTo->top;
1861     rcTo32.right    = lprcTo->right;
1862     rcTo32.bottom   = lprcTo->bottom;
1863     return DrawAnimatedRects( WIN_Handle32(hwnd), idAni, &rcFrom32, &rcTo32 );
1864 }
1865
1866
1867 /***********************************************************************
1868  *              CreateWindowEx (USER.452)
1869  */
1870 HWND16 WINAPI CreateWindowEx16( DWORD exStyle, LPCSTR className,
1871                                 LPCSTR windowName, DWORD style, INT16 x,
1872                                 INT16 y, INT16 width, INT16 height,
1873                                 HWND16 parent, HMENU16 menu,
1874                                 HINSTANCE16 instance, LPVOID data )
1875 {
1876     CREATESTRUCTA cs;
1877     char buffer[256];
1878     HWND hwnd;
1879
1880     /* Fix the coordinates */
1881
1882     cs.x  = (x == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)x;
1883     cs.y  = (y == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)y;
1884     cs.cx = (width == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)width;
1885     cs.cy = (height == CW_USEDEFAULT16) ? CW_USEDEFAULT : (INT)height;
1886
1887     /* Create the window */
1888
1889     cs.lpCreateParams = data;
1890     cs.hInstance      = HINSTANCE_32(instance);
1891     cs.hMenu          = HMENU_32(menu);
1892     cs.hwndParent     = WIN_Handle32( parent );
1893     cs.style          = style;
1894     cs.lpszName       = windowName;
1895     cs.lpszClass      = className;
1896     cs.dwExStyle      = exStyle;
1897
1898     /* load the menu */
1899     if (!menu && (style & (WS_CHILD | WS_POPUP)) != WS_CHILD)
1900     {
1901         WNDCLASSA class;
1902         HINSTANCE16 module = GetExePtr( instance );
1903
1904         if (GetClassInfoA( HINSTANCE_32(module), className, &class ))
1905             cs.hMenu = HMENU_32( LoadMenu16( module, class.lpszMenuName ));
1906     }
1907
1908     if (!IS_INTRESOURCE(className))
1909     {
1910         WCHAR bufferW[256];
1911
1912         if (!MultiByteToWideChar( CP_ACP, 0, className, -1, bufferW, sizeof(bufferW)/sizeof(WCHAR) ))
1913             return 0;
1914         hwnd = create_window16( (CREATESTRUCTW *)&cs, bufferW, HINSTANCE_32(instance), 0 );
1915     }
1916     else
1917     {
1918         if (!GlobalGetAtomNameA( LOWORD(className), buffer, sizeof(buffer) )) return 0;
1919         cs.lpszClass = buffer;
1920         hwnd = create_window16( (CREATESTRUCTW *)&cs, (LPCWSTR)className, HINSTANCE_32(instance), 0 );
1921     }
1922     return HWND_16( hwnd );
1923 }
1924
1925
1926 /***********************************************************************
1927  *              GetInternalWindowPos (USER.460)
1928  */
1929 UINT16 WINAPI GetInternalWindowPos16( HWND16 hwnd, LPRECT16 rectWnd, LPPOINT16 ptIcon )
1930 {
1931     WINDOWPLACEMENT16 wndpl;
1932
1933     if (!GetWindowPlacement16( hwnd, &wndpl )) return 0;
1934     if (rectWnd) *rectWnd = wndpl.rcNormalPosition;
1935     if (ptIcon)  *ptIcon = wndpl.ptMinPosition;
1936     return wndpl.showCmd;
1937 }
1938
1939
1940 /**************************************************************************
1941  *              SetInternalWindowPos   (USER.461)
1942  */
1943 void WINAPI SetInternalWindowPos16( HWND16 hwnd, UINT16 showCmd, LPRECT16 rect, LPPOINT16 pt )
1944 {
1945     RECT rc32;
1946     POINT pt32;
1947
1948     if (rect)
1949     {
1950         rc32.left   = rect->left;
1951         rc32.top    = rect->top;
1952         rc32.right  = rect->right;
1953         rc32.bottom = rect->bottom;
1954     }
1955     if (pt)
1956     {
1957         pt32.x = pt->x;
1958         pt32.y = pt->y;
1959     }
1960     SetInternalWindowPos( WIN_Handle32(hwnd), showCmd,
1961                           rect ? &rc32 : NULL, pt ? &pt32 : NULL );
1962 }
1963
1964
1965 /**************************************************************************
1966  *              CalcChildScroll   (USER.462)
1967  */
1968 void WINAPI CalcChildScroll16( HWND16 hwnd, WORD scroll )
1969 {
1970     CalcChildScroll( WIN_Handle32(hwnd), scroll );
1971 }
1972
1973
1974 /**************************************************************************
1975  *              ScrollChildren   (USER.463)
1976  */
1977 void WINAPI ScrollChildren16(HWND16 hwnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam)
1978 {
1979     ScrollChildren( WIN_Handle32(hwnd), uMsg, wParam, lParam );
1980 }
1981
1982
1983 /**************************************************************************
1984  *              DragDetect   (USER.465)
1985  */
1986 BOOL16 WINAPI DragDetect16( HWND16 hwnd, POINT16 pt )
1987 {
1988     POINT pt32;
1989
1990     pt32.x = pt.x;
1991     pt32.y = pt.y;
1992     return DragDetect( WIN_Handle32(hwnd), pt32 );
1993 }
1994
1995
1996 /**************************************************************************
1997  *              SetScrollInfo   (USER.475)
1998  */
1999 INT16 WINAPI SetScrollInfo16( HWND16 hwnd, INT16 nBar, const SCROLLINFO *info, BOOL16 redraw )
2000 {
2001     return SetScrollInfo( WIN_Handle32(hwnd), nBar, info, redraw );
2002 }
2003
2004
2005 /**************************************************************************
2006  *              GetScrollInfo   (USER.476)
2007  */
2008 BOOL16 WINAPI GetScrollInfo16( HWND16 hwnd, INT16 nBar, LPSCROLLINFO info )
2009 {
2010     return GetScrollInfo( WIN_Handle32(hwnd), nBar, info );
2011 }
2012
2013
2014 /**************************************************************************
2015  *              EnableScrollBar   (USER.482)
2016  */
2017 BOOL16 WINAPI EnableScrollBar16( HWND16 hwnd, INT16 nBar, UINT16 flags )
2018 {
2019     return EnableScrollBar( WIN_Handle32(hwnd), nBar, flags );
2020 }
2021
2022
2023 /**************************************************************************
2024  *              GetShellWindow   (USER.600)
2025  */
2026 HWND16 WINAPI GetShellWindow16(void)
2027 {
2028     return HWND_16( GetShellWindow() );
2029 }
2030
2031
2032 /**************************************************************************
2033  *              GetForegroundWindow   (USER.608)
2034  */
2035 HWND16 WINAPI GetForegroundWindow16(void)
2036 {
2037     return HWND_16( GetForegroundWindow() );
2038 }
2039
2040
2041 /**************************************************************************
2042  *              SetForegroundWindow   (USER.609)
2043  */
2044 BOOL16 WINAPI SetForegroundWindow16( HWND16 hwnd )
2045 {
2046     return SetForegroundWindow( WIN_Handle32(hwnd) );
2047 }
2048
2049
2050 /**************************************************************************
2051  *              DrawCaptionTemp   (USER.657)
2052  */
2053 BOOL16 WINAPI DrawCaptionTemp16( HWND16 hwnd, HDC16 hdc, const RECT16 *rect,
2054                                  HFONT16 hFont, HICON16 hIcon, LPCSTR str, UINT16 uFlags )
2055 {
2056     RECT rect32;
2057
2058     if (rect)
2059     {
2060         rect32.left   = rect->left;
2061         rect32.top    = rect->top;
2062         rect32.right  = rect->right;
2063         rect32.bottom = rect->bottom;
2064     }
2065     return DrawCaptionTempA( WIN_Handle32(hwnd), HDC_32(hdc),
2066                              rect ? &rect32 : NULL, HFONT_32(hFont),
2067                              HICON_32(hIcon), str, uFlags & 0x1f );
2068 }
2069
2070
2071 /**************************************************************************
2072  *              DrawCaption   (USER.660)
2073  */
2074 BOOL16 WINAPI DrawCaption16( HWND16 hwnd, HDC16 hdc, const RECT16 *rect, UINT16 flags )
2075 {
2076     RECT rect32;
2077
2078     if (rect)
2079     {
2080         rect32.left   = rect->left;
2081         rect32.top    = rect->top;
2082         rect32.right  = rect->right;
2083         rect32.bottom = rect->bottom;
2084     }
2085     return DrawCaption(WIN_Handle32(hwnd), HDC_32(hdc), rect ? &rect32 : NULL, flags);
2086 }
2087
2088
2089 /**************************************************************************
2090  *              GetMenuItemRect   (USER.665)
2091  */
2092 BOOL16 WINAPI GetMenuItemRect16( HWND16 hwnd, HMENU16 hMenu, UINT16 uItem,
2093                                  LPRECT16 rect)
2094 {
2095      RECT r32;
2096      BOOL res;
2097      if (!rect) return FALSE;
2098      res = GetMenuItemRect( WIN_Handle32(hwnd), HMENU_32(hMenu), uItem, &r32 );
2099      rect->left   = r32.left;
2100      rect->top    = r32.top;
2101      rect->right  = r32.right;
2102      rect->bottom = r32.bottom;
2103      return res;
2104 }
2105
2106
2107 /**************************************************************************
2108  *              SetWindowRgn   (USER.668)
2109  */
2110 INT16 WINAPI SetWindowRgn16( HWND16 hwnd, HRGN16 hrgn, BOOL16 redraw )
2111 {
2112     return SetWindowRgn( WIN_Handle32(hwnd), HRGN_32(hrgn), redraw );
2113 }
2114
2115
2116 /**************************************************************************
2117  *              MessageBoxIndirect   (USER.827)
2118  */
2119 INT16 WINAPI MessageBoxIndirect16( LPMSGBOXPARAMS16 msgbox )
2120 {
2121     MSGBOXPARAMSA msgbox32;
2122
2123     msgbox32.cbSize             = msgbox->cbSize;
2124     msgbox32.hwndOwner          = WIN_Handle32( msgbox->hwndOwner );
2125     msgbox32.hInstance          = HINSTANCE_32(msgbox->hInstance);
2126     msgbox32.lpszText           = MapSL(msgbox->lpszText);
2127     msgbox32.lpszCaption        = MapSL(msgbox->lpszCaption);
2128     msgbox32.dwStyle            = msgbox->dwStyle;
2129     msgbox32.lpszIcon           = MapSL(msgbox->lpszIcon);
2130     msgbox32.dwContextHelpId    = msgbox->dwContextHelpId;
2131     msgbox32.lpfnMsgBoxCallback = msgbox->lpfnMsgBoxCallback;
2132     msgbox32.dwLanguageId       = msgbox->dwLanguageId;
2133     return MessageBoxIndirectA( &msgbox32 );
2134 }