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