?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
widl: Silence a gcc warning.
[wine.git] / dlls / user.exe16 / user.c
blob27b92793836ae24732a3e619639be3ce6fb1dc21
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 "wine/list.h"
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(user);
38
39 /* handle to handle 16 conversions */
40 #define HANDLE_16(h32) (LOWORD(h32))
41 #define HGDIOBJ_16(h32) (LOWORD(h32))
42
43 /* handle16 to handle conversions */
44 #define HANDLE_32(h16) ((HANDLE)(ULONG_PTR)(h16))
45 #define HGDIOBJ_32(h16) ((HGDIOBJ)(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 #define CID_RESOURCE 0x0001
58 #define CID_WIN32 0x0004
59 #define CID_NONSHARED 0x0008
60
61 WORD USER_HeapSel = 0; /* USER heap selector */
62
63 static HINSTANCE16 gdi_inst;
64
65 struct gray_string_info
66 {
67 GRAYSTRINGPROC16 proc;
68 LPARAM param;
69 char str[1];
70 };
71
72 /* callback for 16-bit gray string proc with opaque pointer */
73 static BOOL CALLBACK gray_string_callback( HDC hdc, LPARAM param, INT len )
74 {
75 const struct gray_string_info *info = (struct gray_string_info *)param;
76 WORD args[4];
77 DWORD ret;
78
79 args[3] = HDC_16(hdc);
80 args[2] = HIWORD(info->param);
81 args[1] = LOWORD(info->param);
82 args[0] = len;
83 WOWCallback16Ex( (DWORD)info->proc, WCB16_PASCAL, sizeof(args), args, &ret );
84 return LOWORD(ret);
85 }
86
87 /* callback for 16-bit gray string proc with string pointer */
88 static BOOL CALLBACK gray_string_callback_ptr( HDC hdc, LPARAM param, INT len )
89 {
90 const struct gray_string_info *info = CONTAINING_RECORD( (void *)param, struct gray_string_info, str );
91 return gray_string_callback( hdc, (LPARAM)info, len );
92 }
93
94 struct draw_state_info
95 {
96 DRAWSTATEPROC16 proc;
97 LPARAM param;
98 };
99
100 /* callback for 16-bit DrawState functions */
101 static BOOL CALLBACK draw_state_callback( HDC hdc, LPARAM lparam, WPARAM wparam, int cx, int cy )
102 {
103 const struct draw_state_info *info = (struct draw_state_info *)lparam;
104 WORD args[6];
105 DWORD ret;
106
107 args[5] = HDC_16(hdc);
108 args[4] = HIWORD(info->param);
109 args[3] = LOWORD(info->param);
110 args[2] = wparam;
111 args[1] = cx;
112 args[0] = cy;
113 WOWCallback16Ex( (DWORD)info->proc, WCB16_PASCAL, sizeof(args), args, &ret );
114 return LOWORD(ret);
115 }
116
117 /* This function is a copy of the one in objects/font.c */
118 static void logfont_32_to_16( const LOGFONTA* font32, LPLOGFONT16 font16 )
119 {
120 font16->lfHeight = font32->lfHeight;
121 font16->lfWidth = font32->lfWidth;
122 font16->lfEscapement = font32->lfEscapement;
123 font16->lfOrientation = font32->lfOrientation;
124 font16->lfWeight = font32->lfWeight;
125 font16->lfItalic = font32->lfItalic;
126 font16->lfUnderline = font32->lfUnderline;
127 font16->lfStrikeOut = font32->lfStrikeOut;
128 font16->lfCharSet = font32->lfCharSet;
129 font16->lfOutPrecision = font32->lfOutPrecision;
130 font16->lfClipPrecision = font32->lfClipPrecision;
131 font16->lfQuality = font32->lfQuality;
132 font16->lfPitchAndFamily = font32->lfPitchAndFamily;
133 lstrcpynA( font16->lfFaceName, font32->lfFaceName, LF_FACESIZE );
134 }
135
136 static int get_bitmap_width_bytes( int width, int bpp )
137 {
138 switch(bpp)
139 {
140 case 1:
141 return 2 * ((width+15) / 16);
142 case 4:
143 return 2 * ((width+3) / 4);
144 case 24:
145 width *= 3;
146 /* fall through */
147 case 8:
148 return width + (width & 1);
149 case 16:
150 case 15:
151 return width * 2;
152 case 32:
153 return width * 4;
154 default:
155 WARN("Unknown depth %d, please report.\n", bpp );
156 }
157 return -1;
158 }
159
160 /***********************************************************************
161 * Helper for wsprintf16
162 */
163
164 #define WPRINTF_LEFTALIGN 0x0001 /* Align output on the left ('-' prefix) */
165 #define WPRINTF_PREFIX_HEX 0x0002 /* Prefix hex with 0x ('#' prefix) */
166 #define WPRINTF_ZEROPAD 0x0004 /* Pad with zeros ('0' prefix) */
167 #define WPRINTF_LONG 0x0008 /* Long arg ('l' prefix) */
168 #define WPRINTF_SHORT 0x0010 /* Short arg ('h' prefix) */
169 #define WPRINTF_UPPER_HEX 0x0020 /* Upper-case hex ('X' specifier) */
170
171 typedef enum
172 {
173 WPR_UNKNOWN,
174 WPR_CHAR,
175 WPR_STRING,
176 WPR_SIGNED,
177 WPR_UNSIGNED,
178 WPR_HEXA
179 } WPRINTF_TYPE;
180
181 typedef struct
182 {
183 UINT flags;
184 UINT width;
185 UINT precision;
186 WPRINTF_TYPE type;
187 } WPRINTF_FORMAT;
188
189 static INT parse_format( LPCSTR format, WPRINTF_FORMAT *res )
190 {
191 LPCSTR p = format;
192
193 res->flags = 0;
194 res->width = 0;
195 res->precision = 0;
196 if (*p == '-') { res->flags |= WPRINTF_LEFTALIGN; p++; }
197 if (*p == '#') { res->flags |= WPRINTF_PREFIX_HEX; p++; }
198 if (*p == '0') { res->flags |= WPRINTF_ZEROPAD; p++; }
199 while ((*p >= '0') && (*p <= '9')) /* width field */
200 {
201 res->width = res->width * 10 + *p - '0';
202 p++;
203 }
204 if (*p == '.') /* precision field */
205 {
206 p++;
207 while ((*p >= '0') && (*p <= '9'))
208 {
209 res->precision = res->precision * 10 + *p - '0';
210 p++;
211 }
212 }
213 if (*p == 'l') { res->flags |= WPRINTF_LONG; p++; }
214 else if (*p == 'h') { res->flags |= WPRINTF_SHORT; p++; }
215 switch(*p)
216 {
217 case 'c':
218 case 'C': /* no Unicode in Win16 */
219 res->type = WPR_CHAR;
220 break;
221 case 's':
222 case 'S':
223 res->type = WPR_STRING;
224 break;
225 case 'd':
226 case 'i':
227 res->type = WPR_SIGNED;
228 break;
229 case 'u':
230 res->type = WPR_UNSIGNED;
231 break;
232 case 'p':
233 res->width = 8;
234 res->flags |= WPRINTF_ZEROPAD;
235 /* fall through */
236 case 'X':
237 res->flags |= WPRINTF_UPPER_HEX;
238 /* fall through */
239 case 'x':
240 res->type = WPR_HEXA;
241 break;
242 default: /* unknown format char */
243 res->type = WPR_UNKNOWN;
244 p--; /* print format as normal char */
245 break;
246 }
247 return (INT)(p - format) + 1;
248 }
249
250
251 /**********************************************************************
252 * Management of the 16-bit cursors and icons
253 */
254
255 struct cache_entry
256 {
257 struct list entry;
258 HINSTANCE16 inst;
259 HRSRC16 rsrc;
260 HRSRC16 group;
261 HICON16 icon;
262 INT count;
263 };
264
265 static struct list icon_cache = LIST_INIT( icon_cache );
266
267 static const WORD ICON_HOTSPOT = 0x4242;
268
269 static HICON16 alloc_icon_handle( unsigned int size )
270 {
271 HGLOBAL16 handle = GlobalAlloc16( GMEM_MOVEABLE, size + sizeof(ULONG_PTR) );
272 char *ptr = GlobalLock16( handle );
273 memset( ptr + size, 0, sizeof(ULONG_PTR) );
274 GlobalUnlock16( handle );
275 FarSetOwner16( handle, 0 );
276 return handle;
277 }
278
279 static CURSORICONINFO *get_icon_ptr( HICON16 handle )
280 {
281 return GlobalLock16( handle );
282 }
283
284 static void release_icon_ptr( HICON16 handle, CURSORICONINFO *ptr )
285 {
286 GlobalUnlock16( handle );
287 }
288
289 static HICON store_icon_32( HICON16 icon16, HICON icon )
290 {
291 HICON ret = 0;
292 CURSORICONINFO *ptr = get_icon_ptr( icon16 );
293
294 if (ptr)
295 {
296 unsigned int and_size = ptr->nHeight * get_bitmap_width_bytes( ptr->nWidth, 1 );
297 unsigned int xor_size = ptr->nHeight * get_bitmap_width_bytes( ptr->nWidth, ptr->bBitsPerPixel );
298 if (GlobalSize16( icon16 ) >= sizeof(*ptr) + sizeof(ULONG_PTR) + and_size + xor_size )
299 {
300 memcpy( &ret, (char *)(ptr + 1) + and_size + xor_size, sizeof(ret) );
301 memcpy( (char *)(ptr + 1) + and_size + xor_size, &icon, sizeof(icon) );
302 wow_handlers32.set_icon_param( icon, icon16 );
303 }
304 release_icon_ptr( icon16, ptr );
305 }
306 return ret;
307 }
308
309 static int free_icon_handle( HICON16 handle )
310 {
311 HICON icon32;
312
313 if ((icon32 = store_icon_32( handle, 0 ))) DestroyIcon( icon32 );
314 return GlobalFree16( handle );
315 }
316
317 /* retrieve the 32-bit counterpart of a 16-bit icon, creating it if needed */
318 HICON get_icon_32( HICON16 icon16 )
319 {
320 HICON ret = 0;
321 CURSORICONINFO *ptr = get_icon_ptr( icon16 );
322
323 if (ptr)
324 {
325 unsigned int and_size = ptr->nHeight * get_bitmap_width_bytes( ptr->nWidth, 1 );
326 unsigned int xor_size = ptr->nHeight * get_bitmap_width_bytes( ptr->nWidth, ptr->bBitsPerPixel );
327 if (GlobalSize16( icon16 ) >= sizeof(*ptr) + sizeof(ULONG_PTR) + xor_size + and_size )
328 {
329 memcpy( &ret, (char *)(ptr + 1) + xor_size + and_size, sizeof(ret) );
330 if (!ret)
331 {
332 ICONINFO iinfo;
333
334 iinfo.fIcon = (ptr->ptHotSpot.x == ICON_HOTSPOT) && (ptr->ptHotSpot.y == ICON_HOTSPOT);
335 iinfo.xHotspot = ptr->ptHotSpot.x;
336 iinfo.yHotspot = ptr->ptHotSpot.y;
337 iinfo.hbmMask = CreateBitmap( ptr->nWidth, ptr->nHeight, 1, 1, ptr + 1 );
338 iinfo.hbmColor = CreateBitmap( ptr->nWidth, ptr->nHeight, ptr->bPlanes, ptr->bBitsPerPixel,
339 (char *)(ptr + 1) + and_size );
340 ret = CreateIconIndirect( &iinfo );
341 DeleteObject( iinfo.hbmMask );
342 DeleteObject( iinfo.hbmColor );
343 memcpy( (char *)(ptr + 1) + xor_size + and_size, &ret, sizeof(ret) );
344 wow_handlers32.set_icon_param( ret, icon16 );
345 }
346 }
347 release_icon_ptr( icon16, ptr );
348 }
349 return ret;
350 }
351
352 /* retrieve the 16-bit counterpart of a 32-bit icon, creating it if needed */
353 HICON16 get_icon_16( HICON icon )
354 {
355 HICON16 ret = wow_handlers32.get_icon_param( icon );
356
357 if (!ret)
358 {
359 ICONINFO info;
360 BITMAP bm;
361 UINT and_size, xor_size;
362 void *xor_bits = NULL, *and_bits;
363 CURSORICONINFO cinfo;
364
365 if (!(GetIconInfo( icon, &info ))) return 0;
366 GetObjectW( info.hbmMask, sizeof(bm), &bm );
367 and_size = bm.bmHeight * bm.bmWidthBytes;
368 if (!(and_bits = HeapAlloc( GetProcessHeap(), 0, and_size ))) goto done;
369 GetBitmapBits( info.hbmMask, and_size, and_bits );
370 if (info.hbmColor)
371 {
372 GetObjectW( info.hbmColor, sizeof(bm), &bm );
373 xor_size = bm.bmHeight * bm.bmWidthBytes;
374 if (!(xor_bits = HeapAlloc( GetProcessHeap(), 0, xor_size ))) goto done;
375 GetBitmapBits( info.hbmColor, xor_size, xor_bits );
376 }
377 else
378 {
379 bm.bmHeight /= 2;
380 xor_bits = (char *)and_bits + and_size / 2;
381 }
382 if (!info.fIcon)
383 {
384 cinfo.ptHotSpot.x = info.xHotspot;
385 cinfo.ptHotSpot.y = info.yHotspot;
386 }
387 else cinfo.ptHotSpot.x = cinfo.ptHotSpot.y = ICON_HOTSPOT;
388
389 cinfo.nWidth = bm.bmWidth;
390 cinfo.nHeight = bm.bmHeight;
391 cinfo.nWidthBytes = bm.bmWidthBytes;
392 cinfo.bPlanes = bm.bmPlanes;
393 cinfo.bBitsPerPixel = bm.bmBitsPixel;
394
395 if ((ret = CreateCursorIconIndirect16( 0, &cinfo, and_bits, xor_bits )))
396 store_icon_32( ret, icon );
397
398 done:
399 if (info.hbmColor)
400 {
401 HeapFree( GetProcessHeap(), 0, xor_bits );
402 DeleteObject( info.hbmColor );
403 }
404 HeapFree( GetProcessHeap(), 0, and_bits );
405 DeleteObject( info.hbmMask );
406 }
407 return ret;
408 }
409
410 static void add_shared_icon( HINSTANCE16 inst, HRSRC16 rsrc, HRSRC16 group, HICON16 icon )
411 {
412 struct cache_entry *cache = HeapAlloc( GetProcessHeap(), 0, sizeof(*cache) );
413
414 if (!cache) return;
415 cache->inst = inst;
416 cache->rsrc = rsrc;
417 cache->group = group;
418 cache->icon = icon;
419 cache->count = 1;
420 list_add_tail( &icon_cache, &cache->entry );
421 }
422
423 static HICON16 find_shared_icon( HINSTANCE16 inst, HRSRC16 rsrc )
424 {
425 struct cache_entry *cache;
426
427 LIST_FOR_EACH_ENTRY( cache, &icon_cache, struct cache_entry, entry )
428 {
429 if (cache->inst != inst || cache->rsrc != rsrc) continue;
430 cache->count++;
431 return cache->icon;
432 }
433 return 0;
434 }
435
436 static int release_shared_icon( HICON16 icon )
437 {
438 struct cache_entry *cache;
439
440 LIST_FOR_EACH_ENTRY( cache, &icon_cache, struct cache_entry, entry )
441 {
442 if (cache->icon != icon) continue;
443 if (!cache->count) return 0;
444 return --cache->count;
445 }
446 return -1;
447 }
448
449 static void free_module_icons( HINSTANCE16 inst )
450 {
451 struct cache_entry *cache, *next;
452
453 LIST_FOR_EACH_ENTRY_SAFE( cache, next, &icon_cache, struct cache_entry, entry )
454 {
455 if (cache->inst != inst) continue;
456 list_remove( &cache->entry );
457 free_icon_handle( cache->icon );
458 HeapFree( GetProcessHeap(), 0, cache );
459 }
460 }
461
462 /**********************************************************************
463 * Management of the 16-bit clipboard formats
464 */
465
466 struct clipboard_format
467 {
468 struct list entry;
469 UINT format;
470 HANDLE16 data;
471 };
472
473 static struct list clipboard_formats = LIST_INIT( clipboard_formats );
474
475 static void set_clipboard_format( UINT format, HANDLE16 data )
476 {
477 struct clipboard_format *fmt;
478
479 /* replace it if it exists already */
480 LIST_FOR_EACH_ENTRY( fmt, &clipboard_formats, struct clipboard_format, entry )
481 {
482 if (fmt->format != format) continue;
483 GlobalFree16( fmt->data );
484 fmt->data = data;
485 return;
486 }
487
488 if ((fmt = HeapAlloc( GetProcessHeap(), 0, sizeof(*fmt) )))
489 {
490 fmt->format = format;
491 fmt->data = data;
492 list_add_tail( &clipboard_formats, &fmt->entry );
493 }
494 }
495
496 static void free_clipboard_formats(void)
497 {
498 struct list *head;
499
500 while ((head = list_head( &clipboard_formats )))
501 {
502 struct clipboard_format *fmt = LIST_ENTRY( head, struct clipboard_format, entry );
503 list_remove( &fmt->entry );
504 GlobalFree16( fmt->data );
505 HeapFree( GetProcessHeap(), 0, fmt );
506 }
507 }
508
509
510 /***********************************************************************
511 * OldExitWindows (USER.2)
512 */
513 void WINAPI OldExitWindows16(void)
514 {
515 ExitWindows16(0, 0);
516 }
517
518
519 /**********************************************************************
520 * InitApp (USER.5)
521 */
522 INT16 WINAPI InitApp16( HINSTANCE16 hInstance )
523 {
524 /* Create task message queue */
525 return (InitThreadInput16( 0, 0 ) != 0);
526 }
527
528
529 /***********************************************************************
530 * ExitWindows (USER.7)
531 */
532 BOOL16 WINAPI ExitWindows16( DWORD dwReturnCode, UINT16 wReserved )
533 {
534 return ExitWindowsEx( EWX_LOGOFF, 0xffffffff );
535 }
536
537
538 /***********************************************************************
539 * GetTimerResolution (USER.14)
540 */
541 LONG WINAPI GetTimerResolution16(void)
542 {
543 return (1000);
544 }
545
546
547 /***********************************************************************
548 * ClipCursor (USER.16)
549 */
550 BOOL16 WINAPI ClipCursor16( const RECT16 *rect )
551 {
552 RECT rect32;
553
554 if (!rect) return ClipCursor( NULL );
555 rect32.left = rect->left;
556 rect32.top = rect->top;
557 rect32.right = rect->right;
558 rect32.bottom = rect->bottom;
559 return ClipCursor( &rect32 );
560 }
561
562
563 /***********************************************************************
564 * GetCursorPos (USER.17)
565 */
566 BOOL16 WINAPI GetCursorPos16( POINT16 *pt )
567 {
568 POINT pos;
569 if (!pt) return FALSE;
570 GetCursorPos(&pos);
571 pt->x = pos.x;
572 pt->y = pos.y;
573 return TRUE;
574 }
575
576
577 /*******************************************************************
578 * AnyPopup (USER.52)
579 */
580 BOOL16 WINAPI AnyPopup16(void)
581 {
582 return AnyPopup();
583 }
584
585
586 /***********************************************************************
587 * SetCursor (USER.69)
588 */
589 HCURSOR16 WINAPI SetCursor16(HCURSOR16 hCursor)
590 {
591 return get_icon_16( SetCursor( get_icon_32(hCursor) ));
592 }
593
594
595 /***********************************************************************
596 * SetCursorPos (USER.70)
597 */
598 void WINAPI SetCursorPos16( INT16 x, INT16 y )
599 {
600 SetCursorPos( x, y );
601 }
602
603
604 /***********************************************************************
605 * ShowCursor (USER.71)
606 */
607 INT16 WINAPI ShowCursor16(BOOL16 bShow)
608 {
609 return ShowCursor(bShow);
610 }
611
612
613 /***********************************************************************
614 * SetRect (USER.72)
615 */
616 void WINAPI SetRect16( LPRECT16 rect, INT16 left, INT16 top, INT16 right, INT16 bottom )
617 {
618 rect->left = left;
619 rect->right = right;
620 rect->top = top;
621 rect->bottom = bottom;
622 }
623
624
625 /***********************************************************************
626 * SetRectEmpty (USER.73)
627 */
628 void WINAPI SetRectEmpty16( LPRECT16 rect )
629 {
630 rect->left = rect->right = rect->top = rect->bottom = 0;
631 }
632
633
634 /***********************************************************************
635 * CopyRect (USER.74)
636 */
637 BOOL16 WINAPI CopyRect16( RECT16 *dest, const RECT16 *src )
638 {
639 *dest = *src;
640 return TRUE;
641 }
642
643
644 /***********************************************************************
645 * IsRectEmpty (USER.75)
646 *
647 * Bug compat: Windows checks for 0 or negative width/height.
648 */
649 BOOL16 WINAPI IsRectEmpty16( const RECT16 *rect )
650 {
651 return ((rect->left >= rect->right) || (rect->top >= rect->bottom));
652 }
653
654
655 /***********************************************************************
656 * PtInRect (USER.76)
657 */
658 BOOL16 WINAPI PtInRect16( const RECT16 *rect, POINT16 pt )
659 {
660 return ((pt.x >= rect->left) && (pt.x < rect->right) &&
661 (pt.y >= rect->top) && (pt.y < rect->bottom));
662 }
663
664
665 /***********************************************************************
666 * OffsetRect (USER.77)
667 */
668 void WINAPI OffsetRect16( LPRECT16 rect, INT16 x, INT16 y )
669 {
670 rect->left += x;
671 rect->right += x;
672 rect->top += y;
673 rect->bottom += y;
674 }
675
676
677 /***********************************************************************
678 * InflateRect (USER.78)
679 */
680 void WINAPI InflateRect16( LPRECT16 rect, INT16 x, INT16 y )
681 {
682 rect->left -= x;
683 rect->top -= y;
684 rect->right += x;
685 rect->bottom += y;
686 }
687
688
689 /***********************************************************************
690 * IntersectRect (USER.79)
691 */
692 BOOL16 WINAPI IntersectRect16( LPRECT16 dest, const RECT16 *src1,
693 const RECT16 *src2 )
694 {
695 if (IsRectEmpty16(src1) || IsRectEmpty16(src2) ||
696 (src1->left >= src2->right) || (src2->left >= src1->right) ||
697 (src1->top >= src2->bottom) || (src2->top >= src1->bottom))
698 {
699 SetRectEmpty16( dest );
700 return FALSE;
701 }
702 dest->left = max( src1->left, src2->left );
703 dest->right = min( src1->right, src2->right );
704 dest->top = max( src1->top, src2->top );
705 dest->bottom = min( src1->bottom, src2->bottom );
706 return TRUE;
707 }
708
709
710 /***********************************************************************
711 * UnionRect (USER.80)
712 */
713 BOOL16 WINAPI UnionRect16( LPRECT16 dest, const RECT16 *src1,
714 const RECT16 *src2 )
715 {
716 if (IsRectEmpty16(src1))
717 {
718 if (IsRectEmpty16(src2))
719 {
720 SetRectEmpty16( dest );
721 return FALSE;
722 }
723 else *dest = *src2;
724 }
725 else
726 {
727 if (IsRectEmpty16(src2)) *dest = *src1;
728 else
729 {
730 dest->left = min( src1->left, src2->left );
731 dest->right = max( src1->right, src2->right );
732 dest->top = min( src1->top, src2->top );
733 dest->bottom = max( src1->bottom, src2->bottom );
734 }
735 }
736 return TRUE;
737 }
738
739
740 /***********************************************************************
741 * FillRect (USER.81)
742 * NOTE
743 * The Win16 variant doesn't support special color brushes like
744 * the Win32 one, despite the fact that Win16, as well as Win32,
745 * supports special background brushes for a window class.
746 */
747 INT16 WINAPI FillRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
748 {
749 HBRUSH prevBrush;
750
751 /* coordinates are logical so we cannot fast-check 'rect',
752 * it will be done later in the PatBlt().
753 */
754
755 if (!(prevBrush = SelectObject( HDC_32(hdc), HBRUSH_32(hbrush) ))) return 0;
756 PatBlt( HDC_32(hdc), rect->left, rect->top,
757 rect->right - rect->left, rect->bottom - rect->top, PATCOPY );
758 SelectObject( HDC_32(hdc), prevBrush );
759 return 1;
760 }
761
762
763 /***********************************************************************
764 * InvertRect (USER.82)
765 */
766 void WINAPI InvertRect16( HDC16 hdc, const RECT16 *rect )
767 {
768 PatBlt( HDC_32(hdc), rect->left, rect->top,
769 rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
770 }
771
772
773 /***********************************************************************
774 * FrameRect (USER.83)
775 */
776 INT16 WINAPI FrameRect16( HDC16 hdc, const RECT16 *rect16, HBRUSH16 hbrush )
777 {
778 RECT rect;
779
780 rect.left = rect16->left;
781 rect.top = rect16->top;
782 rect.right = rect16->right;
783 rect.bottom = rect16->bottom;
784 return FrameRect( HDC_32(hdc), &rect, HBRUSH_32(hbrush) );
785 }
786
787
788 /***********************************************************************
789 * DrawIcon (USER.84)
790 */
791 BOOL16 WINAPI DrawIcon16(HDC16 hdc, INT16 x, INT16 y, HICON16 hIcon)
792 {
793 return DrawIcon(HDC_32(hdc), x, y, get_icon_32(hIcon) );
794 }
795
796
797 /***********************************************************************
798 * DrawText (USER.85)
799 */
800 INT16 WINAPI DrawText16( HDC16 hdc, LPCSTR str, INT16 count, LPRECT16 rect, UINT16 flags )
801 {
802 INT16 ret;
803
804 if (rect)
805 {
806 RECT rect32;
807
808 rect32.left = rect->left;
809 rect32.top = rect->top;
810 rect32.right = rect->right;
811 rect32.bottom = rect->bottom;
812 ret = DrawTextA( HDC_32(hdc), str, count, &rect32, flags );
813 rect->left = rect32.left;
814 rect->top = rect32.top;
815 rect->right = rect32.right;
816 rect->bottom = rect32.bottom;
817 }
818 else ret = DrawTextA( HDC_32(hdc), str, count, NULL, flags);
819 return ret;
820 }
821
822
823 /***********************************************************************
824 * IconSize (USER.86)
825 *
826 * See "Undocumented Windows". Used by W2.0 paint.exe.
827 */
828 DWORD WINAPI IconSize16(void)
829 {
830 return MAKELONG(GetSystemMetrics(SM_CYICON), GetSystemMetrics(SM_CXICON));
831 }
832
833
834 /***********************************************************************
835 * AdjustWindowRect (USER.102)
836 */
837 BOOL16 WINAPI AdjustWindowRect16( LPRECT16 rect, DWORD style, BOOL16 menu )
838 {
839 return AdjustWindowRectEx16( rect, style, menu, 0 );
840 }
841
842
843 /***********************************************************************
844 * MessageBeep (USER.104)
845 */
846 void WINAPI MessageBeep16( UINT16 i )
847 {
848 MessageBeep( i );
849 }
850
851
852 /**************************************************************************
853 * CloseClipboard (USER.138)
854 */
855 BOOL16 WINAPI CloseClipboard16(void)
856 {
857 BOOL ret = CloseClipboard();
858 if (ret) free_clipboard_formats();
859 return ret;
860 }
861
862
863 /**************************************************************************
864 * EmptyClipboard (USER.139)
865 */
866 BOOL16 WINAPI EmptyClipboard16(void)
867 {
868 BOOL ret = EmptyClipboard();
869 if (ret) free_clipboard_formats();
870 return ret;
871 }
872
873
874 /**************************************************************************
875 * SetClipboardData (USER.141)
876 */
877 HANDLE16 WINAPI SetClipboardData16( UINT16 format, HANDLE16 data16 )
878 {
879 HANDLE data32 = 0;
880
881 switch (format)
882 {
883 case CF_BITMAP:
884 case CF_PALETTE:
885 data32 = HGDIOBJ_32( data16 );
886 break;
887
888 case CF_METAFILEPICT:
889 {
890 METAHEADER *header;
891 METAFILEPICT *pict32;
892 METAFILEPICT16 *pict16 = GlobalLock16( data16 );
893
894 if (pict16)
895 {
896 if (!(data32 = GlobalAlloc( GMEM_MOVEABLE, sizeof(*pict32) ))) return 0;
897 pict32 = GlobalLock( data32 );
898 pict32->mm = pict16->mm;
899 pict32->xExt = pict16->xExt;
900 pict32->yExt = pict16->yExt;
901 header = GlobalLock16( pict16->hMF );
902 pict32->hMF = SetMetaFileBitsEx( header->mtSize * 2, (BYTE *)header );
903 GlobalUnlock16( pict16->hMF );
904 GlobalUnlock( data32 );
905 }
906 set_clipboard_format( format, data16 );
907 break;
908 }
909
910 case CF_ENHMETAFILE:
911 FIXME( "enhmetafile not supported in 16-bit\n" );
912 return 0;
913
914 default:
915 if (format >= CF_GDIOBJFIRST && format <= CF_GDIOBJLAST)
916 data32 = HGDIOBJ_32( data16 );
917 else if (format >= CF_PRIVATEFIRST && format <= CF_PRIVATELAST)
918 data32 = HANDLE_32( data16 );
919 else
920 {
921 UINT size = GlobalSize16( data16 );
922 void *ptr32, *ptr16 = GlobalLock16( data16 );
923 if (ptr16)
924 {
925 if (!(data32 = GlobalAlloc( GMEM_MOVEABLE, size ))) return 0;
926 ptr32 = GlobalLock( data32 );
927 memcpy( ptr32, ptr16, size );
928 GlobalUnlock( data32 );
929 }
930 set_clipboard_format( format, data16 );
931 }
932 break;
933 }
934
935 if (!SetClipboardData( format, data32 )) return 0;
936 return data16;
937 }
938
939
940 /**************************************************************************
941 * GetClipboardData (USER.142)
942 */
943 HANDLE16 WINAPI GetClipboardData16( UINT16 format )
944 {
945 HANDLE data32 = GetClipboardData( format );
946 HANDLE16 data16 = 0;
947 UINT size;
948 void *ptr;
949
950 if (!data32) return 0;
951
952 switch (format)
953 {
954 case CF_BITMAP:
955 case CF_PALETTE:
956 data16 = HGDIOBJ_16( data32 );
957 break;
958
959 case CF_METAFILEPICT:
960 {
961 METAFILEPICT16 *pict16;
962 METAFILEPICT *pict32 = GlobalLock( data32 );
963
964 if (pict32)
965 {
966 if (!(data16 = GlobalAlloc16( GMEM_MOVEABLE, sizeof(*pict16) ))) return 0;
967 pict16 = GlobalLock16( data16 );
968 pict16->mm = pict32->mm;
969 pict16->xExt = pict32->xExt;
970 pict16->yExt = pict32->yExt;
971 size = GetMetaFileBitsEx( pict32->hMF, 0, NULL );
972 pict16->hMF = GlobalAlloc16( GMEM_MOVEABLE, size );
973 ptr = GlobalLock16( pict16->hMF );
974 GetMetaFileBitsEx( pict32->hMF, size, ptr );
975 GlobalUnlock16( pict16->hMF );
976 GlobalUnlock16( data16 );
977 set_clipboard_format( format, data16 );
978 }
979 break;
980 }
981
982 case CF_ENHMETAFILE:
983 FIXME( "enhmetafile not supported in 16-bit\n" );
984 return 0;
985
986 default:
987 if (format >= CF_GDIOBJFIRST && format <= CF_GDIOBJLAST)
988 data16 = HGDIOBJ_16( data32 );
989 else if (format >= CF_PRIVATEFIRST && format <= CF_PRIVATELAST)
990 data16 = HANDLE_16( data32 );
991 else
992 {
993 void *ptr16, *ptr32 = GlobalLock( data32 );
994 if (ptr32)
995 {
996 size = GlobalSize( data32 );
997 if (!(data16 = GlobalAlloc16( GMEM_MOVEABLE, size ))) return 0;
998 ptr16 = GlobalLock16( data16 );
999 memcpy( ptr16, ptr32, size );
1000 GlobalUnlock16( data16 );
1001 set_clipboard_format( format, data16 );
1002 }
1003 }
1004 break;
1005 }
1006 return data16;
1007 }
1008
1009
1010 /**************************************************************************
1011 * CountClipboardFormats (USER.143)
1012 */
1013 INT16 WINAPI CountClipboardFormats16(void)
1014 {
1015 return CountClipboardFormats();
1016 }
1017
1018
1019 /**************************************************************************
1020 * EnumClipboardFormats (USER.144)
1021 */
1022 UINT16 WINAPI EnumClipboardFormats16( UINT16 id )
1023 {
1024 return EnumClipboardFormats( id );
1025 }
1026
1027
1028 /**************************************************************************
1029 * RegisterClipboardFormat (USER.145)
1030 */
1031 UINT16 WINAPI RegisterClipboardFormat16( LPCSTR name )
1032 {
1033 return RegisterClipboardFormatA( name );
1034 }
1035
1036
1037 /**************************************************************************
1038 * GetClipboardFormatName (USER.146)
1039 */
1040 INT16 WINAPI GetClipboardFormatName16( UINT16 id, LPSTR buffer, INT16 maxlen )
1041 {
1042 return GetClipboardFormatNameA( id, buffer, maxlen );
1043 }
1044
1045
1046 /**********************************************************************
1047 * LoadMenu (USER.150)
1048 */
1049 HMENU16 WINAPI LoadMenu16( HINSTANCE16 instance, LPCSTR name )
1050 {
1051 HRSRC16 hRsrc;
1052 HGLOBAL16 handle;
1053 HMENU16 hMenu;
1054
1055 if (HIWORD(name) && name[0] == '#') name = ULongToPtr(atoi( name + 1 ));
1056 if (!name) return 0;
1057
1058 instance = GetExePtr( instance );
1059 if (!(hRsrc = FindResource16( instance, name, (LPSTR)RT_MENU ))) return 0;
1060 if (!(handle = LoadResource16( instance, hRsrc ))) return 0;
1061 hMenu = LoadMenuIndirect16(LockResource16(handle));
1062 FreeResource16( handle );
1063 return hMenu;
1064 }
1065
1066
1067 /**********************************************************************
1068 * CreateMenu (USER.151)
1069 */
1070 HMENU16 WINAPI CreateMenu16(void)
1071 {
1072 return HMENU_16( CreateMenu() );
1073 }
1074
1075
1076 /**********************************************************************
1077 * DestroyMenu (USER.152)
1078 */
1079 BOOL16 WINAPI DestroyMenu16( HMENU16 hMenu )
1080 {
1081 return DestroyMenu( HMENU_32(hMenu) );
1082 }
1083
1084
1085 /*******************************************************************
1086 * ChangeMenu (USER.153)
1087 */
1088 BOOL16 WINAPI ChangeMenu16( HMENU16 hMenu, UINT16 pos, SEGPTR data,
1089 UINT16 id, UINT16 flags )
1090 {
1091 if (flags & MF_APPEND) return AppendMenu16( hMenu, flags & ~MF_APPEND, id, data );
1092
1093 /* FIXME: Word passes the item id in 'pos' and 0 or 0xffff as id */
1094 /* for MF_DELETE. We should check the parameters for all others */
1095 /* MF_* actions also (anybody got a doc on ChangeMenu?). */
1096
1097 if (flags & MF_DELETE) return DeleteMenu16(hMenu, pos, flags & ~MF_DELETE);
1098 if (flags & MF_CHANGE) return ModifyMenu16(hMenu, pos, flags & ~MF_CHANGE, id, data );
1099 if (flags & MF_REMOVE) return RemoveMenu16(hMenu, flags & MF_BYPOSITION ? pos : id,
1100 flags & ~MF_REMOVE );
1101 /* Default: MF_INSERT */
1102 return InsertMenu16( hMenu, pos, flags, id, data );
1103 }
1104
1105
1106 /*******************************************************************
1107 * CheckMenuItem (USER.154)
1108 */
1109 BOOL16 WINAPI CheckMenuItem16( HMENU16 hMenu, UINT16 id, UINT16 flags )
1110 {
1111 return CheckMenuItem( HMENU_32(hMenu), id, flags );
1112 }
1113
1114
1115 /**********************************************************************
1116 * EnableMenuItem (USER.155)
1117 */
1118 BOOL16 WINAPI EnableMenuItem16( HMENU16 hMenu, UINT16 wItemID, UINT16 wFlags )
1119 {
1120 return EnableMenuItem( HMENU_32(hMenu), wItemID, wFlags );
1121 }
1122
1123
1124 /**********************************************************************
1125 * GetSubMenu (USER.159)
1126 */
1127 HMENU16 WINAPI GetSubMenu16( HMENU16 hMenu, INT16 nPos )
1128 {
1129 return HMENU_16( GetSubMenu( HMENU_32(hMenu), nPos ) );
1130 }
1131
1132
1133 /*******************************************************************
1134 * GetMenuString (USER.161)
1135 */
1136 INT16 WINAPI GetMenuString16( HMENU16 hMenu, UINT16 wItemID,
1137 LPSTR str, INT16 nMaxSiz, UINT16 wFlags )
1138 {
1139 return GetMenuStringA( HMENU_32(hMenu), wItemID, str, nMaxSiz, wFlags );
1140 }
1141
1142
1143 /**********************************************************************
1144 * WinHelp (USER.171)
1145 */
1146 BOOL16 WINAPI WinHelp16( HWND16 hWnd, LPCSTR lpHelpFile, UINT16 wCommand,
1147 DWORD dwData )
1148 {
1149 BOOL ret;
1150 DWORD mutex_count;
1151
1152 /* We might call WinExec() */
1153 ReleaseThunkLock(&mutex_count);
1154
1155 ret = WinHelpA(WIN_Handle32(hWnd), lpHelpFile, wCommand, (DWORD)MapSL(dwData));
1156
1157 RestoreThunkLock(mutex_count);
1158 return ret;
1159 }
1160
1161
1162 /***********************************************************************
1163 * LoadCursor (USER.173)
1164 */
1165 HCURSOR16 WINAPI LoadCursor16(HINSTANCE16 hInstance, LPCSTR name)
1166 {
1167 return LoadImage16( hInstance, name, IMAGE_CURSOR, 0, 0, LR_SHARED | LR_DEFAULTSIZE );
1168 }
1169
1170
1171 /***********************************************************************
1172 * LoadIcon (USER.174)
1173 */
1174 HICON16 WINAPI LoadIcon16(HINSTANCE16 hInstance, LPCSTR name)
1175 {
1176 return LoadImage16( hInstance, name, IMAGE_ICON, 0, 0, LR_SHARED | LR_DEFAULTSIZE );
1177 }
1178
1179 /**********************************************************************
1180 * LoadBitmap (USER.175)
1181 */
1182 HBITMAP16 WINAPI LoadBitmap16(HINSTANCE16 hInstance, LPCSTR name)
1183 {
1184 return LoadImage16( hInstance, name, IMAGE_BITMAP, 0, 0, 0 );
1185 }
1186
1187 /**********************************************************************
1188 * LoadString (USER.176)
1189 */
1190 INT16 WINAPI LoadString16( HINSTANCE16 instance, UINT16 resource_id, LPSTR buffer, INT16 buflen )
1191 {
1192 HGLOBAL16 hmem;
1193 HRSRC16 hrsrc;
1194 unsigned char *p;
1195 int string_num;
1196 int ret;
1197
1198 TRACE("inst=%04x id=%04x buff=%p len=%d\n", instance, resource_id, buffer, buflen);
1199
1200 hrsrc = FindResource16( instance, MAKEINTRESOURCEA((resource_id>>4)+1), (LPSTR)RT_STRING );
1201 if (!hrsrc) return 0;
1202 hmem = LoadResource16( instance, hrsrc );
1203 if (!hmem) return 0;
1204
1205 p = LockResource16(hmem);
1206 string_num = resource_id & 0x000f;
1207 while (string_num--) p += *p + 1;
1208
1209 if (buffer == NULL) ret = *p;
1210 else
1211 {
1212 ret = min(buflen - 1, *p);
1213 if (ret > 0)
1214 {
1215 memcpy(buffer, p + 1, ret);
1216 buffer[ret] = '\0';
1217 }
1218 else if (buflen > 1)
1219 {
1220 buffer[0] = '\0';
1221 ret = 0;
1222 }
1223 TRACE( "%s loaded\n", debugstr_a(buffer));
1224 }
1225 FreeResource16( hmem );
1226 return ret;
1227 }
1228
1229 /**********************************************************************
1230 * LoadAccelerators (USER.177)
1231 */
1232 HACCEL16 WINAPI LoadAccelerators16(HINSTANCE16 instance, LPCSTR lpTableName)
1233 {
1234 HRSRC16 hRsrc;
1235 HGLOBAL16 hMem;
1236 ACCEL16 *table16;
1237 HACCEL ret = 0;
1238
1239 TRACE("%04x %s\n", instance, debugstr_a(lpTableName) );
1240
1241 if (!(hRsrc = FindResource16( instance, lpTableName, (LPSTR)RT_ACCELERATOR )) ||
1242 !(hMem = LoadResource16(instance,hRsrc)))
1243 {
1244 WARN("couldn't find %04x %s\n", instance, debugstr_a(lpTableName));
1245 return 0;
1246 }
1247 if ((table16 = LockResource16( hMem )))
1248 {
1249 DWORD i, count = SizeofResource16( instance, hRsrc ) / sizeof(*table16);
1250 ACCEL *table = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*table) );
1251 if (table)
1252 {
1253 for (i = 0; i < count; i++)
1254 {
1255 table[i].fVirt = table16[i].fVirt & 0x7f;
1256 table[i].key = table16[i].key;
1257 table[i].cmd = table16[i].cmd;
1258 }
1259 ret = CreateAcceleratorTableA( table, count );
1260 HeapFree( GetProcessHeap(), 0, table );
1261 }
1262 }
1263 FreeResource16( hMem );
1264 return HACCEL_16(ret);
1265 }
1266
1267 /***********************************************************************
1268 * GetSystemMetrics (USER.179)
1269 */
1270 INT16 WINAPI GetSystemMetrics16( INT16 index )
1271 {
1272 return GetSystemMetrics( index );
1273 }
1274
1275
1276 /*************************************************************************
1277 * GetSysColor (USER.180)
1278 */
1279 COLORREF WINAPI GetSysColor16( INT16 index )
1280 {
1281 return GetSysColor( index );
1282 }
1283
1284
1285 /*************************************************************************
1286 * SetSysColors (USER.181)
1287 */
1288 VOID WINAPI SetSysColors16( INT16 count, const INT16 *list16, const COLORREF *values )
1289 {
1290 INT i, *list;
1291
1292 if ((list = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*list) )))
1293 {
1294 for (i = 0; i < count; i++) list[i] = list16[i];
1295 SetSysColors( count, list, values );
1296 HeapFree( GetProcessHeap(), 0, list );
1297 }
1298 }
1299
1300
1301 /***********************************************************************
1302 * GrayString (USER.185)
1303 */
1304 BOOL16 WINAPI GrayString16( HDC16 hdc, HBRUSH16 hbr, GRAYSTRINGPROC16 gsprc,
1305 LPARAM lParam, INT16 cch, INT16 x, INT16 y,
1306 INT16 cx, INT16 cy )
1307 {
1308 BOOL ret;
1309
1310 if (!gsprc) return GrayStringA( HDC_32(hdc), HBRUSH_32(hbr), NULL,
1311 (LPARAM)MapSL(lParam), cch, x, y, cx, cy );
1312
1313 if (cch == -1 || (cch && cx && cy))
1314 {
1315 /* lParam can be treated as an opaque pointer */
1316 struct gray_string_info info;
1317
1318 info.proc = gsprc;
1319 info.param = lParam;
1320 ret = GrayStringA( HDC_32(hdc), HBRUSH_32(hbr), gray_string_callback,
1321 (LPARAM)&info, cch, x, y, cx, cy );
1322 }
1323 else /* here we need some string conversions */
1324 {
1325 char *str16 = MapSL(lParam);
1326 struct gray_string_info *info;
1327
1328 if (!cch) cch = strlen(str16);
1329 info = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET( struct gray_string_info, str[cch] ));
1330 if (!info) return FALSE;
1331 info->proc = gsprc;
1332 info->param = lParam;
1333 memcpy( info->str, str16, cch );
1334 ret = GrayStringA( HDC_32(hdc), HBRUSH_32(hbr), gray_string_callback_ptr,
1335 (LPARAM)info->str, cch, x, y, cx, cy );
1336 HeapFree( GetProcessHeap(), 0, info );
1337 }
1338 return ret;
1339 }
1340
1341
1342 /***********************************************************************
1343 * SwapMouseButton (USER.186)
1344 */
1345 BOOL16 WINAPI SwapMouseButton16( BOOL16 fSwap )
1346 {
1347 return SwapMouseButton( fSwap );
1348 }
1349
1350
1351 /**************************************************************************
1352 * IsClipboardFormatAvailable (USER.193)
1353 */
1354 BOOL16 WINAPI IsClipboardFormatAvailable16( UINT16 wFormat )
1355 {
1356 return IsClipboardFormatAvailable( wFormat );
1357 }
1358
1359
1360 /***********************************************************************
1361 * TabbedTextOut (USER.196)
1362 */
1363 LONG WINAPI TabbedTextOut16( HDC16 hdc, INT16 x, INT16 y, LPCSTR lpstr,
1364 INT16 count, INT16 nb_tabs, const INT16 *tabs16, INT16 tab_org )
1365 {
1366 LONG ret;
1367 INT i, *tabs = HeapAlloc( GetProcessHeap(), 0, nb_tabs * sizeof(*tabs) );
1368 if (!tabs) return 0;
1369 for (i = 0; i < nb_tabs; i++) tabs[i] = tabs16[i];
1370 ret = TabbedTextOutA( HDC_32(hdc), x, y, lpstr, count, nb_tabs, tabs, tab_org );
1371 HeapFree( GetProcessHeap(), 0, tabs );
1372 return ret;
1373 }
1374
1375
1376 /***********************************************************************
1377 * GetTabbedTextExtent (USER.197)
1378 */
1379 DWORD WINAPI GetTabbedTextExtent16( HDC16 hdc, LPCSTR lpstr, INT16 count,
1380 INT16 nb_tabs, const INT16 *tabs16 )
1381 {
1382 LONG ret;
1383 INT i, *tabs = HeapAlloc( GetProcessHeap(), 0, nb_tabs * sizeof(*tabs) );
1384 if (!tabs) return 0;
1385 for (i = 0; i < nb_tabs; i++) tabs[i] = tabs16[i];
1386 ret = GetTabbedTextExtentA( HDC_32(hdc), lpstr, count, nb_tabs, tabs );
1387 HeapFree( GetProcessHeap(), 0, tabs );
1388 return ret;
1389 }
1390
1391
1392 /***********************************************************************
1393 * UserSeeUserDo (USER.216)
1394 */
1395 DWORD WINAPI UserSeeUserDo16(WORD wReqType, WORD wParam1, WORD wParam2, WORD wParam3)
1396 {
1397 STACK16FRAME* stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved);
1398 HANDLE16 oldDS = stack16->ds;
1399 DWORD ret = (DWORD)-1;
1400
1401 stack16->ds = USER_HeapSel;
1402 switch (wReqType)
1403 {
1404 case USUD_LOCALALLOC:
1405 ret = LocalAlloc16(wParam1, wParam3);
1406 break;
1407 case USUD_LOCALFREE:
1408 ret = LocalFree16(wParam1);
1409 break;
1410 case USUD_LOCALCOMPACT:
1411 ret = LocalCompact16(wParam3);
1412 break;
1413 case USUD_LOCALHEAP:
1414 ret = USER_HeapSel;
1415 break;
1416 case USUD_FIRSTCLASS:
1417 FIXME("return a pointer to the first window class.\n");
1418 break;
1419 default:
1420 WARN("wReqType %04x (unknown)\n", wReqType);
1421 }
1422 stack16->ds = oldDS;
1423 return ret;
1424 }
1425
1426
1427 /***********************************************************************
1428 * LookupMenuHandle (USER.217)
1429 */
1430 HMENU16 WINAPI LookupMenuHandle16( HMENU16 hmenu, INT16 id )
1431 {
1432 FIXME( "%04x %04x: stub\n", hmenu, id );
1433 return hmenu;
1434 }
1435
1436
1437 static LPCSTR parse_menu_resource( LPCSTR res, HMENU hMenu, BOOL oldFormat )
1438 {
1439 WORD flags, id = 0;
1440 LPCSTR str;
1441 BOOL end_flag;
1442
1443 do
1444 {
1445 /* Windows 3.00 and later use a WORD for the flags, whereas 1.x and 2.x use a BYTE. */
1446 if (oldFormat)
1447 {
1448 flags = GET_BYTE(res);
1449 res += sizeof(BYTE);
1450 }
1451 else
1452 {
1453 flags = GET_WORD(res);
1454 res += sizeof(WORD);
1455 }
1456
1457 end_flag = flags & MF_END;
1458 /* Remove MF_END because it has the same value as MF_HILITE */
1459 flags &= ~MF_END;
1460 if (!(flags & MF_POPUP))
1461 {
1462 id = GET_WORD(res);
1463 res += sizeof(WORD);
1464 }
1465 str = res;
1466 res += strlen(str) + 1;
1467 if (flags & MF_POPUP)
1468 {
1469 HMENU hSubMenu = CreatePopupMenu();
1470 if (!hSubMenu) return NULL;
1471 if (!(res = parse_menu_resource( res, hSubMenu, oldFormat ))) return NULL;
1472 AppendMenuA( hMenu, flags, (UINT_PTR)hSubMenu, str );
1473 }
1474 else /* Not a popup */
1475 {
1476 AppendMenuA( hMenu, flags, id, *str ? str : NULL );
1477 }
1478 } while (!end_flag);
1479 return res;
1480 }
1481
1482 /**********************************************************************
1483 * LoadMenuIndirect (USER.220)
1484 */
1485 HMENU16 WINAPI LoadMenuIndirect16( LPCVOID template )
1486 {
1487 BOOL oldFormat;
1488 HMENU hMenu;
1489 WORD version, offset;
1490 LPCSTR p = template;
1491
1492 TRACE("(%p)\n", template );
1493
1494 /* Windows 1.x and 2.x menus have a slightly different menu format from 3.x menus */
1495 oldFormat = (GetExeVersion16() < 0x0300);
1496
1497 /* Windows 3.00 and later menu items are preceded by a MENUITEMTEMPLATEHEADER structure */
1498 if (!oldFormat)
1499 {
1500 version = GET_WORD(p);
1501 p += sizeof(WORD);
1502 if (version)
1503 {
1504 WARN("version must be 0 for Win16 >= 3.00 applications\n" );
1505 return 0;
1506 }
1507 offset = GET_WORD(p);
1508 p += sizeof(WORD) + offset;
1509 }
1510
1511 if (!(hMenu = CreateMenu())) return 0;
1512 if (!parse_menu_resource( p, hMenu, oldFormat ))
1513 {
1514 DestroyMenu( hMenu );
1515 return 0;
1516 }
1517 return HMENU_16(hMenu);
1518 }
1519
1520
1521 /*************************************************************************
1522 * ScrollDC (USER.221)
1523 */
1524 BOOL16 WINAPI ScrollDC16( HDC16 hdc, INT16 dx, INT16 dy, const RECT16 *rect,
1525 const RECT16 *cliprc, HRGN16 hrgnUpdate,
1526 LPRECT16 rcUpdate )
1527 {
1528 RECT rect32, clipRect32, rcUpdate32;
1529 BOOL16 ret;
1530
1531 if (rect)
1532 {
1533 rect32.left = rect->left;
1534 rect32.top = rect->top;
1535 rect32.right = rect->right;
1536 rect32.bottom = rect->bottom;
1537 }
1538 if (cliprc)
1539 {
1540 clipRect32.left = cliprc->left;
1541 clipRect32.top = cliprc->top;
1542 clipRect32.right = cliprc->right;
1543 clipRect32.bottom = cliprc->bottom;
1544 }
1545 ret = ScrollDC( HDC_32(hdc), dx, dy, rect ? &rect32 : NULL,
1546 cliprc ? &clipRect32 : NULL, HRGN_32(hrgnUpdate),
1547 &rcUpdate32 );
1548 if (rcUpdate)
1549 {
1550 rcUpdate->left = rcUpdate32.left;
1551 rcUpdate->top = rcUpdate32.top;
1552 rcUpdate->right = rcUpdate32.right;
1553 rcUpdate->bottom = rcUpdate32.bottom;
1554 }
1555 return ret;
1556 }
1557
1558
1559 /***********************************************************************
1560 * GetSystemDebugState (USER.231)
1561 */
1562 WORD WINAPI GetSystemDebugState16(void)
1563 {
1564 return 0; /* FIXME */
1565 }
1566
1567
1568 /***********************************************************************
1569 * EqualRect (USER.244)
1570 */
1571 BOOL16 WINAPI EqualRect16( const RECT16* rect1, const RECT16* rect2 )
1572 {
1573 return ((rect1->left == rect2->left) && (rect1->right == rect2->right) &&
1574 (rect1->top == rect2->top) && (rect1->bottom == rect2->bottom));
1575 }
1576
1577
1578 /***********************************************************************
1579 * ExitWindowsExec (USER.246)
1580 */
1581 BOOL16 WINAPI ExitWindowsExec16( LPCSTR lpszExe, LPCSTR lpszParams )
1582 {
1583 TRACE("Should run the following in DOS-mode: \"%s %s\"\n",
1584 lpszExe, lpszParams);
1585 return ExitWindowsEx( EWX_LOGOFF, 0xffffffff );
1586 }
1587
1588
1589 /***********************************************************************
1590 * GetCursor (USER.247)
1591 */
1592 HCURSOR16 WINAPI GetCursor16(void)
1593 {
1594 return get_icon_16( GetCursor() );
1595 }
1596
1597
1598 /**********************************************************************
1599 * GetAsyncKeyState (USER.249)
1600 */
1601 INT16 WINAPI GetAsyncKeyState16( INT16 key )
1602 {
1603 return GetAsyncKeyState( key );
1604 }
1605
1606
1607 /**********************************************************************
1608 * GetMenuState (USER.250)
1609 */
1610 UINT16 WINAPI GetMenuState16( HMENU16 hMenu, UINT16 wItemID, UINT16 wFlags )
1611 {
1612 return GetMenuState( HMENU_32(hMenu), wItemID, wFlags );
1613 }
1614
1615
1616 /**************************************************************************
1617 * SendDriverMessage (USER.251)
1618 */
1619 LRESULT WINAPI SendDriverMessage16(HDRVR16 hDriver, UINT16 msg, LPARAM lParam1,
1620 LPARAM lParam2)
1621 {
1622 FIXME("(%04x, %04x, %08lx, %08lx): stub\n", hDriver, msg, lParam1, lParam2);
1623 return 0;
1624 }
1625
1626
1627 /**************************************************************************
1628 * OpenDriver (USER.252)
1629 */
1630 HDRVR16 WINAPI OpenDriver16(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2)
1631 {
1632 FIXME( "(%s, %s, %08lx): stub\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2);
1633 return 0;
1634 }
1635
1636
1637 /**************************************************************************
1638 * CloseDriver (USER.253)
1639 */
1640 LRESULT WINAPI CloseDriver16(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
1641 {
1642 FIXME( "(%04x, %08lx, %08lx): stub\n", hDrvr, lParam1, lParam2);
1643 return FALSE;
1644 }
1645
1646
1647 /**************************************************************************
1648 * GetDriverModuleHandle (USER.254)
1649 */
1650 HMODULE16 WINAPI GetDriverModuleHandle16(HDRVR16 hDrvr)
1651 {
1652 FIXME("(%04x): stub\n", hDrvr);
1653 return 0;
1654 }
1655
1656
1657 /**************************************************************************
1658 * DefDriverProc (USER.255)
1659 */
1660 LRESULT WINAPI DefDriverProc16(DWORD dwDevID, HDRVR16 hDriv, UINT16 wMsg,
1661 LPARAM lParam1, LPARAM lParam2)
1662 {
1663 FIXME( "devID=0x%08x hDrv=0x%04x wMsg=%04x lP1=0x%08lx lP2=0x%08lx: stub\n",
1664 dwDevID, hDriv, wMsg, lParam1, lParam2);
1665 return 0;
1666 }
1667
1668
1669 /**************************************************************************
1670 * GetDriverInfo (USER.256)
1671 */
1672 struct DRIVERINFOSTRUCT16;
1673 BOOL16 WINAPI GetDriverInfo16(HDRVR16 hDrvr, struct DRIVERINFOSTRUCT16 *lpDrvInfo)
1674 {
1675 FIXME( "(%04x, %p): stub\n", hDrvr, lpDrvInfo);
1676 return FALSE;
1677 }
1678
1679
1680 /**************************************************************************
1681 * GetNextDriver (USER.257)
1682 */
1683 HDRVR16 WINAPI GetNextDriver16(HDRVR16 hDrvr, DWORD dwFlags)
1684 {
1685 FIXME( "(%04x, %08x): stub\n", hDrvr, dwFlags);
1686 return 0;
1687 }
1688
1689
1690 /**********************************************************************
1691 * GetMenuItemCount (USER.263)
1692 */
1693 INT16 WINAPI GetMenuItemCount16( HMENU16 hMenu )
1694 {
1695 return GetMenuItemCount( HMENU_32(hMenu) );
1696 }
1697
1698
1699 /**********************************************************************
1700 * GetMenuItemID (USER.264)
1701 */
1702 UINT16 WINAPI GetMenuItemID16( HMENU16 hMenu, INT16 nPos )
1703 {
1704 return GetMenuItemID( HMENU_32(hMenu), nPos );
1705 }
1706
1707
1708 /***********************************************************************
1709 * GlobalAddAtom (USER.268)
1710 */
1711 ATOM WINAPI GlobalAddAtom16(LPCSTR lpString)
1712 {
1713 return GlobalAddAtomA(lpString);
1714 }
1715
1716 /***********************************************************************
1717 * GlobalDeleteAtom (USER.269)
1718 */
1719 ATOM WINAPI GlobalDeleteAtom16(ATOM nAtom)
1720 {
1721 return GlobalDeleteAtom(nAtom);
1722 }
1723
1724 /***********************************************************************
1725 * GlobalFindAtom (USER.270)
1726 */
1727 ATOM WINAPI GlobalFindAtom16(LPCSTR lpString)
1728 {
1729 return GlobalFindAtomA(lpString);
1730 }
1731
1732 /***********************************************************************
1733 * GlobalGetAtomName (USER.271)
1734 */
1735 UINT16 WINAPI GlobalGetAtomName16(ATOM nAtom, LPSTR lpBuffer, INT16 nSize)
1736 {
1737 return GlobalGetAtomNameA(nAtom, lpBuffer, nSize);
1738 }
1739
1740
1741 /***********************************************************************
1742 * ControlPanelInfo (USER.273)
1743 */
1744 void WINAPI ControlPanelInfo16( INT16 nInfoType, WORD wData, LPSTR lpBuffer )
1745 {
1746 FIXME("(%d, %04x, %p): stub.\n", nInfoType, wData, lpBuffer);
1747 }
1748
1749
1750 /***********************************************************************
1751 * OldSetDeskPattern (USER.279)
1752 */
1753 BOOL16 WINAPI SetDeskPattern16(void)
1754 {
1755 return SystemParametersInfoA( SPI_SETDESKPATTERN, -1, NULL, FALSE );
1756 }
1757
1758
1759 /***********************************************************************
1760 * GetSysColorBrush (USER.281)
1761 */
1762 HBRUSH16 WINAPI GetSysColorBrush16( INT16 index )
1763 {
1764 return HBRUSH_16( GetSysColorBrush(index) );
1765 }
1766
1767
1768 /***********************************************************************
1769 * SelectPalette (USER.282)
1770 */
1771 HPALETTE16 WINAPI SelectPalette16( HDC16 hdc, HPALETTE16 hpal, BOOL16 bForceBackground )
1772 {
1773 return HPALETTE_16( SelectPalette( HDC_32(hdc), HPALETTE_32(hpal), bForceBackground ));
1774 }
1775
1776 /***********************************************************************
1777 * RealizePalette (USER.283)
1778 */
1779 UINT16 WINAPI RealizePalette16( HDC16 hdc )
1780 {
1781 return UserRealizePalette( HDC_32(hdc) );
1782 }
1783
1784
1785 /***********************************************************************
1786 * GetFreeSystemResources (USER.284)
1787 */
1788 WORD WINAPI GetFreeSystemResources16( WORD resType )
1789 {
1790 STACK16FRAME* stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved);
1791 HANDLE16 oldDS = stack16->ds;
1792 int userPercent, gdiPercent;
1793
1794 switch(resType)
1795 {
1796 case GFSR_USERRESOURCES:
1797 stack16->ds = USER_HeapSel;
1798 userPercent = (int)LocalCountFree16() * 100 / LocalHeapSize16();
1799 gdiPercent = 100;
1800 stack16->ds = oldDS;
1801 break;
1802
1803 case GFSR_GDIRESOURCES:
1804 stack16->ds = gdi_inst;
1805 gdiPercent = (int)LocalCountFree16() * 100 / LocalHeapSize16();
1806 userPercent = 100;
1807 stack16->ds = oldDS;
1808 break;
1809
1810 case GFSR_SYSTEMRESOURCES:
1811 stack16->ds = USER_HeapSel;
1812 userPercent = (int)LocalCountFree16() * 100 / LocalHeapSize16();
1813 stack16->ds = gdi_inst;
1814 gdiPercent = (int)LocalCountFree16() * 100 / LocalHeapSize16();
1815 stack16->ds = oldDS;
1816 break;
1817
1818 default:
1819 userPercent = gdiPercent = 0;
1820 break;
1821 }
1822 TRACE("<- userPercent %d, gdiPercent %d\n", userPercent, gdiPercent);
1823 return (WORD)min( userPercent, gdiPercent );
1824 }
1825
1826
1827 /***********************************************************************
1828 * SetDeskWallPaper (USER.285)
1829 */
1830 BOOL16 WINAPI SetDeskWallPaper16( LPCSTR filename )
1831 {
1832 return SetDeskWallPaper( filename );
1833 }
1834
1835
1836 /***********************************************************************
1837 * keybd_event (USER.289)
1838 */
1839 void WINAPI keybd_event16( CONTEXT *context )
1840 {
1841 DWORD dwFlags = 0;
1842
1843 if (HIBYTE(context->Eax) & 0x80) dwFlags |= KEYEVENTF_KEYUP;
1844 if (HIBYTE(context->Ebx) & 0x01) dwFlags |= KEYEVENTF_EXTENDEDKEY;
1845
1846 keybd_event( LOBYTE(context->Eax), LOBYTE(context->Ebx),
1847 dwFlags, MAKELONG(LOWORD(context->Esi), LOWORD(context->Edi)) );
1848 }
1849
1850
1851 /***********************************************************************
1852 * mouse_event (USER.299)
1853 */
1854 void WINAPI mouse_event16( CONTEXT *context )
1855 {
1856 mouse_event( LOWORD(context->Eax), LOWORD(context->Ebx), LOWORD(context->Ecx),
1857 LOWORD(context->Edx), MAKELONG(context->Esi, context->Edi) );
1858 }
1859
1860
1861 /***********************************************************************
1862 * GetClipCursor (USER.309)
1863 */
1864 void WINAPI GetClipCursor16( RECT16 *rect )
1865 {
1866 if (rect)
1867 {
1868 RECT rect32;
1869 GetClipCursor( &rect32 );
1870 rect->left = rect32.left;
1871 rect->top = rect32.top;
1872 rect->right = rect32.right;
1873 rect->bottom = rect32.bottom;
1874 }
1875 }
1876
1877
1878 /***********************************************************************
1879 * SignalProc (USER.314)
1880 */
1881 void WINAPI SignalProc16( HANDLE16 hModule, UINT16 code,
1882 UINT16 uExitFn, HINSTANCE16 hInstance, HQUEUE16 hQueue )
1883 {
1884 if (code == USIG16_DLL_UNLOAD)
1885 {
1886 hModule = GetExePtr(hModule);
1887 /* HOOK_FreeModuleHooks( hModule ); */
1888 free_module_classes( hModule );
1889 free_module_icons( hModule );
1890 }
1891 }
1892
1893
1894 /***********************************************************************
1895 * SetEventHook (USER.321)
1896 *
1897 * Used by Turbo Debugger for Windows
1898 */
1899 FARPROC16 WINAPI SetEventHook16(FARPROC16 lpfnEventHook)
1900 {
1901 FIXME("(lpfnEventHook=%p): stub\n", lpfnEventHook);
1902 return 0;
1903 }
1904
1905
1906 /**********************************************************************
1907 * EnableHardwareInput (USER.331)
1908 */
1909 BOOL16 WINAPI EnableHardwareInput16(BOOL16 bEnable)
1910 {
1911 FIXME("(%d) - stub\n", bEnable);
1912 return TRUE;
1913 }
1914
1915
1916 /**********************************************************************
1917 * LoadCursorIconHandler (USER.336)
1918 *
1919 * Supposed to load resources of Windows 2.x applications.
1920 */
1921 HGLOBAL16 WINAPI LoadCursorIconHandler16( HGLOBAL16 hResource, HMODULE16 hModule, HRSRC16 hRsrc )
1922 {
1923 FIXME("(%04x,%04x,%04x): old 2.x resources are not supported!\n", hResource, hModule, hRsrc);
1924 return 0;
1925 }
1926
1927
1928 /***********************************************************************
1929 * GetMouseEventProc (USER.337)
1930 */
1931 FARPROC16 WINAPI GetMouseEventProc16(void)
1932 {
1933 HMODULE16 hmodule = GetModuleHandle16("USER");
1934 return GetProcAddress16( hmodule, "mouse_event" );
1935 }
1936
1937
1938 /***********************************************************************
1939 * IsUserIdle (USER.333)
1940 */
1941 BOOL16 WINAPI IsUserIdle16(void)
1942 {
1943 if ( GetAsyncKeyState( VK_LBUTTON ) & 0x8000 )
1944 return FALSE;
1945 if ( GetAsyncKeyState( VK_RBUTTON ) & 0x8000 )
1946 return FALSE;
1947 if ( GetAsyncKeyState( VK_MBUTTON ) & 0x8000 )
1948 return FALSE;
1949 /* Should check for screen saver activation here ... */
1950 return TRUE;
1951 }
1952
1953
1954 /**********************************************************************
1955 * LoadDIBIconHandler (USER.357)
1956 *
1957 * RT_ICON resource loader, installed by USER_SignalProc when module
1958 * is initialized.
1959 */
1960 HGLOBAL16 WINAPI LoadDIBIconHandler16( HGLOBAL16 hMemObj, HMODULE16 hModule, HRSRC16 hRsrc )
1961 {
1962 /* If hResource is zero we must allocate a new memory block, if it's
1963 * non-zero but GlobalLock() returns NULL then it was discarded and
1964 * we have to recommit some memory, otherwise we just need to check
1965 * the block size. See LoadProc() in 16-bit SDK for more.
1966 */
1967 FIXME( "%x %x %x: stub, not supported anymore\n", hMemObj, hModule, hRsrc );
1968 return 0;
1969 }
1970
1971 /**********************************************************************
1972 * LoadDIBCursorHandler (USER.356)
1973 *
1974 * RT_CURSOR resource loader. Same as above.
1975 */
1976 HGLOBAL16 WINAPI LoadDIBCursorHandler16( HGLOBAL16 hMemObj, HMODULE16 hModule, HRSRC16 hRsrc )
1977 {
1978 FIXME( "%x %x %x: stub, not supported anymore\n", hMemObj, hModule, hRsrc );
1979 return 0;
1980 }
1981
1982
1983 /**********************************************************************
1984 * IsMenu (USER.358)
1985 */
1986 BOOL16 WINAPI IsMenu16( HMENU16 hmenu )
1987 {
1988 return IsMenu( HMENU_32(hmenu) );
1989 }
1990
1991
1992 /***********************************************************************
1993 * DCHook (USER.362)
1994 */
1995 BOOL16 WINAPI DCHook16( HDC16 hdc, WORD code, DWORD data, LPARAM lParam )
1996 {
1997 FIXME( "hDC = %x, %i: stub\n", hdc, code );
1998 return FALSE;
1999 }
2000
2001
2002 /**********************************************************************
2003 * LookupIconIdFromDirectoryEx (USER.364)
2004 *
2005 * FIXME: exact parameter sizes
2006 */
2007 INT16 WINAPI LookupIconIdFromDirectoryEx16( LPBYTE dir, BOOL16 bIcon,
2008 INT16 width, INT16 height, UINT16 cFlag )
2009 {
2010 return LookupIconIdFromDirectoryEx( dir, bIcon, width, height, cFlag );
2011 }
2012
2013
2014 /***********************************************************************
2015 * CopyIcon (USER.368)
2016 */
2017 HICON16 WINAPI CopyIcon16( HINSTANCE16 hInstance, HICON16 hIcon )
2018 {
2019 CURSORICONINFO *info = get_icon_ptr( hIcon );
2020 void *and_bits = info + 1;
2021 void *xor_bits = (BYTE *)and_bits + info->nHeight * get_bitmap_width_bytes( info->nWidth, 1 );
2022 HGLOBAL16 ret = CreateCursorIconIndirect16( hInstance, info, and_bits, xor_bits );
2023 release_icon_ptr( hIcon, info );
2024 return ret;
2025 }
2026
2027
2028 /***********************************************************************
2029 * CopyCursor (USER.369)
2030 */
2031 HCURSOR16 WINAPI CopyCursor16( HINSTANCE16 hInstance, HCURSOR16 hCursor )
2032 {
2033 CURSORICONINFO *info = get_icon_ptr( hCursor );
2034 void *and_bits = info + 1;
2035 void *xor_bits = (BYTE *)and_bits + info->nHeight * get_bitmap_width_bytes( info->nWidth, 1 );
2036 HGLOBAL16 ret = CreateCursorIconIndirect16( hInstance, info, and_bits, xor_bits );
2037 release_icon_ptr( hCursor, info );
2038 return ret;
2039 }
2040
2041
2042 /***********************************************************************
2043 * SubtractRect (USER.373)
2044 */
2045 BOOL16 WINAPI SubtractRect16( LPRECT16 dest, const RECT16 *src1,
2046 const RECT16 *src2 )
2047 {
2048 RECT16 tmp;
2049
2050 if (IsRectEmpty16( src1 ))
2051 {
2052 SetRectEmpty16( dest );
2053 return FALSE;
2054 }
2055 *dest = *src1;
2056 if (IntersectRect16( &tmp, src1, src2 ))
2057 {
2058 if (EqualRect16( &tmp, dest ))
2059 {
2060 SetRectEmpty16( dest );
2061 return FALSE;
2062 }
2063 if ((tmp.top == dest->top) && (tmp.bottom == dest->bottom))
2064 {
2065 if (tmp.left == dest->left) dest->left = tmp.right;
2066 else if (tmp.right == dest->right) dest->right = tmp.left;
2067 }
2068 else if ((tmp.left == dest->left) && (tmp.right == dest->right))
2069 {
2070 if (tmp.top == dest->top) dest->top = tmp.bottom;
2071 else if (tmp.bottom == dest->bottom) dest->bottom = tmp.top;
2072 }
2073 }
2074 return TRUE;
2075 }
2076
2077
2078 /**********************************************************************
2079 * DllEntryPoint (USER.374)
2080 */
2081 BOOL WINAPI DllEntryPoint( DWORD reason, HINSTANCE16 inst, WORD ds,
2082 WORD heap, DWORD reserved1, WORD reserved2 )
2083 {
2084 if (reason != DLL_PROCESS_ATTACH) return TRUE;
2085 if (USER_HeapSel) return TRUE; /* already called */
2086
2087 USER_HeapSel = ds;
2088 register_wow_handlers();
2089 gdi_inst = LoadLibrary16( "gdi.exe" );
2090 LoadLibrary16( "display.drv" );
2091 LoadLibrary16( "keyboard.drv" );
2092 LoadLibrary16( "mouse.drv" );
2093 LoadLibrary16( "user.exe" ); /* make sure it never gets unloaded */
2094 return TRUE;
2095 }
2096
2097
2098 /**********************************************************************
2099 * SetMenuContextHelpId (USER.384)
2100 */
2101 BOOL16 WINAPI SetMenuContextHelpId16( HMENU16 hMenu, DWORD dwContextHelpID)
2102 {
2103 return SetMenuContextHelpId( HMENU_32(hMenu), dwContextHelpID );
2104 }
2105
2106
2107 /**********************************************************************
2108 * GetMenuContextHelpId (USER.385)
2109 */
2110 DWORD WINAPI GetMenuContextHelpId16( HMENU16 hMenu )
2111 {
2112 return GetMenuContextHelpId( HMENU_32(hMenu) );
2113 }
2114
2115
2116 /***********************************************************************
2117 * LoadImage (USER.389)
2118 */
2119 HANDLE16 WINAPI LoadImage16(HINSTANCE16 hinst, LPCSTR name, UINT16 type, INT16 cx, INT16 cy, UINT16 flags)
2120 {
2121 HGLOBAL16 handle;
2122 HRSRC16 hRsrc, hGroupRsrc;
2123 DWORD size;
2124
2125 if (!hinst || (flags & LR_LOADFROMFILE))
2126 {
2127 if (type == IMAGE_BITMAP)
2128 return HBITMAP_16( LoadImageA( 0, name, type, cx, cy, flags ));
2129 else
2130 return get_icon_16( LoadImageA( 0, name, type, cx, cy, flags ));
2131 }
2132
2133 hinst = GetExePtr( hinst );
2134
2135 if (flags & LR_DEFAULTSIZE)
2136 {
2137 if (type == IMAGE_ICON)
2138 {
2139 if (!cx) cx = GetSystemMetrics(SM_CXICON);
2140 if (!cy) cy = GetSystemMetrics(SM_CYICON);
2141 }
2142 else if (type == IMAGE_CURSOR)
2143 {
2144 if (!cx) cx = GetSystemMetrics(SM_CXCURSOR);
2145 if (!cy) cy = GetSystemMetrics(SM_CYCURSOR);
2146 }
2147 }
2148
2149 switch (type)
2150 {
2151 case IMAGE_BITMAP:
2152 {
2153 HBITMAP ret = 0;
2154 char *ptr;
2155 static const WCHAR prefixW[] = {'b','m','p',0};
2156 BITMAPFILEHEADER header;
2157 WCHAR path[MAX_PATH], filename[MAX_PATH];
2158 HANDLE file;
2159
2160 filename[0] = 0;
2161 if (!(hRsrc = FindResource16( hinst, name, (LPCSTR)RT_BITMAP ))) return 0;
2162 if (!(handle = LoadResource16( hinst, hRsrc ))) return 0;
2163 if (!(ptr = LockResource16( handle ))) goto done;
2164 size = SizeofResource16( hinst, hRsrc );
2165
2166 header.bfType = 0x4d42; /* 'BM' */
2167 header.bfReserved1 = 0;
2168 header.bfReserved2 = 0;
2169 header.bfSize = sizeof(header) + size;
2170 header.bfOffBits = 0; /* not used by the 32-bit loading code */
2171
2172 if (!GetTempPathW( MAX_PATH, path )) goto done;
2173 if (!GetTempFileNameW( path, prefixW, 0, filename )) goto done;
2174
2175 file = CreateFileW( filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0 );
2176 if (file != INVALID_HANDLE_VALUE)
2177 {
2178 DWORD written;
2179 BOOL ok;
2180 ok = WriteFile( file, &header, sizeof(header), &written, NULL ) && (written == sizeof(header));
2181 if (ok) ok = WriteFile( file, ptr, size, &written, NULL ) && (written == size);
2182 CloseHandle( file );
2183 if (ok) ret = LoadImageW( 0, filename, IMAGE_BITMAP, cx, cy, flags | LR_LOADFROMFILE );
2184 }
2185 done:
2186 if (filename[0]) DeleteFileW( filename );
2187 FreeResource16( handle );
2188 return HBITMAP_16( ret );
2189 }
2190
2191 case IMAGE_ICON:
2192 case IMAGE_CURSOR:
2193 {
2194 HICON16 hIcon = 0;
2195 BYTE *dir, *bits;
2196 INT id = 0;
2197
2198 if (!(hRsrc = FindResource16( hinst, name,
2199 (LPCSTR)(type == IMAGE_ICON ? RT_GROUP_ICON : RT_GROUP_CURSOR ))))
2200 return 0;
2201 hGroupRsrc = hRsrc;
2202
2203 if (!(handle = LoadResource16( hinst, hRsrc ))) return 0;
2204 if ((dir = LockResource16( handle ))) id = LookupIconIdFromDirectory( dir, type == IMAGE_ICON );
2205 FreeResource16( handle );
2206 if (!id) return 0;
2207
2208 if (!(hRsrc = FindResource16( hinst, MAKEINTRESOURCEA(id),
2209 (LPCSTR)(type == IMAGE_ICON ? RT_ICON : RT_CURSOR) ))) return 0;
2210
2211 if ((flags & LR_SHARED) && (hIcon = find_shared_icon( hinst, hRsrc ) ) != 0) return hIcon;
2212
2213 if (!(handle = LoadResource16( hinst, hRsrc ))) return 0;
2214 bits = LockResource16( handle );
2215 size = SizeofResource16( hinst, hRsrc );
2216 hIcon = CreateIconFromResourceEx16( bits, size, type == IMAGE_ICON, 0x00030000, cx, cy, flags );
2217 FreeResource16( handle );
2218
2219 if (hIcon && (flags & LR_SHARED)) add_shared_icon( hinst, hRsrc, hGroupRsrc, hIcon );
2220 return hIcon;
2221 }
2222 default:
2223 return 0;
2224 }
2225 }
2226
2227 /******************************************************************************
2228 * CopyImage (USER.390) Creates new image and copies attributes to it
2229 *
2230 */
2231 HICON16 WINAPI CopyImage16(HANDLE16 hnd, UINT16 type, INT16 desiredx,
2232 INT16 desiredy, UINT16 flags)
2233 {
2234 if (flags & LR_COPYFROMRESOURCE) FIXME( "LR_COPYFROMRESOURCE not supported\n" );
2235
2236 switch (type)
2237 {
2238 case IMAGE_BITMAP:
2239 return HBITMAP_16( CopyImage( HBITMAP_32(hnd), type, desiredx, desiredy, flags ));
2240 case IMAGE_ICON:
2241 case IMAGE_CURSOR:
2242 return CopyIcon16( FarGetOwner16(hnd), hnd );
2243 default:
2244 return 0;
2245 }
2246 }
2247
2248 /**********************************************************************
2249 * DrawIconEx (USER.394)
2250 */
2251 BOOL16 WINAPI DrawIconEx16(HDC16 hdc, INT16 xLeft, INT16 yTop, HICON16 hIcon,
2252 INT16 cxWidth, INT16 cyWidth, UINT16 istep,
2253 HBRUSH16 hbr, UINT16 flags)
2254 {
2255 return DrawIconEx(HDC_32(hdc), xLeft, yTop, get_icon_32(hIcon), cxWidth, cyWidth,
2256 istep, HBRUSH_32(hbr), flags);
2257 }
2258
2259 /**********************************************************************
2260 * GetIconInfo (USER.395)
2261 */
2262 BOOL16 WINAPI GetIconInfo16(HICON16 hIcon, LPICONINFO16 iconinfo)
2263 {
2264 CURSORICONINFO *info = get_icon_ptr( hIcon );
2265 INT height;
2266
2267 if (!info) return FALSE;
2268
2269 if ((info->ptHotSpot.x == ICON_HOTSPOT) && (info->ptHotSpot.y == ICON_HOTSPOT))
2270 {
2271 iconinfo->fIcon = TRUE;
2272 iconinfo->xHotspot = info->nWidth / 2;
2273 iconinfo->yHotspot = info->nHeight / 2;
2274 }
2275 else
2276 {
2277 iconinfo->fIcon = FALSE;
2278 iconinfo->xHotspot = info->ptHotSpot.x;
2279 iconinfo->yHotspot = info->ptHotSpot.y;
2280 }
2281
2282 height = info->nHeight;
2283
2284 if (info->bBitsPerPixel > 1)
2285 {
2286 iconinfo->hbmColor = HBITMAP_16( CreateBitmap( info->nWidth, info->nHeight,
2287 info->bPlanes, info->bBitsPerPixel,
2288 (char *)(info + 1)
2289 + info->nHeight *
2290 get_bitmap_width_bytes(info->nWidth,1) ));
2291 }
2292 else
2293 {
2294 iconinfo->hbmColor = 0;
2295 height *= 2;
2296 }
2297
2298 iconinfo->hbmMask = HBITMAP_16( CreateBitmap( info->nWidth, height, 1, 1, info + 1 ));
2299 release_icon_ptr( hIcon, info );
2300 return TRUE;
2301 }
2302
2303
2304 /***********************************************************************
2305 * FinalUserInit (USER.400)
2306 */
2307 void WINAPI FinalUserInit16( void )
2308 {
2309 /* FIXME: Should chain to FinalGdiInit */
2310 }
2311
2312
2313 /***********************************************************************
2314 * CreateCursor (USER.406)
2315 */
2316 HCURSOR16 WINAPI CreateCursor16(HINSTANCE16 hInstance,
2317 INT16 xHotSpot, INT16 yHotSpot,
2318 INT16 nWidth, INT16 nHeight,
2319 LPCVOID lpANDbits, LPCVOID lpXORbits)
2320 {
2321 CURSORICONINFO info;
2322
2323 info.ptHotSpot.x = xHotSpot;
2324 info.ptHotSpot.y = yHotSpot;
2325 info.nWidth = nWidth;
2326 info.nHeight = nHeight;
2327 info.nWidthBytes = 0;
2328 info.bPlanes = 1;
2329 info.bBitsPerPixel = 1;
2330
2331 return CreateCursorIconIndirect16(hInstance, &info, lpANDbits, lpXORbits);
2332 }
2333
2334
2335 /***********************************************************************
2336 * CreateIcon (USER.407)
2337 */
2338 HICON16 WINAPI CreateIcon16( HINSTANCE16 hInstance, INT16 nWidth,
2339 INT16 nHeight, BYTE bPlanes, BYTE bBitsPixel,
2340 LPCVOID lpANDbits, LPCVOID lpXORbits )
2341 {
2342 CURSORICONINFO info;
2343
2344 info.ptHotSpot.x = ICON_HOTSPOT;
2345 info.ptHotSpot.y = ICON_HOTSPOT;
2346 info.nWidth = nWidth;
2347 info.nHeight = nHeight;
2348 info.nWidthBytes = 0;
2349 info.bPlanes = bPlanes;
2350 info.bBitsPerPixel = bBitsPixel;
2351
2352 return CreateCursorIconIndirect16( hInstance, &info, lpANDbits, lpXORbits );
2353 }
2354
2355
2356 /***********************************************************************
2357 * CreateCursorIconIndirect (USER.408)
2358 */
2359 HGLOBAL16 WINAPI CreateCursorIconIndirect16( HINSTANCE16 hInstance,
2360 CURSORICONINFO *info,
2361 LPCVOID lpANDbits,
2362 LPCVOID lpXORbits )
2363 {
2364 HICON16 handle;
2365 CURSORICONINFO *ptr;
2366 int sizeAnd, sizeXor;
2367
2368 hInstance = GetExePtr( hInstance ); /* Make it a module handle */
2369 if (!lpXORbits || !lpANDbits || info->bPlanes != 1) return 0;
2370 info->nWidthBytes = get_bitmap_width_bytes(info->nWidth,info->bBitsPerPixel);
2371 sizeXor = info->nHeight * info->nWidthBytes;
2372 sizeAnd = info->nHeight * get_bitmap_width_bytes( info->nWidth, 1 );
2373 if (!(handle = alloc_icon_handle( sizeof(CURSORICONINFO) + sizeXor + sizeAnd )))
2374 return 0;
2375 FarSetOwner16( handle, hInstance );
2376 ptr = get_icon_ptr( handle );
2377 memcpy( ptr, info, sizeof(*info) );
2378 memcpy( ptr + 1, lpANDbits, sizeAnd );
2379 memcpy( (char *)(ptr + 1) + sizeAnd, lpXORbits, sizeXor );
2380 release_icon_ptr( handle, ptr );
2381 return handle;
2382 }
2383
2384
2385 /***********************************************************************
2386 * InitThreadInput (USER.409)
2387 */
2388 HQUEUE16 WINAPI InitThreadInput16( WORD unknown, WORD flags )
2389 {
2390 /* nothing to do here */
2391 return 0xbeef;
2392 }
2393
2394
2395 /*******************************************************************
2396 * InsertMenu (USER.410)
2397 */
2398 BOOL16 WINAPI InsertMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
2399 UINT16 id, SEGPTR data )
2400 {
2401 UINT pos32 = (UINT)pos;
2402 if ((pos == (UINT16)-1) && (flags & MF_BYPOSITION)) pos32 = (UINT)-1;
2403 if (IS_MENU_STRING_ITEM(flags) && data)
2404 return InsertMenuA( HMENU_32(hMenu), pos32, flags, id, MapSL(data) );
2405
2406 /* If "data" is an HBITMAP, the high WORD will contain the application's DGROUP selector if the
2407 * application cast (LPSTR)hBitmap rather than (LPSTR)(LONG)hBitmap. */
2408 if (flags & MF_BITMAP) data = (SEGPTR)HBITMAP_32(LOWORD(data));
2409 return InsertMenuA( HMENU_32(hMenu), pos32, flags, id, (LPSTR)data );
2410 }
2411
2412
2413 /*******************************************************************
2414 * AppendMenu (USER.411)
2415 */
2416 BOOL16 WINAPI AppendMenu16(HMENU16 hMenu, UINT16 flags, UINT16 id, SEGPTR data)
2417 {
2418 return InsertMenu16( hMenu, -1, flags | MF_BYPOSITION, id, data );
2419 }
2420
2421
2422 /**********************************************************************
2423 * RemoveMenu (USER.412)
2424 */
2425 BOOL16 WINAPI RemoveMenu16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags )
2426 {
2427 return RemoveMenu( HMENU_32(hMenu), nPos, wFlags );
2428 }
2429
2430
2431 /**********************************************************************
2432 * DeleteMenu (USER.413)
2433 */
2434 BOOL16 WINAPI DeleteMenu16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags )
2435 {
2436 return DeleteMenu( HMENU_32(hMenu), nPos, wFlags );
2437 }
2438
2439
2440 /*******************************************************************
2441 * ModifyMenu (USER.414)
2442 */
2443 BOOL16 WINAPI ModifyMenu16( HMENU16 hMenu, UINT16 pos, UINT16 flags,
2444 UINT16 id, SEGPTR data )
2445 {
2446 if (IS_MENU_STRING_ITEM(flags))
2447 return ModifyMenuA( HMENU_32(hMenu), pos, flags, id, MapSL(data) );
2448 return ModifyMenuA( HMENU_32(hMenu), pos, flags, id, (LPSTR)data );
2449 }
2450
2451
2452 /**********************************************************************
2453 * CreatePopupMenu (USER.415)
2454 */
2455 HMENU16 WINAPI CreatePopupMenu16(void)
2456 {
2457 return HMENU_16( CreatePopupMenu() );
2458 }
2459
2460
2461 /**********************************************************************
2462 * SetMenuItemBitmaps (USER.418)
2463 */
2464 BOOL16 WINAPI SetMenuItemBitmaps16( HMENU16 hMenu, UINT16 nPos, UINT16 wFlags,
2465 HBITMAP16 hNewUnCheck, HBITMAP16 hNewCheck)
2466 {
2467 return SetMenuItemBitmaps( HMENU_32(hMenu), nPos, wFlags,
2468 HBITMAP_32(hNewUnCheck), HBITMAP_32(hNewCheck) );
2469 }
2470
2471
2472 /***********************************************************************
2473 * wvsprintf (USER.421)
2474 */
2475 INT16 WINAPI wvsprintf16( LPSTR buffer, LPCSTR spec, VA_LIST16 args )
2476 {
2477 WPRINTF_FORMAT format;
2478 LPSTR p = buffer;
2479 UINT i, len, sign;
2480 CHAR number[20];
2481 CHAR char_view = 0;
2482 LPCSTR lpcstr_view = NULL;
2483 INT int_view;
2484 SEGPTR seg_str;
2485
2486 while (*spec)
2487 {
2488 if (*spec != '%') { *p++ = *spec++; continue; }
2489 spec++;
2490 if (*spec == '%') { *p++ = *spec++; continue; }
2491 spec += parse_format( spec, &format );
2492 switch(format.type)
2493 {
2494 case WPR_CHAR:
2495 char_view = VA_ARG16( args, CHAR );
2496 len = format.precision = 1;
2497 break;
2498 case WPR_STRING:
2499 seg_str = VA_ARG16( args, SEGPTR );
2500 if (IsBadReadPtr16( seg_str, 1 )) lpcstr_view = "";
2501 else lpcstr_view = MapSL( seg_str );
2502 if (!lpcstr_view) lpcstr_view = "(null)";
2503 for (len = 0; !format.precision || (len < format.precision); len++)
2504 if (!lpcstr_view[len]) break;
2505 format.precision = len;
2506 break;
2507 case WPR_SIGNED:
2508 if (format.flags & WPRINTF_LONG) int_view = VA_ARG16( args, INT );
2509 else int_view = VA_ARG16( args, INT16 );
2510 len = sprintf( number, "%d", int_view );
2511 break;
2512 case WPR_UNSIGNED:
2513 if (format.flags & WPRINTF_LONG) int_view = VA_ARG16( args, UINT );
2514 else int_view = VA_ARG16( args, UINT16 );
2515 len = sprintf( number, "%u", int_view );
2516 break;
2517 case WPR_HEXA:
2518 if (format.flags & WPRINTF_LONG) int_view = VA_ARG16( args, UINT );
2519 else int_view = VA_ARG16( args, UINT16 );
2520 len = sprintf( number, (format.flags & WPRINTF_UPPER_HEX) ? "%X" : "%x", int_view);
2521 break;
2522 case WPR_UNKNOWN:
2523 continue;
2524 }
2525 if (format.precision < len) format.precision = len;
2526 if (format.flags & WPRINTF_LEFTALIGN) format.flags &= ~WPRINTF_ZEROPAD;
2527 if ((format.flags & WPRINTF_ZEROPAD) && (format.width > format.precision))
2528 format.precision = format.width;
2529 if (format.flags & WPRINTF_PREFIX_HEX) len += 2;
2530
2531 sign = 0;
2532 if (!(format.flags & WPRINTF_LEFTALIGN))
2533 for (i = format.precision; i < format.width; i++) *p++ = ' ';
2534 switch(format.type)
2535 {
2536 case WPR_CHAR:
2537 *p = char_view;
2538 /* wsprintf16 ignores null characters */
2539 if (*p != '\0') p++;
2540 else if (format.width > 1) *p++ = ' ';
2541 break;
2542 case WPR_STRING:
2543 if (len) memcpy( p, lpcstr_view, len );
2544 p += len;
2545 break;
2546 case WPR_HEXA:
2547 if (format.flags & WPRINTF_PREFIX_HEX)
2548 {
2549 *p++ = '0';
2550 *p++ = (format.flags & WPRINTF_UPPER_HEX) ? 'X' : 'x';
2551 len -= 2;
2552 }
2553 /* fall through */
2554 case WPR_SIGNED:
2555 /* Transfer the sign now, just in case it will be zero-padded*/
2556 if (number[0] == '-')
2557 {
2558 *p++ = '-';
2559 sign = 1;
2560 }
2561 /* fall through */
2562 case WPR_UNSIGNED:
2563 for (i = len; i < format.precision; i++) *p++ = '0';
2564 if (len > sign) memcpy( p, number + sign, len - sign );
2565 p += len-sign;
2566 break;
2567 case WPR_UNKNOWN:
2568 continue;
2569 }
2570 if (format.flags & WPRINTF_LEFTALIGN)
2571 for (i = format.precision; i < format.width; i++) *p++ = ' ';
2572 }
2573 *p = 0;
2574 return p - buffer;
2575 }
2576
2577
2578 /***********************************************************************
2579 * _wsprintf (USER.420)
2580 */
2581 INT16 WINAPIV wsprintf16( LPSTR buffer, LPCSTR spec, VA_LIST16 valist )
2582 {
2583 return wvsprintf16( buffer, spec, valist );
2584 }
2585
2586
2587 /***********************************************************************
2588 * lstrcmp (USER.430)
2589 */
2590 INT16 WINAPI lstrcmp16( LPCSTR str1, LPCSTR str2 )
2591 {
2592 int ret;
2593 /* Looks too complicated, but in optimized strcpy we might get
2594 * a 32bit wide difference and would truncate it to 16 bit, so
2595 * erroneously returning equality. */
2596 ret = strcmp( str1, str2 );
2597 if (ret < 0) return -1;
2598 if (ret > 0) return 1;
2599 return 0;
2600 }
2601
2602
2603 /***********************************************************************
2604 * AnsiUpper (USER.431)
2605 */
2606 SEGPTR WINAPI AnsiUpper16( SEGPTR strOrChar )
2607 {
2608 /* uppercase only one char if strOrChar < 0x10000 */
2609 if (HIWORD(strOrChar))
2610 {
2611 CharUpperA( MapSL(strOrChar) );
2612 return strOrChar;
2613 }
2614 else return (SEGPTR)CharUpperA( (LPSTR)strOrChar );
2615 }
2616
2617
2618 /***********************************************************************
2619 * AnsiLower (USER.432)
2620 */
2621 SEGPTR WINAPI AnsiLower16( SEGPTR strOrChar )
2622 {
2623 /* lowercase only one char if strOrChar < 0x10000 */
2624 if (HIWORD(strOrChar))
2625 {
2626 CharLowerA( MapSL(strOrChar) );
2627 return strOrChar;
2628 }
2629 else return (SEGPTR)CharLowerA( (LPSTR)strOrChar );
2630 }
2631
2632
2633 /***********************************************************************
2634 * AnsiUpperBuff (USER.437)
2635 */
2636 UINT16 WINAPI AnsiUpperBuff16( LPSTR str, UINT16 len )
2637 {
2638 CharUpperBuffA( str, len ? len : 65536 );
2639 return len;
2640 }
2641
2642
2643 /***********************************************************************
2644 * AnsiLowerBuff (USER.438)
2645 */
2646 UINT16 WINAPI AnsiLowerBuff16( LPSTR str, UINT16 len )
2647 {
2648 CharLowerBuffA( str, len ? len : 65536 );
2649 return len;
2650 }
2651
2652
2653 /*******************************************************************
2654 * InsertMenuItem (USER.441)
2655 *
2656 * FIXME: untested
2657 */
2658 BOOL16 WINAPI InsertMenuItem16( HMENU16 hmenu, UINT16 pos, BOOL16 byposition,
2659 const MENUITEMINFO16 *mii )
2660 {
2661 MENUITEMINFOA miia;
2662
2663 miia.cbSize = sizeof(miia);
2664 miia.fMask = mii->fMask;
2665 miia.dwTypeData = (LPSTR)mii->dwTypeData;
2666 miia.fType = mii->fType;
2667 miia.fState = mii->fState;
2668 miia.wID = mii->wID;
2669 miia.hSubMenu = HMENU_32(mii->hSubMenu);
2670 miia.hbmpChecked = HBITMAP_32(mii->hbmpChecked);
2671 miia.hbmpUnchecked = HBITMAP_32(mii->hbmpUnchecked);
2672 miia.dwItemData = mii->dwItemData;
2673 miia.cch = mii->cch;
2674 if (IS_MENU_STRING_ITEM(miia.fType))
2675 miia.dwTypeData = MapSL(mii->dwTypeData);
2676 return InsertMenuItemA( HMENU_32(hmenu), pos, byposition, &miia );
2677 }
2678
2679
2680 /**********************************************************************
2681 * DrawState (USER.449)
2682 */
2683 BOOL16 WINAPI DrawState16( HDC16 hdc, HBRUSH16 hbr, DRAWSTATEPROC16 func, LPARAM ldata,
2684 WPARAM16 wdata, INT16 x, INT16 y, INT16 cx, INT16 cy, UINT16 flags )
2685 {
2686 struct draw_state_info info;
2687 UINT opcode = flags & 0xf;
2688
2689 if (opcode == DST_TEXT || opcode == DST_PREFIXTEXT)
2690 {
2691 /* make sure DrawStateA doesn't try to use ldata as a pointer */
2692 if (!wdata) wdata = strlen( MapSL(ldata) );
2693 if (!cx || !cy)
2694 {
2695 SIZE s;
2696 if (!GetTextExtentPoint32A( HDC_32(hdc), MapSL(ldata), wdata, &s )) return FALSE;
2697 if (!cx) cx = s.cx;
2698 if (!cy) cy = s.cy;
2699 }
2700 }
2701 info.proc = func;
2702 info.param = ldata;
2703 return DrawStateA( HDC_32(hdc), HBRUSH_32(hbr), draw_state_callback,
2704 (LPARAM)&info, wdata, x, y, cx, cy, flags );
2705 }
2706
2707
2708 /**********************************************************************
2709 * CreateIconFromResourceEx (USER.450)
2710 *
2711 * FIXME: not sure about exact parameter types
2712 */
2713 HICON16 WINAPI CreateIconFromResourceEx16(LPBYTE bits, UINT16 cbSize,
2714 BOOL16 bIcon, DWORD dwVersion,
2715 INT16 width, INT16 height,
2716 UINT16 cFlag)
2717 {
2718 return get_icon_16( CreateIconFromResourceEx( bits, cbSize, bIcon, dwVersion, width, height, cFlag ));
2719 }
2720
2721
2722 /***********************************************************************
2723 * AdjustWindowRectEx (USER.454)
2724 */
2725 BOOL16 WINAPI AdjustWindowRectEx16( LPRECT16 rect, DWORD style, BOOL16 menu, DWORD exStyle )
2726 {
2727 RECT rect32;
2728 BOOL ret;
2729
2730 rect32.left = rect->left;
2731 rect32.top = rect->top;
2732 rect32.right = rect->right;
2733 rect32.bottom = rect->bottom;
2734 ret = AdjustWindowRectEx( &rect32, style, menu, exStyle );
2735 rect->left = rect32.left;
2736 rect->top = rect32.top;
2737 rect->right = rect32.right;
2738 rect->bottom = rect32.bottom;
2739 return ret;
2740 }
2741
2742
2743 /**********************************************************************
2744 * GetIconID (USER.455)
2745 */
2746 WORD WINAPI GetIconID16( HGLOBAL16 hResource, DWORD resType )
2747 {
2748 BYTE *dir = GlobalLock16(hResource);
2749
2750 switch (resType)
2751 {
2752 case RT_CURSOR:
2753 return LookupIconIdFromDirectoryEx16( dir, FALSE, GetSystemMetrics(SM_CXCURSOR),
2754 GetSystemMetrics(SM_CYCURSOR), LR_MONOCHROME );
2755 case RT_ICON:
2756 return LookupIconIdFromDirectoryEx16( dir, TRUE, GetSystemMetrics(SM_CXICON),
2757 GetSystemMetrics(SM_CYICON), 0 );
2758 }
2759 return 0;
2760 }
2761
2762
2763 /**********************************************************************
2764 * LoadIconHandler (USER.456)
2765 */
2766 HICON16 WINAPI LoadIconHandler16( HGLOBAL16 hResource, BOOL16 bNew )
2767 {
2768 return CreateIconFromResourceEx16( LockResource16( hResource ), 0xffff, TRUE,
2769 bNew ? 0x00030000 : 0x00020000, 0, 0, LR_DEFAULTCOLOR );
2770 }
2771
2772
2773 /***********************************************************************
2774 * DestroyIcon (USER.457)
2775 */
2776 BOOL16 WINAPI DestroyIcon16(HICON16 hIcon)
2777 {
2778 int count;
2779
2780 TRACE("%04x\n", hIcon );
2781
2782 count = release_shared_icon( hIcon );
2783 if (count != -1) return !count;
2784 /* assume non-shared */
2785 free_icon_handle( hIcon );
2786 return TRUE;
2787 }
2788
2789 /***********************************************************************
2790 * DestroyCursor (USER.458)
2791 */
2792 BOOL16 WINAPI DestroyCursor16(HCURSOR16 hCursor)
2793 {
2794 return DestroyIcon16( hCursor );
2795 }
2796
2797
2798 /***********************************************************************
2799 * DumpIcon (USER.459)
2800 */
2801 DWORD WINAPI DumpIcon16( SEGPTR pInfo, WORD *lpLen,
2802 SEGPTR *lpXorBits, SEGPTR *lpAndBits )
2803 {
2804 CURSORICONINFO *info = MapSL( pInfo );
2805 int sizeAnd, sizeXor;
2806
2807 if (!info) return 0;
2808 sizeXor = info->nHeight * info->nWidthBytes;
2809 sizeAnd = info->nHeight * get_bitmap_width_bytes( info->nWidth, 1 );
2810 if (lpAndBits) *lpAndBits = pInfo + sizeof(CURSORICONINFO);
2811 if (lpXorBits) *lpXorBits = pInfo + sizeof(CURSORICONINFO) + sizeAnd;
2812 if (lpLen) *lpLen = sizeof(CURSORICONINFO) + sizeAnd + sizeXor;
2813 return MAKELONG( sizeXor, sizeXor );
2814 }
2815
2816
2817 /*******************************************************************
2818 * DRAG_QueryUpdate16
2819 *
2820 * Recursively find a child that contains spDragInfo->pt point
2821 * and send WM_QUERYDROPOBJECT. Helper for DragObject16.
2822 */
2823 static BOOL DRAG_QueryUpdate16( HWND hQueryWnd, SEGPTR spDragInfo )
2824 {
2825 BOOL bResult;
2826 WPARAM wParam;
2827 POINT pt, old_pt;
2828 LPDRAGINFO16 ptrDragInfo = MapSL(spDragInfo);
2829 RECT tempRect;
2830 HWND child;
2831
2832 if (!IsWindowEnabled(hQueryWnd)) return FALSE;
2833
2834 old_pt.x = ptrDragInfo->pt.x;
2835 old_pt.y = ptrDragInfo->pt.y;
2836 pt = old_pt;
2837 ScreenToClient( hQueryWnd, &pt );
2838 child = ChildWindowFromPointEx( hQueryWnd, pt, CWP_SKIPINVISIBLE );
2839 if (!child) return FALSE;
2840
2841 if (child != hQueryWnd)
2842 {
2843 wParam = 0;
2844 if (DRAG_QueryUpdate16( child, spDragInfo )) return TRUE;
2845 }
2846 else
2847 {
2848 GetClientRect( hQueryWnd, &tempRect );
2849 wParam = !PtInRect( &tempRect, pt );
2850 }
2851
2852 ptrDragInfo->pt.x = pt.x;
2853 ptrDragInfo->pt.y = pt.y;
2854 ptrDragInfo->hScope = HWND_16(hQueryWnd);
2855
2856 bResult = SendMessage16( HWND_16(hQueryWnd), WM_QUERYDROPOBJECT, wParam, spDragInfo );
2857
2858 if (!bResult)
2859 {
2860 ptrDragInfo->pt.x = old_pt.x;
2861 ptrDragInfo->pt.y = old_pt.y;
2862 }
2863 return bResult;
2864 }
2865
2866
2867 /******************************************************************************
2868 * DragObject (USER.464)
2869 */
2870 DWORD WINAPI DragObject16( HWND16 hwndScope, HWND16 hWnd, UINT16 wObj,
2871 HANDLE16 hOfStruct, WORD szList, HCURSOR16 hCursor )
2872 {
2873 MSG msg;
2874 LPDRAGINFO16 lpDragInfo;
2875 SEGPTR spDragInfo;
2876 HCURSOR hOldCursor=0, hBummer=0, hCursor32;
2877 HGLOBAL16 hDragInfo = GlobalAlloc16( GMEM_SHARE | GMEM_ZEROINIT, 2*sizeof(DRAGINFO16));
2878 HCURSOR hCurrentCursor = 0;
2879 HWND16 hCurrentWnd = 0;
2880
2881 lpDragInfo = (LPDRAGINFO16) GlobalLock16(hDragInfo);
2882 spDragInfo = WOWGlobalLock16(hDragInfo);
2883
2884 if( !lpDragInfo || !spDragInfo ) return 0L;
2885
2886 if (!(hBummer = LoadCursorA(0, MAKEINTRESOURCEA(OCR_NO))))
2887 {
2888 GlobalFree16(hDragInfo);
2889 return 0L;
2890 }
2891
2892 if ((hCursor32 = get_icon_32( hCursor ))) SetCursor( hCursor32 );
2893
2894 lpDragInfo->hWnd = hWnd;
2895 lpDragInfo->hScope = 0;
2896 lpDragInfo->wFlags = wObj;
2897 lpDragInfo->hList = szList; /* near pointer! */
2898 lpDragInfo->hOfStruct = hOfStruct;
2899 lpDragInfo->l = 0L;
2900
2901 SetCapture( HWND_32(hWnd) );
2902 ShowCursor( TRUE );
2903
2904 do
2905 {
2906 GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST );
2907
2908 *(lpDragInfo+1) = *lpDragInfo;
2909
2910 lpDragInfo->pt.x = msg.pt.x;
2911 lpDragInfo->pt.y = msg.pt.y;
2912
2913 /* update DRAGINFO struct */
2914 if( DRAG_QueryUpdate16(WIN_Handle32(hwndScope), spDragInfo) > 0 )
2915 hCurrentCursor = hCursor32;
2916 else
2917 {
2918 hCurrentCursor = hBummer;
2919 lpDragInfo->hScope = 0;
2920 }
2921 if( hCurrentCursor )
2922 SetCursor(hCurrentCursor);
2923
2924 /* send WM_DRAGLOOP */
2925 SendMessage16( hWnd, WM_DRAGLOOP, hCurrentCursor != hBummer, spDragInfo );
2926 /* send WM_DRAGSELECT or WM_DRAGMOVE */
2927 if( hCurrentWnd != lpDragInfo->hScope )
2928 {
2929 if( hCurrentWnd )
2930 SendMessage16( hCurrentWnd, WM_DRAGSELECT, 0,
2931 MAKELPARAM(LOWORD(spDragInfo)+sizeof(DRAGINFO16),
2932 HIWORD(spDragInfo)) );
2933 hCurrentWnd = lpDragInfo->hScope;
2934 if( hCurrentWnd )
2935 SendMessage16( hCurrentWnd, WM_DRAGSELECT, 1, spDragInfo);
2936 }
2937 else
2938 if( hCurrentWnd )
2939 SendMessage16( hCurrentWnd, WM_DRAGMOVE, 0, spDragInfo);
2940
2941 } while( msg.message != WM_LBUTTONUP && msg.message != WM_NCLBUTTONUP );
2942
2943 ReleaseCapture();
2944 ShowCursor( FALSE );
2945
2946 if( hCursor ) SetCursor(hOldCursor);
2947
2948 if( hCurrentCursor != hBummer )
2949 msg.lParam = SendMessage16( lpDragInfo->hScope, WM_DROPOBJECT,
2950 hWnd, spDragInfo );
2951 else
2952 msg.lParam = 0;
2953 GlobalFree16(hDragInfo);
2954
2955 return (DWORD)(msg.lParam);
2956 }
2957
2958
2959 /***********************************************************************
2960 * DrawFocusRect (USER.466)
2961 */
2962 void WINAPI DrawFocusRect16( HDC16 hdc, const RECT16* rc )
2963 {
2964 RECT rect32;
2965
2966 rect32.left = rc->left;
2967 rect32.top = rc->top;
2968 rect32.right = rc->right;
2969 rect32.bottom = rc->bottom;
2970 DrawFocusRect( HDC_32(hdc), &rect32 );
2971 }
2972
2973
2974 /***********************************************************************
2975 * AnsiNext (USER.472)
2976 */
2977 SEGPTR WINAPI AnsiNext16(SEGPTR current)
2978 {
2979 char *ptr = MapSL(current);
2980 return current + (CharNextA(ptr) - ptr);
2981 }
2982
2983
2984 /***********************************************************************
2985 * AnsiPrev (USER.473)
2986 */
2987 SEGPTR WINAPI AnsiPrev16( LPCSTR start, SEGPTR current )
2988 {
2989 char *ptr = MapSL(current);
2990 return current - (ptr - CharPrevA( start, ptr ));
2991 }
2992
2993
2994 /****************************************************************************
2995 * GetKeyboardLayoutName (USER.477)
2996 */
2997 INT16 WINAPI GetKeyboardLayoutName16( LPSTR name )
2998 {
2999 return GetKeyboardLayoutNameA( name );
3000 }
3001
3002
3003 /***********************************************************************
3004 * SystemParametersInfo (USER.483)
3005 */
3006 BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam,
3007 LPVOID lpvParam, UINT16 fuWinIni )
3008 {
3009 BOOL16 ret;
3010
3011 TRACE("(%u, %u, %p, %u)\n", uAction, uParam, lpvParam, fuWinIni);
3012
3013 switch (uAction)
3014 {
3015 case SPI_GETBEEP:
3016 case SPI_GETSCREENSAVEACTIVE:
3017 case SPI_GETICONTITLEWRAP:
3018 case SPI_GETMENUDROPALIGNMENT:
3019 case SPI_GETFASTTASKSWITCH:
3020 case SPI_GETDRAGFULLWINDOWS:
3021 {
3022 BOOL tmp;
3023 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
3024 if (ret && lpvParam) *(BOOL16 *)lpvParam = tmp;
3025 break;
3026 }
3027
3028 case SPI_GETBORDER:
3029 case SPI_ICONHORIZONTALSPACING:
3030 case SPI_GETSCREENSAVETIMEOUT:
3031 case SPI_GETGRIDGRANULARITY:
3032 case SPI_GETKEYBOARDDELAY:
3033 case SPI_ICONVERTICALSPACING:
3034 {
3035 INT tmp;
3036 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
3037 if (ret && lpvParam) *(INT16 *)lpvParam = tmp;
3038 break;
3039 }
3040
3041 case SPI_GETKEYBOARDSPEED:
3042 case SPI_GETMOUSEHOVERWIDTH:
3043 case SPI_GETMOUSEHOVERHEIGHT:
3044 case SPI_GETMOUSEHOVERTIME:
3045 {
3046 DWORD tmp;
3047 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
3048 if (ret && lpvParam) *(WORD *)lpvParam = tmp;
3049 break;
3050 }
3051
3052 case SPI_GETICONTITLELOGFONT:
3053 {
3054 LOGFONTA tmp;
3055 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
3056 if (ret && lpvParam) logfont_32_to_16( &tmp, (LPLOGFONT16)lpvParam );
3057 break;
3058 }
3059
3060 case SPI_GETNONCLIENTMETRICS:
3061 {
3062 NONCLIENTMETRICSA tmp;
3063 LPNONCLIENTMETRICS16 lpnm16 = (LPNONCLIENTMETRICS16)lpvParam;
3064 if (lpnm16 && lpnm16->cbSize == sizeof(NONCLIENTMETRICS16))
3065 {
3066 tmp.cbSize = sizeof(NONCLIENTMETRICSA);
3067 ret = SystemParametersInfoA( uAction, uParam, &tmp, fuWinIni );
3068 if (ret)
3069 {
3070 lpnm16->iBorderWidth = tmp.iBorderWidth;
3071 lpnm16->iScrollWidth = tmp.iScrollWidth;
3072 lpnm16->iScrollHeight = tmp.iScrollHeight;
3073 lpnm16->iCaptionWidth = tmp.iCaptionWidth;
3074 lpnm16->iCaptionHeight = tmp.iCaptionHeight;
3075 lpnm16->iSmCaptionWidth = tmp.iSmCaptionWidth;
3076 lpnm16->iSmCaptionHeight = tmp.iSmCaptionHeight;
3077 lpnm16->iMenuWidth = tmp.iMenuWidth;
3078 lpnm16->iMenuHeight = tmp.iMenuHeight;
3079 logfont_32_to_16( &tmp.lfCaptionFont, &lpnm16->lfCaptionFont );
3080 logfont_32_to_16( &tmp.lfSmCaptionFont, &lpnm16->lfSmCaptionFont );
3081 logfont_32_to_16( &tmp.lfMenuFont, &lpnm16->lfMenuFont );
3082 logfont_32_to_16( &tmp.lfStatusFont, &lpnm16->lfStatusFont );
3083 logfont_32_to_16( &tmp.lfMessageFont, &lpnm16->lfMessageFont );
3084 }
3085 }
3086 else /* winfile 95 sets cbSize to 340 */
3087 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
3088 break;
3089 }
3090
3091 case SPI_GETWORKAREA:
3092 {
3093 RECT tmp;
3094 ret = SystemParametersInfoA( uAction, uParam, lpvParam ? &tmp : NULL, fuWinIni );
3095 if (ret && lpvParam)
3096 {
3097 RECT16 *r16 = lpvParam;
3098 r16->left = tmp.left;
3099 r16->top = tmp.top;
3100 r16->right = tmp.right;
3101 r16->bottom = tmp.bottom;
3102 }
3103 break;
3104 }
3105
3106 default:
3107 ret = SystemParametersInfoA( uAction, uParam, lpvParam, fuWinIni );
3108 break;
3109 }
3110
3111 return ret;
3112 }
3113
3114
3115 /***********************************************************************
3116 * USER_489 (USER.489)
3117 */
3118 LONG WINAPI stub_USER_489(void)
3119 {
3120 FIXME("stub\n");
3121 return 0;
3122 }
3123
3124
3125 /***********************************************************************
3126 * USER_490 (USER.490)
3127 */
3128 LONG WINAPI stub_USER_490(void)
3129 {
3130 FIXME("stub\n");
3131 return 0;
3132 }
3133
3134
3135 /***********************************************************************
3136 * USER_492 (USER.492)
3137 */
3138 LONG WINAPI stub_USER_492(void)
3139 {
3140 FIXME("stub\n");
3141 return 0;
3142 }
3143
3144
3145 /***********************************************************************
3146 * USER_496 (USER.496)
3147 */
3148 LONG WINAPI stub_USER_496(void)
3149 {
3150 FIXME("stub\n");
3151 return 0;
3152 }
3153
3154
3155 /***********************************************************************
3156 * FormatMessage (USER.606)
3157 */
3158 DWORD WINAPI FormatMessage16(
3159 DWORD dwFlags,
3160 SEGPTR lpSource, /* [in] NOTE: not always a valid pointer */
3161 WORD dwMessageId,
3162 WORD dwLanguageId,
3163 LPSTR lpBuffer, /* [out] NOTE: *((HLOCAL16*)) for FORMAT_MESSAGE_ALLOCATE_BUFFER*/
3164 WORD nSize,
3165 LPDWORD args ) /* [in] NOTE: va_list *args */
3166 {
3167 /* This implementation is completely dependent on the format of the va_list on x86 CPUs */
3168 LPSTR target,t;
3169 DWORD talloced;
3170 LPSTR from,f;
3171 DWORD width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
3172 BOOL eos = FALSE;
3173 LPSTR allocstring = NULL;
3174
3175 TRACE("(0x%x,%x,%d,0x%x,%p,%d,%p)\n",
3176 dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
3177 if ((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
3178 && (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)) return 0;
3179 if ((dwFlags & FORMAT_MESSAGE_FROM_STRING)
3180 &&((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
3181 || (dwFlags & FORMAT_MESSAGE_FROM_HMODULE))) return 0;
3182
3183 if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
3184 FIXME("line wrapping (%u) not supported.\n", width);
3185 from = NULL;
3186 if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
3187 {
3188 char *source = MapSL(lpSource);
3189 from = HeapAlloc( GetProcessHeap(), 0, strlen(source)+1 );
3190 strcpy( from, source );
3191 }
3192 else if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM) {
3193 from = HeapAlloc( GetProcessHeap(),0,200 );
3194 sprintf(from,"Systemmessage, messageid = 0x%08x\n",dwMessageId);
3195 }
3196 else if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE) {
3197 INT16 bufsize;
3198 HINSTANCE16 hinst16 = ((HINSTANCE16)lpSource & 0xffff);
3199
3200 dwMessageId &= 0xFFFF;
3201 bufsize=LoadString16(hinst16,dwMessageId,NULL,0);
3202 if (bufsize) {
3203 from = HeapAlloc( GetProcessHeap(), 0, bufsize +1);
3204 LoadString16(hinst16,dwMessageId,from,bufsize+1);
3205 }
3206 }
3207 target = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
3208 t = target;
3209 talloced= 100;
3210
3211 #define ADD_TO_T(c) \
3212 do { \
3213 *t++=c;\
3214 if (t-target == talloced) {\
3215 target = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
3216 t = target+talloced;\
3217 talloced*=2;\
3218 } \
3219 } while(0)
3220
3221 if (from) {
3222 f=from;
3223 while (*f && !eos) {
3224 if (*f=='%') {
3225 int insertnr;
3226 char *fmtstr,*x,*lastf;
3227 DWORD *argliststart;
3228
3229 fmtstr = NULL;
3230 lastf = f;
3231 f++;
3232 if (!*f) {
3233 ADD_TO_T('%');
3234 continue;
3235 }
3236 switch (*f) {
3237 case '1':case '2':case '3':case '4':case '5':
3238 case '6':case '7':case '8':case '9':
3239 insertnr=*f-'0';
3240 switch (f[1]) {
3241 case '0':case '1':case '2':case '3':
3242 case '4':case '5':case '6':case '7':
3243 case '8':case '9':
3244 f++;
3245 insertnr=insertnr*10+*f-'0';
3246 f++;
3247 break;
3248 default:
3249 f++;
3250 break;
3251 }
3252 if (*f=='!') {
3253 f++;
3254 if (NULL!=(x=strchr(f,'!'))) {
3255 *x='\0';
3256 fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
3257 sprintf(fmtstr,"%%%s",f);
3258 f=x+1;
3259 } else {
3260 fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
3261 sprintf(fmtstr,"%%%s",f);
3262 f+=strlen(f); /*at \0*/
3263 }
3264 }
3265 else
3266 {
3267 if(!args) break;
3268 fmtstr=HeapAlloc( GetProcessHeap(), 0, 3 );
3269 strcpy( fmtstr, "%s" );
3270 }
3271 if (args) {
3272 int ret;
3273 int sz;
3274 LPSTR b = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz = 100);
3275
3276 argliststart=args+insertnr-1;
3277
3278 /* CMF - This makes a BIG assumption about va_list */
3279 while ((ret = vsnprintf(b, sz, fmtstr, (va_list) argliststart)) < 0 || ret >= sz) {
3280 LPSTR new_b;
3281 sz = (ret == -1 ? sz + 100 : ret + 1);
3282 new_b = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, b, sz);
3283 if (!new_b) break;
3284 b = new_b;
3285 }
3286 for (x=b; *x; x++) ADD_TO_T(*x);
3287 HeapFree(GetProcessHeap(), 0, b);
3288 } else {
3289 /* NULL args - copy formatstr
3290 * (probably wrong)
3291 */
3292 while ((lastf<f)&&(*lastf)) {
3293 ADD_TO_T(*lastf++);
3294 }
3295 }
3296 HeapFree(GetProcessHeap(),0,fmtstr);
3297 break;
3298 case '0': /* Just stop processing format string */
3299 eos = TRUE;
3300 f++;
3301 break;
3302 case 'n': /* 16 bit version just outputs 'n' */
3303 default:
3304 ADD_TO_T(*f++);
3305 break;
3306 }
3307 } else { /* '\n' or '\r' gets mapped to "\r\n" */
3308 if(*f == '\n' || *f == '\r') {
3309 if (width == 0) {
3310 ADD_TO_T('\r');
3311 ADD_TO_T('\n');
3312 if(*f++ == '\r' && *f == '\n')
3313 f++;
3314 }
3315 } else {
3316 ADD_TO_T(*f++);
3317 }
3318 }
3319 }
3320 *t='\0';
3321 }
3322 talloced = strlen(target)+1;
3323 TRACE("-- %s\n",debugstr_a(target));
3324 if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
3325 /* nSize is the MINIMUM size */
3326 HLOCAL16 h = LocalAlloc16(LPTR,talloced);
3327 SEGPTR ptr = LocalLock16(h);
3328 allocstring = MapSL( ptr );
3329 memcpy( allocstring,target,talloced);
3330 LocalUnlock16( h );
3331 *((HLOCAL16*)lpBuffer) = h;
3332 } else
3333 lstrcpynA(lpBuffer,target,nSize);
3334 HeapFree(GetProcessHeap(),0,target);
3335 HeapFree(GetProcessHeap(),0,from);
3336 return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
3337 strlen(allocstring):
3338 strlen(lpBuffer);
3339 }
3340 #undef ADD_TO_T
3341
3342
3343 /**********************************************************************
3344 * DestroyIcon32 (USER.610)
3345 *
3346 * This routine is actually exported from Win95 USER under the name
3347 * DestroyIcon32 ... The behaviour implemented here should mimic
3348 * the Win95 one exactly, especially the return values, which
3349 * depend on the setting of various flags.
3350 */
3351 WORD WINAPI DestroyIcon32( HGLOBAL16 handle, UINT16 flags )
3352 {
3353 WORD retv;
3354
3355 /* Check whether destroying active cursor */
3356
3357 if (GetCursor16() == handle)
3358 {
3359 WARN("Destroying active cursor!\n" );
3360 return FALSE;
3361 }
3362
3363 /* Try shared cursor/icon first */
3364
3365 if (!(flags & CID_NONSHARED))
3366 {
3367 INT count = release_shared_icon( handle );
3368 if (count != -1)
3369 return (flags & CID_WIN32) ? TRUE : (count == 0);
3370 }
3371
3372 /* Now assume non-shared cursor/icon */
3373
3374 retv = free_icon_handle( handle );
3375 return (flags & CID_RESOURCE)? retv : TRUE;
3376 }
3377
3378
3379 /***********************************************************************
3380 * ChangeDisplaySettings (USER.620)
3381 */
3382 LONG WINAPI ChangeDisplaySettings16( LPDEVMODEA devmode, DWORD flags )
3383 {
3384 return ChangeDisplaySettingsA( devmode, flags );
3385 }
3386
3387
3388 /***********************************************************************
3389 * EnumDisplaySettings (USER.621)
3390 */
3391 BOOL16 WINAPI EnumDisplaySettings16( LPCSTR name, DWORD n, LPDEVMODEA devmode )
3392 {
3393 return EnumDisplaySettingsA( name, n, devmode );
3394 }
3395
3396 /**********************************************************************
3397 * DrawFrameControl (USER.656)
3398 */
3399 BOOL16 WINAPI DrawFrameControl16( HDC16 hdc, LPRECT16 rc, UINT16 uType, UINT16 uState )
3400 {
3401 RECT rect32;
3402 BOOL ret;
3403
3404 rect32.left = rc->left;
3405 rect32.top = rc->top;
3406 rect32.right = rc->right;
3407 rect32.bottom = rc->bottom;
3408 ret = DrawFrameControl( HDC_32(hdc), &rect32, uType, uState );
3409 rc->left = rect32.left;
3410 rc->top = rect32.top;
3411 rc->right = rect32.right;
3412 rc->bottom = rect32.bottom;
3413 return ret;
3414 }
3415
3416 /**********************************************************************
3417 * DrawEdge (USER.659)
3418 */
3419 BOOL16 WINAPI DrawEdge16( HDC16 hdc, LPRECT16 rc, UINT16 edge, UINT16 flags )
3420 {
3421 RECT rect32;
3422 BOOL ret;
3423
3424 rect32.left = rc->left;
3425 rect32.top = rc->top;
3426 rect32.right = rc->right;
3427 rect32.bottom = rc->bottom;
3428 ret = DrawEdge( HDC_32(hdc), &rect32, edge, flags );
3429 rc->left = rect32.left;
3430 rc->top = rect32.top;
3431 rc->right = rect32.right;
3432 rc->bottom = rect32.bottom;
3433 return ret;
3434 }
3435
3436 /**********************************************************************
3437 * CheckMenuRadioItem (USER.666)
3438 */
3439 BOOL16 WINAPI CheckMenuRadioItem16(HMENU16 hMenu, UINT16 first, UINT16 last,
3440 UINT16 check, BOOL16 bypos)
3441 {
3442 return CheckMenuRadioItem( HMENU_32(hMenu), first, last, check, bypos );
3443 }
Windows API implementation