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