dlls/user32/user16.c

   1 /*
   2  * Misc 16-bit USER functions
   3  *
   4  * Copyright 1993, 1996 Alexandre Julliard
   5  * Copyright 2002 Patrik Stridvall
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26
  27 #define OEMRESOURCE
  28
  29 #include "wine/winuser16.h"
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wownt32.h"
  33 #include "user_private.h"
  34 #include "win.h"
  35 #include "controls.h"
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(user);
  39
  40 /* handle to handle 16 conversions */
  41 #define HANDLE_16(h32)          (LOWORD(h32))
  42
  43 /* handle16 to handle conversions */
  44 #define HANDLE_32(h16)          ((HANDLE)(ULONG_PTR)(h16))
  45 #define HINSTANCE_32(h16)       ((HINSTANCE)(ULONG_PTR)(h16))
  46
  47 #define IS_MENU_STRING_ITEM(flags) \
  48     (((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR)) == MF_STRING)
  49
  50 /* UserSeeUserDo parameters */
  51 #define USUD_LOCALALLOC        0x0001
  52 #define USUD_LOCALFREE         0x0002
  53 #define USUD_LOCALCOMPACT      0x0003
  54 #define USUD_LOCALHEAP         0x0004
  55 #define USUD_FIRSTCLASS        0x0005
  56
  57 WORD WINAPI DestroyIcon32(HGLOBAL16, UINT16);
  58
  59
  60 struct gray_string_info
  61 {
  62     GRAYSTRINGPROC16 proc;
  63     LPARAM           param;
  64     char             str[1];
  65 };
  66
  67 /* callback for 16-bit gray string proc with opaque pointer */
  68 static BOOL CALLBACK gray_string_callback( HDC hdc, LPARAM param, INT len )
  69 {
  70     const struct gray_string_info *info = (struct gray_string_info *)param;
  71     WORD args[4];
  72     DWORD ret;
  73
  74     args[3] = HDC_16(hdc);
  75     args[2] = HIWORD(info->param);
  76     args[1] = LOWORD(info->param);
  77     args[0] = len;
  78     WOWCallback16Ex( (DWORD)info->proc, WCB16_PASCAL, sizeof(args), args, &ret );
  79     return LOWORD(ret);
  80 }
  81
  82 /* callback for 16-bit gray string proc with string pointer */
  83 static BOOL CALLBACK gray_string_callback_ptr( HDC hdc, LPARAM param, INT len )
  84 {
  85     const struct gray_string_info *info;
  86     char *str = (char *)param;
  87
  88     info = (struct gray_string_info *)(str - offsetof( struct gray_string_info, str ));
  89     return gray_string_callback( hdc, (LPARAM)info, len );
  90 }
  91
  92 struct draw_state_info
  93 {
  94     DRAWSTATEPROC16 proc;
  95     LPARAM          param;
  96 };
  97
  98 /* callback for 16-bit DrawState functions */
  99 static BOOL CALLBACK draw_state_callback( HDC hdc, LPARAM lparam, WPARAM wparam, int cx, int cy )
 100 {
 101     const struct draw_state_info *info = (struct draw_state_info *)lparam;
 102     WORD args[6];
 103     DWORD ret;
 104
 105     args[5] = HDC_16(hdc);
 106     args[4] = HIWORD(info->param);
 107     args[3] = LOWORD(info->param);
 108     args[2] = wparam;
 109     args[1] = cx;
 110     args[0] = cy;
 111     WOWCallback16Ex( (DWORD)info->proc, WCB16_PASCAL, sizeof(args), args, &ret );
 112     return LOWORD(ret);
 113 }
 114
 115
 116 /**********************************************************************
 117  *              InitApp (USER.5)
 118  */
 119 INT16 WINAPI InitApp16( HINSTANCE16 hInstance )
 120 {
 121     /* Create task message queue */
 122     return (InitThreadInput16( 0, 0 ) != 0);
 123 }
 124
 125
 126 /***********************************************************************
 127  *              ExitWindows (USER.7)
 128  */
 129 BOOL16 WINAPI ExitWindows16( DWORD dwReturnCode, UINT16 wReserved )
 130 {
 131     return ExitWindowsEx( EWX_LOGOFF, 0xffffffff );
 132 }
 133
 134
 135 /***********************************************************************
 136  *              GetTimerResolution (USER.14)
 137  */
 138 LONG WINAPI GetTimerResolution16(void)
 139 {
 140     return (1000);
 141 }
 142
 143
 144 /***********************************************************************
 145  *              ClipCursor (USER.16)
 146  */
 147 BOOL16 WINAPI ClipCursor16( const RECT16 *rect )
 148 {
 149     RECT rect32;
 150
 151     if (!rect) return ClipCursor( NULL );
 152     rect32.left   = rect->left;
 153     rect32.top    = rect->top;
 154     rect32.right  = rect->right;
 155     rect32.bottom = rect->bottom;
 156     return ClipCursor( &rect32 );
 157 }
 158
 159
 160 /***********************************************************************
 161  *              GetCursorPos (USER.17)
 162  */
 163 BOOL16 WINAPI GetCursorPos16( POINT16 *pt )
 164 {
 165     POINT pos;
 166     if (!pt) return 0;
 167     GetCursorPos(&pos);
 168     pt->x = pos.x;
 169     pt->y = pos.y;
 170     return 1;
 171 }
 172
 173
 174 /***********************************************************************
 175  *              SetCursor (USER.69)
 176  */
 177 HCURSOR16 WINAPI SetCursor16(HCURSOR16 hCursor)
 178 {
 179   return HCURSOR_16(SetCursor(HCURSOR_32(hCursor)));
 180 }
 181
 182
 183 /***********************************************************************
 184  *              SetCursorPos (USER.70)
 185  */
 186 void WINAPI SetCursorPos16( INT16 x, INT16 y )
 187 {
 188     SetCursorPos( x, y );
 189 }
 190
 191
 192 /***********************************************************************
 193  *              ShowCursor (USER.71)
 194  */
 195 INT16 WINAPI ShowCursor16(BOOL16 bShow)
 196 {
 197   return ShowCursor(bShow);
 198 }
 199
 200
 201 /***********************************************************************
 202  *              SetRect (USER.72)
 203  */
 204 void WINAPI SetRect16( LPRECT16 rect, INT16 left, INT16 top, INT16 right, INT16 bottom )
 205 {
 206     rect->left   = left;
 207     rect->right  = right;
 208     rect->top    = top;
 209     rect->bottom = bottom;
 210 }
 211
 212
 213 /***********************************************************************
 214  *              SetRectEmpty (USER.73)
 215  */
 216 void WINAPI SetRectEmpty16( LPRECT16 rect )
 217 {
 218     rect->left = rect->right = rect->top = rect->bottom = 0;
 219 }
 220
 221
 222 /***********************************************************************
 223  *              CopyRect (USER.74)
 224  */
 225 BOOL16 WINAPI CopyRect16( RECT16 *dest, const RECT16 *src )
 226 {
 227     *dest = *src;
 228     return TRUE;
 229 }
 230
 231
 232 /***********************************************************************
 233  *              IsRectEmpty (USER.75)
 234  *
 235  * Bug compat: Windows checks for 0 or negative width/height.
 236  */
 237 BOOL16 WINAPI IsRectEmpty16( const RECT16 *rect )
 238 {
 239     return ((rect->left >= rect->right) || (rect->top >= rect->bottom));
 240 }
 241
 242
 243 /***********************************************************************
 244  *              PtInRect (USER.76)
 245  */
 246 BOOL16 WINAPI PtInRect16( const RECT16 *rect, POINT16 pt )
 247 {
 248     return ((pt.x >= rect->left) && (pt.x < rect->right) &&
 249             (pt.y >= rect->top) && (pt.y < rect->bottom));
 250 }
 251
 252
 253 /***********************************************************************
 254  *              OffsetRect (USER.77)
 255  */
 256 void WINAPI OffsetRect16( LPRECT16 rect, INT16 x, INT16 y )
 257 {
 258     rect->left   += x;
 259     rect->right  += x;
 260     rect->top    += y;
 261     rect->bottom += y;
 262 }
 263
 264
 265 /***********************************************************************
 266  *              InflateRect (USER.78)
 267  */
 268 void WINAPI InflateRect16( LPRECT16 rect, INT16 x, INT16 y )
 269 {
 270     rect->left   -= x;
 271     rect->top    -= y;
 272     rect->right  += x;
 273     rect->bottom += y;
 274 }
 275
 276
 277 /***********************************************************************
 278  *              IntersectRect (USER.79)
 279  */
 280 BOOL16 WINAPI IntersectRect16( LPRECT16 dest, const RECT16 *src1,
 281                                const RECT16 *src2 )
 282 {
 283     if (IsRectEmpty16(src1) || IsRectEmpty16(src2) ||
 284         (src1->left >= src2->right) || (src2->left >= src1->right) ||
 285         (src1->top >= src2->bottom) || (src2->top >= src1->bottom))
 286     {
 287         SetRectEmpty16( dest );
 288         return FALSE;
 289     }
 290     dest->left   = max( src1->left, src2->left );
 291     dest->right  = min( src1->right, src2->right );
 292     dest->top    = max( src1->top, src2->top );
 293     dest->bottom = min( src1->bottom, src2->bottom );
 294     return TRUE;
 295 }
 296
 297
 298 /***********************************************************************
 299  *              UnionRect (USER.80)
 300  */
 301 BOOL16 WINAPI UnionRect16( LPRECT16 dest, const RECT16 *src1,
 302                            const RECT16 *src2 )
 303 {
 304     if (IsRectEmpty16(src1))
 305     {
 306         if (IsRectEmpty16(src2))
 307         {
 308             SetRectEmpty16( dest );
 309             return FALSE;
 310         }
 311         else *dest = *src2;
 312     }
 313     else
 314     {
 315         if (IsRectEmpty16(src2)) *dest = *src1;
 316         else
 317         {
 318             dest->left   = min( src1->left, src2->left );
 319             dest->right  = max( src1->right, src2->right );
 320             dest->top    = min( src1->top, src2->top );
 321             dest->bottom = max( src1->bottom, src2->bottom );
 322         }
 323     }
 324     return TRUE;
 325 }
 326
 327
 328 /***********************************************************************
 329  *              FillRect (USER.81)
 330  * NOTE
 331  *   The Win16 variant doesn't support special color brushes like
 332  *   the Win32 one, despite the fact that Win16, as well as Win32,
 333  *   supports special background brushes for a window class.
 334  */
 335 INT16 WINAPI FillRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
 336 {
 337     HBRUSH prevBrush;
 338
 339     /* coordinates are logical so we cannot fast-check 'rect',
 340      * it will be done later in the PatBlt().
 341      */
 342
 343     if (!(prevBrush = SelectObject( HDC_32(hdc), HBRUSH_32(hbrush) ))) return 0;
 344     PatBlt( HDC_32(hdc), rect->left, rect->top,
 345               rect->right - rect->left, rect->bottom - rect->top, PATCOPY );
 346     SelectObject( HDC_32(hdc), prevBrush );
 347     return 1;
 348 }
 349
 350
 351 /***********************************************************************
 352  *              InvertRect (USER.82)
 353  */
 354 void WINAPI InvertRect16( HDC16 hdc, const RECT16 *rect )
 355 {
 356     PatBlt( HDC_32(hdc), rect->left, rect->top,
 357               rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
 358 }
 359
 360
 361 /***********************************************************************
 362  *              FrameRect (USER.83)
 363  */
 364 INT16 WINAPI FrameRect16( HDC16 hdc, const RECT16 *rect16, HBRUSH16 hbrush )
 365 {
 366     RECT rect;
 367
 368     rect.left   = rect16->left;
 369     rect.top    = rect16->top;
 370     rect.right  = rect16->right;
 371     rect.bottom = rect16->bottom;
 372     return FrameRect( HDC_32(hdc), &rect, HBRUSH_32(hbrush) );
 373 }
 374
 375
 376 /***********************************************************************
 377  *              DrawIcon (USER.84)
 378  */
 379 BOOL16 WINAPI DrawIcon16(HDC16 hdc, INT16 x, INT16 y, HICON16 hIcon)
 380 {
 381   return DrawIcon(HDC_32(hdc), x, y, HICON_32(hIcon));
 382 }
 383
 384
 385 /***********************************************************************
 386  *           DrawText    (USER.85)
 387  */
 388 INT16 WINAPI DrawText16( HDC16 hdc, LPCSTR str, INT16 count, LPRECT16 rect, UINT16 flags )
 389 {
 390     INT16 ret;
 391
 392     if (rect)
 393     {
 394         RECT rect32;
 395
 396         rect32.left   = rect->left;
 397         rect32.top    = rect->top;
 398         rect32.right  = rect->right;
 399         rect32.bottom = rect->bottom;
 400         ret = DrawTextA( HDC_32(hdc), str, count, &rect32, flags );
 401         rect->left   = rect32.left;
 402         rect->top    = rect32.top;
 403         rect->right  = rect32.right;
 404         rect->bottom = rect32.bottom;
 405     }
 406     else ret = DrawTextA( HDC_32(hdc), str, count, NULL, flags);
 407     return ret;
 408 }
 409
 410
 411 /***********************************************************************
 412  *              IconSize (USER.86)
 413  *
 414  * See "Undocumented Windows". Used by W2.0 paint.exe.
 415  */
 416 DWORD WINAPI IconSize16(void)
 417 {
 418   return MAKELONG(GetSystemMetrics(SM_CYICON), GetSystemMetrics(SM_CXICON));
 419 }
 420
 421
 422 /***********************************************************************
 423  *              AdjustWindowRect (USER.102)
 424  */
 425 BOOL16 WINAPI AdjustWindowRect16( LPRECT16 rect, DWORD style, BOOL16 menu )
 426 {
 427     return AdjustWindowRectEx16( rect, style, menu, 0 );
 428 }
 429
 430
 431 /**************************************************************************
 432  *              CloseClipboard (USER.138)
 433  */
 434 BOOL16 WINAPI CloseClipboard16(void)
 435 {
 436     return CloseClipboard();
 437 }
 438
 439
 440 /**************************************************************************
 441  *              EmptyClipboard (USER.139)
 442  */
 443 BOOL16 WINAPI EmptyClipboard16(void)
 444 {
 445     return EmptyClipboard();
 446 }
 447
 448
 449 /**************************************************************************
 450  *              SetClipboardData (USER.141)
 451  */
 452 HANDLE16 WINAPI SetClipboardData16(UINT16 wFormat, HANDLE16 hData)
 453 {
 454     return HANDLE_16(SetClipboardData(wFormat, HANDLE_32(hData)));
 455 }
 456
 457
 458 /**************************************************************************
 459  *              GetClipboardData (USER.142)
 460  */
 461 HANDLE16 WINAPI GetClipboardData16(UINT16 wFormat)
 462 {
 463     return HANDLE_16(GetClipboardData(wFormat));
 464 }
 465
 466
 467 /**************************************************************************
 468  *              CountClipboardFormats (USER.143)
 469  */
 470 INT16 WINAPI CountClipboardFormats16(void)
 471 {
 472     return CountClipboardFormats();
 473 }
 474
 475
 476 /**************************************************************************
 477  *              EnumClipboardFormats (USER.144)
 478  */
 479 UINT16 WINAPI EnumClipboardFormats16( UINT16 id )
 480 {
 481     return EnumClipboardFormats( id );
 482 }
 483
 484
 485 /**************************************************************************
 486  *              RegisterClipboardFormat (USER.145)
 487  */
 488 UINT16 WINAPI RegisterClipboardFormat16( LPCSTR name )
 489 {
 490     return RegisterClipboardFormatA( name );
 491 }
 492
 493
 494 /**************************************************************************
 495  *              GetClipboardFormatName (USER.146)
 496  */
 497 INT16 WINAPI GetClipboardFormatName16( UINT16 id, LPSTR buffer, INT16 maxlen )
 498 {
 499     return GetClipboardFormatNameA( id, buffer, maxlen );
 500 }
 501
 502
 503 /**********************************************************************
 504  *         CreateMenu    (USER.151)
 505  */
 506 HMENU16 WINAPI CreateMenu16(void)
 507 {
 508     return HMENU_16( CreateMenu() );
 509 }
 510
 511
 512 /**********************************************************************
 513  *         DestroyMenu    (USER.152)
 514  */
 515 BOOL16 WINAPI DestroyMenu16( HMENU16 hMenu )
 516 {
 517     return DestroyMenu( HMENU_32(hMenu) );
 518 }
 519
 520
 521 /*******************************************************************
 522  *         ChangeMenu    (USER.153)
 523  */
 524 BOOL16 WINAPI ChangeMenu16( HMENU16 hMenu, UINT16 pos, SEGPTR data,
 525                             UINT16 id, UINT16 flags )
 526 {
 527     if (flags & MF_APPEND) return AppendMenu16( hMenu, flags & ~MF_APPEND, id, data );
 528
 529     /* FIXME: Word passes the item id in 'pos' and 0 or 0xffff as id */
 530     /* for MF_DELETE. We should check the parameters for all others */
 531     /* MF_* actions also (anybody got a doc on ChangeMenu?). */
 532
 533     if (flags & MF_DELETE) return DeleteMenu16(hMenu, pos, flags & ~MF_DELETE);
 534     if (flags & MF_CHANGE) return ModifyMenu16(hMenu, pos, flags & ~MF_CHANGE, id, data );
 535     if (flags & MF_REMOVE) return RemoveMenu16(hMenu, flags & MF_BYPOSITION ? pos : id,
 536                                                flags & ~MF_REMOVE );
 537     /* Default: MF_INSERT */
 538     return InsertMenu16( hMenu, pos, flags, id, data );
 539 }
 540
 541
 542 /*******************************************************************
 543  *         CheckMenuItem    (USER.154)
 544  */
 545 BOOL16 WINAPI CheckMenuItem16( HMENU16 hMenu, UINT16 id, UINT16 flags )
 546 {
 547     return CheckMenuItem( HMENU_32(hMenu), id, flags );
 548 }
 549
 550
 551 /**********************************************************************
 552  *         EnableMenuItem    (USER.155)
 553  */
 554 BOOL16 WINAPI EnableMenuItem16( HMENU16 hMenu, UINT16 wItemID, UINT16 wFlags )
 555 {
 556     return EnableMenuItem( HMENU_32(hMenu), wItemID, wFlags );
 557 }
 558
 559
 560 /**********************************************************************
 561  *         GetSubMenu    (USER.159)
 562  */
 563 HMENU16 WINAPI GetSubMenu16( HMENU16 hMenu, INT16 nPos )
 564 {
 565     return HMENU_16( GetSubMenu( HMENU_32(hMenu), nPos ) );
 566 }
 567
 568
 569 /*******************************************************************
 570  *         GetMenuString    (USER.161)
 571  */
 572 INT16 WINAPI GetMenuString16( HMENU16 hMenu, UINT16 wItemID,
 573                               LPSTR str, INT16 nMaxSiz, UINT16 wFlags )
 574 {
 575     return GetMenuStringA( HMENU_32(hMenu), wItemID, str, nMaxSiz, wFlags );
 576 }
 577
 578
 579 /**********************************************************************
 580  *              WinHelp (USER.171)
 581  */
 582 BOOL16 WINAPI WinHelp16( HWND16 hWnd, LPCSTR lpHelpFile, UINT16 wCommand,
 583                          DWORD dwData )
 584 {
 585     BOOL ret;
 586     DWORD mutex_count;
 587
 588     /* We might call WinExec() */
 589     ReleaseThunkLock(&mutex_count);
 590
 591     ret = WinHelpA(WIN_Handle32(hWnd), lpHelpFile, wCommand, (DWORD)MapSL(dwData));
 592
 593     RestoreThunkLock(mutex_count);
 594     return ret;
 595 }
 596
 597
 598 /***********************************************************************
 599  *              LoadCursor (USER.173)
 600  */
 601 HCURSOR16 WINAPI LoadCursor16(HINSTANCE16 hInstance, LPCSTR name)
 602 {
 603   return HCURSOR_16(LoadCursorA(HINSTANCE_32(hInstance), name));
 604 }
 605
 606
 607 /***********************************************************************
 608  *              LoadIcon (USER.174)
 609  */
 610 HICON16 WINAPI LoadIcon16(HINSTANCE16 hInstance, LPCSTR name)
 611 {
 612   return HICON_16(LoadIconA(HINSTANCE_32(hInstance), name));
 613 }
 614
 615 /**********************************************************************
 616  *              LoadBitmap (USER.175)
 617  */
 618 HBITMAP16 WINAPI LoadBitmap16(HINSTANCE16 hInstance, LPCSTR name)
 619 {
 620   return HBITMAP_16(LoadBitmapA(HINSTANCE_32(hInstance), name));
 621 }
 622
 623
 624 /***********************************************************************
 625  *              GetSystemMetrics (USER.179)
 626  */
 627 INT16 WINAPI GetSystemMetrics16( INT16 index )
 628 {
 629     return GetSystemMetrics( index );
 630 }
 631
 632
 633 /*************************************************************************
 634  *              GetSysColor (USER.180)
 635  */
 636 COLORREF WINAPI GetSysColor16( INT16 index )
 637 {
 638     return GetSysColor( index );
 639 }
 640
 641
 642 /*************************************************************************
 643  *              SetSysColors (USER.181)
 644  */
 645 VOID WINAPI SetSysColors16( INT16 count, const INT16 *list16, const COLORREF *values )
 646 {
 647     INT i, *list;
 648
 649     if ((list = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*list) )))
 650     {
 651         for (i = 0; i < count; i++) list[i] = list16[i];
 652         SetSysColors( count, list, values );
 653         HeapFree( GetProcessHeap(), 0, list );
 654     }
 655 }
 656
 657
 658 /***********************************************************************
 659  *           GrayString   (USER.185)
 660  */
 661 BOOL16 WINAPI GrayString16( HDC16 hdc, HBRUSH16 hbr, GRAYSTRINGPROC16 gsprc,
 662                             LPARAM lParam, INT16 cch, INT16 x, INT16 y,
 663                             INT16 cx, INT16 cy )
 664 {
 665     BOOL ret;
 666
 667     if (!gsprc) return GrayStringA( HDC_32(hdc), HBRUSH_32(hbr), NULL,
 668                                     (LPARAM)MapSL(lParam), cch, x, y, cx, cy );
 669
 670     if (cch == -1 || (cch && cx && cy))
 671     {
 672         /* lParam can be treated as an opaque pointer */
 673         struct gray_string_info info;
 674
 675         info.proc  = gsprc;
 676         info.param = lParam;
 677         ret = GrayStringA( HDC_32(hdc), HBRUSH_32(hbr), gray_string_callback,
 678                            (LPARAM)&info, cch, x, y, cx, cy );
 679     }
 680     else  /* here we need some string conversions */
 681     {
 682         char *str16 = MapSL(lParam);
 683         struct gray_string_info *info;
 684
 685         if (!cch) cch = strlen(str16);
 686         if (!(info = HeapAlloc( GetProcessHeap(), 0, sizeof(*info) + cch ))) return FALSE;
 687         info->proc  = gsprc;
 688         info->param = lParam;
 689         memcpy( info->str, str16, cch );
 690         ret = GrayStringA( HDC_32(hdc), HBRUSH_32(hbr), gray_string_callback_ptr,
 691                            (LPARAM)info->str, cch, x, y, cx, cy );
 692         HeapFree( GetProcessHeap(), 0, info );
 693     }
 694     return ret;
 695 }
 696
 697
 698 /**************************************************************************
 699  *              IsClipboardFormatAvailable (USER.193)
 700  */
 701 BOOL16 WINAPI IsClipboardFormatAvailable16( UINT16 wFormat )
 702 {
 703     return IsClipboardFormatAvailable( wFormat );
 704 }
 705
 706
 707 /***********************************************************************
 708  *           TabbedTextOut    (USER.196)
 709  */
 710 LONG WINAPI TabbedTextOut16( HDC16 hdc, INT16 x, INT16 y, LPCSTR lpstr,
 711                              INT16 count, INT16 nb_tabs, const INT16 *tabs16, INT16 tab_org )
 712 {
 713     LONG ret;
 714     INT i, *tabs = HeapAlloc( GetProcessHeap(), 0, nb_tabs * sizeof(tabs) );
 715     if (!tabs) return 0;
 716     for (i = 0; i < nb_tabs; i++) tabs[i] = tabs16[i];
 717     ret = TabbedTextOutA( HDC_32(hdc), x, y, lpstr, count, nb_tabs, tabs, tab_org );
 718     HeapFree( GetProcessHeap(), 0, tabs );
 719     return ret;
 720 }
 721
 722
 723 /***********************************************************************
 724  *           GetTabbedTextExtent    (USER.197)
 725  */
 726 DWORD WINAPI GetTabbedTextExtent16( HDC16 hdc, LPCSTR lpstr, INT16 count,
 727                                     INT16 nb_tabs, const INT16 *tabs16 )
 728 {
 729     LONG ret;
 730     INT i, *tabs = HeapAlloc( GetProcessHeap(), 0, nb_tabs * sizeof(tabs) );
 731     if (!tabs) return 0;
 732     for (i = 0; i < nb_tabs; i++) tabs[i] = tabs16[i];
 733     ret = GetTabbedTextExtentA( HDC_32(hdc), lpstr, count, nb_tabs, tabs );
 734     HeapFree( GetProcessHeap(), 0, tabs );
 735     return ret;
 736 }
 737
 738
 739 /***********************************************************************
 740  *              UserSeeUserDo (USER.216)
 741  */
 742 DWORD WINAPI UserSeeUserDo16(WORD wReqType, WORD wParam1, WORD wParam2, WORD wParam3)
 743 {
 744     STACK16FRAME* stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved);
 745     HANDLE16 oldDS = stack16->ds;
 746     DWORD ret = (DWORD)-1;
 747
 748     stack16->ds = USER_HeapSel;
 749     switch (wReqType)
 750     {
 751     case USUD_LOCALALLOC:
 752         ret = LocalAlloc16(wParam1, wParam3);
 753         break;
 754     case USUD_LOCALFREE:
 755         ret = LocalFree16(wParam1);
 756         break;
 757     case USUD_LOCALCOMPACT:
 758         ret = LocalCompact16(wParam3);
 759         break;
 760     case USUD_LOCALHEAP:
 761         ret = USER_HeapSel;
 762         break;
 763     case USUD_FIRSTCLASS:
 764         FIXME("return a pointer to the first window class.\n");
 765         break;
 766     default:
 767         WARN("wReqType %04x (unknown)\n", wReqType);
 768     }
 769     stack16->ds = oldDS;
 770     return ret;
 771 }
 772
 773
 774 /*************************************************************************
 775  *              ScrollDC (USER.221)
 776  */
 777 BOOL16 WINAPI ScrollDC16( HDC16 hdc, INT16 dx, INT16 dy, const RECT16 *rect,
 778                           const RECT16 *cliprc, HRGN16 hrgnUpdate,
 779                           LPRECT16 rcUpdate )
 780 {
 781     RECT rect32, clipRect32, rcUpdate32;
 782     BOOL16 ret;
 783
 784     if (rect)
 785     {
 786         rect32.left   = rect->left;
 787         rect32.top    = rect->top;
 788         rect32.right  = rect->right;
 789         rect32.bottom = rect->bottom;
 790     }
 791     if (cliprc)
 792     {
 793         clipRect32.left   = cliprc->left;
 794         clipRect32.top    = cliprc->top;
 795         clipRect32.right  = cliprc->right;
 796         clipRect32.bottom = cliprc->bottom;
 797     }
 798     ret = ScrollDC( HDC_32(hdc), dx, dy, rect ? &rect32 : NULL,
 799                     cliprc ? &clipRect32 : NULL, HRGN_32(hrgnUpdate),
 800                     &rcUpdate32 );
 801     if (rcUpdate)
 802     {
 803         rcUpdate->left   = rcUpdate32.left;
 804         rcUpdate->top    = rcUpdate32.top;
 805         rcUpdate->right  = rcUpdate32.right;
 806         rcUpdate->bottom = rcUpdate32.bottom;
 807     }
 808     return ret;
 809 }
 810
 811
 812 /***********************************************************************
 813  *              GetSystemDebugState (USER.231)
 814  */
 815 WORD WINAPI GetSystemDebugState16(void)
 816 {
 817     return 0;  /* FIXME */
 818 }
 819
 820
 821 /***********************************************************************
 822  *              EqualRect (USER.244)
 823  */
 824 BOOL16 WINAPI EqualRect16( const RECT16* rect1, const RECT16* rect2 )
 825 {
 826     return ((rect1->left == rect2->left) && (rect1->right == rect2->right) &&
 827             (rect1->top == rect2->top) && (rect1->bottom == rect2->bottom));
 828 }
 829
 830
 831 /***********************************************************************
 832  *              ExitWindowsExec (USER.246)
 833  */
 834 BOOL16 WINAPI ExitWindowsExec16( LPCSTR lpszExe, LPCSTR lpszParams )
 835 {
 836     TRACE("Should run the following in DOS-mode: \"%s %s\"\n",
 837           lpszExe, lpszParams);
 838     return ExitWindowsEx( EWX_LOGOFF, 0xffffffff );
 839 }
 840
 841
 842 /***********************************************************************
 843  *              GetCursor (USER.247)
 844  */
 845 HCURSOR16 WINAPI GetCursor16(void)
 846 {
 847   return HCURSOR_16(GetCursor());
 848 }
 849
 850
 851 /**********************************************************************
 852  *              GetAsyncKeyState (USER.249)
 853  */
 854 INT16 WINAPI GetAsyncKeyState16( INT16 key )
 855 {
 856     return GetAsyncKeyState( key );
 857 }
 858
 859
 860 /**********************************************************************
 861  *         GetMenuState    (USER.250)
 862  */
 863 UINT16 WINAPI GetMenuState16( HMENU16 hMenu, UINT16 wItemID, UINT16 wFlags )
 864 {
 865     return GetMenuState( HMENU_32(hMenu), wItemID, wFlags );
 866 }
 867
 868
 869 /**********************************************************************
 870  *         GetMenuItemCount    (USER.263)
 871  */
 872 INT16 WINAPI GetMenuItemCount16( HMENU16 hMenu )
 873 {
 874     return GetMenuItemCount( HMENU_32(hMenu) );
 875 }
 876
 877
 878 /**********************************************************************
 879  *         GetMenuItemID    (USER.264)
 880  */
 881 UINT16 WINAPI GetMenuItemID16( HMENU16 hMenu, INT16 nPos )
 882 {
 883     return GetMenuItemID( HMENU_32(hMenu), nPos );
 884 }
 885
 886
 887 /***********************************************************************
 888  *              GlobalAddAtom (USER.268)
 889  */
 890 ATOM WINAPI GlobalAddAtom16(LPCSTR lpString)
 891 {
 892   return GlobalAddAtomA(lpString);
 893 }
 894
 895 /***********************************************************************
 896  *              GlobalDeleteAtom (USER.269)
 897  */
 898 ATOM WINAPI GlobalDeleteAtom16(ATOM nAtom)
 899 {
 900   return GlobalDeleteAtom(nAtom);
 901 }
 902
 903 /***********************************************************************
 904  *              GlobalFindAtom (USER.270)
 905  */
 906 ATOM WINAPI GlobalFindAtom16(LPCSTR lpString)
 907 {
 908   return GlobalFindAtomA(lpString);
 909 }
 910
 911 /***********************************************************************
 912  *              GlobalGetAtomName (USER.271)
 913  */
 914 UINT16 WINAPI GlobalGetAtomName16(ATOM nAtom, LPSTR lpBuffer, INT16 nSize)
 915 {
 916   return GlobalGetAtomNameA(nAtom, lpBuffer, nSize);
 917 }
 918
 919
 920 /***********************************************************************
 921  *              ControlPanelInfo (USER.273)
 922  */
 923 void WINAPI ControlPanelInfo16( INT16 nInfoType, WORD wData, LPSTR lpBuffer )
 924 {
 925     FIXME("(%d, %04x, %p): stub.\n", nInfoType, wData, lpBuffer);
 926 }
 927
 928
 929 /***********************************************************************
 930  *           OldSetDeskPattern   (USER.279)
 931  */
 932 BOOL16 WINAPI SetDeskPattern16(void)
 933 {
 934     return SystemParametersInfoA( SPI_SETDESKPATTERN, -1, NULL, FALSE );
 935 }
 936
 937
 938 /***********************************************************************
 939  *              GetSysColorBrush (USER.281)
 940  */
 941 HBRUSH16 WINAPI GetSysColorBrush16( INT16 index )
 942 {
 943     return HBRUSH_16( GetSysColorBrush(index) );
 944 }
 945
 946
 947 /***********************************************************************
 948  *              SelectPalette (USER.282)
 949  */
 950 HPALETTE16 WINAPI SelectPalette16( HDC16 hdc, HPALETTE16 hpal, BOOL16 bForceBackground )
 951 {
 952     return HPALETTE_16( SelectPalette( HDC_32(hdc), HPALETTE_32(hpal), bForceBackground ));
 953 }
 954
 955 /***********************************************************************
 956  *              RealizePalette (USER.283)
 957  */
 958 UINT16 WINAPI RealizePalette16( HDC16 hdc )
 959 {
 960     return UserRealizePalette( HDC_32(hdc) );
 961 }
 962
 963
 964 /***********************************************************************
 965  *              GetFreeSystemResources (USER.284)
 966  */
 967 WORD WINAPI GetFreeSystemResources16( WORD resType )
 968 {
 969     STACK16FRAME* stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved);
 970     HANDLE16 oldDS = stack16->ds;
 971     HINSTANCE16 gdi_inst;
 972     WORD gdi_heap;
 973     int userPercent, gdiPercent;
 974
 975     if ((gdi_inst = LoadLibrary16( "GDI" )) < 32) return 0;
 976     gdi_heap = gdi_inst | 7;
 977
 978     switch(resType)
 979     {
 980     case GFSR_USERRESOURCES:
 981         stack16->ds = USER_HeapSel;
 982         userPercent = (int)LocalCountFree16() * 100 / LocalHeapSize16();
 983         gdiPercent  = 100;
 984         stack16->ds = oldDS;
 985         break;
 986
 987     case GFSR_GDIRESOURCES:
 988         stack16->ds = gdi_inst;
 989         gdiPercent  = (int)LocalCountFree16() * 100 / LocalHeapSize16();
 990         userPercent = 100;
 991         stack16->ds = oldDS;
 992         break;
 993
 994     case GFSR_SYSTEMRESOURCES:
 995         stack16->ds = USER_HeapSel;
 996         userPercent = (int)LocalCountFree16() * 100 / LocalHeapSize16();
 997         stack16->ds = gdi_inst;
 998         gdiPercent  = (int)LocalCountFree16() * 100 / LocalHeapSize16();
 999         stack16->ds = oldDS;
1000         break;
1001
1002     default:
1003         userPercent = gdiPercent = 0;
1004         break;
1005     }
1006     FreeLibrary16( gdi_inst );
1007     TRACE("<- userPercent %d, gdiPercent %d\n", userPercent, gdiPercent);
1008     return (WORD)min( userPercent, gdiPercent );
1009 }
1010
1011
1012 /***********************************************************************
1013  *           SetDeskWallPaper   (USER.285)
1014  */
1015 BOOL16 WINAPI SetDeskWallPaper16( LPCSTR filename )
1016 {
1017     return SetDeskWallPaper( filename );
1018 }
1019
1020
1021 /***********************************************************************
1022  *              GetClipCursor (USER.309)
1023  */
1024 void WINAPI GetClipCursor16( RECT16 *rect )
1025 {
1026     if (rect)
1027     {
1028         RECT rect32;
1029         GetClipCursor( &rect32 );
1030         rect->left   = rect32.left;
1031         rect->top    = rect32.top;
1032         rect->right  = rect32.right;
1033         rect->bottom = rect32.bottom;
1034     }
1035 }
1036
1037
1038 /***********************************************************************
1039  *              SignalProc (USER.314)
1040  */
1041 void WINAPI SignalProc16( HANDLE16 hModule, UINT16 code,
1042                           UINT16 uExitFn, HINSTANCE16 hInstance, HQUEUE16 hQueue )
1043 {
1044     if (code == USIG16_DLL_UNLOAD)
1045     {
1046         /* HOOK_FreeModuleHooks( hModule ); */
1047         CLASS_FreeModuleClasses( hModule );
1048         CURSORICON_FreeModuleIcons( hModule );
1049     }
1050 }
1051
1052
1053 /***********************************************************************
1054  *              SetEventHook (USER.321)
1055  *
1056  *      Used by Turbo Debugger for Windows
1057  */
1058 FARPROC16 WINAPI SetEventHook16(FARPROC16 lpfnEventHook)
1059 {
1060     FIXME("(lpfnEventHook=%p): stub\n", lpfnEventHook);
1061     return 0;
1062 }
1063
1064
1065 /**********************************************************************
1066  *              EnableHardwareInput (USER.331)
1067  */
1068 BOOL16 WINAPI EnableHardwareInput16(BOOL16 bEnable)
1069 {
1070     FIXME("(%d) - stub\n", bEnable);
1071     return TRUE;
1072 }
1073
1074
1075 /***********************************************************************
1076  *              IsUserIdle (USER.333)
1077  */
1078 BOOL16 WINAPI IsUserIdle16(void)
1079 {
1080     if ( GetAsyncKeyState( VK_LBUTTON ) & 0x8000 )
1081         return FALSE;
1082     if ( GetAsyncKeyState( VK_RBUTTON ) & 0x8000 )
1083         return FALSE;
1084     if ( GetAsyncKeyState( VK_MBUTTON ) & 0x8000 )
1085         return FALSE;
1086     /* Should check for screen saver activation here ... */
1087     return TRUE;
1088 }
1089
1090
1091 /**********************************************************************
1092  *              LoadDIBIconHandler (USER.357)
1093  *
1094  * RT_ICON resource loader, installed by USER_SignalProc when module
1095  * is initialized.
1096  */
1097 HGLOBAL16 WINAPI LoadDIBIconHandler16( HGLOBAL16 hMemObj, HMODULE16 hModule, HRSRC16 hRsrc )
1098 {
1099     /* If hResource is zero we must allocate a new memory block, if it's
1100      * non-zero but GlobalLock() returns NULL then it was discarded and
1101      * we have to recommit some memory, otherwise we just need to check
1102      * the block size. See LoadProc() in 16-bit SDK for more.
1103      */
1104     FIXME( "%x %x %x: stub, not supported anymore\n", hMemObj, hModule, hRsrc );
1105     return 0;
1106 }
1107
1108 /**********************************************************************
1109  *              LoadDIBCursorHandler (USER.356)
1110  *
1111  * RT_CURSOR resource loader. Same as above.
1112  */
1113 HGLOBAL16 WINAPI LoadDIBCursorHandler16( HGLOBAL16 hMemObj, HMODULE16 hModule, HRSRC16 hRsrc )
1114 {
1115     FIXME( "%x %x %x: stub, not supported anymore\n", hMemObj, hModule, hRsrc );
1116     return 0;
1117 }
1118
1119
1120 /**********************************************************************
1121  *              IsMenu    (USER.358)
1122  */
1123 BOOL16 WINAPI IsMenu16( HMENU16 hmenu )
1124 {
1125     return IsMenu( HMENU_32(hmenu) );
1126 }
1127
1128
1129 /***********************************************************************
1130  *              DCHook (USER.362)
1131  */
1132 BOOL16 WINAPI DCHook16( HDC16 hdc, WORD code, DWORD data, LPARAM lParam )
1133 {
1134     FIXME( "hDC = %x, %i: stub\n", hdc, code );
1135     return FALSE;
1136 }
1137
1138
1139 /***********************************************************************
1140  *              SubtractRect (USER.373)
1141  */
1142 BOOL16 WINAPI SubtractRect16( LPRECT16 dest, const RECT16 *src1,
1143                               const RECT16 *src2 )
1144 {
1145     RECT16 tmp;
1146
1147     if (IsRectEmpty16( src1 ))
1148     {
1149         SetRectEmpty16( dest );
1150         return FALSE;
1151     }
1152     *dest = *src1;
1153     if (IntersectRect16( &tmp, src1, src2 ))
1154     {
1155         if (EqualRect16( &tmp, dest ))
1156         {
1157             SetRectEmpty16( dest );
1158             return FALSE;
1159         }
1160         if ((tmp.top == dest->top) && (tmp.bottom == dest->bottom))
1161         {
1162             if (tmp.left == dest->left) dest->left = tmp.right;
1163             else if (tmp.right == dest->right) dest->right = tmp.left;
1164         }
1165         else if ((tmp.left == dest->left) && (tmp.right == dest->right))
1166         {
1167             if (tmp.top == dest->top) dest->top = tmp.bottom;
1168             else if (tmp.bottom == dest->bottom) dest->bottom = tmp.top;
1169         }
1170     }
1171     return TRUE;
1172 }
1173
1174
1175 /**********************************************************************
1176  *         SetMenuContextHelpId    (USER.384)
1177  */
1178 BOOL16 WINAPI SetMenuContextHelpId16( HMENU16 hMenu, DWORD dwContextHelpID)
1179 {
1180     return SetMenuContextHelpId( HMENU_32(hMenu), dwContextHelpID );
1181 }
1182
1183
1184 /**********************************************************************
1185  *         GetMenuContextHelpId    (USER.385)
1186  */
1187 DWORD WINAPI GetMenuContextHelpId16( HMENU16 hMenu )
1188 {
1189     return GetMenuContextHelpId( HMENU_32(hMenu) );
1190 }
1191
1192
1193 /***********************************************************************
1194  *              LoadImage (USER.389)
1195  *
1196  */
1197 HANDLE16 WINAPI LoadImage16(HINSTANCE16 hinst, LPCSTR name, UINT16 type,
1198                             INT16 desiredx, INT16 desiredy, UINT16 loadflags)
1199 {
1200   return HANDLE_16(LoadImageA(HINSTANCE_32(hinst), name, type, desiredx,
1201                               desiredy, loadflags));
1202 }
1203
1204 /******************************************************************************
1205  *              CopyImage (USER.390) Creates new image and copies attributes to it
1206  *
1207  */
1208 HICON16 WINAPI CopyImage16(HANDLE16 hnd, UINT16 type, INT16 desiredx,
1209                            INT16 desiredy, UINT16 flags)
1210 {
1211   return HICON_16(CopyImage(HANDLE_32(hnd), (UINT)type, (INT)desiredx,
1212                             (INT)desiredy, (UINT)flags));
1213 }
1214
1215 /**********************************************************************
1216  *              DrawIconEx (USER.394)
1217  */
1218 BOOL16 WINAPI DrawIconEx16(HDC16 hdc, INT16 xLeft, INT16 yTop, HICON16 hIcon,
1219                            INT16 cxWidth, INT16 cyWidth, UINT16 istep,
1220                            HBRUSH16 hbr, UINT16 flags)
1221 {
1222   return DrawIconEx(HDC_32(hdc), xLeft, yTop, HICON_32(hIcon), cxWidth, cyWidth,
1223                     istep, HBRUSH_32(hbr), flags);
1224 }
1225
1226 /**********************************************************************
1227  *              GetIconInfo (USER.395)
1228  */
1229 BOOL16 WINAPI GetIconInfo16(HICON16 hIcon, LPICONINFO16 iconinfo)
1230 {
1231   ICONINFO ii32;
1232   BOOL16 ret = GetIconInfo(HICON_32(hIcon), &ii32);
1233
1234   iconinfo->fIcon = ii32.fIcon;
1235   iconinfo->xHotspot = ii32.xHotspot;
1236   iconinfo->yHotspot = ii32.yHotspot;
1237   iconinfo->hbmMask  = HBITMAP_16(ii32.hbmMask);
1238   iconinfo->hbmColor = HBITMAP_16(ii32.hbmColor);
1239   return ret;
1240 }
1241
1242
1243 /***********************************************************************
1244  *              FinalUserInit (USER.400)
1245  */
1246 void WINAPI FinalUserInit16( void )
1247 {
1248     /* FIXME: Should chain to FinalGdiInit */
1249 }
1250
1251
1252 /***********************************************************************
1253  *              CreateCursor (USER.406)
1254  */
1255 HCURSOR16 WINAPI CreateCursor16(HINSTANCE16 hInstance,
1256                                 INT16 xHotSpot, INT16 yHotSpot,
1257                                 INT16 nWidth, INT16 nHeight,
1258                                 LPCVOID lpANDbits, LPCVOID lpXORbits)
1259 {
1260   CURSORICONINFO info;
1261
1262   info.ptHotSpot.x = xHotSpot;
1263   info.ptHotSpot.y = yHotSpot;
1264   info.nWidth = nWidth;
1265   info.nHeight = nHeight;
1266   info.nWidthBytes = 0;
1267   info.bPlanes = 1;
1268   info.bBitsPerPixel = 1;
1269
1270   return CreateCursorIconIndirect16(hInstance, &info, lpANDbits, lpXORbits);
1271 }
1272
1273
1274 /***********************************************************************
1275  *              InitThreadInput   (USER.409)
1276  */
1277 HQUEUE16 WINAPI InitThreadInput16( WORD unknown, WORD flags )
1278 {
1279     /* nothing to do here */
1280     return 0xbeef;
1281 }
1282
1283
1284 /*******************************************************************
1285  *         InsertMenu    (USER.410)
1286  */
1287 BOOL16 WINAPI InsertMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
1288                             UINT16 id, SEGPTR data )
1289 {
1290     UINT pos32 = (UINT)pos;
1291     if ((pos == (UINT16)-1) && (flags & MF_BYPOSITION)) pos32 = (UINT)-1;
1292     if (IS_MENU_STRING_ITEM(flags) && data)
1293         return InsertMenuA( HMENU_32(hMenu), pos32, flags, id, MapSL(data) );
1294     return InsertMenuA( HMENU_32(hMenu), pos32, flags, id, (LPSTR)data );
1295 }
1296
1297
1298 /*******************************************************************
1299  *         AppendMenu    (USER.411)
1300  */
1301 BOOL16 WINAPI AppendMenu16(HMENU16 hMenu, UINT16 flags, UINT16 id, SEGPTR data)
1302 {
1303     return InsertMenu16( hMenu, -1, flags | MF_BYPOSITION, id, data );
1304 }
1305
1306
1307 /**********************************************************************
1308  *         RemoveMenu   (USER.412)
1309  */
1310 BOOL16 WINAPI RemoveMenu16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags )
1311 {
1312     return RemoveMenu( HMENU_32(hMenu), nPos, wFlags );
1313 }
1314
1315
1316 /**********************************************************************
1317  *         DeleteMenu    (USER.413)
1318  */
1319 BOOL16 WINAPI DeleteMenu16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags )
1320 {
1321     return DeleteMenu( HMENU_32(hMenu), nPos, wFlags );
1322 }
1323
1324
1325 /*******************************************************************
1326  *         ModifyMenu    (USER.414)
1327  */
1328 BOOL16 WINAPI ModifyMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
1329                             UINT16 id, SEGPTR data )
1330 {
1331     if (IS_MENU_STRING_ITEM(flags))
1332         return ModifyMenuA( HMENU_32(hMenu), pos, flags, id, MapSL(data) );
1333     return ModifyMenuA( HMENU_32(hMenu), pos, flags, id, (LPSTR)data );
1334 }
1335
1336
1337 /**********************************************************************
1338  *         CreatePopupMenu    (USER.415)
1339  */
1340 HMENU16 WINAPI CreatePopupMenu16(void)
1341 {
1342     return HMENU_16( CreatePopupMenu() );
1343 }
1344
1345
1346 /**********************************************************************
1347  *         SetMenuItemBitmaps    (USER.418)
1348  */
1349 BOOL16 WINAPI SetMenuItemBitmaps16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags,
1350                                     HBITMAP16 hNewUnCheck, HBITMAP16 hNewCheck)
1351 {
1352     return SetMenuItemBitmaps( HMENU_32(hMenu), nPos, wFlags,
1353                                HBITMAP_32(hNewUnCheck), HBITMAP_32(hNewCheck) );
1354 }
1355
1356
1357 /***********************************************************************
1358  *           lstrcmp   (USER.430)
1359  */
1360 INT16 WINAPI lstrcmp16( LPCSTR str1, LPCSTR str2 )
1361 {
1362     return strcmp( str1, str2 );
1363 }
1364
1365
1366 /***********************************************************************
1367  *           AnsiUpper   (USER.431)
1368  */
1369 SEGPTR WINAPI AnsiUpper16( SEGPTR strOrChar )
1370 {
1371     /* uppercase only one char if strOrChar < 0x10000 */
1372     if (HIWORD(strOrChar))
1373     {
1374         CharUpperA( MapSL(strOrChar) );
1375         return strOrChar;
1376     }
1377     else return (SEGPTR)CharUpperA( (LPSTR)strOrChar );
1378 }
1379
1380
1381 /***********************************************************************
1382  *           AnsiLower   (USER.432)
1383  */
1384 SEGPTR WINAPI AnsiLower16( SEGPTR strOrChar )
1385 {
1386     /* lowercase only one char if strOrChar < 0x10000 */
1387     if (HIWORD(strOrChar))
1388     {
1389         CharLowerA( MapSL(strOrChar) );
1390         return strOrChar;
1391     }
1392     else return (SEGPTR)CharLowerA( (LPSTR)strOrChar );
1393 }
1394
1395
1396 /***********************************************************************
1397  *           AnsiUpperBuff   (USER.437)
1398  */
1399 UINT16 WINAPI AnsiUpperBuff16( LPSTR str, UINT16 len )
1400 {
1401     CharUpperBuffA( str, len ? len : 65536 );
1402     return len;
1403 }
1404
1405
1406 /***********************************************************************
1407  *           AnsiLowerBuff   (USER.438)
1408  */
1409 UINT16 WINAPI AnsiLowerBuff16( LPSTR str, UINT16 len )
1410 {
1411     CharLowerBuffA( str, len ? len : 65536 );
1412     return len;
1413 }
1414
1415
1416 /*******************************************************************
1417  *              InsertMenuItem   (USER.441)
1418  *
1419  * FIXME: untested
1420  */
1421 BOOL16 WINAPI InsertMenuItem16( HMENU16 hmenu, UINT16 pos, BOOL16 byposition,
1422                                 const MENUITEMINFO16 *mii )
1423 {
1424     MENUITEMINFOA miia;
1425
1426     miia.cbSize        = sizeof(miia);
1427     miia.fMask         = mii->fMask;
1428     miia.dwTypeData    = (LPSTR)mii->dwTypeData;
1429     miia.fType         = mii->fType;
1430     miia.fState        = mii->fState;
1431     miia.wID           = mii->wID;
1432     miia.hSubMenu      = HMENU_32(mii->hSubMenu);
1433     miia.hbmpChecked   = HBITMAP_32(mii->hbmpChecked);
1434     miia.hbmpUnchecked = HBITMAP_32(mii->hbmpUnchecked);
1435     miia.dwItemData    = mii->dwItemData;
1436     miia.cch           = mii->cch;
1437     if (IS_MENU_STRING_ITEM(miia.fType))
1438         miia.dwTypeData = MapSL(mii->dwTypeData);
1439     return InsertMenuItemA( HMENU_32(hmenu), pos, byposition, &miia );
1440 }
1441
1442
1443 /**********************************************************************
1444  *           DrawState    (USER.449)
1445  */
1446 BOOL16 WINAPI DrawState16( HDC16 hdc, HBRUSH16 hbr, DRAWSTATEPROC16 func, LPARAM ldata,
1447                            WPARAM16 wdata, INT16 x, INT16 y, INT16 cx, INT16 cy, UINT16 flags )
1448 {
1449     struct draw_state_info info;
1450     UINT opcode = flags & 0xf;
1451
1452     if (opcode == DST_TEXT || opcode == DST_PREFIXTEXT)
1453     {
1454         /* make sure DrawStateA doesn't try to use ldata as a pointer */
1455         if (!wdata) wdata = strlen( MapSL(ldata) );
1456         if (!cx || !cy)
1457         {
1458             SIZE s;
1459             if (!GetTextExtentPoint32A( HDC_32(hdc), MapSL(ldata), wdata, &s )) return FALSE;
1460             if (!cx) cx = s.cx;
1461             if (!cy) cy = s.cy;
1462         }
1463     }
1464     info.proc  = func;
1465     info.param = ldata;
1466     return DrawStateA( HDC_32(hdc), HBRUSH_32(hbr), draw_state_callback,
1467                        (LPARAM)&info, wdata, x, y, cx, cy, flags );
1468 }
1469
1470
1471 /**********************************************************************
1472  *              CreateIconFromResourceEx (USER.450)
1473  *
1474  * FIXME: not sure about exact parameter types
1475  */
1476 HICON16 WINAPI CreateIconFromResourceEx16(LPBYTE bits, UINT16 cbSize,
1477                                           BOOL16 bIcon, DWORD dwVersion,
1478                                           INT16 width, INT16 height,
1479                                           UINT16 cFlag)
1480 {
1481   return HICON_16(CreateIconFromResourceEx(bits, cbSize, bIcon, dwVersion,
1482                                            width, height, cFlag));
1483 }
1484
1485
1486 /***********************************************************************
1487  *              AdjustWindowRectEx (USER.454)
1488  */
1489 BOOL16 WINAPI AdjustWindowRectEx16( LPRECT16 rect, DWORD style, BOOL16 menu, DWORD exStyle )
1490 {
1491     RECT rect32;
1492     BOOL ret;
1493
1494     rect32.left   = rect->left;
1495     rect32.top    = rect->top;
1496     rect32.right  = rect->right;
1497     rect32.bottom = rect->bottom;
1498     ret = AdjustWindowRectEx( &rect32, style, menu, exStyle );
1499     rect->left   = rect32.left;
1500     rect->top    = rect32.top;
1501     rect->right  = rect32.right;
1502     rect->bottom = rect32.bottom;
1503     return ret;
1504 }
1505
1506
1507 /***********************************************************************
1508  *              DestroyIcon (USER.457)
1509  */
1510 BOOL16 WINAPI DestroyIcon16(HICON16 hIcon)
1511 {
1512   return DestroyIcon32(hIcon, 0);
1513 }
1514
1515 /***********************************************************************
1516  *              DestroyCursor (USER.458)
1517  */
1518 BOOL16 WINAPI DestroyCursor16(HCURSOR16 hCursor)
1519 {
1520   return DestroyIcon32(hCursor, 0);
1521 }
1522
1523 /*******************************************************************
1524  *                      DRAG_QueryUpdate16
1525  *
1526  * Recursively find a child that contains spDragInfo->pt point
1527  * and send WM_QUERYDROPOBJECT. Helper for DragObject16.
1528  */
1529 static BOOL DRAG_QueryUpdate16( HWND hQueryWnd, SEGPTR spDragInfo )
1530 {
1531     BOOL bResult = 0;
1532     WPARAM wParam;
1533     POINT pt, old_pt;
1534     LPDRAGINFO16 ptrDragInfo = MapSL(spDragInfo);
1535     RECT tempRect;
1536     HWND child;
1537
1538     if (!IsWindowEnabled(hQueryWnd)) return FALSE;
1539
1540     old_pt.x = ptrDragInfo->pt.x;
1541     old_pt.y = ptrDragInfo->pt.y;
1542     pt = old_pt;
1543     ScreenToClient( hQueryWnd, &pt );
1544     child = ChildWindowFromPointEx( hQueryWnd, pt, CWP_SKIPINVISIBLE );
1545     if (!child) return FALSE;
1546
1547     if (child != hQueryWnd)
1548     {
1549         wParam = 0;
1550         if (DRAG_QueryUpdate16( child, spDragInfo )) return TRUE;
1551     }
1552     else
1553     {
1554         GetClientRect( hQueryWnd, &tempRect );
1555         wParam = !PtInRect( &tempRect, pt );
1556     }
1557
1558     ptrDragInfo->pt.x = pt.x;
1559     ptrDragInfo->pt.y = pt.y;
1560     ptrDragInfo->hScope = HWND_16(hQueryWnd);
1561
1562     bResult = SendMessage16( HWND_16(hQueryWnd), WM_QUERYDROPOBJECT, wParam, spDragInfo );
1563
1564     if (!bResult)
1565     {
1566         ptrDragInfo->pt.x = old_pt.x;
1567         ptrDragInfo->pt.y = old_pt.y;
1568     }
1569     return bResult;
1570 }
1571
1572
1573 /******************************************************************************
1574  *              DragObject (USER.464)
1575  */
1576 DWORD WINAPI DragObject16( HWND16 hwndScope, HWND16 hWnd, UINT16 wObj,
1577                            HANDLE16 hOfStruct, WORD szList, HCURSOR16 hCursor )
1578 {
1579     MSG msg;
1580     LPDRAGINFO16 lpDragInfo;
1581     SEGPTR      spDragInfo;
1582     HCURSOR     hOldCursor=0, hBummer=0;
1583     HGLOBAL16   hDragInfo  = GlobalAlloc16( GMEM_SHARE | GMEM_ZEROINIT, 2*sizeof(DRAGINFO16));
1584     HCURSOR     hCurrentCursor = 0;
1585     HWND16      hCurrentWnd = 0;
1586
1587     lpDragInfo = (LPDRAGINFO16) GlobalLock16(hDragInfo);
1588     spDragInfo = WOWGlobalLock16(hDragInfo);
1589
1590     if( !lpDragInfo || !spDragInfo ) return 0L;
1591
1592     if (!(hBummer = LoadCursorA(0, MAKEINTRESOURCEA(OCR_NO))))
1593     {
1594         GlobalFree16(hDragInfo);
1595         return 0L;
1596     }
1597
1598     if(hCursor) hOldCursor = SetCursor(HCURSOR_32(hCursor));
1599
1600     lpDragInfo->hWnd   = hWnd;
1601     lpDragInfo->hScope = 0;
1602     lpDragInfo->wFlags = wObj;
1603     lpDragInfo->hList  = szList; /* near pointer! */
1604     lpDragInfo->hOfStruct = hOfStruct;
1605     lpDragInfo->l = 0L;
1606
1607     SetCapture( HWND_32(hWnd) );
1608     ShowCursor( TRUE );
1609
1610     do
1611     {
1612         GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST );
1613
1614        *(lpDragInfo+1) = *lpDragInfo;
1615
1616         lpDragInfo->pt.x = msg.pt.x;
1617         lpDragInfo->pt.y = msg.pt.y;
1618
1619         /* update DRAGINFO struct */
1620         if( DRAG_QueryUpdate16(WIN_Handle32(hwndScope), spDragInfo) > 0 )
1621             hCurrentCursor = HCURSOR_32(hCursor);
1622         else
1623         {
1624             hCurrentCursor = hBummer;
1625             lpDragInfo->hScope = 0;
1626         }
1627         if( hCurrentCursor )
1628             SetCursor(hCurrentCursor);
1629
1630         /* send WM_DRAGLOOP */
1631         SendMessage16( hWnd, WM_DRAGLOOP, (WPARAM16)(hCurrentCursor != hBummer),
1632                                           (LPARAM) spDragInfo );
1633         /* send WM_DRAGSELECT or WM_DRAGMOVE */
1634         if( hCurrentWnd != lpDragInfo->hScope )
1635         {
1636             if( hCurrentWnd )
1637                 SendMessage16( hCurrentWnd, WM_DRAGSELECT, 0,
1638                        (LPARAM)MAKELONG(LOWORD(spDragInfo)+sizeof(DRAGINFO16),
1639                                         HIWORD(spDragInfo)) );
1640             hCurrentWnd = lpDragInfo->hScope;
1641             if( hCurrentWnd )
1642                 SendMessage16( hCurrentWnd, WM_DRAGSELECT, 1, (LPARAM)spDragInfo);
1643         }
1644         else
1645             if( hCurrentWnd )
1646                 SendMessage16( hCurrentWnd, WM_DRAGMOVE, 0, (LPARAM)spDragInfo);
1647
1648     } while( msg.message != WM_LBUTTONUP && msg.message != WM_NCLBUTTONUP );
1649
1650     ReleaseCapture();
1651     ShowCursor( FALSE );
1652
1653     if( hCursor ) SetCursor(hOldCursor);
1654
1655     if( hCurrentCursor != hBummer )
1656         msg.lParam = SendMessage16( lpDragInfo->hScope, WM_DROPOBJECT,
1657                                    (WPARAM16)hWnd, (LPARAM)spDragInfo );
1658     else
1659         msg.lParam = 0;
1660     GlobalFree16(hDragInfo);
1661
1662     return (DWORD)(msg.lParam);
1663 }
1664
1665
1666 /***********************************************************************
1667  *              DrawFocusRect (USER.466)
1668  */
1669 void WINAPI DrawFocusRect16( HDC16 hdc, const RECT16* rc )
1670 {
1671     RECT rect32;
1672
1673     rect32.left   = rc->left;
1674     rect32.top    = rc->top;
1675     rect32.right  = rc->right;
1676     rect32.bottom = rc->bottom;
1677     DrawFocusRect( HDC_32(hdc), &rect32 );
1678 }
1679
1680
1681 /***********************************************************************
1682  *           AnsiNext   (USER.472)
1683  */
1684 SEGPTR WINAPI AnsiNext16(SEGPTR current)
1685 {
1686     char *ptr = MapSL(current);
1687     return current + (CharNextA(ptr) - ptr);
1688 }
1689
1690
1691 /***********************************************************************
1692  *           AnsiPrev   (USER.473)
1693  */
1694 SEGPTR WINAPI AnsiPrev16( LPCSTR start, SEGPTR current )
1695 {
1696     char *ptr = MapSL(current);
1697     return current - (ptr - CharPrevA( start, ptr ));
1698 }
1699
1700
1701 /***********************************************************************
1702  *           FormatMessage   (USER.606)
1703  */
1704 DWORD WINAPI FormatMessage16(
1705     DWORD   dwFlags,
1706     SEGPTR lpSource,     /* [in] NOTE: not always a valid pointer */
1707     WORD   dwMessageId,
1708     WORD   dwLanguageId,
1709     LPSTR  lpBuffer,     /* [out] NOTE: *((HLOCAL16*)) for FORMAT_MESSAGE_ALLOCATE_BUFFER*/
1710     WORD   nSize,
1711     LPDWORD args )       /* [in] NOTE: va_list *args */
1712 {
1713 #ifdef __i386__
1714 /* This implementation is completely dependent on the format of the va_list on x86 CPUs */
1715     LPSTR       target,t;
1716     DWORD       talloced;
1717     LPSTR       from,f;
1718     DWORD       width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
1719     BOOL        eos = FALSE;
1720     LPSTR       allocstring = NULL;
1721
1722     TRACE("(0x%x,%x,%d,0x%x,%p,%d,%p)\n",
1723           dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
1724         if ((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
1725                 && (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)) return 0;
1726         if ((dwFlags & FORMAT_MESSAGE_FROM_STRING)
1727                 &&((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
1728                         || (dwFlags & FORMAT_MESSAGE_FROM_HMODULE))) return 0;
1729
1730     if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
1731         FIXME("line wrapping (%u) not supported.\n", width);
1732     from = NULL;
1733     if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
1734     {
1735         char *source = MapSL(lpSource);
1736         from = HeapAlloc( GetProcessHeap(), 0, strlen(source)+1 );
1737         strcpy( from, source );
1738     }
1739     else if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM) {
1740         from = HeapAlloc( GetProcessHeap(),0,200 );
1741         sprintf(from,"Systemmessage, messageid = 0x%08x\n",dwMessageId);
1742     }
1743     else if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE) {
1744         INT16   bufsize;
1745         HINSTANCE16 hinst16 = ((HINSTANCE16)lpSource & 0xffff);
1746
1747         dwMessageId &= 0xFFFF;
1748         bufsize=LoadString16(hinst16,dwMessageId,NULL,0);
1749         if (bufsize) {
1750             from = HeapAlloc( GetProcessHeap(), 0, bufsize +1);
1751             LoadString16(hinst16,dwMessageId,from,bufsize+1);
1752         }
1753     }
1754     target      = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
1755     t   = target;
1756     talloced= 100;
1757
1758 #define ADD_TO_T(c) \
1759         *t++=c;\
1760         if (t-target == talloced) {\
1761                 target  = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
1762                 t       = target+talloced;\
1763                 talloced*=2;\
1764         }
1765
1766     if (from) {
1767         f=from;
1768         while (*f && !eos) {
1769             if (*f=='%') {
1770                 int     insertnr;
1771                 char    *fmtstr,*x,*lastf;
1772                 DWORD   *argliststart;
1773
1774                 fmtstr = NULL;
1775                 lastf = f;
1776                 f++;
1777                 if (!*f) {
1778                     ADD_TO_T('%');
1779                     continue;
1780                 }
1781                 switch (*f) {
1782                 case '1':case '2':case '3':case '4':case '5':
1783                 case '6':case '7':case '8':case '9':
1784                     insertnr=*f-'0';
1785                     switch (f[1]) {
1786                     case '0':case '1':case '2':case '3':
1787                     case '4':case '5':case '6':case '7':
1788                     case '8':case '9':
1789                         f++;
1790                         insertnr=insertnr*10+*f-'0';
1791                         f++;
1792                         break;
1793                     default:
1794                         f++;
1795                         break;
1796                     }
1797                     if (*f=='!') {
1798                         f++;
1799                         if (NULL!=(x=strchr(f,'!'))) {
1800                             *x='\0';
1801                             fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
1802                             sprintf(fmtstr,"%%%s",f);
1803                             f=x+1;
1804                         } else {
1805                             fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
1806                             sprintf(fmtstr,"%%%s",f);
1807                             f+=strlen(f); /*at \0*/
1808                         }
1809                     }
1810                     else
1811                     {
1812                         if(!args) break;
1813                         fmtstr=HeapAlloc( GetProcessHeap(), 0, 3 );
1814                         strcpy( fmtstr, "%s" );
1815                     }
1816                     if (args) {
1817                         int     ret;
1818                         int     sz;
1819                         LPSTR   b = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz = 100);
1820
1821                         argliststart=args+insertnr-1;
1822
1823                         /* CMF - This makes a BIG assumption about va_list */
1824                         while ((ret = vsnprintf(b, sz, fmtstr, (va_list) argliststart) < 0) || (ret >= sz)) {
1825                             sz = (ret == -1 ? sz + 100 : ret + 1);
1826                             b = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, b, sz);
1827                         }
1828                         for (x=b; *x; x++) ADD_TO_T(*x);
1829                         HeapFree(GetProcessHeap(), 0, b);
1830                     } else {
1831                         /* NULL args - copy formatstr
1832                          * (probably wrong)
1833                          */
1834                         while ((lastf<f)&&(*lastf)) {
1835                             ADD_TO_T(*lastf++);
1836                         }
1837                     }
1838                     HeapFree(GetProcessHeap(),0,fmtstr);
1839                     break;
1840                 case '0': /* Just stop processing format string */
1841                     eos = TRUE;
1842                     f++;
1843                     break;
1844                 case 'n': /* 16 bit version just outputs 'n' */
1845                 default:
1846                     ADD_TO_T(*f++);
1847                     break;
1848                 }
1849             } else { /* '\n' or '\r' gets mapped to "\r\n" */
1850                 if(*f == '\n' || *f == '\r') {
1851                     if (width == 0) {
1852                         ADD_TO_T('\r');
1853                         ADD_TO_T('\n');
1854                         if(*f++ == '\r' && *f == '\n')
1855                             f++;
1856                     }
1857                 } else {
1858                     ADD_TO_T(*f++);
1859                 }
1860             }
1861         }
1862         *t='\0';
1863     }
1864     talloced = strlen(target)+1;
1865     if (nSize && talloced<nSize) {
1866         target = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
1867     }
1868     TRACE("-- %s\n",debugstr_a(target));
1869     if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
1870         /* nSize is the MINIMUM size */
1871         HLOCAL16 h = LocalAlloc16(LPTR,talloced);
1872         SEGPTR ptr = LocalLock16(h);
1873         allocstring = MapSL( ptr );
1874         memcpy( allocstring,target,talloced);
1875         LocalUnlock16( h );
1876         *((HLOCAL16*)lpBuffer) = h;
1877     } else
1878         lstrcpynA(lpBuffer,target,nSize);
1879     HeapFree(GetProcessHeap(),0,target);
1880     HeapFree(GetProcessHeap(),0,from);
1881     return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
1882         strlen(allocstring):
1883         strlen(lpBuffer);
1884 #else
1885         return 0;
1886 #endif /* __i386__ */
1887 }
1888 #undef ADD_TO_T
1889
1890
1891 /***********************************************************************
1892  *              ChangeDisplaySettings (USER.620)
1893  */
1894 LONG WINAPI ChangeDisplaySettings16( LPDEVMODEA devmode, DWORD flags )
1895 {
1896     return ChangeDisplaySettingsA( devmode, flags );
1897 }
1898
1899
1900 /***********************************************************************
1901  *              EnumDisplaySettings (USER.621)
1902  */
1903 BOOL16 WINAPI EnumDisplaySettings16( LPCSTR name, DWORD n, LPDEVMODEA devmode )
1904 {
1905     return EnumDisplaySettingsA( name, n, devmode );
1906 }
1907
1908 /**********************************************************************
1909  *          DrawFrameControl  (USER.656)
1910  */
1911 BOOL16 WINAPI DrawFrameControl16( HDC16 hdc, LPRECT16 rc, UINT16 uType, UINT16 uState )
1912 {
1913     RECT rect32;
1914     BOOL ret;
1915
1916     rect32.left   = rc->left;
1917     rect32.top    = rc->top;
1918     rect32.right  = rc->right;
1919     rect32.bottom = rc->bottom;
1920     ret = DrawFrameControl( HDC_32(hdc), &rect32, uType, uState );
1921     rc->left   = rect32.left;
1922     rc->top    = rect32.top;
1923     rc->right  = rect32.right;
1924     rc->bottom = rect32.bottom;
1925     return ret;
1926 }
1927
1928 /**********************************************************************
1929  *          DrawEdge   (USER.659)
1930  */
1931 BOOL16 WINAPI DrawEdge16( HDC16 hdc, LPRECT16 rc, UINT16 edge, UINT16 flags )
1932 {
1933     RECT rect32;
1934     BOOL ret;
1935
1936     rect32.left   = rc->left;
1937     rect32.top    = rc->top;
1938     rect32.right  = rc->right;
1939     rect32.bottom = rc->bottom;
1940     ret = DrawEdge( HDC_32(hdc), &rect32, edge, flags );
1941     rc->left   = rect32.left;
1942     rc->top    = rect32.top;
1943     rc->right  = rect32.right;
1944     rc->bottom = rect32.bottom;
1945     return ret;
1946 }
1947
1948 /**********************************************************************
1949  *              CheckMenuRadioItem (USER.666)
1950  */
1951 BOOL16 WINAPI CheckMenuRadioItem16(HMENU16 hMenu, UINT16 first, UINT16 last,
1952                                    UINT16 check, BOOL16 bypos)
1953 {
1954      return CheckMenuRadioItem( HMENU_32(hMenu), first, last, check, bypos );
1955 }