objects/cursoricon.c

   1 /*
   2  * Cursor and icon support
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 /*
   8  * Theory:
   9  *
  10  * Cursors and icons are stored in a global heap block, with the
  11  * following layout:
  12  *
  13  * CURSORICONINFO info;
  14  * BYTE[]         ANDbits;
  15  * BYTE[]         XORbits;
  16  *
  17  * The bits structures are in the format of a device-dependent bitmap.
  18  *
  19  * This layout is very sub-optimal, as the bitmap bits are stored in
  20  * the X client instead of in the server like other bitmaps; however,
  21  * some programs (notably Paint Brush) expect to be able to manipulate
  22  * the bits directly :-(
  23  */
  24
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include "windows.h"
  28 #include "bitmap.h"
  29 #include "callback.h"
  30 #include "cursoricon.h"
  31 #include "sysmetrics.h"
  32 #include "win.h"
  33 #include "stddebug.h"
  34 #include "debug.h"
  35 #include "xmalloc.h"
  36 #include "task.h"
  37
  38 extern UINT16 COLOR_GetSystemPaletteSize();
  39
  40 Cursor CURSORICON_XCursor = None;  /* Current X cursor */
  41 static HCURSOR16 hActiveCursor = 0;  /* Active cursor */
  42 static int CURSOR_ShowCount = 0;   /* Cursor display count */
  43 static RECT32 CURSOR_ClipRect;       /* Cursor clipping rect */
  44
  45 /**********************************************************************
  46  *          CURSORICON_FindBestIcon
  47  *
  48  * Find the icon closest to the requested size and number of colors.
  49  */
  50 static ICONDIRENTRY *CURSORICON_FindBestIcon( CURSORICONDIR *dir, int width,
  51                                               int height, int colors )
  52 {
  53     int i, maxcolors, maxwidth, maxheight;
  54     ICONDIRENTRY *entry, *bestEntry = NULL;
  55
  56     if (dir->idCount < 1)
  57     {
  58         fprintf( stderr, "Icon: empty directory!\n" );
  59         return NULL;
  60     }
  61     if (dir->idCount == 1) return &dir->idEntries[0].icon;  /* No choice... */
  62
  63     /* First find the exact size with less colors */
  64
  65     maxcolors = 0;
  66     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
  67         if ((entry->bWidth == width) && (entry->bHeight == height) &&
  68             (entry->bColorCount <= colors) && (entry->bColorCount > maxcolors))
  69         {
  70             bestEntry = entry;
  71             maxcolors = entry->bColorCount;
  72         }
  73     if (bestEntry) return bestEntry;
  74
  75     /* First find the exact size with more colors */
  76
  77     maxcolors = 255;
  78     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
  79         if ((entry->bWidth == width) && (entry->bHeight == height) &&
  80             (entry->bColorCount > colors) && (entry->bColorCount <= maxcolors))
  81         {
  82             bestEntry = entry;
  83             maxcolors = entry->bColorCount;
  84         }
  85     if (bestEntry) return bestEntry;
  86
  87     /* Now find a smaller one with less colors */
  88
  89     maxcolors = maxwidth = maxheight = 0;
  90     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
  91         if ((entry->bWidth <= width) && (entry->bHeight <= height) &&
  92             (entry->bWidth >= maxwidth) && (entry->bHeight >= maxheight) &&
  93             (entry->bColorCount <= colors) && (entry->bColorCount > maxcolors))
  94         {
  95             bestEntry = entry;
  96             maxwidth  = entry->bWidth;
  97             maxheight = entry->bHeight;
  98             maxcolors = entry->bColorCount;
  99         }
 100     if (bestEntry) return bestEntry;
 101
 102     /* Now find a smaller one with more colors */
 103
 104     maxcolors = 255;
 105     maxwidth = maxheight = 0;
 106     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
 107         if ((entry->bWidth <= width) && (entry->bHeight <= height) &&
 108             (entry->bWidth >= maxwidth) && (entry->bHeight >= maxheight) &&
 109             (entry->bColorCount > colors) && (entry->bColorCount <= maxcolors))
 110         {
 111             bestEntry = entry;
 112             maxwidth  = entry->bWidth;
 113             maxheight = entry->bHeight;
 114             maxcolors = entry->bColorCount;
 115         }
 116     if (bestEntry) return bestEntry;
 117
 118     /* Now find a larger one with less colors */
 119
 120     maxcolors = 0;
 121     maxwidth = maxheight = 255;
 122     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
 123         if ((entry->bWidth <= maxwidth) && (entry->bHeight <= maxheight) &&
 124             (entry->bColorCount <= colors) && (entry->bColorCount > maxcolors))
 125         {
 126             bestEntry = entry;
 127             maxwidth  = entry->bWidth;
 128             maxheight = entry->bHeight;
 129             maxcolors = entry->bColorCount;
 130         }
 131     if (bestEntry) return bestEntry;
 132
 133     /* Now find a larger one with more colors */
 134
 135     maxcolors = maxwidth = maxheight = 255;
 136     for (i = 0, entry = &dir->idEntries[0].icon; i < dir->idCount; i++,entry++)
 137         if ((entry->bWidth <= maxwidth) && (entry->bHeight <= maxheight) &&
 138             (entry->bColorCount > colors) && (entry->bColorCount <= maxcolors))
 139         {
 140             bestEntry = entry;
 141             maxwidth  = entry->bWidth;
 142             maxheight = entry->bHeight;
 143             maxcolors = entry->bColorCount;
 144         }
 145
 146     return bestEntry;
 147 }
 148
 149
 150 /**********************************************************************
 151  *          CURSORICON_FindBestCursor
 152  *
 153  * Find the cursor closest to the requested size.
 154  */
 155 static CURSORDIRENTRY *CURSORICON_FindBestCursor( CURSORICONDIR *dir,
 156                                                   int width, int height )
 157 {
 158     int i, maxwidth, maxheight;
 159     CURSORDIRENTRY *entry, *bestEntry = NULL;
 160
 161     if (dir->idCount < 1)
 162     {
 163         fprintf( stderr, "Cursor: empty directory!\n" );
 164         return NULL;
 165     }
 166     if (dir->idCount == 1) return &dir->idEntries[0].cursor; /* No choice... */
 167
 168     /* First find the largest one smaller than or equal to the requested size*/
 169
 170     maxwidth = maxheight = 0;
 171     for(i = 0,entry = &dir->idEntries[0].cursor; i < dir->idCount; i++,entry++)
 172         if ((entry->wWidth <= width) && (entry->wHeight <= height) &&
 173             (entry->wWidth > maxwidth) && (entry->wHeight > maxheight))
 174         {
 175             bestEntry = entry;
 176             maxwidth  = entry->wWidth;
 177             maxheight = entry->wHeight;
 178         }
 179     if (bestEntry) return bestEntry;
 180
 181     /* Now find the smallest one larger than the requested size */
 182
 183     maxwidth = maxheight = 255;
 184     for(i = 0,entry = &dir->idEntries[0].cursor; i < dir->idCount; i++,entry++)
 185         if ((entry->wWidth < maxwidth) && (entry->wHeight < maxheight))
 186         {
 187             bestEntry = entry;
 188             maxwidth  = entry->wWidth;
 189             maxheight = entry->wHeight;
 190         }
 191
 192     return bestEntry;
 193 }
 194
 195
 196 /**********************************************************************
 197  *          CURSORICON_LoadDirEntry
 198  *
 199  * Load the icon/cursor directory for a given resource name and find the
 200  * best matching entry.
 201  */
 202 static BOOL CURSORICON_LoadDirEntry(HINSTANCE32 hInstance, SEGPTR name,
 203                                     int width, int height, int colors,
 204                                     BOOL fCursor, CURSORICONDIRENTRY *dirEntry)
 205 {
 206     HRSRC16 hRsrc;
 207     HGLOBAL16 hMem;
 208     CURSORICONDIR *dir;
 209     CURSORICONDIRENTRY *entry = NULL;
 210
 211     if (!(hRsrc = FindResource16( hInstance, name,
 212                                 fCursor ? RT_GROUP_CURSOR : RT_GROUP_ICON )))
 213         return FALSE;
 214     if (!(hMem = LoadResource16( hInstance, hRsrc ))) return FALSE;
 215     if ((dir = (CURSORICONDIR *)LockResource16( hMem )))
 216     {
 217         if (fCursor)
 218             entry = (CURSORICONDIRENTRY *)CURSORICON_FindBestCursor( dir,
 219                                                                width, height );
 220         else
 221             entry = (CURSORICONDIRENTRY *)CURSORICON_FindBestIcon( dir,
 222                                                        width, height, colors );
 223         if (entry) *dirEntry = *entry;
 224     }
 225     FreeResource16( hMem );
 226     return (entry != NULL);
 227 }
 228
 229
 230 /**********************************************************************
 231  *          CURSORICON_LoadHandler
 232  *
 233  * Create a cursor or icon from a resource.
 234  */
 235 HANDLE CURSORICON_LoadHandler( HANDLE handle, HINSTANCE hInstance,
 236                                       BOOL fCursor )
 237 {
 238     HANDLE hAndBits, hXorBits;
 239     HDC32 hdc;
 240     int size, sizeAnd, sizeXor;
 241     POINT16 hotspot = { 0 ,0 };
 242     BITMAPOBJ *bmpXor, *bmpAnd;
 243     BITMAPINFO *bmi, *pInfo;
 244     CURSORICONINFO *info;
 245     char *bits;
 246
 247     if (fCursor)  /* If cursor, get the hotspot */
 248     {
 249         POINT16 *pt = (POINT16 *)LockResource16( handle );
 250         hotspot = *pt;
 251         bmi = (BITMAPINFO *)(pt + 1);
 252     }
 253     else bmi = (BITMAPINFO *)LockResource16( handle );
 254
 255     /* Create a copy of the bitmap header */
 256
 257     size = DIB_BitmapInfoSize( bmi, DIB_RGB_COLORS );
 258     /* Make sure we have room for the monochrome bitmap later on */
 259     size = MAX( size, sizeof(BITMAPINFOHEADER) + 2*sizeof(RGBQUAD) );
 260     pInfo = (BITMAPINFO *)xmalloc( size );
 261     memcpy( pInfo, bmi, size );
 262
 263     if (pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))
 264     {
 265         if (pInfo->bmiHeader.biCompression != BI_RGB)
 266         {
 267             fprintf(stderr,"Unknown size for compressed icon bitmap.\n");
 268             free( pInfo );
 269             return 0;
 270         }
 271         pInfo->bmiHeader.biHeight /= 2;
 272     }
 273     else if (pInfo->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
 274     {
 275         BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)pInfo;
 276         core->bcHeight /= 2;
 277     }
 278     else
 279     {
 280         fprintf( stderr, "CURSORICON_Load: Unknown bitmap length %ld!\n",
 281                  pInfo->bmiHeader.biSize );
 282         free( pInfo );
 283         return 0;
 284     }
 285
 286     /* Create the XOR bitmap */
 287
 288     if (!(hdc = GetDC32( 0 )))
 289     {
 290         free( pInfo );
 291         return 0;
 292     }
 293
 294     hXorBits = CreateDIBitmap( hdc, &pInfo->bmiHeader, CBM_INIT,
 295                                (char*)bmi + size, pInfo, DIB_RGB_COLORS );
 296
 297     /* Fix the bitmap header to load the monochrome mask */
 298
 299     if (pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))
 300     {
 301         BITMAPINFOHEADER *bih = &pInfo->bmiHeader;
 302         RGBQUAD *rgb = pInfo->bmiColors;
 303         bits = (char *)bmi + size +
 304             DIB_GetImageWidthBytes(bih->biWidth,bih->biBitCount)*bih->biHeight;
 305         bih->biBitCount = 1;
 306         bih->biClrUsed = bih->biClrImportant = 2;
 307         rgb[0].rgbBlue = rgb[0].rgbGreen = rgb[0].rgbRed = 0x00;
 308         rgb[1].rgbBlue = rgb[1].rgbGreen = rgb[1].rgbRed = 0xff;
 309         rgb[0].rgbReserved = rgb[1].rgbReserved = 0;
 310     }
 311     else
 312     {
 313         BITMAPCOREHEADER *bch = (BITMAPCOREHEADER *)pInfo;
 314         RGBTRIPLE *rgb = (RGBTRIPLE *)(bch + 1);
 315         bits = (char *)bmi + size +
 316             DIB_GetImageWidthBytes(bch->bcWidth,bch->bcBitCount)*bch->bcHeight;
 317         bch->bcBitCount = 1;
 318         rgb[0].rgbtBlue = rgb[0].rgbtGreen = rgb[0].rgbtRed = 0x00;
 319         rgb[1].rgbtBlue = rgb[1].rgbtGreen = rgb[1].rgbtRed = 0xff;
 320     }
 321
 322     /* Create the AND bitmap */
 323
 324     hAndBits = CreateDIBitmap( hdc, &pInfo->bmiHeader, CBM_INIT,
 325                                bits, pInfo, DIB_RGB_COLORS );
 326     ReleaseDC32( 0, hdc );
 327
 328     /* Now create the CURSORICONINFO structure */
 329
 330     bmpXor = (BITMAPOBJ *) GDI_GetObjPtr( hXorBits, BITMAP_MAGIC );
 331     bmpAnd = (BITMAPOBJ *) GDI_GetObjPtr( hAndBits, BITMAP_MAGIC );
 332     sizeXor = bmpXor->bitmap.bmHeight * bmpXor->bitmap.bmWidthBytes;
 333     sizeAnd = bmpAnd->bitmap.bmHeight * bmpAnd->bitmap.bmWidthBytes;
 334
 335     if (!(handle = GlobalAlloc16( GMEM_MOVEABLE,
 336                                   sizeof(CURSORICONINFO) + sizeXor + sizeAnd)))
 337     {
 338         DeleteObject( hXorBits );
 339         DeleteObject( hAndBits );
 340         return 0;
 341     }
 342
 343     /* Make it owned by the module */
 344     if (hInstance) FarSetOwner( handle, GetExePtr(hInstance) );
 345
 346     info = (CURSORICONINFO *)GlobalLock16( handle );
 347     info->ptHotSpot.x   = hotspot.x;
 348     info->ptHotSpot.y   = hotspot.y;
 349     info->nWidth        = bmpXor->bitmap.bmWidth;
 350     info->nHeight       = bmpXor->bitmap.bmHeight;
 351     info->nWidthBytes   = bmpXor->bitmap.bmWidthBytes;
 352     info->bPlanes       = bmpXor->bitmap.bmPlanes;
 353     info->bBitsPerPixel = bmpXor->bitmap.bmBitsPixel;
 354
 355     /* Transfer the bitmap bits to the CURSORICONINFO structure */
 356
 357     GetBitmapBits( hAndBits, sizeAnd, (char *)(info + 1) );
 358     GetBitmapBits( hXorBits, sizeXor, (char *)(info + 1) + sizeAnd );
 359     DeleteObject( hXorBits );
 360     DeleteObject( hAndBits );
 361     GlobalUnlock16( handle );
 362     return handle;
 363 }
 364
 365 /**********************************************************************
 366  *          CURSORICON_Load
 367  *
 368  * Load a cursor or icon.
 369  */
 370 static HANDLE CURSORICON_Load( HANDLE hInstance, SEGPTR name, int width,
 371                                int height, int colors, BOOL fCursor )
 372 {
 373     HANDLE handle,hRet;
 374     HRSRC16 hRsrc;
 375     CURSORICONDIRENTRY dirEntry;
 376
 377     if (!hInstance)  /* OEM cursor/icon */
 378     {
 379         if (HIWORD(name))  /* Check for '#xxx' name */
 380         {
 381             char *ptr = PTR_SEG_TO_LIN( name );
 382             if (ptr[0] != '#') return 0;
 383             if (!(name = (SEGPTR)atoi( ptr + 1 ))) return 0;
 384         }
 385         return OBM_LoadCursorIcon( LOWORD(name), fCursor );
 386     }
 387
 388     /* Find the best entry in the directory */
 389
 390     if (!CURSORICON_LoadDirEntry( hInstance, name, width, height,
 391                                   colors, fCursor, &dirEntry )) return 0;
 392
 393     /* Load the resource */
 394
 395     if (!(hRsrc = FindResource16( hInstance,
 396                                 MAKEINTRESOURCE( dirEntry.icon.wResId ),
 397                                 fCursor ? RT_CURSOR : RT_ICON ))) return 0;
 398     if (!(handle = LoadResource16( hInstance, hRsrc ))) return 0;
 399
 400     hRet = CURSORICON_LoadHandler( handle, hInstance, fCursor );
 401     FreeResource16(handle);
 402     return hRet;
 403 }
 404
 405
 406 /***********************************************************************
 407  *           CURSORICON_Copy
 408  *
 409  * Make a copy of a cursor or icon.
 410  */
 411 static HANDLE CURSORICON_Copy( HANDLE hInstance, HANDLE handle )
 412 {
 413     char *ptrOld, *ptrNew;
 414     int size;
 415     HANDLE hNew;
 416
 417     if (!(ptrOld = (char *)GlobalLock16( handle ))) return 0;
 418     if (!(hInstance = GetExePtr( hInstance ))) return 0;
 419     size = GlobalSize16( handle );
 420     hNew = GlobalAlloc16( GMEM_MOVEABLE, size );
 421     FarSetOwner( hNew, hInstance );
 422     ptrNew = (char *)GlobalLock16( hNew );
 423     memcpy( ptrNew, ptrOld, size );
 424     GlobalUnlock16( handle );
 425     GlobalUnlock16( hNew );
 426     return hNew;
 427 }
 428
 429 /***********************************************************************
 430  *           CURSORICON_IconToCursor
 431  *
 432  * Should convert bitmap to mono and truncate if too large
 433  * FIXME: if icon is passed returns a copy of OCR_DRAGOBJECT cursor
 434  *        but should actually convert icon to cursor.
 435  */
 436 HCURSOR16 CURSORICON_IconToCursor(HICON16 hIcon)
 437 {
 438  CURSORICONINFO *ptr = NULL;
 439
 440  if(hIcon)
 441     if (!(ptr = (CURSORICONINFO*)GlobalLock16( hIcon ))) return FALSE;
 442        if (ptr->bPlanes * ptr->bBitsPerPixel == 1)
 443           {
 444             return hIcon; /* assuming it's a cursor */
 445           }
 446        else
 447           {
 448            /* kludge */
 449
 450            HTASK hTask = GetCurrentTask();
 451            TDB*  pTask = (TDB *)GlobalLock16(hTask);
 452
 453            if(!pTask) return 0;
 454
 455            fprintf( stdnimp, "IconToCursor: Icons are not supported, returning default!\n");
 456            return CURSORICON_Copy( pTask->hInstance ,
 457                                    CURSORICON_Load(0,MAKEINTRESOURCE(OCR_DRAGOBJECT),
 458                                                    SYSMETRICS_CXCURSOR, SYSMETRICS_CYCURSOR, 1, TRUE) );
 459           }
 460
 461  return 0;
 462 }
 463
 464 /***********************************************************************
 465  *           LoadCursor    (USER.173)
 466  */
 467 HCURSOR16 LoadCursor16( HINSTANCE16 hInstance, SEGPTR name )
 468 {
 469     if (HIWORD(name))
 470         dprintf_cursor( stddeb, "LoadCursor16: %04x '%s'\n",
 471                         hInstance, (char *)PTR_SEG_TO_LIN( name ) );
 472     else
 473         dprintf_cursor( stddeb, "LoadCursor16: %04x %04x\n",
 474                         hInstance, LOWORD(name) );
 475
 476     return CURSORICON_Load( hInstance, name,
 477                             SYSMETRICS_CXCURSOR, SYSMETRICS_CYCURSOR, 1, TRUE);
 478 }
 479
 480
 481 /***********************************************************************
 482  *           LoadIcon    (USER.174)
 483  */
 484 HICON16 LoadIcon16(HINSTANCE16 hInstance,SEGPTR name)
 485 {
 486     if (HIWORD(name))
 487         dprintf_icon( stddeb, "LoadIcon: %04x '%s'\n",
 488                       hInstance, (char *)PTR_SEG_TO_LIN( name ) );
 489     else
 490         dprintf_icon( stddeb, "LoadIcon: %04x %04x\n",
 491                       hInstance, LOWORD(name) );
 492
 493     return CURSORICON_Load( hInstance, name,
 494                             SYSMETRICS_CXICON, SYSMETRICS_CYICON,
 495                             MIN( 16, COLOR_GetSystemPaletteSize() ), FALSE );
 496 }
 497
 498
 499 /***********************************************************************
 500  *           CreateCursor    (USER.406)
 501  */
 502 HCURSOR16 CreateCursor( HINSTANCE hInstance, INT xHotSpot, INT yHotSpot,
 503                         INT nWidth, INT nHeight,
 504                         const BYTE *lpANDbits, const BYTE *lpXORbits )
 505 {
 506     CURSORICONINFO info = { { xHotSpot, yHotSpot }, nWidth, nHeight, 0, 1, 1 };
 507
 508     dprintf_cursor( stddeb, "CreateCursor: %dx%d spot=%d,%d xor=%p and=%p\n",
 509                     nWidth, nHeight, xHotSpot, yHotSpot, lpXORbits, lpANDbits);
 510     return CreateCursorIconIndirect( hInstance, &info, lpANDbits, lpXORbits );
 511 }
 512
 513
 514 /***********************************************************************
 515  *           CreateIcon    (USER.407)
 516  */
 517 HICON16 CreateIcon( HINSTANCE hInstance, INT nWidth, INT nHeight, BYTE bPlanes,
 518                   BYTE bBitsPixel, const BYTE* lpANDbits, const BYTE* lpXORbits)
 519 {
 520     CURSORICONINFO info = { { 0, 0 }, nWidth, nHeight, 0, bPlanes, bBitsPixel };
 521
 522     dprintf_icon( stddeb, "CreateIcon: %dx%dx%d, xor=%p, and=%p\n",
 523                   nWidth, nHeight, bPlanes * bBitsPixel, lpXORbits, lpANDbits);
 524     return CreateCursorIconIndirect( hInstance, &info, lpANDbits, lpXORbits );
 525 }
 526
 527
 528 /***********************************************************************
 529  *           CreateCursorIconIndirect    (USER.408)
 530  */
 531 HANDLE CreateCursorIconIndirect( HANDLE hInstance, CURSORICONINFO *info,
 532                                  const BYTE *lpANDbits, const BYTE *lpXORbits )
 533 {
 534     HANDLE handle;
 535     char *ptr;
 536     int sizeAnd, sizeXor;
 537
 538     hInstance = GetExePtr( hInstance );  /* Make it a module handle */
 539     if (!hInstance || !lpXORbits || !lpANDbits || info->bPlanes != 1) return 0;
 540     info->nWidthBytes = BITMAP_WIDTH_BYTES(info->nWidth,info->bBitsPerPixel);
 541     sizeXor = info->nHeight * info->nWidthBytes;
 542     sizeAnd = info->nHeight * BITMAP_WIDTH_BYTES( info->nWidth, 1 );
 543     if (!(handle = DirectResAlloc(hInstance, 0x10,
 544                                   sizeof(CURSORICONINFO) + sizeXor + sizeAnd)))
 545         return 0;
 546     ptr = (char *)GlobalLock16( handle );
 547     memcpy( ptr, info, sizeof(*info) );
 548     memcpy( ptr + sizeof(CURSORICONINFO), lpANDbits, sizeAnd );
 549     memcpy( ptr + sizeof(CURSORICONINFO) + sizeAnd, lpXORbits, sizeXor );
 550     GlobalUnlock16( handle );
 551     return handle;
 552 }
 553
 554
 555 /***********************************************************************
 556  *           CopyIcon16    (USER.368)
 557  */
 558 HICON16 CopyIcon16( HINSTANCE16 hInstance, HICON16 hIcon )
 559 {
 560     dprintf_icon( stddeb, "CopyIcon16: %04x %04x\n", hInstance, hIcon );
 561     return CURSORICON_Copy( hInstance, hIcon );
 562 }
 563
 564
 565 /***********************************************************************
 566  *           CopyIcon32    (USER32.59)
 567  */
 568 HICON32 CopyIcon32( HICON32 hIcon )
 569 {
 570     dprintf_icon( stddeb, "CopyIcon32: %04x\n", hIcon );
 571     return CURSORICON_Copy( 0, hIcon );
 572 }
 573
 574
 575 /***********************************************************************
 576  *           CopyCursor16    (USER.369)
 577  */
 578 HCURSOR16 CopyCursor16( HINSTANCE16 hInstance, HCURSOR16 hCursor )
 579 {
 580     dprintf_cursor( stddeb, "CopyCursor16: %04x %04x\n", hInstance, hCursor );
 581     return CURSORICON_Copy( hInstance, hCursor );
 582 }
 583
 584
 585 /***********************************************************************
 586  *           DestroyIcon    (USER.457)
 587  */
 588 BOOL DestroyIcon( HICON16 hIcon )
 589 {
 590     dprintf_icon( stddeb, "DestroyIcon: %04x\n", hIcon );
 591     /* FIXME: should check for OEM icon here */
 592     return (GlobalFree16( hIcon ) != 0);
 593 }
 594
 595
 596 /***********************************************************************
 597  *           DestroyCursor    (USER.458)
 598  */
 599 BOOL DestroyCursor( HCURSOR16 hCursor )
 600 {
 601     dprintf_cursor( stddeb, "DestroyCursor: %04x\n", hCursor );
 602     /* FIXME: should check for OEM cursor here */
 603     return (GlobalFree16( hCursor ) != 0);
 604 }
 605
 606
 607 /***********************************************************************
 608  *           DrawIcon    (USER.84)
 609  */
 610 BOOL DrawIcon( HDC hdc, INT x, INT y, HICON16 hIcon )
 611 {
 612     CURSORICONINFO *ptr;
 613     HDC hMemDC;
 614     HBITMAP hXorBits, hAndBits;
 615     COLORREF oldFg, oldBg;
 616
 617     if (!(ptr = (CURSORICONINFO *)GlobalLock16( hIcon ))) return FALSE;
 618     if (!(hMemDC = CreateCompatibleDC( hdc ))) return FALSE;
 619     hAndBits = CreateBitmap( ptr->nWidth, ptr->nHeight, 1, 1, (char *)(ptr+1));
 620     hXorBits = CreateBitmap( ptr->nWidth, ptr->nHeight, ptr->bPlanes,
 621                              ptr->bBitsPerPixel, (char *)(ptr + 1)
 622                          + ptr->nHeight * BITMAP_WIDTH_BYTES(ptr->nWidth,1) );
 623     oldFg = SetTextColor( hdc, RGB(0,0,0) );
 624     oldBg = SetBkColor( hdc, RGB(255,255,255) );
 625
 626     if (hXorBits && hAndBits)
 627     {
 628         HBITMAP hBitTemp = SelectObject( hMemDC, hAndBits );
 629         BitBlt( hdc, x, y, ptr->nWidth, ptr->nHeight, hMemDC, 0, 0, SRCAND );
 630         SelectObject( hMemDC, hXorBits );
 631         BitBlt( hdc, x, y, ptr->nWidth, ptr->nHeight, hMemDC, 0, 0, SRCINVERT);
 632         SelectObject( hMemDC, hBitTemp );
 633     }
 634     DeleteDC( hMemDC );
 635     if (hXorBits) DeleteObject( hXorBits );
 636     if (hAndBits) DeleteObject( hAndBits );
 637     GlobalUnlock16( hIcon );
 638     SetTextColor( hdc, oldFg );
 639     SetBkColor( hdc, oldBg );
 640     return TRUE;
 641 }
 642
 643
 644 /***********************************************************************
 645  *           DumpIcon    (USER.459)
 646  */
 647 DWORD DumpIcon( SEGPTR pInfo, WORD *lpLen,
 648                 SEGPTR *lpXorBits, SEGPTR *lpAndBits )
 649 {
 650     CURSORICONINFO *info = PTR_SEG_TO_LIN( pInfo );
 651     int sizeAnd, sizeXor;
 652
 653     if (!info) return 0;
 654     sizeXor = info->nHeight * info->nWidthBytes;
 655     sizeAnd = info->nHeight * BITMAP_WIDTH_BYTES( info->nWidth, 1 );
 656     if (lpAndBits) *lpAndBits = pInfo + sizeof(CURSORICONINFO);
 657     if (lpXorBits) *lpXorBits = pInfo + sizeof(CURSORICONINFO) + sizeAnd;
 658     if (lpLen) *lpLen = sizeof(CURSORICONINFO) + sizeAnd + sizeXor;
 659     return MAKELONG( sizeXor, sizeXor );
 660 }
 661
 662
 663 /***********************************************************************
 664  *           CURSORICON_SetCursor
 665  *
 666  * Change the X cursor. Helper function for SetCursor() and ShowCursor().
 667  */
 668 static BOOL CURSORICON_SetCursor( HCURSOR16 hCursor )
 669 {
 670     Pixmap pixmapBits, pixmapMask, pixmapAll;
 671     XColor fg, bg;
 672     Cursor cursor = None;
 673
 674     if (!hCursor)  /* Create an empty cursor */
 675     {
 676         static const char data[] = { 0 };
 677
 678         bg.red = bg.green = bg.blue = 0x0000;
 679         pixmapBits = XCreateBitmapFromData( display, rootWindow, data, 1, 1 );
 680         if (pixmapBits)
 681         {
 682             cursor = XCreatePixmapCursor( display, pixmapBits, pixmapBits,
 683                                           &bg, &bg, 0, 0 );
 684             XFreePixmap( display, pixmapBits );
 685         }
 686     }
 687     else  /* Create the X cursor from the bits */
 688     {
 689         CURSORICONINFO *ptr;
 690         XImage *image;
 691
 692         if (!(ptr = (CURSORICONINFO*)GlobalLock16( hCursor ))) return FALSE;
 693         if (ptr->bPlanes * ptr->bBitsPerPixel != 1)
 694         {
 695             fprintf( stderr, "Cursor %04x has more than 1 bpp!\n", hCursor );
 696             return FALSE;
 697         }
 698
 699         /* Create a pixmap and transfer all the bits to it */
 700
 701         pixmapAll = XCreatePixmap( display, rootWindow,
 702                                    ptr->nWidth, ptr->nHeight * 2, 1 );
 703         image = XCreateImage( display, DefaultVisualOfScreen(screen),
 704                               1, ZPixmap, 0, (char *)(ptr + 1), ptr->nWidth,
 705                               ptr->nHeight * 2, 16, ptr->nWidthBytes);
 706         if (image)
 707         {
 708             extern void _XInitImageFuncPtrs( XImage* );
 709             image->byte_order = MSBFirst;
 710             image->bitmap_bit_order = MSBFirst;
 711             image->bitmap_unit = 16;
 712             _XInitImageFuncPtrs(image);
 713             if (pixmapAll)
 714                 CallTo32_LargeStack( XPutImage, 10,
 715                                      display, pixmapAll, BITMAP_monoGC, image,
 716                                      0, 0, 0, 0, ptr->nWidth, ptr->nHeight*2 );
 717             image->data = NULL;
 718             XDestroyImage( image );
 719         }
 720
 721         /* Now create the 2 pixmaps for bits and mask */
 722
 723         pixmapBits = XCreatePixmap( display, rootWindow,
 724                                     ptr->nWidth, ptr->nHeight, 1 );
 725         pixmapMask = XCreatePixmap( display, rootWindow,
 726                                     ptr->nWidth, ptr->nHeight, 1 );
 727
 728         /* Make sure everything went OK so far */
 729
 730         if (pixmapBits && pixmapMask && pixmapAll)
 731         {
 732             /* We have to do some magic here, as cursors are not fully
 733              * compatible between Windows and X11. Under X11, there
 734              * are only 3 possible color cursor: black, white and
 735              * masked. So we map the 4th Windows color (invert the
 736              * bits on the screen) to black. This require some boolean
 737              * arithmetic:
 738              *
 739              *         Windows          |          X11
 740              * Xor    And      Result   |   Bits     Mask     Result
 741              *  0      0     black      |    0        1     background
 742              *  0      1     no change  |    X        0     no change
 743              *  1      0     white      |    1        1     foreground
 744              *  1      1     inverted   |    0        1     background
 745              *
 746              * which gives:
 747              *  Bits = 'Xor' and not 'And'
 748              *  Mask = 'Xor' or not 'And'
 749              *
 750              * FIXME: apparently some servers do support 'inverted' color.
 751              * I don't know if it's correct per the X spec, but maybe
 752              * we ought to take advantage of it.  -- AJ
 753              */
 754             XCopyArea( display, pixmapAll, pixmapBits, BITMAP_monoGC,
 755                        0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
 756             XCopyArea( display, pixmapAll, pixmapMask, BITMAP_monoGC,
 757                        0, 0, ptr->nWidth, ptr->nHeight, 0, 0 );
 758             XSetFunction( display, BITMAP_monoGC, GXandReverse );
 759             XCopyArea( display, pixmapAll, pixmapBits, BITMAP_monoGC,
 760                        0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
 761             XSetFunction( display, BITMAP_monoGC, GXorReverse );
 762             XCopyArea( display, pixmapAll, pixmapMask, BITMAP_monoGC,
 763                        0, ptr->nHeight, ptr->nWidth, ptr->nHeight, 0, 0 );
 764             XSetFunction( display, BITMAP_monoGC, GXcopy );
 765             fg.red = fg.green = fg.blue = 0xffff;
 766             bg.red = bg.green = bg.blue = 0x0000;
 767             cursor = XCreatePixmapCursor( display, pixmapBits, pixmapMask,
 768                                 &fg, &bg, ptr->ptHotSpot.x, ptr->ptHotSpot.y );
 769         }
 770
 771         /* Now free everything */
 772
 773         if (pixmapAll) XFreePixmap( display, pixmapAll );
 774         if (pixmapBits) XFreePixmap( display, pixmapBits );
 775         if (pixmapMask) XFreePixmap( display, pixmapMask );
 776         GlobalUnlock16( hCursor );
 777     }
 778
 779     if (cursor == None) return FALSE;
 780     if (CURSORICON_XCursor != None) XFreeCursor( display, CURSORICON_XCursor );
 781     CURSORICON_XCursor = cursor;
 782
 783     if (rootWindow != DefaultRootWindow(display))
 784     {
 785         /* Set the cursor on the desktop window */
 786         XDefineCursor( display, rootWindow, cursor );
 787     }
 788     else
 789     {
 790         /* Set the same cursor for all top-level windows */
 791         HWND hwnd = GetWindow( GetDesktopWindow32(), GW_CHILD );
 792         while(hwnd)
 793         {
 794             Window win = WIN_GetXWindow( hwnd );
 795             if (win) XDefineCursor( display, win, cursor );
 796             hwnd = GetWindow( hwnd, GW_HWNDNEXT );
 797         }
 798     }
 799     return TRUE;
 800 }
 801
 802
 803 /***********************************************************************
 804  *           SetCursor    (USER.69)
 805  */
 806 HCURSOR16 SetCursor( HCURSOR16 hCursor )
 807 {
 808     HCURSOR16 hOldCursor;
 809
 810     if (hCursor == hActiveCursor) return hActiveCursor;  /* No change */
 811     dprintf_cursor( stddeb, "SetCursor: %04x\n", hCursor );
 812     hOldCursor = hActiveCursor;
 813     hActiveCursor = hCursor;
 814     /* Change the cursor shape only if it is visible */
 815     if (CURSOR_ShowCount >= 0) CURSORICON_SetCursor( hActiveCursor );
 816     return hOldCursor;
 817 }
 818
 819
 820 /***********************************************************************
 821  *           SetCursorPos    (USER.70)
 822  */
 823 void SetCursorPos( short x, short y )
 824 {
 825     dprintf_cursor( stddeb, "SetCursorPos: x=%d y=%d\n", x, y );
 826     XWarpPointer( display, rootWindow, rootWindow, 0, 0, 0, 0, x, y );
 827 }
 828
 829
 830 /***********************************************************************
 831  *           ShowCursor    (USER.71)
 832  */
 833 int ShowCursor( BOOL bShow )
 834 {
 835     dprintf_cursor( stddeb, "ShowCursor: %d, count=%d\n",
 836                     bShow, CURSOR_ShowCount );
 837
 838     if (bShow)
 839     {
 840         if (++CURSOR_ShowCount == 0)
 841             CURSORICON_SetCursor( hActiveCursor );  /* Show it */
 842     }
 843     else
 844     {
 845         if (--CURSOR_ShowCount == -1)
 846             CURSORICON_SetCursor( 0 );  /* Hide it */
 847     }
 848     return CURSOR_ShowCount;
 849 }
 850
 851
 852 /***********************************************************************
 853  *           GetCursor    (USER.247)
 854  */
 855 HCURSOR16 GetCursor(void)
 856 {
 857     return hActiveCursor;
 858 }
 859
 860
 861 /***********************************************************************
 862  *           ClipCursor16    (USER.16)
 863  */
 864 BOOL16 ClipCursor16( const RECT16 *rect )
 865 {
 866     if (!rect) SetRectEmpty32( &CURSOR_ClipRect );
 867     else CONV_RECT16TO32( rect, &CURSOR_ClipRect );
 868     return TRUE;
 869 }
 870
 871
 872 /***********************************************************************
 873  *           ClipCursor32    (USER32.52)
 874  */
 875 BOOL32 ClipCursor32( const RECT32 *rect )
 876 {
 877     if (!rect) SetRectEmpty32( &CURSOR_ClipRect );
 878     else CopyRect32( &CURSOR_ClipRect, rect );
 879     return TRUE;
 880 }
 881
 882
 883 /***********************************************************************
 884  *           GetCursorPos16    (USER.17)
 885  */
 886 void GetCursorPos16( POINT16 *pt )
 887 {
 888     Window root, child;
 889     int rootX, rootY, childX, childY;
 890     unsigned int mousebut;
 891
 892     if (!pt) return;
 893     if (!XQueryPointer( display, rootWindow, &root, &child,
 894                         &rootX, &rootY, &childX, &childY, &mousebut ))
 895         pt->x = pt->y = 0;
 896     else
 897     {
 898         pt->x = rootX + desktopX;
 899         pt->y = rootY + desktopY;
 900     }
 901     dprintf_cursor(stddeb, "GetCursorPos: ret=%d,%d\n", pt->x, pt->y );
 902 }
 903
 904
 905 /***********************************************************************
 906  *           GetCursorPos32    (USER32.228)
 907  */
 908 void GetCursorPos32( POINT32 *pt )
 909 {
 910     POINT16 pt16;
 911     GetCursorPos16( &pt16 );
 912     if (pt) CONV_POINT16TO32( &pt16, pt );
 913 }
 914
 915
 916 /***********************************************************************
 917  *           GetClipCursor16    (USER.309)
 918  */
 919 void GetClipCursor16( RECT16 *rect )
 920 {
 921     if (rect) CONV_RECT32TO16( &CURSOR_ClipRect, rect );
 922 }
 923
 924
 925 /***********************************************************************
 926  *           GetClipCursor32    (USER32.220)
 927  */
 928 void GetClipCursor32( RECT32 *rect )
 929 {
 930     if (rect) CopyRect32( rect, &CURSOR_ClipRect );
 931 }
 932
 933
 934 /**********************************************************************
 935  *          GetIconID    (USER.455)
 936  */
 937 WORD GetIconID( HANDLE hResource, DWORD resType )
 938 {
 939     CURSORICONDIR *lpDir = (CURSORICONDIR *)GlobalLock16(hResource);
 940 /* LockResource16(hResource); */
 941
 942     if (!lpDir || lpDir->idReserved ||
 943         ((lpDir->idType != 1) && (lpDir->idType != 2)))
 944     {
 945         dprintf_cursor(stddeb,"GetIconID: invalid resource directory\n");
 946         return 0;
 947     }
 948
 949     dprintf_cursor( stddeb, "GetIconID: hRes=%04x, entries=%i\n",
 950                     hResource, lpDir->idCount );
 951
 952     switch(resType)
 953     {
 954     case 1:  /* cursor */
 955         {
 956             CURSORDIRENTRY *entry = CURSORICON_FindBestCursor( lpDir,
 957                                     SYSMETRICS_CXCURSOR, SYSMETRICS_CYCURSOR );
 958             return entry ? entry->wResId : 0;
 959         }
 960     case 3:  /* icon */
 961         {
 962             ICONDIRENTRY * entry =  CURSORICON_FindBestIcon( lpDir,
 963                                     SYSMETRICS_CXICON, SYSMETRICS_CYICON,
 964                                     MIN( 16, COLOR_GetSystemPaletteSize() ) );
 965             return entry ? entry->wResId : 0;
 966         }
 967     }
 968     fprintf( stderr, "GetIconID: invalid res type %ld\n", resType );
 969     return 0;
 970 }
 971
 972
 973 /**********************************************************************
 974  *          LoadIconHandler    (USER.456)
 975  */
 976 HICON16 LoadIconHandler( HANDLE hResource, BOOL bNew )
 977 {
 978     dprintf_cursor(stddeb,"LoadIconHandler: hRes=%04x\n",hResource);
 979
 980     if( !bNew )
 981       {
 982         fprintf(stdnimp,"LoadIconHandler: 2.xx resources are not supported\n");
 983         return 0;
 984       }
 985     return CURSORICON_LoadHandler( hResource, 0, FALSE);
 986 }