git.oblomov.eu Git - wine/blob - dlls/user32/cursoricon.c

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