?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 52d6b63ba2f2d4f9b02b6b922d27bff05a60596f
[wine/hacks.git] / dlls / user32 / cursoricon.c
blob248f3a0de477b3780faef408eb1df61b7244da9b
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 * 2007 Henri Verbeet
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25 /*
26 * Theory:
27 *
28 * Cursors and icons are stored in a global heap block, with the
29 * following layout:
30 *
31 * CURSORICONINFO info;
32 * BYTE[] ANDbits;
33 * BYTE[] XORbits;
34 *
35 * The bits structures are in the format of a device-dependent bitmap.
36 *
37 * This layout is very sub-optimal, as the bitmap bits are stored in
38 * the X client instead of in the server like other bitmaps; however,
39 * some programs (notably Paint Brush) expect to be able to manipulate
40 * the bits directly :-(
41 */
42
43 #include "config.h"
44 #include "wine/port.h"
45
46 #include <stdarg.h>
47 #include <string.h>
48 #include <stdlib.h>
49
50 #include "windef.h"
51 #include "winbase.h"
52 #include "wingdi.h"
53 #include "winerror.h"
54 #include "wine/winbase16.h"
55 #include "wine/winuser16.h"
56 #include "wine/exception.h"
57 #include "wine/debug.h"
58 #include "user_private.h"
59
60 WINE_DEFAULT_DEBUG_CHANNEL(cursor);
61 WINE_DECLARE_DEBUG_CHANNEL(icon);
62 WINE_DECLARE_DEBUG_CHANNEL(resource);
63
64 #include "pshpack1.h"
65
66 typedef struct {
67 BYTE bWidth;
68 BYTE bHeight;
69 BYTE bColorCount;
70 BYTE bReserved;
71 WORD xHotspot;
72 WORD yHotspot;
73 DWORD dwDIBSize;
74 DWORD dwDIBOffset;
75 } CURSORICONFILEDIRENTRY;
76
77 typedef struct
78 {
79 WORD idReserved;
80 WORD idType;
81 WORD idCount;
82 CURSORICONFILEDIRENTRY idEntries[1];
83 } CURSORICONFILEDIR;
84
85 #include "poppack.h"
86
87 #define CID_RESOURCE 0x0001
88 #define CID_WIN32 0x0004
89 #define CID_NONSHARED 0x0008
90
91 static RECT CURSOR_ClipRect; /* Cursor clipping rect */
92
93 static HDC screen_dc;
94
95 static const WCHAR DISPLAYW[] = {'D','I','S','P','L','A','Y',0};
96
97 /**********************************************************************
98 * ICONCACHE for cursors/icons loaded with LR_SHARED.
99 *
100 * FIXME: This should not be allocated on the system heap, but on a
101 * subsystem-global heap (i.e. one for all Win16 processes,
102 * and one for each Win32 process).
103 */
104 typedef struct tagICONCACHE
105 {
106 struct tagICONCACHE *next;
107
108 HMODULE hModule;
109 HRSRC hRsrc;
110 HRSRC hGroupRsrc;
111 HICON hIcon;
112
113 INT count;
114
115 } ICONCACHE;
116
117 static ICONCACHE *IconAnchor = NULL;
118
119 static CRITICAL_SECTION IconCrst;
120 static CRITICAL_SECTION_DEBUG critsect_debug =
121 {
122 0, 0, &IconCrst,
123 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
124 0, 0, { (DWORD_PTR)(__FILE__ ": IconCrst") }
125 };
126 static CRITICAL_SECTION IconCrst = { &critsect_debug, -1, 0, 0, 0, 0 };
127
128 static const WORD ICON_HOTSPOT = 0x4242;
129
130
131 /***********************************************************************
132 * map_fileW
133 *
134 * Helper function to map a file to memory:
135 * name - file name
136 * [RETURN] ptr - pointer to mapped file
137 * [RETURN] filesize - pointer size of file to be stored if not NULL
138 */
139 static void *map_fileW( LPCWSTR name, LPDWORD filesize )
140 {
141 HANDLE hFile, hMapping;
142 LPVOID ptr = NULL;
143
144 hFile = CreateFileW( name, GENERIC_READ, FILE_SHARE_READ, NULL,
145 OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, 0 );
146 if (hFile != INVALID_HANDLE_VALUE)
147 {
148 hMapping = CreateFileMappingW( hFile, NULL, PAGE_READONLY, 0, 0, NULL );
149 if (hMapping)
150 {
151 ptr = MapViewOfFile( hMapping, FILE_MAP_READ, 0, 0, 0 );
152 CloseHandle( hMapping );
153 if (filesize)
154 *filesize = GetFileSize( hFile, NULL );
155 }
156 CloseHandle( hFile );
157 }
158 return ptr;
159 }
160
161
162 /***********************************************************************
163 * get_bitmap_width_bytes
164 *
165 * Return number of bytes taken by a scanline of 16-bit aligned Windows DDB
166 * data.
167 */
168 static int get_bitmap_width_bytes( int width, int bpp )
169 {
170 switch(bpp)
171 {
172 case 1:
173 return 2 * ((width+15) / 16);
174 case 4:
175 return 2 * ((width+3) / 4);
176 case 24:
177 width *= 3;
178 /* fall through */
179 case 8:
180 return width + (width & 1);
181 case 16:
182 case 15:
183 return width * 2;
184 case 32:
185 return width * 4;
186 default:
187 WARN("Unknown depth %d, please report.\n", bpp );
188 }
189 return -1;
190 }
191
192
193 /***********************************************************************
194 * get_dib_width_bytes
195 *
196 * Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned.
197 */
198 static int get_dib_width_bytes( int width, int depth )
199 {
200 int words;
201
202 switch(depth)
203 {
204 case 1: words = (width + 31) / 32; break;
205 case 4: words = (width + 7) / 8; break;
206 case 8: words = (width + 3) / 4; break;
207 case 15:
208 case 16: words = (width + 1) / 2; break;
209 case 24: words = (width * 3 + 3)/4; break;
210 default:
211 WARN("(%d): Unsupported depth\n", depth );
212 /* fall through */
213 case 32:
214 words = width;
215 }
216 return 4 * words;
217 }
218
219
220 /***********************************************************************
221 * bitmap_info_size
222 *
223 * Return the size of the bitmap info structure including color table.
224 */
225 static int bitmap_info_size( const BITMAPINFO * info, WORD coloruse )
226 {
227 int colors, masks = 0;
228
229 if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
230 {
231 const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
232 colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
233 return sizeof(BITMAPCOREHEADER) + colors *
234 ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
235 }
236 else /* assume BITMAPINFOHEADER */
237 {
238 colors = info->bmiHeader.biClrUsed;
239 if (colors > 256) /* buffer overflow otherwise */
240 colors = 256;
241 if (!colors && (info->bmiHeader.biBitCount <= 8))
242 colors = 1 << info->bmiHeader.biBitCount;
243 if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
244 return sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD) + colors *
245 ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
246 }
247 }
248
249
250 /***********************************************************************
251 * is_dib_monochrome
252 *
253 * Returns whether a DIB can be converted to a monochrome DDB.
254 *
255 * A DIB can be converted if its color table contains only black and
256 * white. Black must be the first color in the color table.
257 *
258 * Note : If the first color in the color table is white followed by
259 * black, we can't convert it to a monochrome DDB with
260 * SetDIBits, because black and white would be inverted.
261 */
262 static BOOL is_dib_monochrome( const BITMAPINFO* info )
263 {
264 if (info->bmiHeader.biBitCount != 1) return FALSE;
265
266 if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
267 {
268 const RGBTRIPLE *rgb = ((const BITMAPCOREINFO*)info)->bmciColors;
269
270 /* Check if the first color is black */
271 if ((rgb->rgbtRed == 0) && (rgb->rgbtGreen == 0) && (rgb->rgbtBlue == 0))
272 {
273 rgb++;
274
275 /* Check if the second color is white */
276 return ((rgb->rgbtRed == 0xff) && (rgb->rgbtGreen == 0xff)
277 && (rgb->rgbtBlue == 0xff));
278 }
279 else return FALSE;
280 }
281 else /* assume BITMAPINFOHEADER */
282 {
283 const RGBQUAD *rgb = info->bmiColors;
284
285 /* Check if the first color is black */
286 if ((rgb->rgbRed == 0) && (rgb->rgbGreen == 0) &&
287 (rgb->rgbBlue == 0) && (rgb->rgbReserved == 0))
288 {
289 rgb++;
290
291 /* Check if the second color is white */
292 return ((rgb->rgbRed == 0xff) && (rgb->rgbGreen == 0xff)
293 && (rgb->rgbBlue == 0xff) && (rgb->rgbReserved == 0));
294 }
295 else return FALSE;
296 }
297 }
298
299 /***********************************************************************
300 * DIB_GetBitmapInfo
301 *
302 * Get the info from a bitmap header.
303 * Return 1 for INFOHEADER, 0 for COREHEADER,
304 * 4 for V4HEADER, 5 for V5HEADER, -1 for error.
305 */
306 static int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, LONG *width,
307 LONG *height, WORD *bpp, DWORD *compr )
308 {
309 if (header->biSize == sizeof(BITMAPINFOHEADER))
310 {
311 *width = header->biWidth;
312 *height = header->biHeight;
313 *bpp = header->biBitCount;
314 *compr = header->biCompression;
315 return 1;
316 }
317 if (header->biSize == sizeof(BITMAPCOREHEADER))
318 {
319 const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)header;
320 *width = core->bcWidth;
321 *height = core->bcHeight;
322 *bpp = core->bcBitCount;
323 *compr = 0;
324 return 0;
325 }
326 if (header->biSize == sizeof(BITMAPV4HEADER))
327 {
328 const BITMAPV4HEADER *v4hdr = (const BITMAPV4HEADER *)header;
329 *width = v4hdr->bV4Width;
330 *height = v4hdr->bV4Height;
331 *bpp = v4hdr->bV4BitCount;
332 *compr = v4hdr->bV4V4Compression;
333 return 4;
334 }
335 if (header->biSize == sizeof(BITMAPV5HEADER))
336 {
337 const BITMAPV5HEADER *v5hdr = (const BITMAPV5HEADER *)header;
338 *width = v5hdr->bV5Width;
339 *height = v5hdr->bV5Height;
340 *bpp = v5hdr->bV5BitCount;
341 *compr = v5hdr->bV5Compression;
342 return 5;
343 }
344 ERR("(%d): unknown/wrong size for header\n", header->biSize );
345 return -1;
346 }
347
348 /**********************************************************************
349 * CURSORICON_FindSharedIcon
350 */
351 static HICON CURSORICON_FindSharedIcon( HMODULE hModule, HRSRC hRsrc )
352 {
353 HICON hIcon = 0;
354 ICONCACHE *ptr;
355
356 EnterCriticalSection( &IconCrst );
357
358 for ( ptr = IconAnchor; ptr; ptr = ptr->next )
359 if ( ptr->hModule == hModule && ptr->hRsrc == hRsrc )
360 {
361 ptr->count++;
362 hIcon = ptr->hIcon;
363 break;
364 }
365
366 LeaveCriticalSection( &IconCrst );
367
368 return hIcon;
369 }
370
371 /*************************************************************************
372 * CURSORICON_FindCache
373 *
374 * Given a handle, find the corresponding cache element
375 *
376 * PARAMS
377 * Handle [I] handle to an Image
378 *
379 * RETURNS
380 * Success: The cache entry
381 * Failure: NULL
382 *
383 */
384 static ICONCACHE* CURSORICON_FindCache(HICON hIcon)
385 {
386 ICONCACHE *ptr;
387 ICONCACHE *pRet=NULL;
388 BOOL IsFound = FALSE;
389
390 EnterCriticalSection( &IconCrst );
391
392 for (ptr = IconAnchor; ptr != NULL && !IsFound; ptr = ptr->next)
393 {
394 if ( hIcon == ptr->hIcon )
395 {
396 IsFound = TRUE;
397 pRet = ptr;
398 }
399 }
400
401 LeaveCriticalSection( &IconCrst );
402
403 return pRet;
404 }
405
406 /**********************************************************************
407 * CURSORICON_AddSharedIcon
408 */
409 static void CURSORICON_AddSharedIcon( HMODULE hModule, HRSRC hRsrc, HRSRC hGroupRsrc, HICON hIcon )
410 {
411 ICONCACHE *ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(ICONCACHE) );
412 if ( !ptr ) return;
413
414 ptr->hModule = hModule;
415 ptr->hRsrc = hRsrc;
416 ptr->hIcon = hIcon;
417 ptr->hGroupRsrc = hGroupRsrc;
418 ptr->count = 1;
419
420 EnterCriticalSection( &IconCrst );
421 ptr->next = IconAnchor;
422 IconAnchor = ptr;
423 LeaveCriticalSection( &IconCrst );
424 }
425
426 /**********************************************************************
427 * CURSORICON_DelSharedIcon
428 */
429 static INT CURSORICON_DelSharedIcon( HICON hIcon )
430 {
431 INT count = -1;
432 ICONCACHE *ptr;
433
434 EnterCriticalSection( &IconCrst );
435
436 for ( ptr = IconAnchor; ptr; ptr = ptr->next )
437 if ( ptr->hIcon == hIcon )
438 {
439 if ( ptr->count > 0 ) ptr->count--;
440 count = ptr->count;
441 break;
442 }
443
444 LeaveCriticalSection( &IconCrst );
445
446 return count;
447 }
448
449 /**********************************************************************
450 * CURSORICON_FreeModuleIcons
451 */
452 void CURSORICON_FreeModuleIcons( HMODULE16 hMod16 )
453 {
454 ICONCACHE **ptr = &IconAnchor;
455 HMODULE hModule = HMODULE_32(GetExePtr( hMod16 ));
456
457 EnterCriticalSection( &IconCrst );
458
459 while ( *ptr )
460 {
461 if ( (*ptr)->hModule == hModule )
462 {
463 ICONCACHE *freePtr = *ptr;
464 *ptr = freePtr->next;
465
466 GlobalFree16(HICON_16(freePtr->hIcon));
467 HeapFree( GetProcessHeap(), 0, freePtr );
468 continue;
469 }
470 ptr = &(*ptr)->next;
471 }
472
473 LeaveCriticalSection( &IconCrst );
474 }
475
476 /**********************************************************************
477 * get_icon_size
478 */
479 BOOL get_icon_size( HICON handle, SIZE *size )
480 {
481 CURSORICONINFO *info;
482
483 if (!(info = GlobalLock16( HICON_16(handle) ))) return FALSE;
484 size->cx = info->nWidth;
485 size->cy = info->nHeight;
486 GlobalUnlock16( HICON_16(handle) );
487 return TRUE;
488 }
489
490 /*
491 * The following macro functions account for the irregularities of
492 * accessing cursor and icon resources in files and resource entries.
493 */
494 typedef BOOL (*fnGetCIEntry)( LPVOID dir, int n,
495 int *width, int *height, int *bits );
496
497 /**********************************************************************
498 * CURSORICON_FindBestIcon
499 *
500 * Find the icon closest to the requested size and number of colors.
501 */
502 static int CURSORICON_FindBestIcon( LPVOID dir, fnGetCIEntry get_entry,
503 int width, int height, int colors )
504 {
505 int i, cx, cy, bits, bestEntry = -1;
506 UINT iTotalDiff, iXDiff=0, iYDiff=0, iColorDiff;
507 UINT iTempXDiff, iTempYDiff, iTempColorDiff;
508
509 /* Find Best Fit */
510 iTotalDiff = 0xFFFFFFFF;
511 iColorDiff = 0xFFFFFFFF;
512 for ( i = 0; get_entry( dir, i, &cx, &cy, &bits ); i++ )
513 {
514 iTempXDiff = abs(width - cx);
515 iTempYDiff = abs(height - cy);
516
517 if(iTotalDiff > (iTempXDiff + iTempYDiff))
518 {
519 iXDiff = iTempXDiff;
520 iYDiff = iTempYDiff;
521 iTotalDiff = iXDiff + iYDiff;
522 }
523 }
524
525 /* Find Best Colors for Best Fit */
526 for ( i = 0; get_entry( dir, i, &cx, &cy, &bits ); i++ )
527 {
528 if(abs(width - cx) == iXDiff && abs(height - cy) == iYDiff)
529 {
530 iTempColorDiff = abs(colors - (1<<bits));
531 if(iColorDiff > iTempColorDiff)
532 {
533 bestEntry = i;
534 iColorDiff = iTempColorDiff;
535 }
536 }
537 }
538
539 return bestEntry;
540 }
541
542 static BOOL CURSORICON_GetResIconEntry( LPVOID dir, int n,
543 int *width, int *height, int *bits )
544 {
545 CURSORICONDIR *resdir = dir;
546 ICONRESDIR *icon;
547
548 if ( resdir->idCount <= n )
549 return FALSE;
550 icon = &resdir->idEntries[n].ResInfo.icon;
551 *width = icon->bWidth;
552 *height = icon->bHeight;
553 *bits = resdir->idEntries[n].wBitCount;
554 return TRUE;
555 }
556
557 /**********************************************************************
558 * CURSORICON_FindBestCursor
559 *
560 * Find the cursor closest to the requested size.
561 *
562 * FIXME: parameter 'color' ignored.
563 */
564 static int CURSORICON_FindBestCursor( LPVOID dir, fnGetCIEntry get_entry,
565 int width, int height, int color )
566 {
567 int i, maxwidth, maxheight, cx, cy, bits, bestEntry = -1;
568
569 /* Double height to account for AND and XOR masks */
570
571 height *= 2;
572
573 /* First find the largest one smaller than or equal to the requested size*/
574
575 maxwidth = maxheight = 0;
576 for ( i = 0; get_entry( dir, i, &cx, &cy, &bits ); i++ )
577 {
578 if ((cx <= width) && (cy <= height) &&
579 (cx > maxwidth) && (cy > maxheight))
580 {
581 bestEntry = i;
582 maxwidth = cx;
583 maxheight = cy;
584 }
585 }
586 if (bestEntry != -1) return bestEntry;
587
588 /* Now find the smallest one larger than the requested size */
589
590 maxwidth = maxheight = 255;
591 for ( i = 0; get_entry( dir, i, &cx, &cy, &bits ); i++ )
592 {
593 if (((cx < maxwidth) && (cy < maxheight)) || (bestEntry == -1))
594 {
595 bestEntry = i;
596 maxwidth = cx;
597 maxheight = cy;
598 }
599 }
600
601 return bestEntry;
602 }
603
604 static BOOL CURSORICON_GetResCursorEntry( LPVOID dir, int n,
605 int *width, int *height, int *bits )
606 {
607 CURSORICONDIR *resdir = dir;
608 CURSORDIR *cursor;
609
610 if ( resdir->idCount <= n )
611 return FALSE;
612 cursor = &resdir->idEntries[n].ResInfo.cursor;
613 *width = cursor->wWidth;
614 *height = cursor->wHeight;
615 *bits = resdir->idEntries[n].wBitCount;
616 return TRUE;
617 }
618
619 static CURSORICONDIRENTRY *CURSORICON_FindBestIconRes( CURSORICONDIR * dir,
620 int width, int height, int colors )
621 {
622 int n;
623
624 n = CURSORICON_FindBestIcon( dir, CURSORICON_GetResIconEntry,
625 width, height, colors );
626 if ( n < 0 )
627 return NULL;
628 return &dir->idEntries[n];
629 }
630
631 static CURSORICONDIRENTRY *CURSORICON_FindBestCursorRes( CURSORICONDIR *dir,
632 int width, int height, int color )
633 {
634 int n = CURSORICON_FindBestCursor( dir, CURSORICON_GetResCursorEntry,
635 width, height, color );
636 if ( n < 0 )
637 return NULL;
638 return &dir->idEntries[n];
639 }
640
641 static BOOL CURSORICON_GetFileEntry( LPVOID dir, int n,
642 int *width, int *height, int *bits )
643 {
644 CURSORICONFILEDIR *filedir = dir;
645 CURSORICONFILEDIRENTRY *entry;
646
647 if ( filedir->idCount <= n )
648 return FALSE;
649 entry = &filedir->idEntries[n];
650 *width = entry->bWidth;
651 *height = entry->bHeight;
652 *bits = entry->bColorCount;
653 return TRUE;
654 }
655
656 static CURSORICONFILEDIRENTRY *CURSORICON_FindBestCursorFile( CURSORICONFILEDIR *dir,
657 int width, int height, int color )
658 {
659 int n = CURSORICON_FindBestCursor( dir, CURSORICON_GetFileEntry,
660 width, height, color );
661 if ( n < 0 )
662 return NULL;
663 return &dir->idEntries[n];
664 }
665
666 static CURSORICONFILEDIRENTRY *CURSORICON_FindBestIconFile( CURSORICONFILEDIR *dir,
667 int width, int height, int color )
668 {
669 int n = CURSORICON_FindBestIcon( dir, CURSORICON_GetFileEntry,
670 width, height, color );
671 if ( n < 0 )
672 return NULL;
673 return &dir->idEntries[n];
674 }
675
676 /***********************************************************************
677 * stretch_blt_icon
678 *
679 * A helper function that stretches a bitmap buffer into an HBITMAP.
680 *
681 * PARAMS
682 * hDest [I] The handle of the destination bitmap.
683 * pDestInfo [I] The BITMAPINFO of the destination bitmap.
684 * pSrcInfo [I] The BITMAPINFO of the source bitmap.
685 * pSrcBits [I] A pointer to the source bitmap buffer.
686 **/
687 static BOOL stretch_blt_icon(HBITMAP hDest, BITMAPINFO *pDestInfo, BITMAPINFO *pSrcInfo, char *pSrcBits)
688 {
689 HBITMAP hOld;
690 BOOL res = FALSE;
691 HDC hdcMem = CreateCompatibleDC(screen_dc);
692
693 if (hdcMem)
694 {
695 hOld = SelectObject(hdcMem, hDest);
696 res = StretchDIBits(hdcMem,
697 0, 0, pDestInfo->bmiHeader.biWidth, pDestInfo->bmiHeader.biHeight,
698 0, 0, pSrcInfo->bmiHeader.biWidth, pSrcInfo->bmiHeader.biHeight,
699 pSrcBits, pSrcInfo, DIB_RGB_COLORS, SRCCOPY);
700 SelectObject(hdcMem, hOld);
701 DeleteDC( hdcMem );
702 }
703
704 return res;
705 }
706
707 static HICON CURSORICON_CreateIconFromBMI( BITMAPINFO *bmi,
708 POINT16 hotspot, BOOL bIcon,
709 DWORD dwVersion,
710 INT width, INT height,
711 UINT cFlag )
712 {
713 HGLOBAL16 hObj;
714 int sizeAnd, sizeXor;
715 HBITMAP hAndBits = 0, hXorBits = 0; /* error condition for later */
716 BITMAP bmpXor, bmpAnd;
717 INT size;
718 BITMAPINFO *pSrcInfo, *pDestInfo;
719
720 if (dwVersion == 0x00020000)
721 {
722 FIXME_(cursor)("\t2.xx resources are not supported\n");
723 return 0;
724 }
725
726 /* Check bitmap header */
727
728 if ( (bmi->bmiHeader.biSize != sizeof(BITMAPCOREHEADER)) &&
729 (bmi->bmiHeader.biSize != sizeof(BITMAPINFOHEADER) ||
730 bmi->bmiHeader.biCompression != BI_RGB) )
731 {
732 WARN_(cursor)("\tinvalid resource bitmap header.\n");
733 return 0;
734 }
735
736 size = bitmap_info_size( bmi, DIB_RGB_COLORS );
737
738 if (!width) width = bmi->bmiHeader.biWidth;
739 if (!height) height = bmi->bmiHeader.biHeight/2;
740
741 /* Scale the hotspot */
742 if (((bmi->bmiHeader.biHeight/2 != height) || (bmi->bmiHeader.biWidth != width)) &&
743 hotspot.x != ICON_HOTSPOT && hotspot.y != ICON_HOTSPOT)
744 {
745 hotspot.x = (hotspot.x * width) / bmi->bmiHeader.biWidth;
746 hotspot.y = (hotspot.y * height) / (bmi->bmiHeader.biHeight / 2);
747 }
748
749 if (!screen_dc) screen_dc = CreateDCW( DISPLAYW, NULL, NULL, NULL );
750 if (screen_dc)
751 {
752 /* Make sure we have room for the monochrome bitmap later on.
753 * Note that BITMAPINFOINFO and BITMAPCOREHEADER are the same
754 * up to and including the biBitCount. In-memory icon resource
755 * format is as follows:
756 *
757 * BITMAPINFOHEADER icHeader // DIB header
758 * RGBQUAD icColors[] // Color table
759 * BYTE icXOR[] // DIB bits for XOR mask
760 * BYTE icAND[] // DIB bits for AND mask
761 */
762
763 pSrcInfo = HeapAlloc( GetProcessHeap(), 0,
764 max(size, sizeof(BITMAPINFOHEADER) + 2*sizeof(RGBQUAD)));
765 pDestInfo = HeapAlloc( GetProcessHeap(), 0,
766 max(size, sizeof(BITMAPINFOHEADER) + 2*sizeof(RGBQUAD)));
767 if (pSrcInfo && pDestInfo)
768 {
769 memcpy( pSrcInfo, bmi, size );
770 pSrcInfo->bmiHeader.biHeight /= 2;
771
772 memcpy( pDestInfo, bmi, size );
773 pDestInfo->bmiHeader.biWidth = width;
774 pDestInfo->bmiHeader.biHeight = height;
775 pDestInfo->bmiHeader.biSizeImage = 0;
776
777 /* Create the XOR bitmap */
778 if(pSrcInfo->bmiHeader.biBitCount == 32)
779 {
780 void *pDIBBuffer = NULL;
781 hXorBits = CreateDIBSection(screen_dc, pDestInfo, DIB_RGB_COLORS, &pDIBBuffer, NULL, 0);
782
783 if(hXorBits)
784 {
785 if (!stretch_blt_icon(hXorBits, pDestInfo, pSrcInfo, (char*)bmi + size))
786 {
787 DeleteObject(hXorBits);
788 hXorBits = 0;
789 }
790 }
791 }
792 else
793 {
794 hXorBits = CreateCompatibleBitmap(screen_dc, width, height);
795
796 if(hXorBits)
797 {
798 if(!stretch_blt_icon(hXorBits, pDestInfo, pSrcInfo, (char*)bmi + size))
799 {
800 DeleteObject(hXorBits);
801 hXorBits = 0;
802 }
803 }
804 }
805
806 if( hXorBits )
807 {
808 char* xbits = (char *)bmi + size +
809 get_dib_width_bytes( bmi->bmiHeader.biWidth,
810 bmi->bmiHeader.biBitCount ) * abs( bmi->bmiHeader.biHeight ) / 2;
811
812 pSrcInfo->bmiHeader.biBitCount = 1;
813 if (pSrcInfo->bmiHeader.biSize != sizeof(BITMAPCOREHEADER))
814 {
815 RGBQUAD *rgb = pSrcInfo->bmiColors;
816
817 pSrcInfo->bmiHeader.biClrUsed = pSrcInfo->bmiHeader.biClrImportant = 2;
818 rgb[0].rgbBlue = rgb[0].rgbGreen = rgb[0].rgbRed = 0x00;
819 rgb[1].rgbBlue = rgb[1].rgbGreen = rgb[1].rgbRed = 0xff;
820 rgb[0].rgbReserved = rgb[1].rgbReserved = 0;
821 }
822 else
823 {
824 RGBTRIPLE *rgb = (RGBTRIPLE *)(((BITMAPCOREHEADER *)pSrcInfo) + 1);
825
826 rgb[0].rgbtBlue = rgb[0].rgbtGreen = rgb[0].rgbtRed = 0x00;
827 rgb[1].rgbtBlue = rgb[1].rgbtGreen = rgb[1].rgbtRed = 0xff;
828 }
829
830 /* Create the AND bitmap */
831 hAndBits = CreateBitmap(width, height, 1, 1, NULL);
832
833 if(!stretch_blt_icon(hAndBits, pDestInfo, pSrcInfo, xbits))
834 {
835 DeleteObject(hAndBits);
836 hAndBits = 0;
837 }
838
839 if( !hAndBits )
840 {
841 DeleteObject( hXorBits );
842 hXorBits = 0;
843 }
844 }
845 }
846
847 HeapFree( GetProcessHeap(), 0, pSrcInfo );
848 HeapFree( GetProcessHeap(), 0, pDestInfo );
849 }
850
851 if( !hXorBits || !hAndBits )
852 {
853 WARN_(cursor)("\tunable to create an icon bitmap.\n");
854 return 0;
855 }
856
857 /* Now create the CURSORICONINFO structure */
858 GetObjectA( hXorBits, sizeof(bmpXor), &bmpXor );
859 GetObjectA( hAndBits, sizeof(bmpAnd), &bmpAnd );
860 sizeXor = bmpXor.bmHeight * bmpXor.bmWidthBytes;
861 sizeAnd = bmpAnd.bmHeight * bmpAnd.bmWidthBytes;
862
863 hObj = GlobalAlloc16( GMEM_MOVEABLE,
864 sizeof(CURSORICONINFO) + sizeXor + sizeAnd );
865 if (hObj)
866 {
867 CURSORICONINFO *info;
868
869 info = GlobalLock16( hObj );
870 info->ptHotSpot.x = hotspot.x;
871 info->ptHotSpot.y = hotspot.y;
872 info->nWidth = bmpXor.bmWidth;
873 info->nHeight = bmpXor.bmHeight;
874 info->nWidthBytes = bmpXor.bmWidthBytes;
875 info->bPlanes = bmpXor.bmPlanes;
876 info->bBitsPerPixel = bmpXor.bmBitsPixel;
877
878 /* Transfer the bitmap bits to the CURSORICONINFO structure */
879
880 GetBitmapBits( hAndBits, sizeAnd, info + 1 );
881 GetBitmapBits( hXorBits, sizeXor, (char *)(info + 1) + sizeAnd );
882 GlobalUnlock16( hObj );
883 }
884
885 DeleteObject( hAndBits );
886 DeleteObject( hXorBits );
887 return HICON_32(hObj);
888 }
889
890
891 /**********************************************************************
892 * .ANI cursor support
893 */
894 #define RIFF_FOURCC( c0, c1, c2, c3 ) \
895 ( (DWORD)(BYTE)(c0) | ( (DWORD)(BYTE)(c1) << 8 ) | \
896 ( (DWORD)(BYTE)(c2) << 16 ) | ( (DWORD)(BYTE)(c3) << 24 ) )
897
898 #define ANI_RIFF_ID RIFF_FOURCC('R', 'I', 'F', 'F')
899 #define ANI_LIST_ID RIFF_FOURCC('L', 'I', 'S', 'T')
900 #define ANI_ACON_ID RIFF_FOURCC('A', 'C', 'O', 'N')
901 #define ANI_anih_ID RIFF_FOURCC('a', 'n', 'i', 'h')
902 #define ANI_seq__ID RIFF_FOURCC('s', 'e', 'q', ' ')
903 #define ANI_fram_ID RIFF_FOURCC('f', 'r', 'a', 'm')
904
905 #define ANI_FLAG_ICON 0x1
906 #define ANI_FLAG_SEQUENCE 0x2
907
908 typedef struct {
909 DWORD header_size;
910 DWORD num_frames;
911 DWORD num_steps;
912 DWORD width;
913 DWORD height;
914 DWORD bpp;
915 DWORD num_planes;
916 DWORD display_rate;
917 DWORD flags;
918 } ani_header;
919
920 typedef struct {
921 DWORD data_size;
922 const unsigned char *data;
923 } riff_chunk_t;
924
925 static void dump_ani_header( const ani_header *header )
926 {
927 TRACE(" header size: %d\n", header->header_size);
928 TRACE(" frames: %d\n", header->num_frames);
929 TRACE(" steps: %d\n", header->num_steps);
930 TRACE(" width: %d\n", header->width);
931 TRACE(" height: %d\n", header->height);
932 TRACE(" bpp: %d\n", header->bpp);
933 TRACE(" planes: %d\n", header->num_planes);
934 TRACE(" display rate: %d\n", header->display_rate);
935 TRACE(" flags: 0x%08x\n", header->flags);
936 }
937
938
939 /*
940 * RIFF:
941 * DWORD "RIFF"
942 * DWORD size
943 * DWORD riff_id
944 * BYTE[] data
945 *
946 * LIST:
947 * DWORD "LIST"
948 * DWORD size
949 * DWORD list_id
950 * BYTE[] data
951 *
952 * CHUNK:
953 * DWORD chunk_id
954 * DWORD size
955 * BYTE[] data
956 */
957 static void riff_find_chunk( DWORD chunk_id, DWORD chunk_type, const riff_chunk_t *parent_chunk, riff_chunk_t *chunk )
958 {
959 const unsigned char *ptr = parent_chunk->data;
960 const unsigned char *end = parent_chunk->data + (parent_chunk->data_size - (2 * sizeof(DWORD)));
961
962 if (chunk_type == ANI_LIST_ID || chunk_type == ANI_RIFF_ID) end -= sizeof(DWORD);
963
964 while (ptr < end)
965 {
966 if ((!chunk_type && *(DWORD *)ptr == chunk_id )
967 || (chunk_type && *(DWORD *)ptr == chunk_type && *((DWORD *)ptr + 2) == chunk_id ))
968 {
969 ptr += sizeof(DWORD);
970 chunk->data_size = (*(DWORD *)ptr + 1) & ~1;
971 ptr += sizeof(DWORD);
972 if (chunk_type == ANI_LIST_ID || chunk_type == ANI_RIFF_ID) ptr += sizeof(DWORD);
973 chunk->data = ptr;
974
975 return;
976 }
977
978 ptr += sizeof(DWORD);
979 ptr += (*(DWORD *)ptr + 1) & ~1;
980 ptr += sizeof(DWORD);
981 }
982 }
983
984
985 /*
986 * .ANI layout:
987 *
988 * RIFF:'ACON' RIFF chunk
989 * |- CHUNK:'anih' Header
990 * |- CHUNK:'seq ' Sequence information (optional)
991 * \- LIST:'fram' Frame list
992 * |- CHUNK:icon Cursor frames
993 * |- CHUNK:icon
994 * |- ...
995 * \- CHUNK:icon
996 */
997 static HCURSOR CURSORICON_CreateIconFromANI( const LPBYTE bits, DWORD bits_size,
998 INT width, INT height, INT colors )
999 {
1000 HCURSOR cursor;
1001 ani_header header = {0};
1002 LPBYTE frame_bits = 0;
1003 POINT16 hotspot;
1004 CURSORICONFILEDIRENTRY *entry;
1005
1006 riff_chunk_t root_chunk = { bits_size, bits };
1007 riff_chunk_t ACON_chunk = {0};
1008 riff_chunk_t anih_chunk = {0};
1009 riff_chunk_t fram_chunk = {0};
1010 const unsigned char *icon_data;
1011
1012 TRACE("bits %p, bits_size %d\n", bits, bits_size);
1013
1014 if (!bits) return 0;
1015
1016 riff_find_chunk( ANI_ACON_ID, ANI_RIFF_ID, &root_chunk, &ACON_chunk );
1017 if (!ACON_chunk.data)
1018 {
1019 ERR("Failed to get root chunk.\n");
1020 return 0;
1021 }
1022
1023 riff_find_chunk( ANI_anih_ID, 0, &ACON_chunk, &anih_chunk );
1024 if (!anih_chunk.data)
1025 {
1026 ERR("Failed to get 'anih' chunk.\n");
1027 return 0;
1028 }
1029 memcpy( &header, anih_chunk.data, sizeof(header) );
1030 dump_ani_header( &header );
1031
1032 riff_find_chunk( ANI_fram_ID, ANI_LIST_ID, &ACON_chunk, &fram_chunk );
1033 if (!fram_chunk.data)
1034 {
1035 ERR("Failed to get icon list.\n");
1036 return 0;
1037 }
1038
1039 /* FIXME: For now, just load the first frame. Before we can load all the
1040 * frames, we need to write the needed code in wineserver, etc. to handle
1041 * cursors. Once this code is written, we can extend it to support .ani
1042 * cursors and then update user32 and winex11.drv to load all frames.
1043 *
1044 * Hopefully this will at least make some games (C&C3, etc.) more playable
1045 * in the meantime.
1046 */
1047 FIXME("Loading all frames for .ani cursors not implemented.\n");
1048 icon_data = fram_chunk.data + (2 * sizeof(DWORD));
1049
1050 entry = CURSORICON_FindBestIconFile( (CURSORICONFILEDIR *) icon_data,
1051 width, height, colors );
1052
1053 frame_bits = HeapAlloc( GetProcessHeap(), 0, entry->dwDIBSize );
1054 memcpy( frame_bits, icon_data + entry->dwDIBOffset, entry->dwDIBSize );
1055
1056 if (!header.width || !header.height)
1057 {
1058 header.width = entry->bWidth;
1059 header.height = entry->bHeight;
1060 }
1061
1062 hotspot.x = entry->xHotspot;
1063 hotspot.y = entry->yHotspot;
1064
1065 cursor = CURSORICON_CreateIconFromBMI( (BITMAPINFO *) frame_bits, hotspot,
1066 FALSE, 0x00030000, header.width, header.height, 0 );
1067
1068 HeapFree( GetProcessHeap(), 0, frame_bits );
1069
1070 return cursor;
1071 }
1072
1073
1074 /**********************************************************************
1075 * CreateIconFromResourceEx (USER32.@)
1076 *
1077 * FIXME: Convert to mono when cFlag is LR_MONOCHROME. Do something
1078 * with cbSize parameter as well.
1079 */
1080 HICON WINAPI CreateIconFromResourceEx( LPBYTE bits, UINT cbSize,
1081 BOOL bIcon, DWORD dwVersion,
1082 INT width, INT height,
1083 UINT cFlag )
1084 {
1085 POINT16 hotspot;
1086 BITMAPINFO *bmi;
1087
1088 hotspot.x = ICON_HOTSPOT;
1089 hotspot.y = ICON_HOTSPOT;
1090
1091 TRACE_(cursor)("%p (%u bytes), ver %08x, %ix%i %s %s\n",
1092 bits, cbSize, dwVersion, width, height,
1093 bIcon ? "icon" : "cursor", (cFlag & LR_MONOCHROME) ? "mono" : "" );
1094
1095 if (bIcon)
1096 bmi = (BITMAPINFO *)bits;
1097 else /* get the hotspot */
1098 {
1099 POINT16 *pt = (POINT16 *)bits;
1100 hotspot = *pt;
1101 bmi = (BITMAPINFO *)(pt + 1);
1102 }
1103
1104 return CURSORICON_CreateIconFromBMI( bmi, hotspot, bIcon, dwVersion,
1105 width, height, cFlag );
1106 }
1107
1108
1109 /**********************************************************************
1110 * CreateIconFromResource (USER32.@)
1111 */
1112 HICON WINAPI CreateIconFromResource( LPBYTE bits, UINT cbSize,
1113 BOOL bIcon, DWORD dwVersion)
1114 {
1115 return CreateIconFromResourceEx( bits, cbSize, bIcon, dwVersion, 0,0,0);
1116 }
1117
1118
1119 static HICON CURSORICON_LoadFromFile( LPCWSTR filename,
1120 INT width, INT height, INT colors,
1121 BOOL fCursor, UINT loadflags)
1122 {
1123 CURSORICONFILEDIRENTRY *entry;
1124 CURSORICONFILEDIR *dir;
1125 DWORD filesize = 0;
1126 HICON hIcon = 0;
1127 LPBYTE bits;
1128 POINT16 hotspot;
1129
1130 TRACE("loading %s\n", debugstr_w( filename ));
1131
1132 bits = map_fileW( filename, &filesize );
1133 if (!bits)
1134 return hIcon;
1135
1136 /* Check for .ani. */
1137 if (memcmp( bits, "RIFF", 4 ) == 0)
1138 {
1139 hIcon = CURSORICON_CreateIconFromANI( bits, filesize, width, height,
1140 colors );
1141 goto end;
1142 }
1143
1144 dir = (CURSORICONFILEDIR*) bits;
1145 if ( filesize < sizeof(*dir) )
1146 goto end;
1147
1148 if ( filesize < (sizeof(*dir) + sizeof(dir->idEntries[0])*(dir->idCount-1)) )
1149 goto end;
1150
1151 if ( fCursor )
1152 entry = CURSORICON_FindBestCursorFile( dir, width, height, colors );
1153 else
1154 entry = CURSORICON_FindBestIconFile( dir, width, height, colors );
1155
1156 if ( !entry )
1157 goto end;
1158
1159 /* check that we don't run off the end of the file */
1160 if ( entry->dwDIBOffset > filesize )
1161 goto end;
1162 if ( entry->dwDIBOffset + entry->dwDIBSize > filesize )
1163 goto end;
1164
1165 /* Set the actual hotspot for cursors and ICON_HOTSPOT for icons. */
1166 if ( fCursor )
1167 {
1168 hotspot.x = entry->xHotspot;
1169 hotspot.y = entry->yHotspot;
1170 }
1171 else
1172 {
1173 hotspot.x = ICON_HOTSPOT;
1174 hotspot.y = ICON_HOTSPOT;
1175 }
1176 hIcon = CURSORICON_CreateIconFromBMI( (BITMAPINFO *)&bits[entry->dwDIBOffset],
1177 hotspot, !fCursor, 0x00030000,
1178 width, height, loadflags );
1179 end:
1180 TRACE("loaded %s -> %p\n", debugstr_w( filename ), hIcon );
1181 UnmapViewOfFile( bits );
1182 return hIcon;
1183 }
1184
1185 /**********************************************************************
1186 * CURSORICON_Load
1187 *
1188 * Load a cursor or icon from resource or file.
1189 */
1190 static HICON CURSORICON_Load(HINSTANCE hInstance, LPCWSTR name,
1191 INT width, INT height, INT colors,
1192 BOOL fCursor, UINT loadflags)
1193 {
1194 HANDLE handle = 0;
1195 HICON hIcon = 0;
1196 HRSRC hRsrc, hGroupRsrc;
1197 CURSORICONDIR *dir;
1198 CURSORICONDIRENTRY *dirEntry;
1199 LPBYTE bits;
1200 WORD wResId;
1201 DWORD dwBytesInRes;
1202
1203 TRACE("%p, %s, %dx%d, colors %d, fCursor %d, flags 0x%04x\n",
1204 hInstance, debugstr_w(name), width, height, colors, fCursor, loadflags);
1205
1206 if ( loadflags & LR_LOADFROMFILE ) /* Load from file */
1207 return CURSORICON_LoadFromFile( name, width, height, colors, fCursor, loadflags );
1208
1209 if (!hInstance) hInstance = user32_module; /* Load OEM cursor/icon */
1210
1211 /* Normalize hInstance (must be uniquely represented for icon cache) */
1212
1213 if (!HIWORD( hInstance ))
1214 hInstance = HINSTANCE_32(GetExePtr( HINSTANCE_16(hInstance) ));
1215
1216 /* Get directory resource ID */
1217
1218 if (!(hRsrc = FindResourceW( hInstance, name,
1219 (LPWSTR)(fCursor ? RT_GROUP_CURSOR : RT_GROUP_ICON) )))
1220 return 0;
1221 hGroupRsrc = hRsrc;
1222
1223 /* Find the best entry in the directory */
1224
1225 if (!(handle = LoadResource( hInstance, hRsrc ))) return 0;
1226 if (!(dir = LockResource( handle ))) return 0;
1227 if (fCursor)
1228 dirEntry = CURSORICON_FindBestCursorRes( dir, width, height, colors );
1229 else
1230 dirEntry = CURSORICON_FindBestIconRes( dir, width, height, colors );
1231 if (!dirEntry) return 0;
1232 wResId = dirEntry->wResId;
1233 dwBytesInRes = dirEntry->dwBytesInRes;
1234 FreeResource( handle );
1235
1236 /* Load the resource */
1237
1238 if (!(hRsrc = FindResourceW(hInstance,MAKEINTRESOURCEW(wResId),
1239 (LPWSTR)(fCursor ? RT_CURSOR : RT_ICON) ))) return 0;
1240
1241 /* If shared icon, check whether it was already loaded */
1242 if ( (loadflags & LR_SHARED)
1243 && (hIcon = CURSORICON_FindSharedIcon( hInstance, hRsrc ) ) != 0 )
1244 return hIcon;
1245
1246 if (!(handle = LoadResource( hInstance, hRsrc ))) return 0;
1247 bits = LockResource( handle );
1248 hIcon = CreateIconFromResourceEx( bits, dwBytesInRes,
1249 !fCursor, 0x00030000, width, height, loadflags);
1250 FreeResource( handle );
1251
1252 /* If shared icon, add to icon cache */
1253
1254 if ( hIcon && (loadflags & LR_SHARED) )
1255 CURSORICON_AddSharedIcon( hInstance, hRsrc, hGroupRsrc, hIcon );
1256
1257 return hIcon;
1258 }
1259
1260 /***********************************************************************
1261 * CURSORICON_Copy
1262 *
1263 * Make a copy of a cursor or icon.
1264 */
1265 static HICON CURSORICON_Copy( HINSTANCE16 hInst16, HICON hIcon )
1266 {
1267 char *ptrOld, *ptrNew;
1268 int size;
1269 HICON16 hOld = HICON_16(hIcon);
1270 HICON16 hNew;
1271
1272 if (!(ptrOld = GlobalLock16( hOld ))) return 0;
1273 if (hInst16 && !(hInst16 = GetExePtr( hInst16 ))) return 0;
1274 size = GlobalSize16( hOld );
1275 hNew = GlobalAlloc16( GMEM_MOVEABLE, size );
1276 FarSetOwner16( hNew, hInst16 );
1277 ptrNew = GlobalLock16( hNew );
1278 memcpy( ptrNew, ptrOld, size );
1279 GlobalUnlock16( hOld );
1280 GlobalUnlock16( hNew );
1281 return HICON_32(hNew);
1282 }
1283
1284 /*************************************************************************
1285 * CURSORICON_ExtCopy
1286 *
1287 * Copies an Image from the Cache if LR_COPYFROMRESOURCE is specified
1288 *
1289 * PARAMS
1290 * Handle [I] handle to an Image
1291 * nType [I] Type of Handle (IMAGE_CURSOR | IMAGE_ICON)
1292 * iDesiredCX [I] The Desired width of the Image
1293 * iDesiredCY [I] The desired height of the Image
1294 * nFlags [I] The flags from CopyImage
1295 *
1296 * RETURNS
1297 * Success: The new handle of the Image
1298 *
1299 * NOTES
1300 * LR_COPYDELETEORG and LR_MONOCHROME are currently not implemented.
1301 * LR_MONOCHROME should be implemented by CreateIconFromResourceEx.
1302 * LR_COPYFROMRESOURCE will only work if the Image is in the Cache.
1303 *
1304 *
1305 */
1306
1307 static HICON CURSORICON_ExtCopy(HICON hIcon, UINT nType,
1308 INT iDesiredCX, INT iDesiredCY,
1309 UINT nFlags)
1310 {
1311 HICON hNew=0;
1312
1313 TRACE_(icon)("hIcon %p, nType %u, iDesiredCX %i, iDesiredCY %i, nFlags %u\n",
1314 hIcon, nType, iDesiredCX, iDesiredCY, nFlags);
1315
1316 if(hIcon == 0)
1317 {
1318 return 0;
1319 }
1320
1321 /* Best Fit or Monochrome */
1322 if( (nFlags & LR_COPYFROMRESOURCE
1323 && (iDesiredCX > 0 || iDesiredCY > 0))
1324 || nFlags & LR_MONOCHROME)
1325 {
1326 ICONCACHE* pIconCache = CURSORICON_FindCache(hIcon);
1327
1328 /* Not Found in Cache, then do a straight copy
1329 */
1330 if(pIconCache == NULL)
1331 {
1332 hNew = CURSORICON_Copy(0, hIcon);
1333 if(nFlags & LR_COPYFROMRESOURCE)
1334 {
1335 TRACE_(icon)("LR_COPYFROMRESOURCE: Failed to load from cache\n");
1336 }
1337 }
1338 else
1339 {
1340 int iTargetCY = iDesiredCY, iTargetCX = iDesiredCX;
1341 LPBYTE pBits;
1342 HANDLE hMem;
1343 HRSRC hRsrc;
1344 DWORD dwBytesInRes;
1345 WORD wResId;
1346 CURSORICONDIR *pDir;
1347 CURSORICONDIRENTRY *pDirEntry;
1348 BOOL bIsIcon = (nType == IMAGE_ICON);
1349
1350 /* Completing iDesiredCX CY for Monochrome Bitmaps if needed
1351 */
1352 if(((nFlags & LR_MONOCHROME) && !(nFlags & LR_COPYFROMRESOURCE))
1353 || (iDesiredCX == 0 && iDesiredCY == 0))
1354 {
1355 iDesiredCY = GetSystemMetrics(bIsIcon ?
1356 SM_CYICON : SM_CYCURSOR);
1357 iDesiredCX = GetSystemMetrics(bIsIcon ?
1358 SM_CXICON : SM_CXCURSOR);
1359 }
1360
1361 /* Retrieve the CURSORICONDIRENTRY
1362 */
1363 if (!(hMem = LoadResource( pIconCache->hModule ,
1364 pIconCache->hGroupRsrc)))
1365 {
1366 return 0;
1367 }
1368 if (!(pDir = LockResource( hMem )))
1369 {
1370 return 0;
1371 }
1372
1373 /* Find Best Fit
1374 */
1375 if(bIsIcon)
1376 {
1377 pDirEntry = CURSORICON_FindBestIconRes(
1378 pDir, iDesiredCX, iDesiredCY, 256 );
1379 }
1380 else
1381 {
1382 pDirEntry = CURSORICON_FindBestCursorRes(
1383 pDir, iDesiredCX, iDesiredCY, 1);
1384 }
1385
1386 wResId = pDirEntry->wResId;
1387 dwBytesInRes = pDirEntry->dwBytesInRes;
1388 FreeResource(hMem);
1389
1390 TRACE_(icon)("ResID %u, BytesInRes %u, Width %d, Height %d DX %d, DY %d\n",
1391 wResId, dwBytesInRes, pDirEntry->ResInfo.icon.bWidth,
1392 pDirEntry->ResInfo.icon.bHeight, iDesiredCX, iDesiredCY);
1393
1394 /* Get the Best Fit
1395 */
1396 if (!(hRsrc = FindResourceW(pIconCache->hModule ,
1397 MAKEINTRESOURCEW(wResId), (LPWSTR)(bIsIcon ? RT_ICON : RT_CURSOR))))
1398 {
1399 return 0;
1400 }
1401 if (!(hMem = LoadResource( pIconCache->hModule , hRsrc )))
1402 {
1403 return 0;
1404 }
1405
1406 pBits = LockResource( hMem );
1407
1408 if(nFlags & LR_DEFAULTSIZE)
1409 {
1410 iTargetCY = GetSystemMetrics(SM_CYICON);
1411 iTargetCX = GetSystemMetrics(SM_CXICON);
1412 }
1413
1414 /* Create a New Icon with the proper dimension
1415 */
1416 hNew = CreateIconFromResourceEx( pBits, dwBytesInRes,
1417 bIsIcon, 0x00030000, iTargetCX, iTargetCY, nFlags);
1418 FreeResource(hMem);
1419 }
1420 }
1421 else hNew = CURSORICON_Copy(0, hIcon);
1422 return hNew;
1423 }
1424
1425
1426 /***********************************************************************
1427 * CreateCursor (USER32.@)
1428 */
1429 HCURSOR WINAPI CreateCursor( HINSTANCE hInstance,
1430 INT xHotSpot, INT yHotSpot,
1431 INT nWidth, INT nHeight,
1432 LPCVOID lpANDbits, LPCVOID lpXORbits )
1433 {
1434 CURSORICONINFO info;
1435
1436 TRACE_(cursor)("%dx%d spot=%d,%d xor=%p and=%p\n",
1437 nWidth, nHeight, xHotSpot, yHotSpot, lpXORbits, lpANDbits);
1438
1439 info.ptHotSpot.x = xHotSpot;
1440 info.ptHotSpot.y = yHotSpot;
1441 info.nWidth = nWidth;
1442 info.nHeight = nHeight;
1443 info.nWidthBytes = 0;
1444 info.bPlanes = 1;
1445 info.bBitsPerPixel = 1;
1446
1447 return HICON_32(CreateCursorIconIndirect16(0, &info, lpANDbits, lpXORbits));
1448 }
1449
1450
1451 /***********************************************************************
1452 * CreateIcon (USER.407)
1453 */
1454 HICON16 WINAPI CreateIcon16( HINSTANCE16 hInstance, INT16 nWidth,
1455 INT16 nHeight, BYTE bPlanes, BYTE bBitsPixel,
1456 LPCVOID lpANDbits, LPCVOID lpXORbits )
1457 {
1458 CURSORICONINFO info;
1459
1460 TRACE_(icon)("%dx%dx%d, xor=%p, and=%p\n",
1461 nWidth, nHeight, bPlanes * bBitsPixel, lpXORbits, lpANDbits);
1462
1463 info.ptHotSpot.x = ICON_HOTSPOT;
1464 info.ptHotSpot.y = ICON_HOTSPOT;
1465 info.nWidth = nWidth;
1466 info.nHeight = nHeight;
1467 info.nWidthBytes = 0;
1468 info.bPlanes = bPlanes;
1469 info.bBitsPerPixel = bBitsPixel;
1470
1471 return CreateCursorIconIndirect16( hInstance, &info, lpANDbits, lpXORbits );
1472 }
1473
1474
1475 /***********************************************************************
1476 * CreateIcon (USER32.@)
1477 *
1478 * Creates an icon based on the specified bitmaps. The bitmaps must be
1479 * provided in a device dependent format and will be resized to
1480 * (SM_CXICON,SM_CYICON) and depth converted to match the screen's color
1481 * depth. The provided bitmaps must be top-down bitmaps.
1482 * Although Windows does not support 15bpp(*) this API must support it
1483 * for Winelib applications.
1484 *
1485 * (*) Windows does not support 15bpp but it supports the 555 RGB 16bpp
1486 * format!
1487 *
1488 * RETURNS
1489 * Success: handle to an icon
1490 * Failure: NULL
1491 *
1492 * FIXME: Do we need to resize the bitmaps?
1493 */
1494 HICON WINAPI CreateIcon(
1495 HINSTANCE hInstance, /* [in] the application's hInstance */
1496 INT nWidth, /* [in] the width of the provided bitmaps */
1497 INT nHeight, /* [in] the height of the provided bitmaps */
1498 BYTE bPlanes, /* [in] the number of planes in the provided bitmaps */
1499 BYTE bBitsPixel, /* [in] the number of bits per pixel of the lpXORbits bitmap */
1500 LPCVOID lpANDbits, /* [in] a monochrome bitmap representing the icon's mask */
1501 LPCVOID lpXORbits) /* [in] the icon's 'color' bitmap */
1502 {
1503 ICONINFO iinfo;
1504 HICON hIcon;
1505
1506 TRACE_(icon)("%dx%d, planes %d, bpp %d, xor %p, and %p\n",
1507 nWidth, nHeight, bPlanes, bBitsPixel, lpXORbits, lpANDbits);
1508
1509 iinfo.fIcon = TRUE;
1510 iinfo.xHotspot = ICON_HOTSPOT;
1511 iinfo.yHotspot = ICON_HOTSPOT;
1512 iinfo.hbmMask = CreateBitmap( nWidth, nHeight, 1, 1, lpANDbits );
1513 iinfo.hbmColor = CreateBitmap( nWidth, nHeight, bPlanes, bBitsPixel, lpXORbits );
1514
1515 hIcon = CreateIconIndirect( &iinfo );
1516
1517 DeleteObject( iinfo.hbmMask );
1518 DeleteObject( iinfo.hbmColor );
1519
1520 return hIcon;
1521 }
1522
1523
1524 /***********************************************************************
1525 * CreateCursorIconIndirect (USER.408)
1526 */
1527 HGLOBAL16 WINAPI CreateCursorIconIndirect16( HINSTANCE16 hInstance,
1528 CURSORICONINFO *info,
1529 LPCVOID lpANDbits,
1530 LPCVOID lpXORbits )
1531 {
1532 HGLOBAL16 handle;
1533 char *ptr;
1534 int sizeAnd, sizeXor;
1535
1536 hInstance = GetExePtr( hInstance ); /* Make it a module handle */
1537 if (!lpXORbits || !lpANDbits || info->bPlanes != 1) return 0;
1538 info->nWidthBytes = get_bitmap_width_bytes(info->nWidth,info->bBitsPerPixel);
1539 sizeXor = info->nHeight * info->nWidthBytes;
1540 sizeAnd = info->nHeight * get_bitmap_width_bytes( info->nWidth, 1 );
1541 if (!(handle = GlobalAlloc16( GMEM_MOVEABLE,
1542 sizeof(CURSORICONINFO) + sizeXor + sizeAnd)))
1543 return 0;
1544 FarSetOwner16( handle, hInstance );
1545 ptr = GlobalLock16( handle );
1546 memcpy( ptr, info, sizeof(*info) );
1547 memcpy( ptr + sizeof(CURSORICONINFO), lpANDbits, sizeAnd );
1548 memcpy( ptr + sizeof(CURSORICONINFO) + sizeAnd, lpXORbits, sizeXor );
1549 GlobalUnlock16( handle );
1550 return handle;
1551 }
1552
1553
1554 /***********************************************************************
1555 * CopyIcon (USER.368)
1556 */
1557 HICON16 WINAPI CopyIcon16( HINSTANCE16 hInstance, HICON16 hIcon )
1558 {
1559 TRACE_(icon)("%04x %04x\n", hInstance, hIcon );
1560 return HICON_16(CURSORICON_Copy(hInstance, HICON_32(hIcon)));
1561 }
1562
1563
1564 /***********************************************************************
1565 * CopyIcon (USER32.@)
1566 */
1567 HICON WINAPI CopyIcon( HICON hIcon )
1568 {
1569 TRACE_(icon)("%p\n", hIcon );
1570 return CURSORICON_Copy( 0, hIcon );
1571 }
1572
1573
1574 /***********************************************************************
1575 * CopyCursor (USER.369)
1576 */
1577 HCURSOR16 WINAPI CopyCursor16( HINSTANCE16 hInstance, HCURSOR16 hCursor )
1578 {
1579 TRACE_(cursor)("%04x %04x\n", hInstance, hCursor );
1580 return HICON_16(CURSORICON_Copy(hInstance, HCURSOR_32(hCursor)));
1581 }
1582
1583 /**********************************************************************
1584 * DestroyIcon32 (USER.610)
1585 *
1586 * This routine is actually exported from Win95 USER under the name
1587 * DestroyIcon32 ... The behaviour implemented here should mimic
1588 * the Win95 one exactly, especially the return values, which
1589 * depend on the setting of various flags.
1590 */
1591 WORD WINAPI DestroyIcon32( HGLOBAL16 handle, UINT16 flags )
1592 {
1593 WORD retv;
1594
1595 TRACE_(icon)("(%04x, %04x)\n", handle, flags );
1596
1597 /* Check whether destroying active cursor */
1598
1599 if ( get_user_thread_info()->cursor == HICON_32(handle) )
1600 {
1601 WARN_(cursor)("Destroying active cursor!\n" );
1602 return FALSE;
1603 }
1604
1605 /* Try shared cursor/icon first */
1606
1607 if ( !(flags & CID_NONSHARED) )
1608 {
1609 INT count = CURSORICON_DelSharedIcon(HICON_32(handle));
1610
1611 if ( count != -1 )
1612 return (flags & CID_WIN32)? TRUE : (count == 0);
1613
1614 /* FIXME: OEM cursors/icons should be recognized */
1615 }
1616
1617 /* Now assume non-shared cursor/icon */
1618
1619 retv = GlobalFree16( handle );
1620 return (flags & CID_RESOURCE)? retv : TRUE;
1621 }
1622
1623 /***********************************************************************
1624 * DestroyIcon (USER32.@)
1625 */
1626 BOOL WINAPI DestroyIcon( HICON hIcon )
1627 {
1628 return DestroyIcon32(HICON_16(hIcon), CID_WIN32);
1629 }
1630
1631
1632 /***********************************************************************
1633 * DestroyCursor (USER32.@)
1634 */
1635 BOOL WINAPI DestroyCursor( HCURSOR hCursor )
1636 {
1637 return DestroyIcon32(HCURSOR_16(hCursor), CID_WIN32);
1638 }
1639
1640 /***********************************************************************
1641 * bitmap_has_alpha_channel
1642 *
1643 * Analyses bits bitmap to determine if alpha data is present.
1644 *
1645 * PARAMS
1646 * bpp [I] The bits-per-pixel of the bitmap
1647 * bitmapBits [I] A pointer to the bitmap data
1648 * bitmapLength [I] The length of the bitmap in bytes
1649 *
1650 * RETURNS
1651 * TRUE if an alpha channel is discovered, FALSE
1652 *
1653 * NOTE
1654 * Windows' behaviour is that if the icon bitmap is 32-bit and at
1655 * least one pixel has a non-zero alpha, then the bitmap is a
1656 * treated as having an alpha channel transparentcy. Otherwise,
1657 * it's treated as being completely opaque.
1658 *
1659 */
1660 static BOOL bitmap_has_alpha_channel( int bpp, unsigned char *bitmapBits,
1661 unsigned int bitmapLength )
1662 {
1663 /* Detect an alpha channel by looking for non-zero alpha pixels */
1664 if(bpp == 32)
1665 {
1666 unsigned int offset;
1667 for(offset = 3; offset < bitmapLength; offset += 4)
1668 {
1669 if(bitmapBits[offset] != 0)
1670 {
1671 return TRUE;
1672 }
1673 }
1674 }
1675 return FALSE;
1676 }
1677
1678 /***********************************************************************
1679 * premultiply_alpha_channel
1680 *
1681 * Premultiplies the color channels of a 32-bit bitmap by the alpha
1682 * channel. This is a necessary step that must be carried out on
1683 * the image before it is passed to GdiAlphaBlend
1684 *
1685 * PARAMS
1686 * destBitmap [I] The destination bitmap buffer
1687 * srcBitmap [I] The source bitmap buffer
1688 * bitmapLength [I] The length of the bitmap in bytes
1689 *
1690 */
1691 static void premultiply_alpha_channel( unsigned char *destBitmap,
1692 unsigned char *srcBitmap,
1693 unsigned int bitmapLength )
1694 {
1695 unsigned char *destPixel = destBitmap;
1696 unsigned char *srcPixel = srcBitmap;
1697
1698 while(destPixel < destBitmap + bitmapLength)
1699 {
1700 unsigned char alpha = srcPixel[3];
1701 *(destPixel++) = *(srcPixel++) * alpha / 255;
1702 *(destPixel++) = *(srcPixel++) * alpha / 255;
1703 *(destPixel++) = *(srcPixel++) * alpha / 255;
1704 *(destPixel++) = *(srcPixel++);
1705 }
1706 }
1707
1708 /***********************************************************************
1709 * DrawIcon (USER32.@)
1710 */
1711 BOOL WINAPI DrawIcon( HDC hdc, INT x, INT y, HICON hIcon )
1712 {
1713 CURSORICONINFO *ptr;
1714 HDC hMemDC;
1715 HBITMAP hXorBits = NULL, hAndBits = NULL, hBitTemp = NULL;
1716 COLORREF oldFg, oldBg;
1717 unsigned char *xorBitmapBits;
1718 unsigned int dibLength;
1719
1720 TRACE("%p, (%d,%d), %p\n", hdc, x, y, hIcon);
1721
1722 if (!(ptr = GlobalLock16(HICON_16(hIcon)))) return FALSE;
1723 if (!(hMemDC = CreateCompatibleDC( hdc ))) return FALSE;
1724
1725 dibLength = ptr->nHeight * get_bitmap_width_bytes(
1726 ptr->nWidth, ptr->bBitsPerPixel);
1727
1728 xorBitmapBits = (unsigned char *)(ptr + 1) + ptr->nHeight *
1729 get_bitmap_width_bytes(ptr->nWidth, 1);
1730
1731 oldFg = SetTextColor( hdc, RGB(0,0,0) );
1732 oldBg = SetBkColor( hdc, RGB(255,255,255) );
1733
1734 if(bitmap_has_alpha_channel(ptr->bBitsPerPixel, xorBitmapBits, dibLength))
1735 {
1736 BITMAPINFOHEADER bmih;
1737 unsigned char *dibBits;
1738
1739 memset(&bmih, 0, sizeof(BITMAPINFOHEADER));
1740 bmih.biSize = sizeof(BITMAPINFOHEADER);
1741 bmih.biWidth = ptr->nWidth;
1742 bmih.biHeight = -ptr->nHeight;
1743 bmih.biPlanes = ptr->bPlanes;
1744 bmih.biBitCount = 32;
1745 bmih.biCompression = BI_RGB;
1746
1747 hXorBits = CreateDIBSection(hdc, (BITMAPINFO*)&bmih, DIB_RGB_COLORS,
1748 (void*)&dibBits, NULL, 0);
1749
1750 if (hXorBits && dibBits)
1751 {
1752 BLENDFUNCTION pixelblend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
1753
1754 /* Do the alpha blending render */
1755 premultiply_alpha_channel(dibBits, xorBitmapBits, dibLength);
1756 hBitTemp = SelectObject( hMemDC, hXorBits );
1757 /* Destination width/height has to be "System Large" size */
1758 GdiAlphaBlend(hdc, x, y, GetSystemMetrics(SM_CXICON),
1759 GetSystemMetrics(SM_CYICON), hMemDC,
1760 0, 0, ptr->nWidth, ptr->nHeight, pixelblend);
1761 SelectObject( hMemDC, hBitTemp );
1762 }
1763 }
1764 else
1765 {
1766 hAndBits = CreateBitmap( ptr->nWidth, ptr->nHeight, 1, 1, ptr + 1 );
1767 hXorBits = CreateBitmap( ptr->nWidth, ptr->nHeight, ptr->bPlanes,
1768 ptr->bBitsPerPixel, xorBitmapBits);
1769
1770 if (hXorBits && hAndBits)
1771 {
1772 hBitTemp = SelectObject( hMemDC, hAndBits );
1773 StretchBlt( hdc, x, y, GetSystemMetrics(SM_CXICON),
1774 GetSystemMetrics(SM_CYICON), hMemDC, 0, 0,
1775 ptr->nWidth, ptr->nHeight, SRCAND );
1776 SelectObject( hMemDC, hXorBits );
1777 StretchBlt( hdc, x, y, GetSystemMetrics(SM_CXICON),
1778 GetSystemMetrics(SM_CYICON), hMemDC, 0, 0,
1779 ptr->nWidth, ptr->nHeight, SRCINVERT );
1780 SelectObject( hMemDC, hBitTemp );
1781 }
1782 }
1783
1784 DeleteDC( hMemDC );
1785 if (hXorBits) DeleteObject( hXorBits );
1786 if (hAndBits) DeleteObject( hAndBits );
1787 GlobalUnlock16(HICON_16(hIcon));
1788 SetTextColor( hdc, oldFg );
1789 SetBkColor( hdc, oldBg );
1790 return TRUE;
1791 }
1792
1793 /***********************************************************************
1794 * DumpIcon (USER.459)
1795 */
1796 DWORD WINAPI DumpIcon16( SEGPTR pInfo, WORD *lpLen,
1797 SEGPTR *lpXorBits, SEGPTR *lpAndBits )
1798 {
1799 CURSORICONINFO *info = MapSL( pInfo );
1800 int sizeAnd, sizeXor;
1801
1802 if (!info) return 0;
1803 sizeXor = info->nHeight * info->nWidthBytes;
1804 sizeAnd = info->nHeight * get_bitmap_width_bytes( info->nWidth, 1 );
1805 if (lpAndBits) *lpAndBits = pInfo + sizeof(CURSORICONINFO);
1806 if (lpXorBits) *lpXorBits = pInfo + sizeof(CURSORICONINFO) + sizeAnd;
1807 if (lpLen) *lpLen = sizeof(CURSORICONINFO) + sizeAnd + sizeXor;
1808 return MAKELONG( sizeXor, sizeXor );
1809 }
1810
1811
1812 /***********************************************************************
1813 * SetCursor (USER32.@)
1814 *
1815 * Set the cursor shape.
1816 *
1817 * RETURNS
1818 * A handle to the previous cursor shape.
1819 */
1820 HCURSOR WINAPI DECLSPEC_HOTPATCH SetCursor( HCURSOR hCursor /* [in] Handle of cursor to show */ )
1821 {
1822 struct user_thread_info *thread_info = get_user_thread_info();
1823 HCURSOR hOldCursor;
1824
1825 if (hCursor == thread_info->cursor) return hCursor; /* No change */
1826 TRACE("%p\n", hCursor);
1827 hOldCursor = thread_info->cursor;
1828 thread_info->cursor = hCursor;
1829 /* Change the cursor shape only if it is visible */
1830 if (thread_info->cursor_count >= 0)
1831 {
1832 USER_Driver->pSetCursor(GlobalLock16(HCURSOR_16(hCursor)));
1833 GlobalUnlock16(HCURSOR_16(hCursor));
1834 }
1835 return hOldCursor;
1836 }
1837
1838 /***********************************************************************
1839 * ShowCursor (USER32.@)
1840 */
1841 INT WINAPI DECLSPEC_HOTPATCH ShowCursor( BOOL bShow )
1842 {
1843 struct user_thread_info *thread_info = get_user_thread_info();
1844
1845 TRACE("%d, count=%d\n", bShow, thread_info->cursor_count );
1846
1847 if (bShow)
1848 {
1849 if (++thread_info->cursor_count == 0) /* Show it */
1850 {
1851 USER_Driver->pSetCursor(GlobalLock16(HCURSOR_16(thread_info->cursor)));
1852 GlobalUnlock16(HCURSOR_16(thread_info->cursor));
1853 }
1854 }
1855 else
1856 {
1857 if (--thread_info->cursor_count == -1) /* Hide it */
1858 USER_Driver->pSetCursor( NULL );
1859 }
1860 return thread_info->cursor_count;
1861 }
1862
1863 /***********************************************************************
1864 * GetCursor (USER32.@)
1865 */
1866 HCURSOR WINAPI GetCursor(void)
1867 {
1868 return get_user_thread_info()->cursor;
1869 }
1870
1871
1872 /***********************************************************************
1873 * ClipCursor (USER32.@)
1874 */
1875 BOOL WINAPI DECLSPEC_HOTPATCH ClipCursor( const RECT *rect )
1876 {
1877 RECT virt;
1878
1879 SetRect( &virt, 0, 0, GetSystemMetrics( SM_CXVIRTUALSCREEN ),
1880 GetSystemMetrics( SM_CYVIRTUALSCREEN ) );
1881 OffsetRect( &virt, GetSystemMetrics( SM_XVIRTUALSCREEN ),
1882 GetSystemMetrics( SM_YVIRTUALSCREEN ) );
1883
1884 TRACE( "Clipping to: %s was: %s screen: %s\n", wine_dbgstr_rect(rect),
1885 wine_dbgstr_rect(&CURSOR_ClipRect), wine_dbgstr_rect(&virt) );
1886
1887 if (!IntersectRect( &CURSOR_ClipRect, &virt, rect ))
1888 CURSOR_ClipRect = virt;
1889
1890 USER_Driver->pClipCursor( rect );
1891 return TRUE;
1892 }
1893
1894
1895 /***********************************************************************
1896 * GetClipCursor (USER32.@)
1897 */
1898 BOOL WINAPI DECLSPEC_HOTPATCH GetClipCursor( RECT *rect )
1899 {
1900 /* If this is first time - initialize the rect */
1901 if (IsRectEmpty( &CURSOR_ClipRect )) ClipCursor( NULL );
1902
1903 return CopyRect( rect, &CURSOR_ClipRect );
1904 }
1905
1906
1907 /***********************************************************************
1908 * SetSystemCursor (USER32.@)
1909 */
1910 BOOL WINAPI SetSystemCursor(HCURSOR hcur, DWORD id)
1911 {
1912 FIXME("(%p,%08x),stub!\n", hcur, id);
1913 return TRUE;
1914 }
1915
1916
1917 /**********************************************************************
1918 * LookupIconIdFromDirectoryEx (USER.364)
1919 *
1920 * FIXME: exact parameter sizes
1921 */
1922 INT16 WINAPI LookupIconIdFromDirectoryEx16( LPBYTE dir, BOOL16 bIcon,
1923 INT16 width, INT16 height, UINT16 cFlag )
1924 {
1925 return LookupIconIdFromDirectoryEx( dir, bIcon, width, height, cFlag );
1926 }
1927
1928 /**********************************************************************
1929 * LookupIconIdFromDirectoryEx (USER32.@)
1930 */
1931 INT WINAPI LookupIconIdFromDirectoryEx( LPBYTE xdir, BOOL bIcon,
1932 INT width, INT height, UINT cFlag )
1933 {
1934 CURSORICONDIR *dir = (CURSORICONDIR*)xdir;
1935 UINT retVal = 0;
1936 if( dir && !dir->idReserved && (dir->idType & 3) )
1937 {
1938 CURSORICONDIRENTRY* entry;
1939 HDC hdc;
1940 UINT palEnts;
1941 int colors;
1942 hdc = GetDC(0);
1943 palEnts = GetSystemPaletteEntries(hdc, 0, 0, NULL);
1944 if (palEnts == 0)
1945 palEnts = 256;
1946 colors = (cFlag & LR_MONOCHROME) ? 2 : palEnts;
1947
1948 ReleaseDC(0, hdc);
1949
1950 if( bIcon )
1951 entry = CURSORICON_FindBestIconRes( dir, width, height, colors );
1952 else
1953 entry = CURSORICON_FindBestCursorRes( dir, width, height, colors );
1954
1955 if( entry ) retVal = entry->wResId;
1956 }
1957 else WARN_(cursor)("invalid resource directory\n");
1958 return retVal;
1959 }
1960
1961 /**********************************************************************
1962 * LookupIconIdFromDirectory (USER32.@)
1963 */
1964 INT WINAPI LookupIconIdFromDirectory( LPBYTE dir, BOOL bIcon )
1965 {
1966 return LookupIconIdFromDirectoryEx( dir, bIcon,
1967 bIcon ? GetSystemMetrics(SM_CXICON) : GetSystemMetrics(SM_CXCURSOR),
1968 bIcon ? GetSystemMetrics(SM_CYICON) : GetSystemMetrics(SM_CYCURSOR), bIcon ? 0 : LR_MONOCHROME );
1969 }
1970
1971 /**********************************************************************
1972 * GetIconID (USER.455)
1973 */
1974 WORD WINAPI GetIconID16( HGLOBAL16 hResource, DWORD resType )
1975 {
1976 LPBYTE lpDir = GlobalLock16(hResource);
1977
1978 TRACE_(cursor)("hRes=%04x, entries=%i\n",
1979 hResource, lpDir ? ((CURSORICONDIR*)lpDir)->idCount : 0);
1980
1981 switch(resType)
1982 {
1983 case RT_CURSOR:
1984 return (WORD)LookupIconIdFromDirectoryEx16( lpDir, FALSE,
1985 GetSystemMetrics(SM_CXCURSOR), GetSystemMetrics(SM_CYCURSOR), LR_MONOCHROME );
1986 case RT_ICON:
1987 return (WORD)LookupIconIdFromDirectoryEx16( lpDir, TRUE,
1988 GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), 0 );
1989 default:
1990 WARN_(cursor)("invalid res type %d\n", resType );
1991 }
1992 return 0;
1993 }
1994
1995 /**********************************************************************
1996 * LoadCursorIconHandler (USER.336)
1997 *
1998 * Supposed to load resources of Windows 2.x applications.
1999 */
2000 HGLOBAL16 WINAPI LoadCursorIconHandler16( HGLOBAL16 hResource, HMODULE16 hModule, HRSRC16 hRsrc )
2001 {
2002 FIXME_(cursor)("(%04x,%04x,%04x): old 2.x resources are not supported!\n",
2003 hResource, hModule, hRsrc);
2004 return 0;
2005 }
2006
2007 /**********************************************************************
2008 * LoadIconHandler (USER.456)
2009 */
2010 HICON16 WINAPI LoadIconHandler16( HGLOBAL16 hResource, BOOL16 bNew )
2011 {
2012 LPBYTE bits = LockResource16( hResource );
2013
2014 TRACE_(cursor)("hRes=%04x\n",hResource);
2015
2016 return HICON_16(CreateIconFromResourceEx( bits, 0, TRUE,
2017 bNew ? 0x00030000 : 0x00020000, 0, 0, LR_DEFAULTCOLOR));
2018 }
2019
2020 /***********************************************************************
2021 * LoadCursorW (USER32.@)
2022 */
2023 HCURSOR WINAPI LoadCursorW(HINSTANCE hInstance, LPCWSTR name)
2024 {
2025 TRACE("%p, %s\n", hInstance, debugstr_w(name));
2026
2027 return LoadImageW( hInstance, name, IMAGE_CURSOR, 0, 0,
2028 LR_SHARED | LR_DEFAULTSIZE );
2029 }
2030
2031 /***********************************************************************
2032 * LoadCursorA (USER32.@)
2033 */
2034 HCURSOR WINAPI LoadCursorA(HINSTANCE hInstance, LPCSTR name)
2035 {
2036 TRACE("%p, %s\n", hInstance, debugstr_a(name));
2037
2038 return LoadImageA( hInstance, name, IMAGE_CURSOR, 0, 0,
2039 LR_SHARED | LR_DEFAULTSIZE );
2040 }
2041
2042 /***********************************************************************
2043 * LoadCursorFromFileW (USER32.@)
2044 */
2045 HCURSOR WINAPI LoadCursorFromFileW (LPCWSTR name)
2046 {
2047 TRACE("%s\n", debugstr_w(name));
2048
2049 return LoadImageW( 0, name, IMAGE_CURSOR, 0, 0,
2050 LR_LOADFROMFILE | LR_DEFAULTSIZE );
2051 }
2052
2053 /***********************************************************************
2054 * LoadCursorFromFileA (USER32.@)
2055 */
2056 HCURSOR WINAPI LoadCursorFromFileA (LPCSTR name)
2057 {
2058 TRACE("%s\n", debugstr_a(name));
2059
2060 return LoadImageA( 0, name, IMAGE_CURSOR, 0, 0,
2061 LR_LOADFROMFILE | LR_DEFAULTSIZE );
2062 }
2063
2064 /***********************************************************************
2065 * LoadIconW (USER32.@)
2066 */
2067 HICON WINAPI LoadIconW(HINSTANCE hInstance, LPCWSTR name)
2068 {
2069 TRACE("%p, %s\n", hInstance, debugstr_w(name));
2070
2071 return LoadImageW( hInstance, name, IMAGE_ICON, 0, 0,
2072 LR_SHARED | LR_DEFAULTSIZE );
2073 }
2074
2075 /***********************************************************************
2076 * LoadIconA (USER32.@)
2077 */
2078 HICON WINAPI LoadIconA(HINSTANCE hInstance, LPCSTR name)
2079 {
2080 TRACE("%p, %s\n", hInstance, debugstr_a(name));
2081
2082 return LoadImageA( hInstance, name, IMAGE_ICON, 0, 0,
2083 LR_SHARED | LR_DEFAULTSIZE );
2084 }
2085
2086 /**********************************************************************
2087 * GetIconInfo (USER32.@)
2088 */
2089 BOOL WINAPI GetIconInfo(HICON hIcon, PICONINFO iconinfo)
2090 {
2091 CURSORICONINFO *ciconinfo;
2092 INT height;
2093
2094 ciconinfo = GlobalLock16(HICON_16(hIcon));
2095 if (!ciconinfo)
2096 return FALSE;
2097
2098 TRACE("%p => %dx%d, %d bpp\n", hIcon,
2099 ciconinfo->nWidth, ciconinfo->nHeight, ciconinfo->bBitsPerPixel);
2100
2101 if ( (ciconinfo->ptHotSpot.x == ICON_HOTSPOT) &&
2102 (ciconinfo->ptHotSpot.y == ICON_HOTSPOT) )
2103 {
2104 iconinfo->fIcon = TRUE;
2105 iconinfo->xHotspot = ciconinfo->nWidth / 2;
2106 iconinfo->yHotspot = ciconinfo->nHeight / 2;
2107 }
2108 else
2109 {
2110 iconinfo->fIcon = FALSE;
2111 iconinfo->xHotspot = ciconinfo->ptHotSpot.x;
2112 iconinfo->yHotspot = ciconinfo->ptHotSpot.y;
2113 }
2114
2115 height = ciconinfo->nHeight;
2116
2117 if (ciconinfo->bBitsPerPixel > 1)
2118 {
2119 iconinfo->hbmColor = CreateBitmap( ciconinfo->nWidth, ciconinfo->nHeight,
2120 ciconinfo->bPlanes, ciconinfo->bBitsPerPixel,
2121 (char *)(ciconinfo + 1)
2122 + ciconinfo->nHeight *
2123 get_bitmap_width_bytes (ciconinfo->nWidth,1) );
2124 }
2125 else
2126 {
2127 iconinfo->hbmColor = 0;
2128 height *= 2;
2129 }
2130
2131 iconinfo->hbmMask = CreateBitmap ( ciconinfo->nWidth, height,
2132 1, 1, ciconinfo + 1);
2133
2134 GlobalUnlock16(HICON_16(hIcon));
2135
2136 return TRUE;
2137 }
2138
2139 /**********************************************************************
2140 * CreateIconIndirect (USER32.@)
2141 */
2142 HICON WINAPI CreateIconIndirect(PICONINFO iconinfo)
2143 {
2144 DIBSECTION bmpXor;
2145 BITMAP bmpAnd;
2146 HICON16 hObj;
2147 int xor_objsize = 0, sizeXor = 0, sizeAnd, planes, bpp;
2148
2149 TRACE("color %p, mask %p, hotspot %ux%u, fIcon %d\n",
2150 iconinfo->hbmColor, iconinfo->hbmMask,
2151 iconinfo->xHotspot, iconinfo->yHotspot, iconinfo->fIcon);
2152
2153 if (!iconinfo->hbmMask) return 0;
2154
2155 planes = GetDeviceCaps( screen_dc, PLANES );
2156 bpp = GetDeviceCaps( screen_dc, BITSPIXEL );
2157
2158 if (iconinfo->hbmColor)
2159 {
2160 xor_objsize = GetObjectW( iconinfo->hbmColor, sizeof(bmpXor), &bmpXor );
2161 TRACE("color: width %d, height %d, width bytes %d, planes %u, bpp %u\n",
2162 bmpXor.dsBm.bmWidth, bmpXor.dsBm.bmHeight, bmpXor.dsBm.bmWidthBytes,
2163 bmpXor.dsBm.bmPlanes, bmpXor.dsBm.bmBitsPixel);
2164 /* we can use either depth 1 or screen depth for xor bitmap */
2165 if (bmpXor.dsBm.bmPlanes == 1 && bmpXor.dsBm.bmBitsPixel == 1) planes = bpp = 1;
2166 sizeXor = bmpXor.dsBm.bmHeight * planes * get_bitmap_width_bytes( bmpXor.dsBm.bmWidth, bpp );
2167 }
2168 GetObjectW( iconinfo->hbmMask, sizeof(bmpAnd), &bmpAnd );
2169 TRACE("mask: width %d, height %d, width bytes %d, planes %u, bpp %u\n",
2170 bmpAnd.bmWidth, bmpAnd.bmHeight, bmpAnd.bmWidthBytes,
2171 bmpAnd.bmPlanes, bmpAnd.bmBitsPixel);
2172
2173 sizeAnd = bmpAnd.bmHeight * get_bitmap_width_bytes(bmpAnd.bmWidth, 1);
2174
2175 hObj = GlobalAlloc16( GMEM_MOVEABLE,
2176 sizeof(CURSORICONINFO) + sizeXor + sizeAnd );
2177 if (hObj)
2178 {
2179 CURSORICONINFO *info;
2180
2181 info = GlobalLock16( hObj );
2182
2183 /* If we are creating an icon, the hotspot is unused */
2184 if (iconinfo->fIcon)
2185 {
2186 info->ptHotSpot.x = ICON_HOTSPOT;
2187 info->ptHotSpot.y = ICON_HOTSPOT;
2188 }
2189 else
2190 {
2191 info->ptHotSpot.x = iconinfo->xHotspot;
2192 info->ptHotSpot.y = iconinfo->yHotspot;
2193 }
2194
2195 if (iconinfo->hbmColor)
2196 {
2197 info->nWidth = bmpXor.dsBm.bmWidth;
2198 info->nHeight = bmpXor.dsBm.bmHeight;
2199 info->nWidthBytes = bmpXor.dsBm.bmWidthBytes;
2200 info->bPlanes = planes;
2201 info->bBitsPerPixel = bpp;
2202 }
2203 else
2204 {
2205 info->nWidth = bmpAnd.bmWidth;
2206 info->nHeight = bmpAnd.bmHeight / 2;
2207 info->nWidthBytes = get_bitmap_width_bytes(bmpAnd.bmWidth, 1);
2208 info->bPlanes = 1;
2209 info->bBitsPerPixel = 1;
2210 }
2211
2212 /* Transfer the bitmap bits to the CURSORICONINFO structure */
2213
2214 /* Some apps pass a color bitmap as a mask, convert it to b/w */
2215 if (bmpAnd.bmBitsPixel == 1)
2216 {
2217 GetBitmapBits( iconinfo->hbmMask, sizeAnd, info + 1 );
2218 }
2219 else
2220 {
2221 HDC hdc, hdc_mem;
2222 HBITMAP hbmp_old, hbmp_mem_old, hbmp_mono;
2223
2224 hdc = GetDC( 0 );
2225 hdc_mem = CreateCompatibleDC( hdc );
2226
2227 hbmp_mono = CreateBitmap( bmpAnd.bmWidth, bmpAnd.bmHeight, 1, 1, NULL );
2228
2229 hbmp_old = SelectObject( hdc, iconinfo->hbmMask );
2230 hbmp_mem_old = SelectObject( hdc_mem, hbmp_mono );
2231
2232 BitBlt( hdc_mem, 0, 0, bmpAnd.bmWidth, bmpAnd.bmHeight, hdc, 0, 0, SRCCOPY );
2233
2234 SelectObject( hdc, hbmp_old );
2235 SelectObject( hdc_mem, hbmp_mem_old );
2236
2237 DeleteDC( hdc_mem );
2238 ReleaseDC( 0, hdc );
2239
2240 GetBitmapBits( hbmp_mono, sizeAnd, info + 1 );
2241 DeleteObject( hbmp_mono );
2242 }
2243
2244 if (iconinfo->hbmColor)
2245 {
2246 char *dst_bits = (char*)(info + 1) + sizeAnd;
2247
2248 if (bmpXor.dsBm.bmPlanes == planes && bmpXor.dsBm.bmBitsPixel == bpp)
2249 GetBitmapBits( iconinfo->hbmColor, sizeXor, dst_bits );
2250 else
2251 {
2252 BITMAPINFO bminfo;
2253 int dib_width = get_dib_width_bytes( info->nWidth, info->bBitsPerPixel );
2254 int bitmap_width = get_bitmap_width_bytes( info->nWidth, info->bBitsPerPixel );
2255
2256 bminfo.bmiHeader.biSize = sizeof(bminfo);
2257 bminfo.bmiHeader.biWidth = info->nWidth;
2258 bminfo.bmiHeader.biHeight = info->nHeight;
2259 bminfo.bmiHeader.biPlanes = info->bPlanes;
2260 bminfo.bmiHeader.biBitCount = info->bBitsPerPixel;
2261 bminfo.bmiHeader.biCompression = BI_RGB;
2262 bminfo.bmiHeader.biSizeImage = info->nHeight * dib_width;
2263 bminfo.bmiHeader.biXPelsPerMeter = 0;
2264 bminfo.bmiHeader.biYPelsPerMeter = 0;
2265 bminfo.bmiHeader.biClrUsed = 0;
2266 bminfo.bmiHeader.biClrImportant = 0;
2267
2268 /* swap lines for dib sections */
2269 if (xor_objsize == sizeof(DIBSECTION))
2270 bminfo.bmiHeader.biHeight = -bminfo.bmiHeader.biHeight;
2271
2272 if (dib_width != bitmap_width) /* need to fixup alignment */
2273 {
2274 char *src_bits = HeapAlloc( GetProcessHeap(), 0, bminfo.bmiHeader.biSizeImage );
2275
2276 if (src_bits && GetDIBits( screen_dc, iconinfo->hbmColor, 0, info->nHeight,
2277 src_bits, &bminfo, DIB_RGB_COLORS ))
2278 {
2279 int y;
2280 for (y = 0; y < info->nHeight; y++)
2281 memcpy( dst_bits + y * bitmap_width, src_bits + y * dib_width, bitmap_width );
2282 }
2283 HeapFree( GetProcessHeap(), 0, src_bits );
2284 }
2285 else
2286 GetDIBits( screen_dc, iconinfo->hbmColor, 0, info->nHeight,
2287 dst_bits, &bminfo, DIB_RGB_COLORS );
2288 }
2289 }
2290 GlobalUnlock16( hObj );
2291 }
2292 return HICON_32(hObj);
2293 }
2294
2295 /******************************************************************************
2296 * DrawIconEx (USER32.@) Draws an icon or cursor on device context
2297 *
2298 * NOTES
2299 * Why is this using SM_CXICON instead of SM_CXCURSOR?
2300 *
2301 * PARAMS
2302 * hdc [I] Handle to device context
2303 * x0 [I] X coordinate of upper left corner
2304 * y0 [I] Y coordinate of upper left corner
2305 * hIcon [I] Handle to icon to draw
2306 * cxWidth [I] Width of icon
2307 * cyWidth [I] Height of icon
2308 * istep [I] Index of frame in animated cursor
2309 * hbr [I] Handle to background brush
2310 * flags [I] Icon-drawing flags
2311 *
2312 * RETURNS
2313 * Success: TRUE
2314 * Failure: FALSE
2315 */
2316 BOOL WINAPI DrawIconEx( HDC hdc, INT x0, INT y0, HICON hIcon,
2317 INT cxWidth, INT cyWidth, UINT istep,
2318 HBRUSH hbr, UINT flags )
2319 {
2320 CURSORICONINFO *ptr;
2321 HDC hDC_off = 0, hMemDC;
2322 BOOL result = FALSE, DoOffscreen;
2323 HBITMAP hB_off = 0, hOld = 0;
2324 unsigned char *xorBitmapBits;
2325 unsigned int xorLength;
2326 BOOL has_alpha = FALSE;
2327
2328 TRACE_(icon)("(hdc=%p,pos=%d.%d,hicon=%p,extend=%d.%d,istep=%d,br=%p,flags=0x%08x)\n",
2329 hdc,x0,y0,hIcon,cxWidth,cyWidth,istep,hbr,flags );
2330
2331 if (!(ptr = GlobalLock16(HICON_16(hIcon)))) return FALSE;
2332 if (!(hMemDC = CreateCompatibleDC( hdc ))) return FALSE;
2333
2334 if (istep)
2335 FIXME_(icon)("Ignoring istep=%d\n", istep);
2336 if (flags & DI_NOMIRROR)
2337 FIXME_(icon)("Ignoring flag DI_NOMIRROR\n");
2338
2339 xorLength = ptr->nHeight * get_bitmap_width_bytes(
2340 ptr->nWidth, ptr->bBitsPerPixel);
2341 xorBitmapBits = (unsigned char *)(ptr + 1) + ptr->nHeight *
2342 get_bitmap_width_bytes(ptr->nWidth, 1);
2343
2344 if (flags & DI_IMAGE)
2345 has_alpha = bitmap_has_alpha_channel(
2346 ptr->bBitsPerPixel, xorBitmapBits, xorLength);
2347
2348 /* Calculate the size of the destination image. */
2349 if (cxWidth == 0)
2350 {
2351 if (flags & DI_DEFAULTSIZE)
2352 cxWidth = GetSystemMetrics (SM_CXICON);
2353 else
2354 cxWidth = ptr->nWidth;
2355 }
2356 if (cyWidth == 0)
2357 {
2358 if (flags & DI_DEFAULTSIZE)
2359 cyWidth = GetSystemMetrics (SM_CYICON);
2360 else
2361 cyWidth = ptr->nHeight;
2362 }
2363
2364 DoOffscreen = (GetObjectType( hbr ) == OBJ_BRUSH);
2365
2366 if (DoOffscreen) {
2367 RECT r;
2368
2369 r.left = 0;
2370 r.top = 0;
2371 r.right = cxWidth;
2372 r.bottom = cxWidth;
2373
2374 hDC_off = CreateCompatibleDC(hdc);
2375 hB_off = CreateCompatibleBitmap(hdc, cxWidth, cyWidth);
2376 if (hDC_off && hB_off) {
2377 hOld = SelectObject(hDC_off, hB_off);
2378 FillRect(hDC_off, &r, hbr);
2379 }
2380 }
2381
2382 if (hMemDC && (!DoOffscreen || (hDC_off && hB_off)))
2383 {
2384 HBITMAP hBitTemp;
2385 HBITMAP hXorBits = NULL, hAndBits = NULL;
2386 COLORREF oldFg, oldBg;
2387 INT nStretchMode;
2388
2389 nStretchMode = SetStretchBltMode (hdc, STRETCH_DELETESCANS);
2390
2391 oldFg = SetTextColor( hdc, RGB(0,0,0) );
2392 oldBg = SetBkColor( hdc, RGB(255,255,255) );
2393
2394 if (((flags & DI_MASK) && !(flags & DI_IMAGE)) ||
2395 ((flags & DI_MASK) && !has_alpha))
2396 {
2397 hAndBits = CreateBitmap ( ptr->nWidth, ptr->nHeight, 1, 1, ptr + 1 );
2398 if (hAndBits)
2399 {
2400 hBitTemp = SelectObject( hMemDC, hAndBits );
2401 if (DoOffscreen)
2402 StretchBlt (hDC_off, 0, 0, cxWidth, cyWidth,
2403 hMemDC, 0, 0, ptr->nWidth, ptr->nHeight, SRCAND);
2404 else
2405 StretchBlt (hdc, x0, y0, cxWidth, cyWidth,
2406 hMemDC, 0, 0, ptr->nWidth, ptr->nHeight, SRCAND);
2407 SelectObject( hMemDC, hBitTemp );
2408 }
2409 }
2410
2411 if (flags & DI_IMAGE)
2412 {
2413 BITMAPINFOHEADER bmih;
2414 unsigned char *dibBits;
2415
2416 memset(&bmih, 0, sizeof(BITMAPINFOHEADER));
2417 bmih.biSize = sizeof(BITMAPINFOHEADER);
2418 bmih.biWidth = ptr->nWidth;
2419 bmih.biHeight = -ptr->nHeight;
2420 bmih.biPlanes = ptr->bPlanes;
2421 bmih.biBitCount = ptr->bBitsPerPixel;
2422 bmih.biCompression = BI_RGB;
2423
2424 hXorBits = CreateDIBSection(hdc, (BITMAPINFO*)&bmih, DIB_RGB_COLORS,
2425 (void*)&dibBits, NULL, 0);
2426
2427 if (hXorBits && dibBits)
2428 {
2429 if(has_alpha)
2430 {
2431 BLENDFUNCTION pixelblend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
2432
2433 /* Do the alpha blending render */
2434 premultiply_alpha_channel(dibBits, xorBitmapBits, xorLength);
2435 hBitTemp = SelectObject( hMemDC, hXorBits );
2436
2437 if (DoOffscreen)
2438 GdiAlphaBlend(hDC_off, 0, 0, cxWidth, cyWidth, hMemDC,
2439 0, 0, ptr->nWidth, ptr->nHeight, pixelblend);
2440 else
2441 GdiAlphaBlend(hdc, x0, y0, cxWidth, cyWidth, hMemDC,
2442 0, 0, ptr->nWidth, ptr->nHeight, pixelblend);
2443
2444 SelectObject( hMemDC, hBitTemp );
2445 }
2446 else
2447 {
2448 memcpy(dibBits, xorBitmapBits, xorLength);
2449 hBitTemp = SelectObject( hMemDC, hXorBits );
2450 if (DoOffscreen)
2451 StretchBlt (hDC_off, 0, 0, cxWidth, cyWidth,
2452 hMemDC, 0, 0, ptr->nWidth, ptr->nHeight, SRCPAINT);
2453 else
2454 StretchBlt (hdc, x0, y0, cxWidth, cyWidth,
2455 hMemDC, 0, 0, ptr->nWidth, ptr->nHeight, SRCPAINT);
2456 SelectObject( hMemDC, hBitTemp );
2457 }
2458
2459 DeleteObject( hXorBits );
2460 }
2461 }
2462
2463 result = TRUE;
2464
2465 SetTextColor( hdc, oldFg );
2466 SetBkColor( hdc, oldBg );
2467
2468 if (hAndBits) DeleteObject( hAndBits );
2469 SetStretchBltMode (hdc, nStretchMode);
2470 if (DoOffscreen) {
2471 BitBlt(hdc, x0, y0, cxWidth, cyWidth, hDC_off, 0, 0, SRCCOPY);
2472 SelectObject(hDC_off, hOld);
2473 }
2474 }
2475 if (hMemDC) DeleteDC( hMemDC );
2476 if (hDC_off) DeleteDC(hDC_off);
2477 if (hB_off) DeleteObject(hB_off);
2478 GlobalUnlock16(HICON_16(hIcon));
2479 return result;
2480 }
2481
2482 /***********************************************************************
2483 * DIB_FixColorsToLoadflags
2484 *
2485 * Change color table entries when LR_LOADTRANSPARENT or LR_LOADMAP3DCOLORS
2486 * are in loadflags
2487 */
2488 static void DIB_FixColorsToLoadflags(BITMAPINFO * bmi, UINT loadflags, BYTE pix)
2489 {
2490 int colors;
2491 COLORREF c_W, c_S, c_F, c_L, c_C;
2492 int incr,i;
2493 RGBQUAD *ptr;
2494 int bitmap_type;
2495 LONG width;
2496 LONG height;
2497 WORD bpp;
2498 DWORD compr;
2499
2500 if (((bitmap_type = DIB_GetBitmapInfo((BITMAPINFOHEADER*) bmi, &width, &height, &bpp, &compr)) == -1))
2501 {
2502 WARN_(resource)("Invalid bitmap\n");
2503 return;
2504 }
2505
2506 if (bpp > 8) return;
2507
2508 if (bitmap_type == 0) /* BITMAPCOREHEADER */
2509 {
2510 incr = 3;
2511 colors = 1 << bpp;
2512 }
2513 else
2514 {
2515 incr = 4;
2516 colors = bmi->bmiHeader.biClrUsed;
2517 if (colors > 256) colors = 256;
2518 if (!colors && (bpp <= 8)) colors = 1 << bpp;
2519 }
2520
2521 c_W = GetSysColor(COLOR_WINDOW);
2522 c_S = GetSysColor(COLOR_3DSHADOW);
2523 c_F = GetSysColor(COLOR_3DFACE);
2524 c_L = GetSysColor(COLOR_3DLIGHT);
2525
2526 if (loadflags & LR_LOADTRANSPARENT) {
2527 switch (bpp) {
2528 case 1: pix = pix >> 7; break;
2529 case 4: pix = pix >> 4; break;
2530 case 8: break;
2531 default:
2532 WARN_(resource)("(%d): Unsupported depth\n", bpp);
2533 return;
2534 }
2535 if (pix >= colors) {
2536 WARN_(resource)("pixel has color index greater than biClrUsed!\n");
2537 return;
2538 }
2539 if (loadflags & LR_LOADMAP3DCOLORS) c_W = c_F;
2540 ptr = (RGBQUAD*)((char*)bmi->bmiColors+pix*incr);
2541 ptr->rgbBlue = GetBValue(c_W);
2542 ptr->rgbGreen = GetGValue(c_W);
2543 ptr->rgbRed = GetRValue(c_W);
2544 }
2545 if (loadflags & LR_LOADMAP3DCOLORS)
2546 for (i=0; i<colors; i++) {
2547 ptr = (RGBQUAD*)((char*)bmi->bmiColors+i*incr);
2548 c_C = RGB(ptr->rgbRed, ptr->rgbGreen, ptr->rgbBlue);
2549 if (c_C == RGB(128, 128, 128)) {
2550 ptr->rgbRed = GetRValue(c_S);
2551 ptr->rgbGreen = GetGValue(c_S);
2552 ptr->rgbBlue = GetBValue(c_S);
2553 } else if (c_C == RGB(192, 192, 192)) {
2554 ptr->rgbRed = GetRValue(c_F);
2555 ptr->rgbGreen = GetGValue(c_F);
2556 ptr->rgbBlue = GetBValue(c_F);
2557 } else if (c_C == RGB(223, 223, 223)) {
2558 ptr->rgbRed = GetRValue(c_L);
2559 ptr->rgbGreen = GetGValue(c_L);
2560 ptr->rgbBlue = GetBValue(c_L);
2561 }
2562 }
2563 }
2564
2565
2566 /**********************************************************************
2567 * BITMAP_Load
2568 */
2569 static HBITMAP BITMAP_Load( HINSTANCE instance, LPCWSTR name,
2570 INT desiredx, INT desiredy, UINT loadflags )
2571 {
2572 HBITMAP hbitmap = 0, orig_bm;
2573 HRSRC hRsrc;
2574 HGLOBAL handle;
2575 char *ptr = NULL;
2576 BITMAPINFO *info, *fix_info = NULL, *scaled_info = NULL;
2577 int size;
2578 BYTE pix;
2579 char *bits;
2580 LONG width, height, new_width, new_height;
2581 WORD bpp_dummy;
2582 DWORD compr_dummy;
2583 INT bm_type;
2584 HDC screen_mem_dc = NULL;
2585
2586 if (!(loadflags & LR_LOADFROMFILE))
2587 {
2588 if (!instance)
2589 {
2590 /* OEM bitmap: try to load the resource from user32.dll */
2591 instance = user32_module;
2592 }
2593
2594 if (!(hRsrc = FindResourceW( instance, name, (LPWSTR)RT_BITMAP ))) return 0;
2595 if (!(handle = LoadResource( instance, hRsrc ))) return 0;
2596
2597 if ((info = LockResource( handle )) == NULL) return 0;
2598 }
2599 else
2600 {
2601 BITMAPFILEHEADER * bmfh;
2602
2603 if (!(ptr = map_fileW( name, NULL ))) return 0;
2604 info = (BITMAPINFO *)(ptr + sizeof(BITMAPFILEHEADER));
2605 bmfh = (BITMAPFILEHEADER *)ptr;
2606 if (!( bmfh->bfType == 0x4d42 /* 'BM' */ &&
2607 bmfh->bfReserved1 == 0 &&
2608 bmfh->bfReserved2 == 0))
2609 {
2610 WARN("Invalid/unsupported bitmap format!\n");
2611 UnmapViewOfFile( ptr );
2612 return 0;
2613 }
2614 }
2615
2616 size = bitmap_info_size(info, DIB_RGB_COLORS);
2617 fix_info = HeapAlloc(GetProcessHeap(), 0, size);
2618 scaled_info = HeapAlloc(GetProcessHeap(), 0, size);
2619
2620 if (!fix_info || !scaled_info) goto end;
2621 memcpy(fix_info, info, size);
2622
2623 pix = *((LPBYTE)info + size);
2624 DIB_FixColorsToLoadflags(fix_info, loadflags, pix);
2625
2626 memcpy(scaled_info, fix_info, size);
2627 bm_type = DIB_GetBitmapInfo( &fix_info->bmiHeader, &width, &height,
2628 &bpp_dummy, &compr_dummy);
2629 if(desiredx != 0)
2630 new_width = desiredx;
2631 else
2632 new_width = width;
2633
2634 if(desiredy != 0)
2635 new_height = height > 0 ? desiredy : -desiredy;
2636 else
2637 new_height = height;
2638
2639 if(bm_type == 0)
2640 {
2641 BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)&scaled_info->bmiHeader;
2642 core->bcWidth = new_width;
2643 core->bcHeight = new_height;
2644 }
2645 else
2646 {
2647 scaled_info->bmiHeader.biWidth = new_width;
2648 scaled_info->bmiHeader.biHeight = new_height;
2649 }
2650
2651 if (new_height < 0) new_height = -new_height;
2652
2653 if (!screen_dc) screen_dc = CreateDCW( DISPLAYW, NULL, NULL, NULL );
2654 if (!(screen_mem_dc = CreateCompatibleDC( screen_dc ))) goto end;
2655
2656 bits = (char *)info + size;
2657
2658 if (loadflags & LR_CREATEDIBSECTION)
2659 {
2660 scaled_info->bmiHeader.biCompression = 0; /* DIBSection can't be compressed */
2661 hbitmap = CreateDIBSection(screen_dc, scaled_info, DIB_RGB_COLORS, NULL, 0, 0);
2662 }
2663 else
2664 {
2665 if (is_dib_monochrome(fix_info))
2666 hbitmap = CreateBitmap(new_width, new_height, 1, 1, NULL);
2667 else
2668 hbitmap = CreateCompatibleBitmap(screen_dc, new_width, new_height);
2669 }
2670
2671 orig_bm = SelectObject(screen_mem_dc, hbitmap);
2672 StretchDIBits(screen_mem_dc, 0, 0, new_width, new_height, 0, 0, width, height, bits, fix_info, DIB_RGB_COLORS, SRCCOPY);
2673 SelectObject(screen_mem_dc, orig_bm);
2674
2675 end:
2676 if (screen_mem_dc) DeleteDC(screen_mem_dc);
2677 HeapFree(GetProcessHeap(), 0, scaled_info);
2678 HeapFree(GetProcessHeap(), 0, fix_info);
2679 if (loadflags & LR_LOADFROMFILE) UnmapViewOfFile( ptr );
2680
2681 return hbitmap;
2682 }
2683
2684 /**********************************************************************
2685 * LoadImageA (USER32.@)
2686 *
2687 * See LoadImageW.
2688 */
2689 HANDLE WINAPI LoadImageA( HINSTANCE hinst, LPCSTR name, UINT type,
2690 INT desiredx, INT desiredy, UINT loadflags)
2691 {
2692 HANDLE res;
2693 LPWSTR u_name;
2694
2695 if (!HIWORD(name))
2696 return LoadImageW(hinst, (LPCWSTR)name, type, desiredx, desiredy, loadflags);
2697
2698 __TRY {
2699 DWORD len = MultiByteToWideChar( CP_ACP, 0, name, -1, NULL, 0 );
2700 u_name = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
2701 MultiByteToWideChar( CP_ACP, 0, name, -1, u_name, len );
2702 }
2703 __EXCEPT_PAGE_FAULT {
2704 SetLastError( ERROR_INVALID_PARAMETER );
2705 return 0;
2706 }
2707 __ENDTRY
2708 res = LoadImageW(hinst, u_name, type, desiredx, desiredy, loadflags);
2709 HeapFree(GetProcessHeap(), 0, u_name);
2710 return res;
2711 }
2712
2713
2714 /******************************************************************************
2715 * LoadImageW (USER32.@) Loads an icon, cursor, or bitmap
2716 *
2717 * PARAMS
2718 * hinst [I] Handle of instance that contains image
2719 * name [I] Name of image
2720 * type [I] Type of image
2721 * desiredx [I] Desired width
2722 * desiredy [I] Desired height
2723 * loadflags [I] Load flags
2724 *
2725 * RETURNS
2726 * Success: Handle to newly loaded image
2727 * Failure: NULL
2728 *
2729 * FIXME: Implementation lacks some features, see LR_ defines in winuser.h
2730 */
2731 HANDLE WINAPI LoadImageW( HINSTANCE hinst, LPCWSTR name, UINT type,
2732 INT desiredx, INT desiredy, UINT loadflags )
2733 {
2734 TRACE_(resource)("(%p,%s,%d,%d,%d,0x%08x)\n",
2735 hinst,debugstr_w(name),type,desiredx,desiredy,loadflags);
2736
2737 if (loadflags & LR_DEFAULTSIZE) {
2738 if (type == IMAGE_ICON) {
2739 if (!desiredx) desiredx = GetSystemMetrics(SM_CXICON);
2740 if (!desiredy) desiredy = GetSystemMetrics(SM_CYICON);
2741 } else if (type == IMAGE_CURSOR) {
2742 if (!desiredx) desiredx = GetSystemMetrics(SM_CXCURSOR);
2743 if (!desiredy) desiredy = GetSystemMetrics(SM_CYCURSOR);
2744 }
2745 }
2746 if (loadflags & LR_LOADFROMFILE) loadflags &= ~LR_SHARED;
2747 switch (type) {
2748 case IMAGE_BITMAP:
2749 return BITMAP_Load( hinst, name, desiredx, desiredy, loadflags );
2750
2751 case IMAGE_ICON:
2752 if (!screen_dc) screen_dc = CreateDCW( DISPLAYW, NULL, NULL, NULL );
2753 if (screen_dc)
2754 {
2755 UINT palEnts = GetSystemPaletteEntries(screen_dc, 0, 0, NULL);
2756 if (palEnts == 0) palEnts = 256;
2757 return CURSORICON_Load(hinst, name, desiredx, desiredy,
2758 palEnts, FALSE, loadflags);
2759 }
2760 break;
2761
2762 case IMAGE_CURSOR:
2763 return CURSORICON_Load(hinst, name, desiredx, desiredy,
2764 1, TRUE, loadflags);
2765 }
2766 return 0;
2767 }
2768
2769 /******************************************************************************
2770 * CopyImage (USER32.@) Creates new image and copies attributes to it
2771 *
2772 * PARAMS
2773 * hnd [I] Handle to image to copy
2774 * type [I] Type of image to copy
2775 * desiredx [I] Desired width of new image
2776 * desiredy [I] Desired height of new image
2777 * flags [I] Copy flags
2778 *
2779 * RETURNS
2780 * Success: Handle to newly created image
2781 * Failure: NULL
2782 *
2783 * BUGS
2784 * Only Windows NT 4.0 supports the LR_COPYRETURNORG flag for bitmaps,
2785 * all other versions (95/2000/XP have been tested) ignore it.
2786 *
2787 * NOTES
2788 * If LR_CREATEDIBSECTION is absent, the copy will be monochrome for
2789 * a monochrome source bitmap or if LR_MONOCHROME is present, otherwise
2790 * the copy will have the same depth as the screen.
2791 * The content of the image will only be copied if the bit depth of the
2792 * original image is compatible with the bit depth of the screen, or
2793 * if the source is a DIB section.
2794 * The LR_MONOCHROME flag is ignored if LR_CREATEDIBSECTION is present.
2795 */
2796 HANDLE WINAPI CopyImage( HANDLE hnd, UINT type, INT desiredx,
2797 INT desiredy, UINT flags )
2798 {
2799 TRACE("hnd=%p, type=%u, desiredx=%d, desiredy=%d, flags=%x\n",
2800 hnd, type, desiredx, desiredy, flags);
2801
2802 switch (type)
2803 {
2804 case IMAGE_BITMAP:
2805 {
2806 HBITMAP res = NULL;
2807 DIBSECTION ds;
2808 int objSize;
2809 BITMAPINFO * bi;
2810
2811 objSize = GetObjectW( hnd, sizeof(ds), &ds );
2812 if (!objSize) return 0;
2813 if ((desiredx < 0) || (desiredy < 0)) return 0;
2814
2815 if (flags & LR_COPYFROMRESOURCE)
2816 {
2817 FIXME("The flag LR_COPYFROMRESOURCE is not implemented for bitmaps\n");
2818 }
2819
2820 if (desiredx == 0) desiredx = ds.dsBm.bmWidth;
2821 if (desiredy == 0) desiredy = ds.dsBm.bmHeight;
2822
2823 /* Allocate memory for a BITMAPINFOHEADER structure and a
2824 color table. The maximum number of colors in a color table
2825 is 256 which corresponds to a bitmap with depth 8.
2826 Bitmaps with higher depths don't have color tables. */
2827 bi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
2828 if (!bi) return 0;
2829
2830 bi->bmiHeader.biSize = sizeof(bi->bmiHeader);
2831 bi->bmiHeader.biPlanes = ds.dsBm.bmPlanes;
2832 bi->bmiHeader.biBitCount = ds.dsBm.bmBitsPixel;
2833 bi->bmiHeader.biCompression = BI_RGB;
2834
2835 if (flags & LR_CREATEDIBSECTION)
2836 {
2837 /* Create a DIB section. LR_MONOCHROME is ignored */
2838 void * bits;
2839 HDC dc = CreateCompatibleDC(NULL);
2840
2841 if (objSize == sizeof(DIBSECTION))
2842 {
2843 /* The source bitmap is a DIB.
2844 Get its attributes to create an exact copy */
2845 memcpy(bi, &ds.dsBmih, sizeof(BITMAPINFOHEADER));
2846 }
2847
2848 /* Get the color table or the color masks */
2849 GetDIBits(dc, hnd, 0, ds.dsBm.bmHeight, NULL, bi, DIB_RGB_COLORS);
2850
2851 bi->bmiHeader.biWidth = desiredx;
2852 bi->bmiHeader.biHeight = desiredy;
2853 bi->bmiHeader.biSizeImage = 0;
2854
2855 res = CreateDIBSection(dc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
2856 DeleteDC(dc);
2857 }
2858 else
2859 {
2860 /* Create a device-dependent bitmap */
2861
2862 BOOL monochrome = (flags & LR_MONOCHROME);
2863
2864 if (objSize == sizeof(DIBSECTION))
2865 {
2866 /* The source bitmap is a DIB section.
2867 Get its attributes */
2868 HDC dc = CreateCompatibleDC(NULL);
2869 bi->bmiHeader.biSize = sizeof(bi->bmiHeader);
2870 bi->bmiHeader.biBitCount = ds.dsBm.bmBitsPixel;
2871 GetDIBits(dc, hnd, 0, ds.dsBm.bmHeight, NULL, bi, DIB_RGB_COLORS);
2872 DeleteDC(dc);
2873
2874 if (!monochrome && ds.dsBm.bmBitsPixel == 1)
2875 {
2876 /* Look if the colors of the DIB are black and white */
2877
2878 monochrome =
2879 (bi->bmiColors[0].rgbRed == 0xff
2880 && bi->bmiColors[0].rgbGreen == 0xff
2881 && bi->bmiColors[0].rgbBlue == 0xff
2882 && bi->bmiColors[0].rgbReserved == 0
2883 && bi->bmiColors[1].rgbRed == 0
2884 && bi->bmiColors[1].rgbGreen == 0
2885 && bi->bmiColors[1].rgbBlue == 0
2886 && bi->bmiColors[1].rgbReserved == 0)
2887 ||
2888 (bi->bmiColors[0].rgbRed == 0
2889 && bi->bmiColors[0].rgbGreen == 0
2890 && bi->bmiColors[0].rgbBlue == 0
2891 && bi->bmiColors[0].rgbReserved == 0
2892 && bi->bmiColors[1].rgbRed == 0xff
2893 && bi->bmiColors[1].rgbGreen == 0xff
2894 && bi->bmiColors[1].rgbBlue == 0xff
2895 && bi->bmiColors[1].rgbReserved == 0);
2896 }
2897 }
2898 else if (!monochrome)
2899 {
2900 monochrome = ds.dsBm.bmBitsPixel == 1;
2901 }
2902
2903 if (monochrome)
2904 {
2905 res = CreateBitmap(desiredx, desiredy, 1, 1, NULL);
2906 }
2907 else
2908 {
2909 HDC screenDC = GetDC(NULL);
2910 res = CreateCompatibleBitmap(screenDC, desiredx, desiredy);
2911 ReleaseDC(NULL, screenDC);
2912 }
2913 }
2914
2915 if (res)
2916 {
2917 /* Only copy the bitmap if it's a DIB section or if it's
2918 compatible to the screen */
2919 BOOL copyContents;
2920
2921 if (objSize == sizeof(DIBSECTION))
2922 {
2923 copyContents = TRUE;
2924 }
2925 else
2926 {
2927 HDC screenDC = GetDC(NULL);
2928 int screen_depth = GetDeviceCaps(screenDC, BITSPIXEL);
2929 ReleaseDC(NULL, screenDC);
2930
2931 copyContents = (ds.dsBm.bmBitsPixel == 1 || ds.dsBm.bmBitsPixel == screen_depth);
2932 }
2933
2934 if (copyContents)
2935 {
2936 /* The source bitmap may already be selected in a device context,
2937 use GetDIBits/StretchDIBits and not StretchBlt */
2938
2939 HDC dc;
2940 void * bits;
2941
2942 dc = CreateCompatibleDC(NULL);
2943
2944 bi->bmiHeader.biWidth = ds.dsBm.bmWidth;
2945 bi->bmiHeader.biHeight = ds.dsBm.bmHeight;
2946 bi->bmiHeader.biSizeImage = 0;
2947 bi->bmiHeader.biClrUsed = 0;
2948 bi->bmiHeader.biClrImportant = 0;
2949
2950 /* Fill in biSizeImage */
2951 GetDIBits(dc, hnd, 0, ds.dsBm.bmHeight, NULL, bi, DIB_RGB_COLORS);
2952 bits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bi->bmiHeader.biSizeImage);
2953
2954 if (bits)
2955 {
2956 HBITMAP oldBmp;
2957
2958 /* Get the image bits of the source bitmap */
2959 GetDIBits(dc, hnd, 0, ds.dsBm.bmHeight, bits, bi, DIB_RGB_COLORS);
2960
2961 /* Copy it to the destination bitmap */
2962 oldBmp = SelectObject(dc, res);
2963 StretchDIBits(dc, 0, 0, desiredx, desiredy,
2964 0, 0, ds.dsBm.bmWidth, ds.dsBm.bmHeight,
2965 bits, bi, DIB_RGB_COLORS, SRCCOPY);
2966 SelectObject(dc, oldBmp);
2967
2968 HeapFree(GetProcessHeap(), 0, bits);
2969 }
2970
2971 DeleteDC(dc);
2972 }
2973
2974 if (flags & LR_COPYDELETEORG)
2975 {
2976 DeleteObject(hnd);
2977 }
2978 }
2979 HeapFree(GetProcessHeap(), 0, bi);
2980 return res;
2981 }
2982 case IMAGE_ICON:
2983 return CURSORICON_ExtCopy(hnd,type, desiredx, desiredy, flags);
2984 case IMAGE_CURSOR:
2985 /* Should call CURSORICON_ExtCopy but more testing
2986 * needs to be done before we change this
2987 */
2988 if (flags) FIXME("Flags are ignored\n");
2989 return CopyCursor(hnd);
2990 }
2991 return 0;
2992 }
2993
2994
2995 /******************************************************************************
2996 * LoadBitmapW (USER32.@) Loads bitmap from the executable file
2997 *
2998 * RETURNS
2999 * Success: Handle to specified bitmap
3000 * Failure: NULL
3001 */
3002 HBITMAP WINAPI LoadBitmapW(
3003 HINSTANCE instance, /* [in] Handle to application instance */
3004 LPCWSTR name) /* [in] Address of bitmap resource name */
3005 {
3006 return LoadImageW( instance, name, IMAGE_BITMAP, 0, 0, 0 );
3007 }
3008
3009 /**********************************************************************
3010 * LoadBitmapA (USER32.@)
3011 *
3012 * See LoadBitmapW.
3013 */
3014 HBITMAP WINAPI LoadBitmapA( HINSTANCE instance, LPCSTR name )
3015 {
3016 return LoadImageA( instance, name, IMAGE_BITMAP, 0, 0, 0 );
3017 }
useful hacks and other patches not (yet) suitable for mainline