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