?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shell32: Fix drag-scrolling in the shellview object.
[wine/multimedia.git] / dlls / user / cursoricon.c
blobc3bb046b29fb332478791327933efa56642a7664
1 /*
2 * Cursor and icon support
3 *
4 * Copyright 1995 Alexandre Julliard
5 * 1996 Martin Von Loewis
6 * 1997 Alex Korobka
7 * 1998 Turchanov Sergey
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 /*
25 * Theory:
26 *
27 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnwui/html/msdn_icons.asp
28 *
29 * Cursors and icons are stored in a global heap block, with the
30 * following layout:
31 *
32 * CURSORICONINFO info;
33 * BYTE[] ANDbits;
34 * BYTE[] XORbits;
35 *
36 * The bits structures are in the format of a device-dependent bitmap.
37 *
38 * This layout is very sub-optimal, as the bitmap bits are stored in
39 * the X client instead of in the server like other bitmaps; however,
40 * some programs (notably Paint Brush) expect to be able to manipulate
41 * the bits directly :-(
42 *
43 * FIXME: what are we going to do with animation and color (bpp > 1) cursors ?!
44 */
45
46 #include "config.h"
47 #include "wine/port.h"
48
49 #include <stdarg.h>
50 #include <string.h>
51 #include <stdlib.h>
52
53 #include "windef.h"
54 #include "winbase.h"
55 #include "wingdi.h"
56 #include "wownt32.h"
57 #include "winerror.h"
58 #include "excpt.h"
59 #include "wine/winbase16.h"
60 #include "wine/winuser16.h"
61 #include "wine/exception.h"
62 #include "wine/debug.h"
63 #include "user_private.h"
64
65 WINE_DEFAULT_DEBUG_CHANNEL(cursor);
66 WINE_DECLARE_DEBUG_CHANNEL(icon);
67 WINE_DECLARE_DEBUG_CHANNEL(resource);
68
69 #include "pshpack1.h"
70
71 typedef struct {
72 BYTE bWidth;
73 BYTE bHeight;
74 BYTE bColorCount;
75 BYTE bReserved;
76 WORD xHotspot;
77 WORD yHotspot;
78 DWORD dwDIBSize;
79 DWORD dwDIBOffset;
80 } CURSORICONFILEDIRENTRY;
81
82 typedef struct
83 {
84 WORD idReserved;
85 WORD idType;
86 WORD idCount;
87 CURSORICONFILEDIRENTRY idEntries[1];
88 } CURSORICONFILEDIR;
89
90 #include "poppack.h"
91
92 #define CID_RESOURCE 0x0001
93 #define CID_WIN32 0x0004
94 #define CID_NONSHARED 0x0008
95
96 static RECT CURSOR_ClipRect; /* Cursor clipping rect */
97
98 static HDC screen_dc;
99
100 static const WCHAR DISPLAYW[] = {'D','I','S','P','L','A','Y',0};
101
102 /**********************************************************************
103 * ICONCACHE for cursors/icons loaded with LR_SHARED.
104 *
105 * FIXME: This should not be allocated on the system heap, but on a
106 * subsystem-global heap (i.e. one for all Win16 processes,
107 * and one for each Win32 process).
108 */
109 typedef struct tagICONCACHE
110 {
111 struct tagICONCACHE *next;
112
113 HMODULE hModule;
114 HRSRC hRsrc;
115 HRSRC hGroupRsrc;
116 HICON hIcon;
117
118 INT count;
119
120 } ICONCACHE;
121
122 static ICONCACHE *IconAnchor = NULL;
123
124 static CRITICAL_SECTION IconCrst;
125 static CRITICAL_SECTION_DEBUG critsect_debug =
126 {
127 0, 0, &IconCrst,
128 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
129 0, 0, { (DWORD_PTR)(__FILE__ ": IconCrst") }
130 };
131 static CRITICAL_SECTION IconCrst = { &critsect_debug, -1, 0, 0, 0, 0 };
132
133 static WORD ICON_HOTSPOT = 0x4242;
134
135
136 /***********************************************************************
137 * map_fileW
138 *
139 * Helper function to map a file to memory:
140 * name - file name
141 * [RETURN] ptr - pointer to mapped file
142 * [RETURN] filesize - pointer size of file to be stored if not NULL
143 */
144 static void *map_fileW( LPCWSTR name, LPDWORD filesize )
145 {
146 HANDLE hFile, hMapping;
147 LPVOID ptr = NULL;
148
149 hFile = CreateFileW( name, GENERIC_READ, FILE_SHARE_READ, NULL,
150 OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, 0 );
151 if (hFile != INVALID_HANDLE_VALUE)
152 {
153 hMapping = CreateFileMappingW( hFile, NULL, PAGE_READONLY, 0, 0, NULL );
154 if (hMapping)
155 {
156 ptr = MapViewOfFile( hMapping, FILE_MAP_READ, 0, 0, 0 );
157 CloseHandle( hMapping );
158 if (filesize)
159 *filesize = GetFileSize( hFile, NULL );
160 }
161 CloseHandle( hFile );
162 }
163 return ptr;
164 }
165
166
167 /***********************************************************************
168 * get_bitmap_width_bytes
169 *
170 * Return number of bytes taken by a scanline of 16-bit aligned Windows DDB
171 * data.
172 */
173 static int get_bitmap_width_bytes( int width, int bpp )
174 {
175 switch(bpp)
176 {
177 case 1:
178 return 2 * ((width+15) / 16);
179 case 4:
180 return 2 * ((width+3) / 4);
181 case 24:
182 width *= 3;
183 /* fall through */
184 case 8:
185 return width + (width & 1);
186 case 16:
187 case 15:
188 return width * 2;
189 case 32:
190 return width * 4;
191 default:
192 WARN("Unknown depth %d, please report.\n", bpp );
193 }
194 return -1;
195 }
196
197
198 /***********************************************************************
199 * get_dib_width_bytes
200 *
201 * Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned.
202 */
203 static int get_dib_width_bytes( int width, int depth )
204 {
205 int words;
206
207 switch(depth)
208 {
209 case 1: words = (width + 31) / 32; break;
210 case 4: words = (width + 7) / 8; break;
211 case 8: words = (width + 3) / 4; break;
212 case 15:
213 case 16: words = (width + 1) / 2; break;
214 case 24: words = (width * 3 + 3)/4; break;
215 default:
216 WARN("(%d): Unsupported depth\n", depth );
217 /* fall through */
218 case 32:
219 words = width;
220 }
221 return 4 * words;
222 }
223
224
225 /***********************************************************************
226 * bitmap_info_size
227 *
228 * Return the size of the bitmap info structure including color table.
229 */
230 static int bitmap_info_size( const BITMAPINFO * info, WORD coloruse )
231 {
232 int colors;
233
234 if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
235 {
236 const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
237 colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
238 return sizeof(BITMAPCOREHEADER) + colors *
239 ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
240 }
241 else /* assume BITMAPINFOHEADER */
242 {
243 colors = info->bmiHeader.biClrUsed;
244 if (colors > 256) /* buffer overflow otherwise */
245 colors = 256;
246 if (!colors && (info->bmiHeader.biBitCount <= 8))
247 colors = 1 << info->bmiHeader.biBitCount;
248 return sizeof(BITMAPINFOHEADER) + colors *
249 ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
250 }
251 }
252
253
254 /***********************************************************************
255 * is_dib_monochrome
256 *
257 * Returns whether a DIB can be converted to a monochrome DDB.
258 *
259 * A DIB can be converted if its color table contains only black and
260 * white. Black must be the first color in the color table.
261 *
262 * Note : If the first color in the color table is white followed by
263 * black, we can't convert it to a monochrome DDB with
264 * SetDIBits, because black and white would be inverted.
265 */
266 static BOOL is_dib_monochrome( const BITMAPINFO* info )
267 {
268 if (info->bmiHeader.biBitCount != 1) return FALSE;
269
270 if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
271 {
272 RGBTRIPLE *rgb = ((BITMAPCOREINFO *) info)->bmciColors;
273
274 /* Check if the first color is black */
275 if ((rgb->rgbtRed == 0) && (rgb->rgbtGreen == 0) && (rgb->rgbtBlue == 0))
276 {
277 rgb++;
278
279 /* Check if the second color is white */
280 return ((rgb->rgbtRed == 0xff) && (rgb->rgbtGreen == 0xff)
281 && (rgb->rgbtBlue == 0xff));
282 }
283 else return FALSE;
284 }
285 else /* assume BITMAPINFOHEADER */
286 {
287 const RGBQUAD *rgb = info->bmiColors;
288
289 /* Check if the first color is black */
290 if ((rgb->rgbRed == 0) && (rgb->rgbGreen == 0) &&
291 (rgb->rgbBlue == 0) && (rgb->rgbReserved == 0))
292 {
293 rgb++;
294
295 /* Check if the second color is white */
296 return ((rgb->rgbRed == 0xff) && (rgb->rgbGreen == 0xff)
297 && (rgb->rgbBlue == 0xff) && (rgb->rgbReserved == 0));
298 }
299 else return FALSE;
300 }
301 }
302
303 /***********************************************************************
304 * DIB_GetBitmapInfo
305 *
306 * Get the info from a bitmap header.
307 * Return 1 for INFOHEADER, 0 for COREHEADER,
308 * 4 for V4HEADER, 5 for V5HEADER, -1 for error.
309 */
310 static int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, LONG *width,
311 LONG *height, WORD *bpp, DWORD *compr )
312 {
313 if (header->biSize == sizeof(BITMAPINFOHEADER))
314 {
315 *width = header->biWidth;
316 *height = header->biHeight;
317 *bpp = header->biBitCount;
318 *compr = header->biCompression;
319 return 1;
320 }
321 if (header->biSize == sizeof(BITMAPCOREHEADER))
322 {
323 BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)header;
324 *width = core->bcWidth;
325 *height = core->bcHeight;
326 *bpp = core->bcBitCount;
327 *compr = 0;
328 return 0;
329 }
330 if (header->biSize == sizeof(BITMAPV4HEADER))
331 {
332 BITMAPV4HEADER *v4hdr = (BITMAPV4HEADER *)header;
333 *width = v4hdr->bV4Width;
334 *height = v4hdr->bV4Height;
335 *bpp = v4hdr->bV4BitCount;
336 *compr = v4hdr->bV4V4Compression;
337 return 4;
338 }
339 if (header->biSize == sizeof(BITMAPV5HEADER))
340 {
341 BITMAPV5HEADER *v5hdr = (BITMAPV5HEADER *)header;
342 *width = v5hdr->bV5Width;
343 *height = v5hdr->bV5Height;
344 *bpp = v5hdr->bV5BitCount;
345 *compr = v5hdr->bV5Compression;
346 return 5;
347 }
348 ERR("(%ld): unknown/wrong size for header\n", header->biSize );
349 return -1;
350 }
351
352 /**********************************************************************
353 * CURSORICON_FindSharedIcon
354 */
355 static HICON CURSORICON_FindSharedIcon( HMODULE hModule, HRSRC hRsrc )
356 {
357 HICON hIcon = 0;
358 ICONCACHE *ptr;
359
360 EnterCriticalSection( &IconCrst );
361
362 for ( ptr = IconAnchor; ptr; ptr = ptr->next )
363 if ( ptr->hModule == hModule && ptr->hRsrc == hRsrc )
364 {
365 ptr->count++;
366 hIcon = ptr->hIcon;
367 break;
368 }
369
370 LeaveCriticalSection( &IconCrst );
371
372 return hIcon;
373 }
374
375 /*************************************************************************
376 * CURSORICON_FindCache
377 *
378 * Given a handle, find the corresponding cache element
379 *
380 * PARAMS
381 * Handle [I] handle to an Image
382 *
383 * RETURNS
384 * Success: The cache entry
385 * Failure: NULL
386 *
387 */
388 static ICONCACHE* CURSORICON_FindCache(HICON hIcon)
389 {
390 ICONCACHE *ptr;
391 ICONCACHE *pRet=NULL;
392 BOOL IsFound = FALSE;
393 int count;
394
395 EnterCriticalSection( &IconCrst );
396
397 for (count = 0, ptr = IconAnchor; ptr != NULL && !IsFound; ptr = ptr->next, count++ )
398 {
399 if ( hIcon == ptr->hIcon )
400 {
401 IsFound = TRUE;
402 pRet = ptr;
403 }
404 }
405
406 LeaveCriticalSection( &IconCrst );
407
408 return pRet;
409 }
410
411 /**********************************************************************
412 * CURSORICON_AddSharedIcon
413 */
414 static void CURSORICON_AddSharedIcon( HMODULE hModule, HRSRC hRsrc, HRSRC hGroupRsrc, HICON hIcon )
415 {
416 ICONCACHE *ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(ICONCACHE) );
417 if ( !ptr ) return;
418
419 ptr->hModule = hModule;
420 ptr->hRsrc = hRsrc;
421 ptr->hIcon = hIcon;
422 ptr->hGroupRsrc = hGroupRsrc;
423 ptr->count = 1;
424
425 EnterCriticalSection( &IconCrst );
426 ptr->next = IconAnchor;
427 IconAnchor = ptr;
428 LeaveCriticalSection( &IconCrst );
429 }
430
431 /**********************************************************************
432 * CURSORICON_DelSharedIcon
433 */
434 static INT CURSORICON_DelSharedIcon( HICON hIcon )
435 {
436 INT count = -1;
437 ICONCACHE *ptr;
438
439 EnterCriticalSection( &IconCrst );
440
441 for ( ptr = IconAnchor; ptr; ptr = ptr->next )
442 if ( ptr->hIcon == hIcon )
443 {
444 if ( ptr->count > 0 ) ptr->count--;
445 count = ptr->count;
446 break;
447 }
448
449 LeaveCriticalSection( &IconCrst );
450
451 return count;
452 }
453
454 /**********************************************************************
455 * CURSORICON_FreeModuleIcons
456 */
457 void CURSORICON_FreeModuleIcons( HMODULE16 hMod16 )
458 {
459 ICONCACHE **ptr = &IconAnchor;
460 HMODULE hModule = HMODULE_32(GetExePtr( hMod16 ));
461
462 EnterCriticalSection( &IconCrst );
463
464 while ( *ptr )
465 {
466 if ( (*ptr)->hModule == hModule )
467 {
468 ICONCACHE *freePtr = *ptr;
469 *ptr = freePtr->next;
470
471 GlobalFree16(HICON_16(freePtr->hIcon));
472 HeapFree( GetProcessHeap(), 0, freePtr );
473 continue;
474 }
475 ptr = &(*ptr)->next;
476 }
477
478 LeaveCriticalSection( &IconCrst );
479 }
480
481 /*
482 * The following macro functions account for the irregularities of
483 * accessing cursor and icon resources in files and resource entries.
484 */
485 typedef BOOL (*fnGetCIEntry)( LPVOID dir, int n,
486 int *width, int *height, int *bits );
487
488 /**********************************************************************
489 * CURSORICON_FindBestIcon
490 *
491 * Find the icon closest to the requested size and number of colors.
492 */
493 static int CURSORICON_FindBestIcon( LPVOID dir, fnGetCIEntry get_entry,
494 int width, int height, int colors )
495 {
496 int i, cx, cy, bits, bestEntry = -1;
497 UINT iTotalDiff, iXDiff=0, iYDiff=0, iColorDiff;
498 UINT iTempXDiff, iTempYDiff, iTempColorDiff;
499
500 /* Find Best Fit */
501 iTotalDiff = 0xFFFFFFFF;
502 iColorDiff = 0xFFFFFFFF;
503 for ( i = 0; get_entry( dir, i, &cx, &cy, &bits ); i++ )
504 {
505 iTempXDiff = abs(width - cx);
506 iTempYDiff = abs(height - cy);
507
508 if(iTotalDiff > (iTempXDiff + iTempYDiff))
509 {
510 iXDiff = iTempXDiff;
511 iYDiff = iTempYDiff;
512 iTotalDiff = iXDiff + iYDiff;
513 }
514 }
515
516 /* Find Best Colors for Best Fit */
517 for ( i = 0; get_entry( dir, i, &cx, &cy, &bits ); i++ )
518 {
519 if(abs(width - cx) == iXDiff && abs(height - cy) == iYDiff)
520 {
521 iTempColorDiff = abs(colors - (1<<bits));
522 if(iColorDiff > iTempColorDiff)
523 {
524 bestEntry = i;
525 iColorDiff = iTempColorDiff;
526 }
527 }
528 }
529
530 return bestEntry;
531 }
532
533 static BOOL CURSORICON_GetResIconEntry( LPVOID dir, int n,
534 int *width, int *height, int *bits )
535 {
536 CURSORICONDIR *resdir = dir;
537 ICONRESDIR *icon;
538
539 if ( resdir->idCount <= n )
540 return FALSE;
541 icon = &resdir->idEntries[n].ResInfo.icon;
542 *width = icon->bWidth;
543 *height = icon->bHeight;
544 *bits = resdir->idEntries[n].wBitCount;
545 return TRUE;
546 }
547
548 /**********************************************************************
549 * CURSORICON_FindBestCursor
550 *
551 * Find the cursor closest to the requested size.
552 * FIXME: parameter 'color' ignored and entries with more than 1 bpp
553 * ignored too
554 */
555 static int CURSORICON_FindBestCursor( LPVOID dir, fnGetCIEntry get_entry,
556 int width, int height, int color )
557 {
558 int i, maxwidth, maxheight, cx, cy, bits, bestEntry = -1;
559
560 /* Double height to account for AND and XOR masks */
561
562 height *= 2;
563
564 /* First find the largest one smaller than or equal to the requested size*/
565
566 maxwidth = maxheight = 0;
567 for ( i = 0; get_entry( dir, i, &cx, &cy, &bits ); i++ )
568 {
569 if ((cx <= width) && (cy <= height) &&
570 (cx > maxwidth) && (cy > maxheight) &&
571 (bits == 1))
572 {
573 bestEntry = i;
574 maxwidth = cx;
575 maxheight = cy;
576 }
577 }
578 if (bestEntry != -1) return bestEntry;
579
580 /* Now find the smallest one larger than the requested size */
581
582 maxwidth = maxheight = 255;
583 for ( i = 0; get_entry( dir, i, &cx, &cy, &bits ); i++ )
584 {
585 if (((cx < maxwidth) && (cy < maxheight) && (bits == 1)) ||
586 (bestEntry==-1))
587 {
588 bestEntry = i;
589 maxwidth = cx;
590 maxheight = cy;
591 }
592 }
593
594 return bestEntry;
595 }
596
597 static BOOL CURSORICON_GetResCursorEntry( LPVOID dir, int n,
598 int *width, int *height, int *bits )
599 {
600 CURSORICONDIR *resdir = dir;
601 CURSORDIR *cursor;
602
603 if ( resdir->idCount <= n )
604 return FALSE;
605 cursor = &resdir->idEntries[n].ResInfo.cursor;
606 *width = cursor->wWidth;
607 *height = cursor->wHeight;
608 *bits = resdir->idEntries[n].wBitCount;
609 return TRUE;
610 }
611
612 static CURSORICONDIRENTRY *CURSORICON_FindBestIconRes( CURSORICONDIR * dir,
613 int width, int height, int colors )
614 {
615 int n;
616
617 n = CURSORICON_FindBestIcon( dir, CURSORICON_GetResIconEntry,
618 width, height, colors );
619 if ( n < 0 )
620 return NULL;
621 return &dir->idEntries[n];
622 }
623
624 static CURSORICONDIRENTRY *CURSORICON_FindBestCursorRes( CURSORICONDIR *dir,
625 int width, int height, int color )
626 {
627 int n = CURSORICON_FindBestCursor( dir, CURSORICON_GetResCursorEntry,
628 width, height, color );
629 if ( n < 0 )
630 return NULL;
631 return &dir->idEntries[n];
632 }
633
634 static BOOL CURSORICON_GetFileEntry( LPVOID dir, int n,
635 int *width, int *height, int *bits )
636 {
637 CURSORICONFILEDIR *filedir = dir;
638 CURSORICONFILEDIRENTRY *entry;
639
640 if ( filedir->idCount <= n )
641 return FALSE;
642 entry = &filedir->idEntries[n];
643 *width = entry->bWidth;
644 *height = entry->bHeight;
645 *bits = entry->bColorCount;
646 return TRUE;
647 }
648
649 static CURSORICONFILEDIRENTRY *CURSORICON_FindBestCursorFile( CURSORICONFILEDIR *dir,
650 int width, int height, int color )
651 {
652 int n = CURSORICON_FindBestCursor( dir, CURSORICON_GetFileEntry,
653 width, height, color );
654 if ( n < 0 )
655 return NULL;
656 return &dir->idEntries[n];
657 }
658
659 static CURSORICONFILEDIRENTRY *CURSORICON_FindBestIconFile( CURSORICONFILEDIR *dir,
660 int width, int height, int color )
661 {
662 int n = CURSORICON_FindBestIcon( dir, CURSORICON_GetFileEntry,
663 width, height, color );
664 if ( n < 0 )
665 return NULL;
666 return &dir->idEntries[n];
667 }
668
669 /**********************************************************************
670 * CreateIconFromResourceEx (USER32.@)
671 *
672 * FIXME: Convert to mono when cFlag is LR_MONOCHROME. Do something
673 * with cbSize parameter as well.
674 */
675 HICON WINAPI CreateIconFromResourceEx( LPBYTE bits, UINT cbSize,
676 BOOL bIcon, DWORD dwVersion,
677 INT width, INT height,
678 UINT cFlag )
679 {
680 HGLOBAL16 hObj;
681 static HDC hdcMem;
682 int sizeAnd, sizeXor;
683 HBITMAP hAndBits = 0, hXorBits = 0; /* error condition for later */
684 BITMAP bmpXor, bmpAnd;
685 POINT16 hotspot;
686 BITMAPINFO *bmi;
687 BOOL DoStretch;
688 INT size;
689
690 hotspot.x = ICON_HOTSPOT;
691 hotspot.y = ICON_HOTSPOT;
692
693 TRACE_(cursor)("%p (%u bytes), ver %08x, %ix%i %s %s\n",
694 bits, cbSize, (unsigned)dwVersion, width, height,
695 bIcon ? "icon" : "cursor", (cFlag & LR_MONOCHROME) ? "mono" : "" );
696 if (dwVersion == 0x00020000)
697 {
698 FIXME_(cursor)("\t2.xx resources are not supported\n");
699 return 0;
700 }
701
702 if (bIcon)
703 bmi = (BITMAPINFO *)bits;
704 else /* get the hotspot */
705 {
706 POINT16 *pt = (POINT16 *)bits;
707 hotspot = *pt;
708 bmi = (BITMAPINFO *)(pt + 1);
709 }
710 size = bitmap_info_size( bmi, DIB_RGB_COLORS );
711
712 if (!width) width = bmi->bmiHeader.biWidth;
713 if (!height) height = bmi->bmiHeader.biHeight/2;
714 DoStretch = (bmi->bmiHeader.biHeight/2 != height) ||
715 (bmi->bmiHeader.biWidth != width);
716
717 /* Check bitmap header */
718
719 if ( (bmi->bmiHeader.biSize != sizeof(BITMAPCOREHEADER)) &&
720 (bmi->bmiHeader.biSize != sizeof(BITMAPINFOHEADER) ||
721 bmi->bmiHeader.biCompression != BI_RGB) )
722 {
723 WARN_(cursor)("\tinvalid resource bitmap header.\n");
724 return 0;
725 }
726
727 if (!screen_dc) screen_dc = CreateDCW( DISPLAYW, NULL, NULL, NULL );
728 if (screen_dc)
729 {
730 BITMAPINFO* pInfo;
731
732 /* Make sure we have room for the monochrome bitmap later on.
733 * Note that BITMAPINFOINFO and BITMAPCOREHEADER are the same
734 * up to and including the biBitCount. In-memory icon resource
735 * format is as follows:
736 *
737 * BITMAPINFOHEADER icHeader // DIB header
738 * RGBQUAD icColors[] // Color table
739 * BYTE icXOR[] // DIB bits for XOR mask
740 * BYTE icAND[] // DIB bits for AND mask
741 */
742
743 if ((pInfo = HeapAlloc( GetProcessHeap(), 0,
744 max(size, sizeof(BITMAPINFOHEADER) + 2*sizeof(RGBQUAD)))))
745 {
746 memcpy( pInfo, bmi, size );
747 pInfo->bmiHeader.biHeight /= 2;
748
749 /* Create the XOR bitmap */
750
751 if (DoStretch) {
752 if(bIcon)
753 {
754 hXorBits = CreateCompatibleBitmap(screen_dc, width, height);
755 }
756 else
757 {
758 hXorBits = CreateBitmap(width, height, 1, 1, NULL);
759 }
760 if(hXorBits)
761 {
762 HBITMAP hOld;
763 BOOL res = FALSE;
764
765 if (!hdcMem) hdcMem = CreateCompatibleDC(screen_dc);
766 if (hdcMem) {
767 hOld = SelectObject(hdcMem, hXorBits);
768 res = StretchDIBits(hdcMem, 0, 0, width, height, 0, 0,
769 bmi->bmiHeader.biWidth, bmi->bmiHeader.biHeight/2,
770 (char*)bmi + size, pInfo, DIB_RGB_COLORS, SRCCOPY);
771 SelectObject(hdcMem, hOld);
772 }
773 if (!res) { DeleteObject(hXorBits); hXorBits = 0; }
774 }
775 } else {
776 if (is_dib_monochrome(bmi)) {
777 hXorBits = CreateBitmap(width, height, 1, 1, NULL);
778 SetDIBits(screen_dc, hXorBits, 0, height,
779 (char*)bmi + size, pInfo, DIB_RGB_COLORS);
780 }
781 else
782 hXorBits = CreateDIBitmap(screen_dc, &pInfo->bmiHeader,
783 CBM_INIT, (char*)bmi + size, pInfo, DIB_RGB_COLORS);
784 }
785
786 if( hXorBits )
787 {
788 char* xbits = (char *)bmi + size +
789 get_dib_width_bytes( bmi->bmiHeader.biWidth,
790 bmi->bmiHeader.biBitCount ) * abs( bmi->bmiHeader.biHeight ) / 2;
791
792 pInfo->bmiHeader.biBitCount = 1;
793 if (pInfo->bmiHeader.biSize != sizeof(BITMAPCOREHEADER))
794 {
795 RGBQUAD *rgb = pInfo->bmiColors;
796
797 pInfo->bmiHeader.biClrUsed = pInfo->bmiHeader.biClrImportant = 2;
798 rgb[0].rgbBlue = rgb[0].rgbGreen = rgb[0].rgbRed = 0x00;
799 rgb[1].rgbBlue = rgb[1].rgbGreen = rgb[1].rgbRed = 0xff;
800 rgb[0].rgbReserved = rgb[1].rgbReserved = 0;
801 }
802 else
803 {
804 RGBTRIPLE *rgb = (RGBTRIPLE *)(((BITMAPCOREHEADER *)pInfo) + 1);
805
806 rgb[0].rgbtBlue = rgb[0].rgbtGreen = rgb[0].rgbtRed = 0x00;
807 rgb[1].rgbtBlue = rgb[1].rgbtGreen = rgb[1].rgbtRed = 0xff;
808 }
809
810 /* Create the AND bitmap */
811
812 if (DoStretch) {
813 if ((hAndBits = CreateBitmap(width, height, 1, 1, NULL))) {
814 HBITMAP hOld;
815 BOOL res = FALSE;
816
817 if (!hdcMem) hdcMem = CreateCompatibleDC(screen_dc);
818 if (hdcMem) {
819 hOld = SelectObject(hdcMem, hAndBits);
820 res = StretchDIBits(hdcMem, 0, 0, width, height, 0, 0,
821 pInfo->bmiHeader.biWidth, pInfo->bmiHeader.biHeight,
822 xbits, pInfo, DIB_RGB_COLORS, SRCCOPY);
823 SelectObject(hdcMem, hOld);
824 }
825 if (!res) { DeleteObject(hAndBits); hAndBits = 0; }
826 }
827 } else {
828 hAndBits = CreateBitmap(width, height, 1, 1, NULL);
829
830 if (hAndBits) SetDIBits(screen_dc, hAndBits, 0, height,
831 xbits, pInfo, DIB_RGB_COLORS);
832
833 }
834 if( !hAndBits ) DeleteObject( hXorBits );
835 }
836 HeapFree( GetProcessHeap(), 0, pInfo );
837 }
838 }
839
840 if( !hXorBits || !hAndBits )
841 {
842 WARN_(cursor)("\tunable to create an icon bitmap.\n");
843 return 0;
844 }
845
846 /* Now create the CURSORICONINFO structure */
847 GetObjectA( hXorBits, sizeof(bmpXor), &bmpXor );
848 GetObjectA( hAndBits, sizeof(bmpAnd), &bmpAnd );
849 sizeXor = bmpXor.bmHeight * bmpXor.bmWidthBytes;
850 sizeAnd = bmpAnd.bmHeight * bmpAnd.bmWidthBytes;
851
852 hObj = GlobalAlloc16( GMEM_MOVEABLE,
853 sizeof(CURSORICONINFO) + sizeXor + sizeAnd );
854 if (hObj)
855 {
856 CURSORICONINFO *info;
857
858 info = (CURSORICONINFO *)GlobalLock16( hObj );
859 info->ptHotSpot.x = hotspot.x;
860 info->ptHotSpot.y = hotspot.y;
861 info->nWidth = bmpXor.bmWidth;
862 info->nHeight = bmpXor.bmHeight;
863 info->nWidthBytes = bmpXor.bmWidthBytes;
864 info->bPlanes = bmpXor.bmPlanes;
865 info->bBitsPerPixel = bmpXor.bmBitsPixel;
866
867 /* Transfer the bitmap bits to the CURSORICONINFO structure */
868
869 GetBitmapBits( hAndBits, sizeAnd, (char *)(info + 1) );
870 GetBitmapBits( hXorBits, sizeXor, (char *)(info + 1) + sizeAnd );
871 GlobalUnlock16( hObj );
872 }
873
874 DeleteObject( hAndBits );
875 DeleteObject( hXorBits );
876 return HICON_32((HICON16)hObj);
877 }
878
879
880 /**********************************************************************
881 * CreateIconFromResource (USER32.@)
882 */
883 HICON WINAPI CreateIconFromResource( LPBYTE bits, UINT cbSize,
884 BOOL bIcon, DWORD dwVersion)
885 {
886 return CreateIconFromResourceEx( bits, cbSize, bIcon, dwVersion, 0,0,0);
887 }
888
889
890 static HICON CURSORICON_LoadFromFile( LPCWSTR filename,
891 INT width, INT height, INT colors,
892 BOOL fCursor, UINT loadflags)
893 {
894 CURSORICONFILEDIRENTRY *entry;
895 CURSORICONFILEDIR *dir;
896 DWORD filesize = 0;
897 HICON hIcon = 0;
898 LPBYTE bits;
899
900 TRACE("loading %s\n", debugstr_w( filename ));
901
902 bits = map_fileW( filename, &filesize );
903 if (!bits)
904 return hIcon;
905
906 dir = (CURSORICONFILEDIR*) bits;
907 if ( filesize < sizeof(*dir) )
908 goto end;
909
910 if ( filesize < (sizeof(*dir) + sizeof(dir->idEntries[0])*(dir->idCount-1)) )
911 goto end;
912
913 if ( fCursor )
914 entry = CURSORICON_FindBestCursorFile( dir, width, height, 1 );
915 else
916 entry = CURSORICON_FindBestIconFile( dir, width, height, colors );
917
918 if ( !entry )
919 goto end;
920
921 /* check that we don't run off the end of the file */
922 if ( entry->dwDIBOffset > filesize )
923 goto end;
924 if ( entry->dwDIBOffset + entry->dwDIBSize > filesize )
925 goto end;
926
927 hIcon = CreateIconFromResourceEx( &bits[entry->dwDIBOffset], entry->dwDIBSize,
928 !fCursor, 0x00030000, width, height, loadflags );
929 end:
930 TRACE("loaded %s -> %p\n", debugstr_w( filename ), hIcon );
931 UnmapViewOfFile( bits );
932 return hIcon;
933 }
934
935 /**********************************************************************
936 * CURSORICON_Load
937 *
938 * Load a cursor or icon from resource or file.
939 */
940 static HICON CURSORICON_Load(HINSTANCE hInstance, LPCWSTR name,
941 INT width, INT height, INT colors,
942 BOOL fCursor, UINT loadflags)
943 {
944 HANDLE handle = 0;
945 HICON hIcon = 0;
946 HRSRC hRsrc, hGroupRsrc;
947 CURSORICONDIR *dir;
948 CURSORICONDIRENTRY *dirEntry;
949 LPBYTE bits;
950 WORD wResId;
951 DWORD dwBytesInRes;
952
953 if ( loadflags & LR_LOADFROMFILE ) /* Load from file */
954 return CURSORICON_LoadFromFile( name, width, height, colors, fCursor, loadflags );
955
956 if (!hInstance) hInstance = user32_module; /* Load OEM cursor/icon */
957
958 /* Normalize hInstance (must be uniquely represented for icon cache) */
959
960 if (!HIWORD( hInstance ))
961 hInstance = HINSTANCE_32(GetExePtr( HINSTANCE_16(hInstance) ));
962
963 /* Get directory resource ID */
964
965 if (!(hRsrc = FindResourceW( hInstance, name,
966 (LPWSTR)(fCursor ? RT_GROUP_CURSOR : RT_GROUP_ICON) )))
967 return 0;
968 hGroupRsrc = hRsrc;
969
970 /* Find the best entry in the directory */
971
972 if (!(handle = LoadResource( hInstance, hRsrc ))) return 0;
973 if (!(dir = (CURSORICONDIR*)LockResource( handle ))) return 0;
974 if (fCursor)
975 dirEntry = CURSORICON_FindBestCursorRes( dir, width, height, 1);
976 else
977 dirEntry = CURSORICON_FindBestIconRes( dir, width, height, colors );
978 if (!dirEntry) return 0;
979 wResId = dirEntry->wResId;
980 dwBytesInRes = dirEntry->dwBytesInRes;
981 FreeResource( handle );
982
983 /* Load the resource */
984
985 if (!(hRsrc = FindResourceW(hInstance,MAKEINTRESOURCEW(wResId),
986 (LPWSTR)(fCursor ? RT_CURSOR : RT_ICON) ))) return 0;
987
988 /* If shared icon, check whether it was already loaded */
989 if ( (loadflags & LR_SHARED)
990 && (hIcon = CURSORICON_FindSharedIcon( hInstance, hRsrc ) ) != 0 )
991 return hIcon;
992
993 if (!(handle = LoadResource( hInstance, hRsrc ))) return 0;
994 bits = (LPBYTE)LockResource( handle );
995 hIcon = CreateIconFromResourceEx( bits, dwBytesInRes,
996 !fCursor, 0x00030000, width, height, loadflags);
997 FreeResource( handle );
998
999 /* If shared icon, add to icon cache */
1000
1001 if ( hIcon && (loadflags & LR_SHARED) )
1002 CURSORICON_AddSharedIcon( hInstance, hRsrc, hGroupRsrc, hIcon );
1003
1004 return hIcon;
1005 }
1006
1007 /***********************************************************************
1008 * CURSORICON_Copy
1009 *
1010 * Make a copy of a cursor or icon.
1011 */
1012 static HICON CURSORICON_Copy( HINSTANCE16 hInst16, HICON hIcon )
1013 {
1014 char *ptrOld, *ptrNew;
1015 int size;
1016 HICON16 hOld = HICON_16(hIcon);
1017 HICON16 hNew;
1018
1019 if (!(ptrOld = (char *)GlobalLock16( hOld ))) return 0;
1020 if (hInst16 && !(hInst16 = GetExePtr( hInst16 ))) return 0;
1021 size = GlobalSize16( hOld );
1022 hNew = GlobalAlloc16( GMEM_MOVEABLE, size );
1023 FarSetOwner16( hNew, hInst16 );
1024 ptrNew = (char *)GlobalLock16( hNew );
1025 memcpy( ptrNew, ptrOld, size );
1026 GlobalUnlock16( hOld );
1027 GlobalUnlock16( hNew );
1028 return HICON_32(hNew);
1029 }
1030
1031 /*************************************************************************
1032 * CURSORICON_ExtCopy
1033 *
1034 * Copies an Image from the Cache if LR_COPYFROMRESOURCE is specified
1035 *
1036 * PARAMS
1037 * Handle [I] handle to an Image
1038 * nType [I] Type of Handle (IMAGE_CURSOR | IMAGE_ICON)
1039 * iDesiredCX [I] The Desired width of the Image
1040 * iDesiredCY [I] The desired height of the Image
1041 * nFlags [I] The flags from CopyImage
1042 *
1043 * RETURNS
1044 * Success: The new handle of the Image
1045 *
1046 * NOTES
1047 * LR_COPYDELETEORG and LR_MONOCHROME are currently not implemented.
1048 * LR_MONOCHROME should be implemented by CreateIconFromResourceEx.
1049 * LR_COPYFROMRESOURCE will only work if the Image is in the Cache.
1050 *
1051 *
1052 */
1053
1054 static HICON CURSORICON_ExtCopy(HICON hIcon, UINT nType,
1055 INT iDesiredCX, INT iDesiredCY,
1056 UINT nFlags)
1057 {
1058 HICON hNew=0;
1059
1060 TRACE_(icon)("hIcon %p, nType %u, iDesiredCX %i, iDesiredCY %i, nFlags %u\n",
1061 hIcon, nType, iDesiredCX, iDesiredCY, nFlags);
1062
1063 if(hIcon == 0)
1064 {
1065 return 0;
1066 }
1067
1068 /* Best Fit or Monochrome */
1069 if( (nFlags & LR_COPYFROMRESOURCE
1070 && (iDesiredCX > 0 || iDesiredCY > 0))
1071 || nFlags & LR_MONOCHROME)
1072 {
1073 ICONCACHE* pIconCache = CURSORICON_FindCache(hIcon);
1074
1075 /* Not Found in Cache, then do a straight copy
1076 */
1077 if(pIconCache == NULL)
1078 {
1079 hNew = CURSORICON_Copy(0, hIcon);
1080 if(nFlags & LR_COPYFROMRESOURCE)
1081 {
1082 TRACE_(icon)("LR_COPYFROMRESOURCE: Failed to load from cache\n");
1083 }
1084 }
1085 else
1086 {
1087 int iTargetCY = iDesiredCY, iTargetCX = iDesiredCX;
1088 LPBYTE pBits;
1089 HANDLE hMem;
1090 HRSRC hRsrc;
1091 DWORD dwBytesInRes;
1092 WORD wResId;
1093 CURSORICONDIR *pDir;
1094 CURSORICONDIRENTRY *pDirEntry;
1095 BOOL bIsIcon = (nType == IMAGE_ICON);
1096
1097 /* Completing iDesiredCX CY for Monochrome Bitmaps if needed
1098 */
1099 if(((nFlags & LR_MONOCHROME) && !(nFlags & LR_COPYFROMRESOURCE))
1100 || (iDesiredCX == 0 && iDesiredCY == 0))
1101 {
1102 iDesiredCY = GetSystemMetrics(bIsIcon ?
1103 SM_CYICON : SM_CYCURSOR);
1104 iDesiredCX = GetSystemMetrics(bIsIcon ?
1105 SM_CXICON : SM_CXCURSOR);
1106 }
1107
1108 /* Retrieve the CURSORICONDIRENTRY
1109 */
1110 if (!(hMem = LoadResource( pIconCache->hModule ,
1111 pIconCache->hGroupRsrc)))
1112 {
1113 return 0;
1114 }
1115 if (!(pDir = (CURSORICONDIR*)LockResource( hMem )))
1116 {
1117 return 0;
1118 }
1119
1120 /* Find Best Fit
1121 */
1122 if(bIsIcon)
1123 {
1124 pDirEntry = CURSORICON_FindBestIconRes(
1125 pDir, iDesiredCX, iDesiredCY, 256 );
1126 }
1127 else
1128 {
1129 pDirEntry = (CURSORICONDIRENTRY *)CURSORICON_FindBestCursorRes(
1130 pDir, iDesiredCX, iDesiredCY, 1);
1131 }
1132
1133 wResId = pDirEntry->wResId;
1134 dwBytesInRes = pDirEntry->dwBytesInRes;
1135 FreeResource(hMem);
1136
1137 TRACE_(icon)("ResID %u, BytesInRes %lu, Width %d, Height %d DX %d, DY %d\n",
1138 wResId, dwBytesInRes, pDirEntry->ResInfo.icon.bWidth,
1139 pDirEntry->ResInfo.icon.bHeight, iDesiredCX, iDesiredCY);
1140
1141 /* Get the Best Fit
1142 */
1143 if (!(hRsrc = FindResourceW(pIconCache->hModule ,
1144 MAKEINTRESOURCEW(wResId), (LPWSTR)(bIsIcon ? RT_ICON : RT_CURSOR))))
1145 {
1146 return 0;
1147 }
1148 if (!(hMem = LoadResource( pIconCache->hModule , hRsrc )))
1149 {
1150 return 0;
1151 }
1152
1153 pBits = (LPBYTE)LockResource( hMem );
1154
1155 if(nFlags & LR_DEFAULTSIZE)
1156 {
1157 iTargetCY = GetSystemMetrics(SM_CYICON);
1158 iTargetCX = GetSystemMetrics(SM_CXICON);
1159 }
1160
1161 /* Create a New Icon with the proper dimension
1162 */
1163 hNew = CreateIconFromResourceEx( pBits, dwBytesInRes,
1164 bIsIcon, 0x00030000, iTargetCX, iTargetCY, nFlags);
1165 FreeResource(hMem);
1166 }
1167 }
1168 else hNew = CURSORICON_Copy(0, hIcon);
1169 return hNew;
1170 }
1171
1172
1173 /***********************************************************************
1174 * CreateCursor (USER32.@)
1175 */
1176 HCURSOR WINAPI CreateCursor( HINSTANCE hInstance,
1177 INT xHotSpot, INT yHotSpot,
1178 INT nWidth, INT nHeight,
1179 LPCVOID lpANDbits, LPCVOID lpXORbits )
1180 {
1181 CURSORICONINFO info;
1182
1183 TRACE_(cursor)("%dx%d spot=%d,%d xor=%p and=%p\n",
1184 nWidth, nHeight, xHotSpot, yHotSpot, lpXORbits, lpANDbits);
1185
1186 info.ptHotSpot.x = xHotSpot;
1187 info.ptHotSpot.y = yHotSpot;
1188 info.nWidth = nWidth;
1189 info.nHeight = nHeight;
1190 info.nWidthBytes = 0;
1191 info.bPlanes = 1;
1192 info.bBitsPerPixel = 1;
1193
1194 return HICON_32(CreateCursorIconIndirect16(0, &info, lpANDbits, lpXORbits));
1195 }
1196
1197
1198 /***********************************************************************
1199 * CreateIcon (USER.407)
1200 */
1201 HICON16 WINAPI CreateIcon16( HINSTANCE16 hInstance, INT16 nWidth,
1202 INT16 nHeight, BYTE bPlanes, BYTE bBitsPixel,
1203 LPCVOID lpANDbits, LPCVOID lpXORbits )
1204 {
1205 CURSORICONINFO info;
1206
1207 TRACE_(icon)("%dx%dx%d, xor=%p, and=%p\n",
1208 nWidth, nHeight, bPlanes * bBitsPixel, lpXORbits, lpANDbits);
1209
1210 info.ptHotSpot.x = ICON_HOTSPOT;
1211 info.ptHotSpot.y = ICON_HOTSPOT;
1212 info.nWidth = nWidth;
1213 info.nHeight = nHeight;
1214 info.nWidthBytes = 0;
1215 info.bPlanes = bPlanes;
1216 info.bBitsPerPixel = bBitsPixel;
1217
1218 return CreateCursorIconIndirect16( hInstance, &info, lpANDbits, lpXORbits );
1219 }
1220
1221
1222 /***********************************************************************
1223 * CreateIcon (USER32.@)
1224 *
1225 * Creates an icon based on the specified bitmaps. The bitmaps must be
1226 * provided in a device dependent format and will be resized to
1227 * (SM_CXICON,SM_CYICON) and depth converted to match the screen's color
1228 * depth. The provided bitmaps must be top-down bitmaps.
1229 * Although Windows does not support 15bpp(*) this API must support it
1230 * for Winelib applications.
1231 *
1232 * (*) Windows does not support 15bpp but it supports the 555 RGB 16bpp
1233 * format!
1234 *
1235 * RETURNS
1236 * Success: handle to an icon
1237 * Failure: NULL
1238 *
1239 * BUGS
1240 *
1241 * - The provided bitmaps are not resized!
1242 * - The documentation says the lpXORbits bitmap must be in a device
1243 * dependent format. But we must still resize it and perform depth
1244 * conversions if necessary.
1245 * - I'm a bit unsure about the how the 'device dependent format' thing works.
1246 * I did some tests on windows and found that if you provide a 16bpp bitmap
1247 * in lpXORbits, then its format but be 565 RGB if the screen's bit depth
1248 * is 16bpp but it must be 555 RGB if the screen's bit depth is anything
1249 * else. I don't know if this is part of the GDI specs or if this is a
1250 * quirk of the graphics card driver.
1251 * - You may think that we check whether the bit depths match or not
1252 * as an optimization. But the truth is that the conversion using
1253 * CreateDIBitmap does not work for some bit depth (e.g. 8bpp) and I have
1254 * no idea why.
1255 * - I'm pretty sure that all the things we do in CreateIcon should
1256 * also be done in CreateIconIndirect...
1257 */
1258 HICON WINAPI CreateIcon(
1259 HINSTANCE hInstance, /* [in] the application's hInstance */
1260 INT nWidth, /* [in] the width of the provided bitmaps */
1261 INT nHeight, /* [in] the height of the provided bitmaps */
1262 BYTE bPlanes, /* [in] the number of planes in the provided bitmaps */
1263 BYTE bBitsPixel, /* [in] the number of bits per pixel of the lpXORbits bitmap */
1264 LPCVOID lpANDbits, /* [in] a monochrome bitmap representing the icon's mask */
1265 LPCVOID lpXORbits) /* [in] the icon's 'color' bitmap */
1266 {
1267 HICON hIcon;
1268 HDC hdc;
1269
1270 TRACE_(icon)("%dx%dx%d, xor=%p, and=%p\n",
1271 nWidth, nHeight, bPlanes * bBitsPixel, lpXORbits, lpANDbits);
1272
1273 hdc=GetDC(0);
1274 if (!hdc)
1275 return 0;
1276
1277 if (GetDeviceCaps(hdc,BITSPIXEL)==bBitsPixel) {
1278 CURSORICONINFO info;
1279
1280 info.ptHotSpot.x = ICON_HOTSPOT;
1281 info.ptHotSpot.y = ICON_HOTSPOT;
1282 info.nWidth = nWidth;
1283 info.nHeight = nHeight;
1284 info.nWidthBytes = 0;
1285 info.bPlanes = bPlanes;
1286 info.bBitsPerPixel = bBitsPixel;
1287
1288 hIcon=HICON_32(CreateCursorIconIndirect16(0, &info, lpANDbits, lpXORbits));
1289 } else {
1290 ICONINFO iinfo;
1291 BITMAPINFO bmi;
1292
1293 iinfo.fIcon=TRUE;
1294 iinfo.xHotspot=ICON_HOTSPOT;
1295 iinfo.yHotspot=ICON_HOTSPOT;
1296 iinfo.hbmMask=CreateBitmap(nWidth,nHeight,1,1,lpANDbits);
1297
1298 bmi.bmiHeader.biSize=sizeof(bmi.bmiHeader);
1299 bmi.bmiHeader.biWidth=nWidth;
1300 bmi.bmiHeader.biHeight=-nHeight;
1301 bmi.bmiHeader.biPlanes=bPlanes;
1302 bmi.bmiHeader.biBitCount=bBitsPixel;
1303 bmi.bmiHeader.biCompression=BI_RGB;
1304 bmi.bmiHeader.biSizeImage=0;
1305 bmi.bmiHeader.biXPelsPerMeter=0;
1306 bmi.bmiHeader.biYPelsPerMeter=0;
1307 bmi.bmiHeader.biClrUsed=0;
1308 bmi.bmiHeader.biClrImportant=0;
1309
1310 iinfo.hbmColor = CreateDIBitmap( hdc, &bmi.bmiHeader,
1311 CBM_INIT, lpXORbits,
1312 &bmi, DIB_RGB_COLORS );
1313
1314 hIcon=CreateIconIndirect(&iinfo);
1315 DeleteObject(iinfo.hbmMask);
1316 DeleteObject(iinfo.hbmColor);
1317 }
1318 ReleaseDC(0,hdc);
1319 return hIcon;
1320 }
1321
1322
1323 /***********************************************************************
1324 * CreateCursorIconIndirect (USER.408)
1325 */
1326 HGLOBAL16 WINAPI CreateCursorIconIndirect16( HINSTANCE16 hInstance,
1327 CURSORICONINFO *info,
1328 LPCVOID lpANDbits,
1329 LPCVOID lpXORbits )
1330 {
1331 HGLOBAL16 handle;
1332 char *ptr;
1333 int sizeAnd, sizeXor;
1334
1335 hInstance = GetExePtr( hInstance ); /* Make it a module handle */
1336 if (!lpXORbits || !lpANDbits || info->bPlanes != 1) return 0;
1337 info->nWidthBytes = get_bitmap_width_bytes(info->nWidth,info->bBitsPerPixel);
1338 sizeXor = info->nHeight * info->nWidthBytes;
1339 sizeAnd = info->nHeight * get_bitmap_width_bytes( info->nWidth, 1 );
1340 if (!(handle = GlobalAlloc16( GMEM_MOVEABLE,
1341 sizeof(CURSORICONINFO) + sizeXor + sizeAnd)))
1342 return 0;
1343 FarSetOwner16( handle, hInstance );
1344 ptr = (char *)GlobalLock16( handle );
1345 memcpy( ptr, info, sizeof(*info) );
1346 memcpy( ptr + sizeof(CURSORICONINFO), lpANDbits, sizeAnd );
1347 memcpy( ptr + sizeof(CURSORICONINFO) + sizeAnd, lpXORbits, sizeXor );
1348 GlobalUnlock16( handle );
1349 return handle;
1350 }
1351
1352
1353 /***********************************************************************
1354 * CopyIcon (USER.368)
1355 */
1356 HICON16 WINAPI CopyIcon16( HINSTANCE16 hInstance, HICON16 hIcon )
1357 {
1358 TRACE_(icon)("%04x %04x\n", hInstance, hIcon );
1359 return HICON_16(CURSORICON_Copy(hInstance, HICON_32(hIcon)));
1360 }
1361
1362
1363 /***********************************************************************
1364 * CopyIcon (USER32.@)
1365 */
1366 HICON WINAPI CopyIcon( HICON hIcon )
1367 {
1368 TRACE_(icon)("%p\n", hIcon );
1369 return CURSORICON_Copy( 0, hIcon );
1370 }
1371
1372
1373 /***********************************************************************
1374 * CopyCursor (USER.369)
1375 */
1376 HCURSOR16 WINAPI CopyCursor16( HINSTANCE16 hInstance, HCURSOR16 hCursor )
1377 {
1378 TRACE_(cursor)("%04x %04x\n", hInstance, hCursor );
1379 return HICON_16(CURSORICON_Copy(hInstance, HCURSOR_32(hCursor)));
1380 }
1381
1382 /**********************************************************************
1383 * DestroyIcon32 (USER.610)
1384 *
1385 * This routine is actually exported from Win95 USER under the name
1386 * DestroyIcon32 ... The behaviour implemented here should mimic
1387 * the Win95 one exactly, especially the return values, which
1388 * depend on the setting of various flags.
1389 */
1390 WORD WINAPI DestroyIcon32( HGLOBAL16 handle, UINT16 flags )
1391 {
1392 WORD retv;
1393
1394 TRACE_(icon)("(%04x, %04x)\n", handle, flags );
1395
1396 /* Check whether destroying active cursor */
1397
1398 if ( get_user_thread_info()->cursor == HICON_32(handle) )
1399 {
1400 WARN_(cursor)("Destroying active cursor!\n" );
1401 SetCursor( 0 );
1402 }
1403
1404 /* Try shared cursor/icon first */
1405
1406 if ( !(flags & CID_NONSHARED) )
1407 {
1408 INT count = CURSORICON_DelSharedIcon(HICON_32(handle));
1409
1410 if ( count != -1 )
1411 return (flags & CID_WIN32)? TRUE : (count == 0);
1412
1413 /* FIXME: OEM cursors/icons should be recognized */
1414 }
1415
1416 /* Now assume non-shared cursor/icon */
1417
1418 retv = GlobalFree16( handle );
1419 return (flags & CID_RESOURCE)? retv : TRUE;
1420 }
1421
1422 /***********************************************************************
1423 * DestroyIcon (USER32.@)
1424 */
1425 BOOL WINAPI DestroyIcon( HICON hIcon )
1426 {
1427 return DestroyIcon32(HICON_16(hIcon), CID_WIN32);
1428 }
1429
1430
1431 /***********************************************************************
1432 * DestroyCursor (USER32.@)
1433 */
1434 BOOL WINAPI DestroyCursor( HCURSOR hCursor )
1435 {
1436 return DestroyIcon32(HCURSOR_16(hCursor), CID_WIN32);
1437 }
1438
1439
1440 /***********************************************************************
1441 * DrawIcon (USER32.@)
1442 */
1443 BOOL WINAPI DrawIcon( HDC hdc, INT x, INT y, HICON hIcon )
1444 {
1445 CURSORICONINFO *ptr;
1446 HDC hMemDC;
1447 HBITMAP hXorBits, hAndBits;
1448 COLORREF oldFg, oldBg;
1449
1450 if (!(ptr = (CURSORICONINFO *)GlobalLock16(HICON_16(hIcon)))) return FALSE;
1451 if (!(hMemDC = CreateCompatibleDC( hdc ))) return FALSE;
1452 hAndBits = CreateBitmap( ptr->nWidth, ptr->nHeight, 1, 1,
1453 (char *)(ptr+1) );
1454 hXorBits = CreateBitmap( ptr->nWidth, ptr->nHeight, ptr->bPlanes,
1455 ptr->bBitsPerPixel, (char *)(ptr + 1)
1456 + ptr->nHeight * get_bitmap_width_bytes(ptr->nWidth,1) );
1457 oldFg = SetTextColor( hdc, RGB(0,0,0) );
1458 oldBg = SetBkColor( hdc, RGB(255,255,255) );
1459
1460 if (hXorBits && hAndBits)
1461 {
1462 HBITMAP hBitTemp = SelectObject( hMemDC, hAndBits );
1463 BitBlt( hdc, x, y, ptr->nWidth, ptr->nHeight, hMemDC, 0, 0, SRCAND );
1464 SelectObject( hMemDC, hXorBits );
1465 BitBlt(hdc, x, y, ptr->nWidth, ptr->nHeight, hMemDC, 0, 0,SRCINVERT);
1466 SelectObject( hMemDC, hBitTemp );
1467 }
1468 DeleteDC( hMemDC );
1469 if (hXorBits) DeleteObject( hXorBits );
1470 if (hAndBits) DeleteObject( hAndBits );
1471 GlobalUnlock16(HICON_16(hIcon));
1472 SetTextColor( hdc, oldFg );
1473 SetBkColor( hdc, oldBg );
1474 return TRUE;
1475 }
1476
1477 /***********************************************************************
1478 * DumpIcon (USER.459)
1479 */
1480 DWORD WINAPI DumpIcon16( SEGPTR pInfo, WORD *lpLen,
1481 SEGPTR *lpXorBits, SEGPTR *lpAndBits )
1482 {
1483 CURSORICONINFO *info = MapSL( pInfo );
1484 int sizeAnd, sizeXor;
1485
1486 if (!info) return 0;
1487 sizeXor = info->nHeight * info->nWidthBytes;
1488 sizeAnd = info->nHeight * get_bitmap_width_bytes( info->nWidth, 1 );
1489 if (lpAndBits) *lpAndBits = pInfo + sizeof(CURSORICONINFO);
1490 if (lpXorBits) *lpXorBits = pInfo + sizeof(CURSORICONINFO) + sizeAnd;
1491 if (lpLen) *lpLen = sizeof(CURSORICONINFO) + sizeAnd + sizeXor;
1492 return MAKELONG( sizeXor, sizeXor );
1493 }
1494
1495
1496 /***********************************************************************
1497 * SetCursor (USER32.@)
1498 *
1499 * Set the cursor shape.
1500 *
1501 * RETURNS
1502 * A handle to the previous cursor shape.
1503 */
1504 HCURSOR WINAPI SetCursor( HCURSOR hCursor /* [in] Handle of cursor to show */ )
1505 {
1506 struct user_thread_info *thread_info = get_user_thread_info();
1507 HCURSOR hOldCursor;
1508
1509 if (hCursor == thread_info->cursor) return hCursor; /* No change */
1510 TRACE_(cursor)("%p\n", hCursor );
1511 hOldCursor = thread_info->cursor;
1512 thread_info->cursor = hCursor;
1513 /* Change the cursor shape only if it is visible */
1514 if (thread_info->cursor_count >= 0)
1515 {
1516 USER_Driver->pSetCursor( (CURSORICONINFO*)GlobalLock16(HCURSOR_16(hCursor)) );
1517 GlobalUnlock16(HCURSOR_16(hCursor));
1518 }
1519 return hOldCursor;
1520 }
1521
1522 /***********************************************************************
1523 * ShowCursor (USER32.@)
1524 */
1525 INT WINAPI ShowCursor( BOOL bShow )
1526 {
1527 struct user_thread_info *thread_info = get_user_thread_info();
1528
1529 TRACE_(cursor)("%d, count=%d\n", bShow, thread_info->cursor_count );
1530
1531 if (bShow)
1532 {
1533 if (++thread_info->cursor_count == 0) /* Show it */
1534 {
1535 USER_Driver->pSetCursor((CURSORICONINFO*)GlobalLock16(HCURSOR_16(thread_info->cursor)));
1536 GlobalUnlock16(HCURSOR_16(thread_info->cursor));
1537 }
1538 }
1539 else
1540 {
1541 if (--thread_info->cursor_count == -1) /* Hide it */
1542 USER_Driver->pSetCursor( NULL );
1543 }
1544 return thread_info->cursor_count;
1545 }
1546
1547 /***********************************************************************
1548 * GetCursor (USER32.@)
1549 */
1550 HCURSOR WINAPI GetCursor(void)
1551 {
1552 return get_user_thread_info()->cursor;
1553 }
1554
1555
1556 /***********************************************************************
1557 * ClipCursor (USER32.@)
1558 */
1559 BOOL WINAPI ClipCursor( const RECT *rect )
1560 {
1561 if (!rect) SetRectEmpty( &CURSOR_ClipRect );
1562 else CopyRect( &CURSOR_ClipRect, rect );
1563 return TRUE;
1564 }
1565
1566
1567 /***********************************************************************
1568 * GetClipCursor (USER32.@)
1569 */
1570 BOOL WINAPI GetClipCursor( RECT *rect )
1571 {
1572 if (rect)
1573 {
1574 CopyRect( rect, &CURSOR_ClipRect );
1575 return TRUE;
1576 }
1577 return FALSE;
1578 }
1579
1580
1581 /***********************************************************************
1582 * SetSystemCursor (USER32.@)
1583 */
1584 BOOL WINAPI SetSystemCursor(HCURSOR hcur, DWORD id)
1585 {
1586 FIXME("(%p,%08lx),stub!\n", hcur, id);
1587 return TRUE;
1588 }
1589
1590
1591 /**********************************************************************
1592 * LookupIconIdFromDirectoryEx (USER.364)
1593 *
1594 * FIXME: exact parameter sizes
1595 */
1596 INT16 WINAPI LookupIconIdFromDirectoryEx16( LPBYTE dir, BOOL16 bIcon,
1597 INT16 width, INT16 height, UINT16 cFlag )
1598 {
1599 return LookupIconIdFromDirectoryEx( dir, bIcon, width, height, cFlag );
1600 }
1601
1602 /**********************************************************************
1603 * LookupIconIdFromDirectoryEx (USER32.@)
1604 */
1605 INT WINAPI LookupIconIdFromDirectoryEx( LPBYTE xdir, BOOL bIcon,
1606 INT width, INT height, UINT cFlag )
1607 {
1608 CURSORICONDIR *dir = (CURSORICONDIR*)xdir;
1609 UINT retVal = 0;
1610 if( dir && !dir->idReserved && (dir->idType & 3) )
1611 {
1612 CURSORICONDIRENTRY* entry;
1613 HDC hdc;
1614 UINT palEnts;
1615 int colors;
1616 hdc = GetDC(0);
1617 palEnts = GetSystemPaletteEntries(hdc, 0, 0, NULL);
1618 if (palEnts == 0)
1619 palEnts = 256;
1620 colors = (cFlag & LR_MONOCHROME) ? 2 : palEnts;
1621
1622 ReleaseDC(0, hdc);
1623
1624 if( bIcon )
1625 entry = CURSORICON_FindBestIconRes( dir, width, height, colors );
1626 else
1627 entry = CURSORICON_FindBestCursorRes( dir, width, height, 1);
1628
1629 if( entry ) retVal = entry->wResId;
1630 }
1631 else WARN_(cursor)("invalid resource directory\n");
1632 return retVal;
1633 }
1634
1635 /**********************************************************************
1636 * LookupIconIdFromDirectory (USER.?)
1637 */
1638 INT16 WINAPI LookupIconIdFromDirectory16( LPBYTE dir, BOOL16 bIcon )
1639 {
1640 return LookupIconIdFromDirectoryEx16( dir, bIcon,
1641 bIcon ? GetSystemMetrics(SM_CXICON) : GetSystemMetrics(SM_CXCURSOR),
1642 bIcon ? GetSystemMetrics(SM_CYICON) : GetSystemMetrics(SM_CYCURSOR), bIcon ? 0 : LR_MONOCHROME );
1643 }
1644
1645 /**********************************************************************
1646 * LookupIconIdFromDirectory (USER32.@)
1647 */
1648 INT WINAPI LookupIconIdFromDirectory( LPBYTE dir, BOOL bIcon )
1649 {
1650 return LookupIconIdFromDirectoryEx( dir, bIcon,
1651 bIcon ? GetSystemMetrics(SM_CXICON) : GetSystemMetrics(SM_CXCURSOR),
1652 bIcon ? GetSystemMetrics(SM_CYICON) : GetSystemMetrics(SM_CYCURSOR), bIcon ? 0 : LR_MONOCHROME );
1653 }
1654
1655 /**********************************************************************
1656 * GetIconID (USER.455)
1657 */
1658 WORD WINAPI GetIconID16( HGLOBAL16 hResource, DWORD resType )
1659 {
1660 LPBYTE lpDir = (LPBYTE)GlobalLock16(hResource);
1661
1662 TRACE_(cursor)("hRes=%04x, entries=%i\n",
1663 hResource, lpDir ? ((CURSORICONDIR*)lpDir)->idCount : 0);
1664
1665 switch(resType)
1666 {
1667 case RT_CURSOR:
1668 return (WORD)LookupIconIdFromDirectoryEx16( lpDir, FALSE,
1669 GetSystemMetrics(SM_CXCURSOR), GetSystemMetrics(SM_CYCURSOR), LR_MONOCHROME );
1670 case RT_ICON:
1671 return (WORD)LookupIconIdFromDirectoryEx16( lpDir, TRUE,
1672 GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), 0 );
1673 default:
1674 WARN_(cursor)("invalid res type %ld\n", resType );
1675 }
1676 return 0;
1677 }
1678
1679 /**********************************************************************
1680 * LoadCursorIconHandler (USER.336)
1681 *
1682 * Supposed to load resources of Windows 2.x applications.
1683 */
1684 HGLOBAL16 WINAPI LoadCursorIconHandler16( HGLOBAL16 hResource, HMODULE16 hModule, HRSRC16 hRsrc )
1685 {
1686 FIXME_(cursor)("(%04x,%04x,%04x): old 2.x resources are not supported!\n",
1687 hResource, hModule, hRsrc);
1688 return (HGLOBAL16)0;
1689 }
1690
1691 /**********************************************************************
1692 * LoadIconHandler (USER.456)
1693 */
1694 HICON16 WINAPI LoadIconHandler16( HGLOBAL16 hResource, BOOL16 bNew )
1695 {
1696 LPBYTE bits = (LPBYTE)LockResource16( hResource );
1697
1698 TRACE_(cursor)("hRes=%04x\n",hResource);
1699
1700 return HICON_16(CreateIconFromResourceEx( bits, 0, TRUE,
1701 bNew ? 0x00030000 : 0x00020000, 0, 0, LR_DEFAULTCOLOR));
1702 }
1703
1704 /***********************************************************************
1705 * LoadCursorW (USER32.@)
1706 */
1707 HCURSOR WINAPI LoadCursorW(HINSTANCE hInstance, LPCWSTR name)
1708 {
1709 return LoadImageW( hInstance, name, IMAGE_CURSOR, 0, 0,
1710 LR_SHARED | LR_DEFAULTSIZE );
1711 }
1712
1713 /***********************************************************************
1714 * LoadCursorA (USER32.@)
1715 */
1716 HCURSOR WINAPI LoadCursorA(HINSTANCE hInstance, LPCSTR name)
1717 {
1718 return LoadImageA( hInstance, name, IMAGE_CURSOR, 0, 0,
1719 LR_SHARED | LR_DEFAULTSIZE );
1720 }
1721
1722 /***********************************************************************
1723 * LoadCursorFromFileW (USER32.@)
1724 */
1725 HCURSOR WINAPI LoadCursorFromFileW (LPCWSTR name)
1726 {
1727 return LoadImageW( 0, name, IMAGE_CURSOR, 0, 0,
1728 LR_LOADFROMFILE | LR_DEFAULTSIZE );
1729 }
1730
1731 /***********************************************************************
1732 * LoadCursorFromFileA (USER32.@)
1733 */
1734 HCURSOR WINAPI LoadCursorFromFileA (LPCSTR name)
1735 {
1736 return LoadImageA( 0, name, IMAGE_CURSOR, 0, 0,
1737 LR_LOADFROMFILE | LR_DEFAULTSIZE );
1738 }
1739
1740 /***********************************************************************
1741 * LoadIconW (USER32.@)
1742 */
1743 HICON WINAPI LoadIconW(HINSTANCE hInstance, LPCWSTR name)
1744 {
1745 return LoadImageW( hInstance, name, IMAGE_ICON, 0, 0,
1746 LR_SHARED | LR_DEFAULTSIZE );
1747 }
1748
1749 /***********************************************************************
1750 * LoadIconA (USER32.@)
1751 */
1752 HICON WINAPI LoadIconA(HINSTANCE hInstance, LPCSTR name)
1753 {
1754 return LoadImageA( hInstance, name, IMAGE_ICON, 0, 0,
1755 LR_SHARED | LR_DEFAULTSIZE );
1756 }
1757
1758 /**********************************************************************
1759 * GetIconInfo (USER32.@)
1760 */
1761 BOOL WINAPI GetIconInfo(HICON hIcon, PICONINFO iconinfo)
1762 {
1763 CURSORICONINFO *ciconinfo;
1764 INT height;
1765
1766 ciconinfo = GlobalLock16(HICON_16(hIcon));
1767 if (!ciconinfo)
1768 return FALSE;
1769
1770 if ( (ciconinfo->ptHotSpot.x == ICON_HOTSPOT) &&
1771 (ciconinfo->ptHotSpot.y == ICON_HOTSPOT) )
1772 {
1773 iconinfo->fIcon = TRUE;
1774 iconinfo->xHotspot = ciconinfo->nWidth / 2;
1775 iconinfo->yHotspot = ciconinfo->nHeight / 2;
1776 }
1777 else
1778 {
1779 iconinfo->fIcon = FALSE;
1780 iconinfo->xHotspot = ciconinfo->ptHotSpot.x;
1781 iconinfo->yHotspot = ciconinfo->ptHotSpot.y;
1782 }
1783
1784 if (ciconinfo->bBitsPerPixel > 1)
1785 {
1786 iconinfo->hbmColor = CreateBitmap( ciconinfo->nWidth, ciconinfo->nHeight,
1787 ciconinfo->bPlanes, ciconinfo->bBitsPerPixel,
1788 (char *)(ciconinfo + 1)
1789 + ciconinfo->nHeight *
1790 get_bitmap_width_bytes (ciconinfo->nWidth,1) );
1791 height = ciconinfo->nHeight;
1792 }
1793 else
1794 {
1795 iconinfo->hbmColor = 0;
1796 height = ciconinfo->nHeight * 2;
1797 }
1798
1799 iconinfo->hbmMask = CreateBitmap ( ciconinfo->nWidth, height,
1800 1, 1, (char *)(ciconinfo + 1));
1801
1802 GlobalUnlock16(HICON_16(hIcon));
1803
1804 return TRUE;
1805 }
1806
1807 /**********************************************************************
1808 * CreateIconIndirect (USER32.@)
1809 */
1810 HICON WINAPI CreateIconIndirect(PICONINFO iconinfo)
1811 {
1812 BITMAP bmpXor,bmpAnd;
1813 HICON16 hObj;
1814 int sizeXor,sizeAnd;
1815
1816 if (iconinfo->hbmColor) GetObjectA( iconinfo->hbmColor, sizeof(bmpXor), &bmpXor );
1817 GetObjectA( iconinfo->hbmMask, sizeof(bmpAnd), &bmpAnd );
1818
1819 sizeXor = iconinfo->hbmColor ? (bmpXor.bmHeight * bmpXor.bmWidthBytes) : 0;
1820 sizeAnd = bmpAnd.bmHeight * bmpAnd.bmWidthBytes;
1821
1822 hObj = GlobalAlloc16( GMEM_MOVEABLE,
1823 sizeof(CURSORICONINFO) + sizeXor + sizeAnd );
1824 if (hObj)
1825 {
1826 CURSORICONINFO *info;
1827
1828 info = (CURSORICONINFO *)GlobalLock16( hObj );
1829
1830 /* If we are creating an icon, the hotspot is unused */
1831 if (iconinfo->fIcon)
1832 {
1833 info->ptHotSpot.x = ICON_HOTSPOT;
1834 info->ptHotSpot.y = ICON_HOTSPOT;
1835 }
1836 else
1837 {
1838 info->ptHotSpot.x = iconinfo->xHotspot;
1839 info->ptHotSpot.y = iconinfo->yHotspot;
1840 }
1841
1842 if (iconinfo->hbmColor)
1843 {
1844 info->nWidth = bmpXor.bmWidth;
1845 info->nHeight = bmpXor.bmHeight;
1846 info->nWidthBytes = bmpXor.bmWidthBytes;
1847 info->bPlanes = bmpXor.bmPlanes;
1848 info->bBitsPerPixel = bmpXor.bmBitsPixel;
1849 }
1850 else
1851 {
1852 info->nWidth = bmpAnd.bmWidth;
1853 info->nHeight = bmpAnd.bmHeight / 2;
1854 info->nWidthBytes = bmpAnd.bmWidthBytes;
1855 info->bPlanes = bmpAnd.bmPlanes;
1856 info->bBitsPerPixel = bmpAnd.bmBitsPixel;
1857 }
1858
1859 /* Transfer the bitmap bits to the CURSORICONINFO structure */
1860
1861 GetBitmapBits( iconinfo->hbmMask, sizeAnd, (char*)(info + 1) );
1862 if (iconinfo->hbmColor) GetBitmapBits( iconinfo->hbmColor, sizeXor, (char*)(info + 1) + sizeAnd );
1863 GlobalUnlock16( hObj );
1864 }
1865 return HICON_32(hObj);
1866 }
1867
1868 /******************************************************************************
1869 * DrawIconEx (USER32.@) Draws an icon or cursor on device context
1870 *
1871 * NOTES
1872 * Why is this using SM_CXICON instead of SM_CXCURSOR?
1873 *
1874 * PARAMS
1875 * hdc [I] Handle to device context
1876 * x0 [I] X coordinate of upper left corner
1877 * y0 [I] Y coordinate of upper left corner
1878 * hIcon [I] Handle to icon to draw
1879 * cxWidth [I] Width of icon
1880 * cyWidth [I] Height of icon
1881 * istep [I] Index of frame in animated cursor
1882 * hbr [I] Handle to background brush
1883 * flags [I] Icon-drawing flags
1884 *
1885 * RETURNS
1886 * Success: TRUE
1887 * Failure: FALSE
1888 */
1889 BOOL WINAPI DrawIconEx( HDC hdc, INT x0, INT y0, HICON hIcon,
1890 INT cxWidth, INT cyWidth, UINT istep,
1891 HBRUSH hbr, UINT flags )
1892 {
1893 CURSORICONINFO *ptr = (CURSORICONINFO *)GlobalLock16(HICON_16(hIcon));
1894 HDC hDC_off = 0, hMemDC;
1895 BOOL result = FALSE, DoOffscreen;
1896 HBITMAP hB_off = 0, hOld = 0;
1897
1898 if (!ptr) return FALSE;
1899 TRACE_(icon)("(hdc=%p,pos=%d.%d,hicon=%p,extend=%d.%d,istep=%d,br=%p,flags=0x%08x)\n",
1900 hdc,x0,y0,hIcon,cxWidth,cyWidth,istep,hbr,flags );
1901
1902 hMemDC = CreateCompatibleDC (hdc);
1903 if (istep)
1904 FIXME_(icon)("Ignoring istep=%d\n", istep);
1905 if (flags & DI_COMPAT)
1906 FIXME_(icon)("Ignoring flag DI_COMPAT\n");
1907
1908 if (!flags) {
1909 FIXME_(icon)("no flags set? setting to DI_NORMAL\n");
1910 flags = DI_NORMAL;
1911 }
1912
1913 /* Calculate the size of the destination image. */
1914 if (cxWidth == 0)
1915 {
1916 if (flags & DI_DEFAULTSIZE)
1917 cxWidth = GetSystemMetrics (SM_CXICON);
1918 else
1919 cxWidth = ptr->nWidth;
1920 }
1921 if (cyWidth == 0)
1922 {
1923 if (flags & DI_DEFAULTSIZE)
1924 cyWidth = GetSystemMetrics (SM_CYICON);
1925 else
1926 cyWidth = ptr->nHeight;
1927 }
1928
1929 DoOffscreen = (GetObjectType( hbr ) == OBJ_BRUSH);
1930
1931 if (DoOffscreen) {
1932 RECT r;
1933
1934 r.left = 0;
1935 r.top = 0;
1936 r.right = cxWidth;
1937 r.bottom = cxWidth;
1938
1939 hDC_off = CreateCompatibleDC(hdc);
1940 hB_off = CreateCompatibleBitmap(hdc, cxWidth, cyWidth);
1941 if (hDC_off && hB_off) {
1942 hOld = SelectObject(hDC_off, hB_off);
1943 FillRect(hDC_off, &r, hbr);
1944 }
1945 }
1946
1947 if (hMemDC && (!DoOffscreen || (hDC_off && hB_off)))
1948 {
1949 HBITMAP hXorBits, hAndBits;
1950 COLORREF oldFg, oldBg;
1951 INT nStretchMode;
1952
1953 nStretchMode = SetStretchBltMode (hdc, STRETCH_DELETESCANS);
1954
1955 hXorBits = CreateBitmap ( ptr->nWidth, ptr->nHeight,
1956 ptr->bPlanes, ptr->bBitsPerPixel,
1957 (char *)(ptr + 1)
1958 + ptr->nHeight *
1959 get_bitmap_width_bytes(ptr->nWidth,1) );
1960 hAndBits = CreateBitmap ( ptr->nWidth, ptr->nHeight,
1961 1, 1, (char *)(ptr+1) );
1962 oldFg = SetTextColor( hdc, RGB(0,0,0) );
1963 oldBg = SetBkColor( hdc, RGB(255,255,255) );
1964
1965 if (hXorBits && hAndBits)
1966 {
1967 HBITMAP hBitTemp = SelectObject( hMemDC, hAndBits );
1968 if (flags & DI_MASK)
1969 {
1970 if (DoOffscreen)
1971 StretchBlt (hDC_off, 0, 0, cxWidth, cyWidth,
1972 hMemDC, 0, 0, ptr->nWidth, ptr->nHeight, SRCAND);
1973 else
1974 StretchBlt (hdc, x0, y0, cxWidth, cyWidth,
1975 hMemDC, 0, 0, ptr->nWidth, ptr->nHeight, SRCAND);
1976 }
1977 SelectObject( hMemDC, hXorBits );
1978 if (flags & DI_IMAGE)
1979 {
1980 if (DoOffscreen)
1981 StretchBlt (hDC_off, 0, 0, cxWidth, cyWidth,
1982 hMemDC, 0, 0, ptr->nWidth, ptr->nHeight, SRCPAINT);
1983 else
1984 StretchBlt (hdc, x0, y0, cxWidth, cyWidth,
1985 hMemDC, 0, 0, ptr->nWidth, ptr->nHeight, SRCPAINT);
1986 }
1987 SelectObject( hMemDC, hBitTemp );
1988 result = TRUE;
1989 }
1990
1991 SetTextColor( hdc, oldFg );
1992 SetBkColor( hdc, oldBg );
1993 if (hXorBits) DeleteObject( hXorBits );
1994 if (hAndBits) DeleteObject( hAndBits );
1995 SetStretchBltMode (hdc, nStretchMode);
1996 if (DoOffscreen) {
1997 BitBlt(hdc, x0, y0, cxWidth, cyWidth, hDC_off, 0, 0, SRCCOPY);
1998 SelectObject(hDC_off, hOld);
1999 }
2000 }
2001 if (hMemDC) DeleteDC( hMemDC );
2002 if (hDC_off) DeleteDC(hDC_off);
2003 if (hB_off) DeleteObject(hB_off);
2004 GlobalUnlock16(HICON_16(hIcon));
2005 return result;
2006 }
2007
2008 /***********************************************************************
2009 * DIB_FixColorsToLoadflags
2010 *
2011 * Change color table entries when LR_LOADTRANSPARENT or LR_LOADMAP3DCOLORS
2012 * are in loadflags
2013 */
2014 static void DIB_FixColorsToLoadflags(BITMAPINFO * bmi, UINT loadflags, BYTE pix)
2015 {
2016 int colors;
2017 COLORREF c_W, c_S, c_F, c_L, c_C;
2018 int incr,i;
2019 RGBQUAD *ptr;
2020 int bitmap_type;
2021 LONG width;
2022 LONG height;
2023 WORD bpp;
2024 DWORD compr;
2025
2026 if (((bitmap_type = DIB_GetBitmapInfo((BITMAPINFOHEADER*) bmi, &width, &height, &bpp, &compr)) == -1))
2027 {
2028 WARN_(resource)("Invalid bitmap\n");
2029 return;
2030 }
2031
2032 if (bpp > 8) return;
2033
2034 if (bitmap_type == 0) /* BITMAPCOREHEADER */
2035 {
2036 incr = 3;
2037 colors = 1 << bpp;
2038 }
2039 else
2040 {
2041 incr = 4;
2042 colors = bmi->bmiHeader.biClrUsed;
2043 if (colors > 256) colors = 256;
2044 if (!colors && (bpp <= 8)) colors = 1 << bpp;
2045 }
2046
2047 c_W = GetSysColor(COLOR_WINDOW);
2048 c_S = GetSysColor(COLOR_3DSHADOW);
2049 c_F = GetSysColor(COLOR_3DFACE);
2050 c_L = GetSysColor(COLOR_3DLIGHT);
2051
2052 if (loadflags & LR_LOADTRANSPARENT) {
2053 switch (bpp) {
2054 case 1: pix = pix >> 7; break;
2055 case 4: pix = pix >> 4; break;
2056 case 8: break;
2057 default:
2058 WARN_(resource)("(%d): Unsupported depth\n", bpp);
2059 return;
2060 }
2061 if (pix >= colors) {
2062 WARN_(resource)("pixel has color index greater than biClrUsed!\n");
2063 return;
2064 }
2065 if (loadflags & LR_LOADMAP3DCOLORS) c_W = c_F;
2066 ptr = (RGBQUAD*)((char*)bmi->bmiColors+pix*incr);
2067 ptr->rgbBlue = GetBValue(c_W);
2068 ptr->rgbGreen = GetGValue(c_W);
2069 ptr->rgbRed = GetRValue(c_W);
2070 }
2071 if (loadflags & LR_LOADMAP3DCOLORS)
2072 for (i=0; i<colors; i++) {
2073 ptr = (RGBQUAD*)((char*)bmi->bmiColors+i*incr);
2074 c_C = RGB(ptr->rgbRed, ptr->rgbGreen, ptr->rgbBlue);
2075 if (c_C == RGB(128, 128, 128)) {
2076 ptr->rgbRed = GetRValue(c_S);
2077 ptr->rgbGreen = GetGValue(c_S);
2078 ptr->rgbBlue = GetBValue(c_S);
2079 } else if (c_C == RGB(192, 192, 192)) {
2080 ptr->rgbRed = GetRValue(c_F);
2081 ptr->rgbGreen = GetGValue(c_F);
2082 ptr->rgbBlue = GetBValue(c_F);
2083 } else if (c_C == RGB(223, 223, 223)) {
2084 ptr->rgbRed = GetRValue(c_L);
2085 ptr->rgbGreen = GetGValue(c_L);
2086 ptr->rgbBlue = GetBValue(c_L);
2087 }
2088 }
2089 }
2090
2091
2092 /**********************************************************************
2093 * BITMAP_Load
2094 */
2095 static HBITMAP BITMAP_Load( HINSTANCE instance, LPCWSTR name,
2096 INT desiredx, INT desiredy, UINT loadflags )
2097 {
2098 HBITMAP hbitmap = 0, orig_bm;
2099 HRSRC hRsrc;
2100 HGLOBAL handle;
2101 char *ptr = NULL;
2102 BITMAPINFO *info, *fix_info = NULL, *scaled_info = NULL;
2103 int size;
2104 BYTE pix;
2105 char *bits;
2106 LONG width, height, new_width, new_height;
2107 WORD bpp_dummy;
2108 DWORD compr_dummy;
2109 INT bm_type;
2110 HDC screen_mem_dc = NULL;
2111
2112 if (!(loadflags & LR_LOADFROMFILE))
2113 {
2114 if (!instance)
2115 {
2116 /* OEM bitmap: try to load the resource from user32.dll */
2117 if (HIWORD(name)) return 0;
2118 instance = user32_module;
2119 }
2120
2121 if (!(hRsrc = FindResourceW( instance, name, (LPWSTR)RT_BITMAP ))) return 0;
2122 if (!(handle = LoadResource( instance, hRsrc ))) return 0;
2123
2124 if ((info = (BITMAPINFO *)LockResource( handle )) == NULL) return 0;
2125 }
2126 else
2127 {
2128 if (!(ptr = map_fileW( name, NULL ))) return 0;
2129 info = (BITMAPINFO *)(ptr + sizeof(BITMAPFILEHEADER));
2130 }
2131
2132 size = bitmap_info_size(info, DIB_RGB_COLORS);
2133 fix_info = HeapAlloc(GetProcessHeap(), 0, size);
2134 scaled_info = HeapAlloc(GetProcessHeap(), 0, size);
2135
2136 if (!fix_info || !scaled_info) goto end;
2137 memcpy(fix_info, info, size);
2138
2139 pix = *((LPBYTE)info + size);
2140 DIB_FixColorsToLoadflags(fix_info, loadflags, pix);
2141
2142 memcpy(scaled_info, fix_info, size);
2143 bm_type = DIB_GetBitmapInfo( &fix_info->bmiHeader, &width, &height,
2144 &bpp_dummy, &compr_dummy);
2145 if(desiredx != 0)
2146 new_width = desiredx;
2147 else
2148 new_width = width;
2149
2150 if(desiredy != 0)
2151 new_height = height > 0 ? desiredy : -desiredy;
2152 else
2153 new_height = height;
2154
2155 if(bm_type == 0)
2156 {
2157 BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)&scaled_info->bmiHeader;
2158 core->bcWidth = new_width;
2159 core->bcHeight = new_height;
2160 }
2161 else
2162 {
2163 scaled_info->bmiHeader.biWidth = new_width;
2164 scaled_info->bmiHeader.biHeight = new_height;
2165 }
2166
2167 if (new_height < 0) new_height = -new_height;
2168
2169 if (!screen_dc) screen_dc = CreateDCW( DISPLAYW, NULL, NULL, NULL );
2170 if (!(screen_mem_dc = CreateCompatibleDC( screen_dc ))) goto end;
2171
2172 bits = (char *)info + size;
2173
2174 if (loadflags & LR_CREATEDIBSECTION)
2175 {
2176 scaled_info->bmiHeader.biCompression = 0; /* DIBSection can't be compressed */
2177 hbitmap = CreateDIBSection(screen_dc, scaled_info, DIB_RGB_COLORS, NULL, 0, 0);
2178 }
2179 else
2180 {
2181 if (is_dib_monochrome(fix_info))
2182 hbitmap = CreateBitmap(new_width, new_height, 1, 1, NULL);
2183 else
2184 hbitmap = CreateCompatibleBitmap(screen_dc, new_width, new_height);
2185 }
2186
2187 orig_bm = SelectObject(screen_mem_dc, hbitmap);
2188 StretchDIBits(screen_mem_dc, 0, 0, new_width, new_height, 0, 0, width, height, bits, fix_info, DIB_RGB_COLORS, SRCCOPY);
2189 SelectObject(screen_mem_dc, orig_bm);
2190
2191 end:
2192 if (screen_mem_dc) DeleteDC(screen_mem_dc);
2193 HeapFree(GetProcessHeap(), 0, scaled_info);
2194 HeapFree(GetProcessHeap(), 0, fix_info);
2195 if (loadflags & LR_LOADFROMFILE) UnmapViewOfFile( ptr );
2196
2197 return hbitmap;
2198 }
2199
2200 /**********************************************************************
2201 * LoadImageA (USER32.@)
2202 *
2203 * See LoadImageW.
2204 */
2205
2206 /* filter for page-fault exceptions */
2207 static WINE_EXCEPTION_FILTER(page_fault)
2208 {
2209 if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
2210 return EXCEPTION_EXECUTE_HANDLER;
2211 return EXCEPTION_CONTINUE_SEARCH;
2212 }
2213
2214 /*********************************************************************/
2215
2216 HANDLE WINAPI LoadImageA( HINSTANCE hinst, LPCSTR name, UINT type,
2217 INT desiredx, INT desiredy, UINT loadflags)
2218 {
2219 HANDLE res;
2220 LPWSTR u_name;
2221
2222 if (!HIWORD(name))
2223 return LoadImageW(hinst, (LPCWSTR)name, type, desiredx, desiredy, loadflags);
2224
2225 __TRY {
2226 DWORD len = MultiByteToWideChar( CP_ACP, 0, name, -1, NULL, 0 );
2227 u_name = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
2228 MultiByteToWideChar( CP_ACP, 0, name, -1, u_name, len );
2229 }
2230 __EXCEPT(page_fault) {
2231 SetLastError( ERROR_INVALID_PARAMETER );
2232 return 0;
2233 }
2234 __ENDTRY
2235 res = LoadImageW(hinst, u_name, type, desiredx, desiredy, loadflags);
2236 HeapFree(GetProcessHeap(), 0, u_name);
2237 return res;
2238 }
2239
2240
2241 /******************************************************************************
2242 * LoadImageW (USER32.@) Loads an icon, cursor, or bitmap
2243 *
2244 * PARAMS
2245 * hinst [I] Handle of instance that contains image
2246 * name [I] Name of image
2247 * type [I] Type of image
2248 * desiredx [I] Desired width
2249 * desiredy [I] Desired height
2250 * loadflags [I] Load flags
2251 *
2252 * RETURNS
2253 * Success: Handle to newly loaded image
2254 * Failure: NULL
2255 *
2256 * FIXME: Implementation lacks some features, see LR_ defines in winuser.h
2257 */
2258 HANDLE WINAPI LoadImageW( HINSTANCE hinst, LPCWSTR name, UINT type,
2259 INT desiredx, INT desiredy, UINT loadflags )
2260 {
2261 TRACE_(resource)("(%p,%s,%d,%d,%d,0x%08x)\n",
2262 hinst,debugstr_w(name),type,desiredx,desiredy,loadflags);
2263
2264 if (loadflags & LR_DEFAULTSIZE) {
2265 if (type == IMAGE_ICON) {
2266 if (!desiredx) desiredx = GetSystemMetrics(SM_CXICON);
2267 if (!desiredy) desiredy = GetSystemMetrics(SM_CYICON);
2268 } else if (type == IMAGE_CURSOR) {
2269 if (!desiredx) desiredx = GetSystemMetrics(SM_CXCURSOR);
2270 if (!desiredy) desiredy = GetSystemMetrics(SM_CYCURSOR);
2271 }
2272 }
2273 if (loadflags & LR_LOADFROMFILE) loadflags &= ~LR_SHARED;
2274 switch (type) {
2275 case IMAGE_BITMAP:
2276 return BITMAP_Load( hinst, name, desiredx, desiredy, loadflags );
2277
2278 case IMAGE_ICON:
2279 if (!screen_dc) screen_dc = CreateDCW( DISPLAYW, NULL, NULL, NULL );
2280 if (screen_dc)
2281 {
2282 UINT palEnts = GetSystemPaletteEntries(screen_dc, 0, 0, NULL);
2283 if (palEnts == 0) palEnts = 256;
2284 return CURSORICON_Load(hinst, name, desiredx, desiredy,
2285 palEnts, FALSE, loadflags);
2286 }
2287 break;
2288
2289 case IMAGE_CURSOR:
2290 return CURSORICON_Load(hinst, name, desiredx, desiredy,
2291 1, TRUE, loadflags);
2292 }
2293 return 0;
2294 }
2295
2296 /******************************************************************************
2297 * CopyImage (USER32.@) Creates new image and copies attributes to it
2298 *
2299 * PARAMS
2300 * hnd [I] Handle to image to copy
2301 * type [I] Type of image to copy
2302 * desiredx [I] Desired width of new image
2303 * desiredy [I] Desired height of new image
2304 * flags [I] Copy flags
2305 *
2306 * RETURNS
2307 * Success: Handle to newly created image
2308 * Failure: NULL
2309 *
2310 * FIXME
2311 * implementation still lacks nearly all features, see LR_* defines in winuser.h.
2312 */
2313 HICON WINAPI CopyImage( HANDLE hnd, UINT type, INT desiredx,
2314 INT desiredy, UINT flags )
2315 {
2316 switch (type)
2317 {
2318 case IMAGE_BITMAP:
2319 {
2320 HBITMAP res;
2321 BITMAP bm;
2322
2323 if (!GetObjectW( hnd, sizeof(bm), &bm )) return 0;
2324 bm.bmBits = NULL;
2325 if ((res = CreateBitmapIndirect(&bm)))
2326 {
2327 char *buf = HeapAlloc( GetProcessHeap(), 0, bm.bmWidthBytes * bm.bmHeight );
2328 GetBitmapBits( hnd, bm.bmWidthBytes * bm.bmHeight, buf );
2329 SetBitmapBits( res, bm.bmWidthBytes * bm.bmHeight, buf );
2330 HeapFree( GetProcessHeap(), 0, buf );
2331 }
2332 return (HICON)res;
2333 }
2334 case IMAGE_ICON:
2335 return CURSORICON_ExtCopy(hnd,type, desiredx, desiredy, flags);
2336 case IMAGE_CURSOR:
2337 /* Should call CURSORICON_ExtCopy but more testing
2338 * needs to be done before we change this
2339 */
2340 return CopyCursor(hnd);
2341 }
2342 return 0;
2343 }
2344
2345
2346 /******************************************************************************
2347 * LoadBitmapW (USER32.@) Loads bitmap from the executable file
2348 *
2349 * RETURNS
2350 * Success: Handle to specified bitmap
2351 * Failure: NULL
2352 */
2353 HBITMAP WINAPI LoadBitmapW(
2354 HINSTANCE instance, /* [in] Handle to application instance */
2355 LPCWSTR name) /* [in] Address of bitmap resource name */
2356 {
2357 return LoadImageW( instance, name, IMAGE_BITMAP, 0, 0, 0 );
2358 }
2359
2360 /**********************************************************************
2361 * LoadBitmapA (USER32.@)
2362 *
2363 * See LoadBitmapW.
2364 */
2365 HBITMAP WINAPI LoadBitmapA( HINSTANCE instance, LPCSTR name )
2366 {
2367 return LoadImageA( instance, name, IMAGE_BITMAP, 0, 0, 0 );
2368 }
Maarten's multimedia branch