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