win32/cursoricon32.c

   1 /*
   2  * Cursor and icon support
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  * Copyright 1996 Martin von Loewis
   6  */
   7
   8 /*
   9  * Theory:
  10  *
  11  * Cursors and icons are stored in a global heap block, with the
  12  * following layout:
  13  *
  14  * CURSORICONINFO info;
  15  * BYTE[]         ANDbits;
  16  * BYTE[]         XORbits;
  17  *
  18  * The bits structures are in the format of a device-dependent bitmap.
  19  *
  20  * This layout is very sub-optimal, as the bitmap bits are stored in
  21  * the X client instead of in the server like other bitmaps; however,
  22  * some programs (notably Paint Brush) expect to be able to manipulate
  23  * the bits directly :-(
  24  */
  25
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include "windows.h"
  29 #include "callback.h"
  30 #include "cursoricon.h"
  31 #include "sysmetrics.h"
  32 #include "win.h"
  33 #include "bitmap.h"
  34 #include "struct32.h"
  35 #include "heap.h"
  36 #include "task.h"
  37 #include "stddebug.h"
  38 #include "debug.h"
  39 #include "xmalloc.h"
  40
  41 /* This dictionary could might eventually become a macro for better reuse */
  42 struct MAP_DWORD_DWORD{
  43         DWORD key;
  44         DWORD value;
  45 };
  46
  47 struct MAP_DWORD_DWORD *CURSORICON_map;
  48 int CURSORICON_count;
  49
  50 BOOL CURSORICON_lookup(DWORD key,DWORD *value)
  51 {
  52         int i;
  53         for(i=0;i<CURSORICON_count;i++)
  54         {
  55                 if(key==CURSORICON_map[i].key)
  56                 {
  57                         *value=CURSORICON_map[i].value;
  58                         return TRUE;
  59                 }
  60         }
  61         return FALSE;
  62 }
  63
  64 void CURSORICON_insert(DWORD key,DWORD value)
  65 {
  66         if(!CURSORICON_count)
  67         {
  68                 CURSORICON_count=1;
  69                 CURSORICON_map=malloc(sizeof(struct MAP_DWORD_DWORD));
  70         }else{
  71                 CURSORICON_count++;
  72                 CURSORICON_map=realloc(CURSORICON_map,
  73                         sizeof(struct MAP_DWORD_DWORD)*CURSORICON_count);
  74         }
  75         CURSORICON_map[CURSORICON_count-1].key=key;
  76         CURSORICON_map[CURSORICON_count-1].value=value;
  77 }
  78
  79 /**********************************************************************
  80  *          CURSORICON32_FindBestIcon
  81  *
  82  * Find the icon closest to the requested size and number of colors.
  83  */
  84 static ICONDIRENTRY32 *CURSORICON32_FindBestIcon( CURSORICONDIR32 *dir,
  85         int width, int height, int colors )
  86 {
  87     int i, maxcolors, maxwidth, maxheight;
  88     ICONDIRENTRY32 *entry, *bestEntry = NULL;
  89
  90     if (dir->idCount < 1)
  91     {
  92         fprintf( stderr, "Icon: empty directory!\n" );
  93         return NULL;
  94     }
  95     if (dir->idCount == 1) return &dir->idEntries[0].icon;  /* No choice... */
  96
  97     /* First find the exact size with less colors */
  98
  99     maxcolors = 0;
 100     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
 101         if ((entry->bWidth == width) && (entry->bHeight == height) &&
 102             (entry->bColorCount <= colors) && (entry->bColorCount > maxcolors))
 103         {
 104             bestEntry = entry;
 105             maxcolors = entry->bColorCount;
 106         }
 107     if (bestEntry) return bestEntry;
 108
 109     /* First find the exact size with more colors */
 110
 111     maxcolors = 255;
 112     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
 113         if ((entry->bWidth == width) && (entry->bHeight == height) &&
 114             (entry->bColorCount > colors) && (entry->bColorCount <= maxcolors))
 115         {
 116             bestEntry = entry;
 117             maxcolors = entry->bColorCount;
 118         }
 119     if (bestEntry) return bestEntry;
 120
 121     /* Now find a smaller one with less colors */
 122
 123     maxcolors = maxwidth = maxheight = 0;
 124     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
 125         if ((entry->bWidth <= width) && (entry->bHeight <= height) &&
 126             (entry->bWidth >= maxwidth) && (entry->bHeight >= maxheight) &&
 127             (entry->bColorCount <= colors) && (entry->bColorCount > maxcolors))
 128         {
 129             bestEntry = entry;
 130             maxwidth  = entry->bWidth;
 131             maxheight = entry->bHeight;
 132             maxcolors = entry->bColorCount;
 133         }
 134     if (bestEntry) return bestEntry;
 135
 136     /* Now find a smaller one with more colors */
 137
 138     maxcolors = 255;
 139     maxwidth = maxheight = 0;
 140     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
 141         if ((entry->bWidth <= width) && (entry->bHeight <= height) &&
 142             (entry->bWidth >= maxwidth) && (entry->bHeight >= maxheight) &&
 143             (entry->bColorCount > colors) && (entry->bColorCount <= maxcolors))
 144         {
 145             bestEntry = entry;
 146             maxwidth  = entry->bWidth;
 147             maxheight = entry->bHeight;
 148             maxcolors = entry->bColorCount;
 149         }
 150     if (bestEntry) return bestEntry;
 151
 152     /* Now find a larger one with less colors */
 153
 154     maxcolors = 0;
 155     maxwidth = maxheight = 255;
 156     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
 157         if ((entry->bWidth <= maxwidth) && (entry->bHeight <= maxheight) &&
 158             (entry->bColorCount <= colors) && (entry->bColorCount > maxcolors))
 159         {
 160             bestEntry = entry;
 161             maxwidth  = entry->bWidth;
 162             maxheight = entry->bHeight;
 163             maxcolors = entry->bColorCount;
 164         }
 165     if (bestEntry) return bestEntry;
 166
 167     /* Now find a larger one with more colors */
 168
 169     maxcolors = maxwidth = maxheight = 255;
 170     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
 171         if ((entry->bWidth <= maxwidth) && (entry->bHeight <= maxheight) &&
 172             (entry->bColorCount > colors) && (entry->bColorCount <= maxcolors))
 173         {
 174             bestEntry = entry;
 175             maxwidth  = entry->bWidth;
 176             maxheight = entry->bHeight;
 177             maxcolors = entry->bColorCount;
 178         }
 179
 180     return bestEntry;
 181 }
 182
 183
 184 /**********************************************************************
 185  *          CURSORICON32_FindBestCursor
 186  *
 187  * Find the cursor closest to the requested size.
 188  */
 189 static CURSORDIRENTRY32 *CURSORICON32_FindBestCursor( CURSORICONDIR32 *dir,
 190                                                   int width, int height )
 191 {
 192     int i, maxwidth, maxheight;
 193     CURSORDIRENTRY32 *entry, *bestEntry = NULL;
 194
 195     if (dir->idCount < 1)
 196     {
 197         fprintf( stderr, "Cursor: empty directory!\n" );
 198         return NULL;
 199     }
 200     if (dir->idCount == 1) return &dir->idEntries[0].cursor; /* No choice... */
 201
 202     /* First find the largest one smaller than or equal to the requested size*/
 203
 204     maxwidth = maxheight = 0;
 205     for(i = 0,entry = &dir->idEntries[0].cursor; i < dir->idCount; i++,entry++)
 206         if ((entry->wWidth <= width) && (entry->wHeight <= height) &&
 207             (entry->wWidth > maxwidth) && (entry->wHeight > maxheight))
 208         {
 209             bestEntry = entry;
 210             maxwidth  = entry->wWidth;
 211             maxheight = entry->wHeight;
 212         }
 213     if (bestEntry) return bestEntry;
 214
 215     /* Now find the smallest one larger than the requested size */
 216
 217     maxwidth = maxheight = 255;
 218     for(i = 0,entry = &dir->idEntries[0].cursor; i < dir->idCount; i++,entry++)
 219         if ((entry->wWidth < maxwidth) && (entry->wHeight < maxheight))
 220         {
 221             bestEntry = entry;
 222             maxwidth  = entry->wWidth;
 223             maxheight = entry->wHeight;
 224         }
 225
 226     return bestEntry;
 227 }
 228
 229
 230 /**********************************************************************
 231  *          CURSORICON32_LoadDirEntry
 232  *
 233  * Load the icon/cursor directory for a given resource name and find the
 234  * best matching entry.
 235  */
 236 static BOOL CURSORICON32_LoadDirEntry(HINSTANCE32 hInstance, LPCWSTR name,
 237                                     int width, int height, int colors,
 238                                     BOOL fCursor, CURSORICONDIRENTRY32 *dirEntry)
 239 {
 240     HANDLE32 hRsrc;
 241     HANDLE32 hMem;
 242     CURSORICONDIR32 *dir;
 243     CURSORICONDIRENTRY32 *entry = NULL;
 244
 245     if (!(hRsrc = FindResource32W( hInstance, name,
 246                 (LPCWSTR)(fCursor ? RT_GROUP_CURSOR : RT_GROUP_ICON) )))
 247         return FALSE;
 248     if (!(hMem = LoadResource32( hInstance, hRsrc ))) return FALSE;
 249     if ((dir = (CURSORICONDIR32 *)LockResource32( hMem )))
 250     {
 251         if (fCursor)
 252             entry = (CURSORICONDIRENTRY32 *)CURSORICON32_FindBestCursor( dir,
 253                                                                width, height );
 254         else
 255             entry = (CURSORICONDIRENTRY32 *)CURSORICON32_FindBestIcon( dir,
 256                                                        width, height, colors );
 257         if (entry) *dirEntry = *entry;
 258     }
 259     FreeResource32( hMem );
 260     return (entry != NULL);
 261 }
 262
 263
 264 /**********************************************************************
 265  *          CURSORICON32_LoadHandler
 266  *
 267  * Create a cursor or icon from a resource.
 268  */
 269 static HGLOBAL32 CURSORICON32_LoadHandler( HANDLE32 handle,
 270                                            HINSTANCE32 hInstance,
 271                                            BOOL32 fCursor )
 272 {
 273     HBITMAP32 hAndBits, hXorBits;
 274     HGLOBAL32 hRes;
 275     HDC32 hdc;
 276     int size, sizeAnd, sizeXor;
 277     POINT16 hotspot = { 0 ,0 };
 278     BITMAPOBJ *bmpXor, *bmpAnd;
 279     BITMAPINFO *bmi, *pInfo;
 280     CURSORICONINFO *info;
 281     char *bits;
 282
 283         hRes=0;
 284     if (fCursor)  /* If cursor, get the hotspot */
 285     {
 286         POINT16 *pt = (POINT16 *)LockResource32( handle );
 287         hotspot = *pt;
 288         bmi = (BITMAPINFO *)(pt + 1);
 289     }
 290     else bmi = (BITMAPINFO *)LockResource32( handle );
 291
 292     /* Create a copy of the bitmap header */
 293
 294     size = DIB_BitmapInfoSize( bmi, DIB_RGB_COLORS );
 295     /* Make sure we have room for the monochrome bitmap later on */
 296     size = MAX( size, sizeof(BITMAPINFOHEADER) + 2*sizeof(RGBQUAD) );
 297     pInfo = (BITMAPINFO *)xmalloc( size );
 298     memcpy( pInfo, bmi, size );
 299
 300     if (pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))
 301     {
 302         if (pInfo->bmiHeader.biCompression != BI_RGB)
 303         {
 304             fprintf(stderr,"Unknown size for compressed icon bitmap.\n");
 305             free( pInfo );
 306             return 0;
 307         }
 308         pInfo->bmiHeader.biHeight /= 2;
 309     }
 310     else if (pInfo->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
 311     {
 312         BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)pInfo;
 313         core->bcHeight /= 2;
 314     }
 315     else
 316     {
 317         fprintf( stderr, "CURSORICON32_Load: Unknown bitmap length %ld!\n",
 318                  pInfo->bmiHeader.biSize );
 319         free( pInfo );
 320         return 0;
 321     }
 322
 323     /* Create the XOR bitmap */
 324
 325     if (!(hdc = GetDC32( 0 )))
 326     {
 327         free( pInfo );
 328         return 0;
 329     }
 330
 331     hXorBits = CreateDIBitmap32( hdc, &pInfo->bmiHeader, CBM_INIT,
 332                                  (char*)bmi + size, pInfo, DIB_RGB_COLORS );
 333
 334     /* Fix the bitmap header to load the monochrome mask */
 335
 336     if (pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))
 337     {
 338         BITMAPINFOHEADER *bih = &pInfo->bmiHeader;
 339         RGBQUAD *rgb = pInfo->bmiColors;
 340         bits = (char *)bmi + size +
 341             DIB_GetImageWidthBytes(bih->biWidth,bih->biBitCount)*bih->biHeight;
 342         bih->biBitCount = 1;
 343         bih->biClrUsed = bih->biClrImportant = 2;
 344         rgb[0].rgbBlue = rgb[0].rgbGreen = rgb[0].rgbRed = 0x00;
 345         rgb[1].rgbBlue = rgb[1].rgbGreen = rgb[1].rgbRed = 0xff;
 346         rgb[0].rgbReserved = rgb[1].rgbReserved = 0;
 347     }
 348     else
 349     {
 350         BITMAPCOREHEADER *bch = (BITMAPCOREHEADER *)pInfo;
 351         RGBTRIPLE *rgb = (RGBTRIPLE *)(bch + 1);
 352         bits = (char *)bmi + size +
 353             DIB_GetImageWidthBytes(bch->bcWidth,bch->bcBitCount)*bch->bcHeight;
 354         bch->bcBitCount = 1;
 355         rgb[0].rgbtBlue = rgb[0].rgbtGreen = rgb[0].rgbtRed = 0x00;
 356         rgb[1].rgbtBlue = rgb[1].rgbtGreen = rgb[1].rgbtRed = 0xff;
 357     }
 358
 359     /* Create the AND bitmap */
 360
 361     hAndBits = CreateDIBitmap32( hdc, &pInfo->bmiHeader, CBM_INIT,
 362                                  bits, pInfo, DIB_RGB_COLORS );
 363     ReleaseDC32( 0, hdc );
 364
 365     /* Now create the CURSORICONINFO structure */
 366
 367     bmpXor = (BITMAPOBJ *) GDI_GetObjPtr( hXorBits, BITMAP_MAGIC );
 368     bmpAnd = (BITMAPOBJ *) GDI_GetObjPtr( hAndBits, BITMAP_MAGIC );
 369     sizeXor = bmpXor->bitmap.bmHeight * bmpXor->bitmap.bmWidthBytes;
 370     sizeAnd = bmpAnd->bitmap.bmHeight * bmpAnd->bitmap.bmWidthBytes;
 371
 372     if (!(hRes = GlobalAlloc16( GMEM_MOVEABLE,
 373                                 sizeof(CURSORICONINFO) + sizeXor + sizeAnd)))
 374     {
 375         DeleteObject32( hXorBits );
 376         DeleteObject32( hAndBits );
 377         return 0;
 378     }
 379
 380     /* Make it owned by the module */
 381     if (hInstance) FarSetOwner( hRes, (WORD)(DWORD)GetExePtr(hInstance) );
 382
 383     info = (CURSORICONINFO *)GlobalLock16( hRes );
 384     info->ptHotSpot.x   = hotspot.x;
 385     info->ptHotSpot.y   = hotspot.y;
 386     info->nWidth        = bmpXor->bitmap.bmWidth;
 387     info->nHeight       = bmpXor->bitmap.bmHeight;
 388     info->nWidthBytes   = bmpXor->bitmap.bmWidthBytes;
 389     info->bPlanes       = bmpXor->bitmap.bmPlanes;
 390     info->bBitsPerPixel = bmpXor->bitmap.bmBitsPixel;
 391
 392     /* Transfer the bitmap bits to the CURSORICONINFO structure */
 393
 394     GetBitmapBits( hAndBits, sizeAnd, (char *)(info + 1) );
 395     GetBitmapBits( hXorBits, sizeXor, (char *)(info + 1) + sizeAnd );
 396     DeleteObject32( hXorBits );
 397     DeleteObject32( hAndBits );
 398     GlobalUnlock16( hRes );
 399     return hRes;
 400 }
 401
 402 /**********************************************************************
 403  *          CURSORICON32_Load
 404  *
 405  * Load a cursor or icon.
 406  */
 407 static HGLOBAL32 CURSORICON32_Load( HINSTANCE32 hInstance, LPCWSTR name,
 408                                     int width, int height, int colors,
 409                                     BOOL fCursor )
 410 {
 411     HANDLE32 handle;
 412     HANDLE32 hRet;
 413     HANDLE32 hRsrc;
 414     CURSORICONDIRENTRY32 dirEntry;
 415
 416         if(!hInstance)  /* OEM cursor/icon */
 417         {
 418                 WORD resid;
 419                 if(HIWORD(name))
 420                 {
 421                         LPSTR ansi = HEAP_strdupWtoA(GetProcessHeap(),0,name);
 422                         if(ansi[0]=='#')        /*Check for '#xxx' name */
 423                         {
 424                             resid = atoi(ansi+1);
 425                             HeapFree( GetProcessHeap(), 0, ansi );
 426                         }
 427                         else
 428                         {
 429                             HeapFree( GetProcessHeap(), 0, ansi );
 430                             return 0;
 431                         }
 432                 }
 433                 else resid = LOWORD(name);
 434                 return OBM_LoadCursorIcon(resid, fCursor);
 435         }
 436
 437     /* Find the best entry in the directory */
 438
 439     if (!CURSORICON32_LoadDirEntry( hInstance, name, width, height,
 440                                   colors, fCursor, &dirEntry )) return 0;
 441
 442     /* Load the resource */
 443
 444     if (!(hRsrc = FindResource32W( hInstance,
 445                       (LPWSTR) (DWORD) dirEntry.icon.wResId,
 446                       (LPWSTR) (fCursor ? RT_CURSOR : RT_ICON )))) return 0;
 447     if (!(handle = LoadResource32( hInstance, hRsrc ))) return 0;
 448
 449         /* Use the resource handle as key to detect multiple loading */
 450         if(CURSORICON_lookup(handle,&hRet))
 451                 return hRet;
 452
 453     hRet = CURSORICON32_LoadHandler( handle, hInstance, fCursor );
 454     /* Obsolete - FreeResource32(handle);*/
 455         CURSORICON_insert(handle,hRet);
 456     return hRet;
 457 }
 458
 459
 460 /***********************************************************************
 461  *           LoadCursorW                (USER32.361)
 462  */
 463 HCURSOR32 LoadCursor32W(HINSTANCE32 hInstance,LPCWSTR name)
 464 {
 465     return CURSORICON32_Load( hInstance, name,
 466                             SYSMETRICS_CXCURSOR, SYSMETRICS_CYCURSOR, 1, TRUE);
 467 }
 468
 469 /***********************************************************************
 470  *           LoadCursorA                (USER32.358)
 471  */
 472 HCURSOR32 LoadCursor32A(HINSTANCE32 hInstance,LPCSTR name)
 473 {
 474         HCURSOR32 res=0;
 475         if(!HIWORD(name))
 476                 return LoadCursor32W(hInstance,(LPCWSTR)name);
 477         else
 478         {
 479             LPWSTR uni = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
 480             res = LoadCursor32W(hInstance, uni);
 481             HeapFree( GetProcessHeap(), 0, uni);
 482         }
 483         return res;
 484 }
 485
 486
 487 /***********************************************************************
 488  *           LoadIconW          (USER32.363)
 489  */
 490 HICON32 LoadIcon32W(HINSTANCE32 hInstance,LPCWSTR name)
 491 {
 492     return CURSORICON32_Load( hInstance, name,
 493                             SYSMETRICS_CXICON, SYSMETRICS_CYICON,
 494                             MIN( 16, 1 << screenDepth ), FALSE );
 495 }
 496
 497 /***********************************************************************
 498  *           LoadIconA          (USER32.362)
 499  */
 500 HICON32 LoadIcon32A(HINSTANCE32 hInstance,LPCSTR name)
 501 {
 502         HICON32 res=0;
 503         if(!HIWORD(name))
 504                 return LoadIcon32W(hInstance, (LPCWSTR)name);
 505         else
 506         {
 507             LPWSTR uni = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
 508             res = LoadIcon32W( hInstance, uni );
 509             HeapFree( GetProcessHeap(), 0, uni );
 510         }
 511         return res;
 512 }
 513