git.oblomov.eu Git - wine/blob - graphics/x11drv/oembitmap.c

   1 /*
   2  * X11DRV OEM bitmap objects
   3  *
   4  * Copyright 1994, 1995 Alexandre Julliard
   5  *
   6  */
   7
   8 #include "config.h"
   9
  10 #include "ts_xlib.h"
  11 #include "ts_xutil.h"
  12
  13 #ifdef HAVE_LIBXXPM
  14 #include "ts_xpm.h"
  15 #else /* defined(HAVE_LIBXXPM) */
  16 typedef unsigned long Pixel;
  17 #endif /* defined(HAVE_LIBXXPM) */
  18
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 #include "bitmap.h"
  23 #include "callback.h"
  24 #include "color.h"
  25 #include "cursoricon.h"
  26 #include "debugtools.h"
  27 #include "gdi.h"
  28 #include "heap.h"
  29 #include "user.h" /* for TWEAK_WineLook (FIXME) */
  30 #include "x11drv.h"
  31
  32   /* Include OEM pixmaps */
  33 #include "bitmaps/obm_lfarrowi"
  34 #include "bitmaps/obm_rgarrowi"
  35 #include "bitmaps/obm_dnarrowi"
  36 #include "bitmaps/obm_uparrowi"
  37 #include "bitmaps/obm_combo"
  38 #include "bitmaps/obm_mnarrow"
  39 #include "bitmaps/obm_lfarrowd"
  40 #include "bitmaps/obm_rgarrowd"
  41 #include "bitmaps/obm_dnarrowd"
  42 #include "bitmaps/obm_uparrowd"
  43 #include "bitmaps/obm_restored"
  44 #include "bitmaps/obm_restore"
  45 #include "bitmaps/obm_lfarrow"
  46 #include "bitmaps/obm_rgarrow"
  47 #include "bitmaps/obm_dnarrow"
  48 #include "bitmaps/obm_uparrow"
  49 #include "bitmaps/obm_old_restore"
  50 #include "bitmaps/obm_old_zoom"
  51 #include "bitmaps/obm_old_reduce"
  52 #include "bitmaps/obm_btncorners"
  53 #include "bitmaps/obm_checkboxes"
  54 #include "bitmaps/obm_check"
  55 #include "bitmaps/obm_btsize"
  56 #include "bitmaps/obm_old_lfarrow"
  57 #include "bitmaps/obm_old_rgarrow"
  58 #include "bitmaps/obm_old_dnarrow"
  59 #include "bitmaps/obm_old_uparrow"
  60 #include "bitmaps/obm_size"
  61 #include "bitmaps/obm_old_close"
  62 #include "bitmaps/obm_trtype"
  63 #include "bitmaps/obm_radiocheck"
  64
  65 #include "bitmaps/obm_zoomd"
  66 #include "bitmaps/obm_reduced"
  67 #include "bitmaps/obm_zoom"
  68 #include "bitmaps/obm_reduce"
  69 #include "bitmaps/obm_close"
  70 #include "bitmaps/obm_zoomd_95"
  71 #include "bitmaps/obm_reduced_95"
  72 #include "bitmaps/obm_zoom_95"
  73 #include "bitmaps/obm_reduce_95"
  74 #include "bitmaps/obm_close_95"
  75 #include "bitmaps/obm_closed_95"
  76 #include "bitmaps/obm_restore_95"
  77 #include "bitmaps/obm_restored_95"
  78
  79 DECLARE_DEBUG_CHANNEL(bitmap);
  80 DECLARE_DEBUG_CHANNEL(cursor);
  81 DECLARE_DEBUG_CHANNEL(x11drv);
  82
  83
  84 #define OBM_FIRST  OBM_CLOSED  /* First OEM bitmap */
  85 #define OBM_LAST   OBM_OLD_CLOSE   /* Last OEM bitmap */
  86
  87 static struct
  88 {
  89     char** data;   /* Pointer to bitmap data */
  90     BOOL color;  /* Is it a color bitmap?  */
  91 } OBM_Pixmaps_Data[OBM_LAST-OBM_FIRST+1] = {
  92     { obm_closed_95,TRUE},      /* OBM_CLOSED */
  93     { obm_radiocheck, FALSE },  /* OBM_RADIOCHECK */
  94     { obm_trtype, TRUE },       /* OBM_TRTYPE */
  95     { obm_lfarrowi, TRUE },     /* OBM_LFARROWI */
  96     { obm_rgarrowi, TRUE },     /* OBM_RGARROWI */
  97     { obm_dnarrowi, TRUE },     /* OBM_DNARROWI */
  98     { obm_uparrowi, TRUE },     /* OBM_UPARROWI */
  99     { obm_combo, FALSE },       /* OBM_COMBO */
 100     { obm_mnarrow, FALSE },     /* OBM_MNARROW */
 101     { obm_lfarrowd, TRUE },     /* OBM_LFARROWD */
 102     { obm_rgarrowd, TRUE },     /* OBM_RGARROWD */
 103     { obm_dnarrowd, TRUE },     /* OBM_DNARROWD */
 104     { obm_uparrowd, TRUE },     /* OBM_UPARROWD */
 105     { obm_restored, TRUE },     /* OBM_RESTORED */
 106     { obm_zoomd, TRUE },        /* OBM_ZOOMD */
 107     { obm_reduced, TRUE },      /* OBM_REDUCED */
 108     { obm_restore, TRUE },      /* OBM_RESTORE */
 109     { obm_zoom, TRUE },         /* OBM_ZOOM */
 110     { obm_reduce, TRUE },       /* OBM_REDUCE */
 111     { obm_lfarrow, TRUE },      /* OBM_LFARROW */
 112     { obm_rgarrow, TRUE },      /* OBM_RGARROW */
 113     { obm_dnarrow, TRUE },      /* OBM_DNARROW */
 114     { obm_uparrow, TRUE },      /* OBM_UPARROW */
 115     { obm_close, TRUE },        /* OBM_CLOSE */
 116     { obm_old_restore, FALSE }, /* OBM_OLD_RESTORE */
 117     { obm_old_zoom, FALSE },    /* OBM_OLD_ZOOM */
 118     { obm_old_reduce, FALSE },  /* OBM_OLD_REDUCE */
 119     { obm_btncorners, FALSE },  /* OBM_BTNCORNERS */
 120     { obm_checkboxes, FALSE },  /* OBM_CHECKBOXES */
 121     { obm_check, FALSE },       /* OBM_CHECK */
 122     { obm_btsize, FALSE },      /* OBM_BTSIZE */
 123     { obm_old_lfarrow, FALSE }, /* OBM_OLD_LFARROW */
 124     { obm_old_rgarrow, FALSE }, /* OBM_OLD_RGARROW */
 125     { obm_old_dnarrow, FALSE }, /* OBM_OLD_DNARROW */
 126     { obm_old_uparrow, FALSE }, /* OBM_OLD_UPARROW */
 127     { obm_size, FALSE },        /* OBM_SIZE */
 128     { obm_old_close, FALSE },   /* OBM_OLD_CLOSE */
 129 };
 130
 131
 132   /* Include OEM icons */
 133 #include "bitmaps/oic_sample"
 134 #include "bitmaps/oic_hand"
 135 #include "bitmaps/oic_ques"
 136 #include "bitmaps/oic_bang"
 137 #include "bitmaps/oic_note"
 138 #include "bitmaps/oic_portrait"
 139 #include "bitmaps/oic_landscape"
 140 #include "bitmaps/oic_wineicon"
 141 #include "bitmaps/oic_hand_95"
 142 #include "bitmaps/oic_ques_95"
 143 #include "bitmaps/oic_bang_95"
 144 #include "bitmaps/oic_note_95"
 145 #include "bitmaps/oic_folder"
 146 #include "bitmaps/oic_folder2"
 147 #include "bitmaps/oic_floppy"
 148 #include "bitmaps/oic_cdrom"
 149 #include "bitmaps/oic_hdisk"
 150 #include "bitmaps/oic_network"
 151
 152 #define OIC_FIRST  OIC_SAMPLE      /* First OEM icon */
 153 #define OIC_LAST   OIC_NETWORK     /* Last OEM icon */
 154
 155 static char **OBM_Icons_Data[OIC_LAST-OIC_FIRST+1] =
 156 {
 157     oic_sample,    /* OIC_SAMPLE */
 158     oic_hand,      /* OIC_HAND */
 159     oic_ques,      /* OIC_QUES */
 160     oic_bang,      /* OIC_BANG */
 161     oic_note,      /* OIC_NOTE */
 162     oic_portrait,  /* OIC_PORTRAIT */
 163     oic_landscape, /* OIC_LANDSCAPE */
 164     oic_wineicon,  /* OIC_WINEICON */
 165     oic_folder,    /* OIC_FOLDER */
 166     oic_folder2,   /* OIC_FOLDER2 */
 167     oic_floppy,    /* OIC_FLOPPY */
 168     oic_cdrom,     /* OIC_CDROM */
 169     oic_hdisk,     /* OIC_HDISK */
 170     oic_network    /* OIC_NETWORK */
 171 };
 172
 173
 174   /* Include OEM cursors */
 175 #include "bitmaps/ocr_normal"
 176 #include "bitmaps/ocr_ibeam"
 177 #include "bitmaps/ocr_wait"
 178 #include "bitmaps/ocr_cross"
 179 #include "bitmaps/ocr_up"
 180 #include "bitmaps/ocr_size"
 181 #include "bitmaps/ocr_icon"
 182 #include "bitmaps/ocr_sizenwse"
 183 #include "bitmaps/ocr_sizenesw"
 184 #include "bitmaps/ocr_sizewe"
 185 #include "bitmaps/ocr_sizens"
 186 #include "bitmaps/ocr_bummer"
 187 #include "bitmaps/ocr_dragobject"
 188 #include "bitmaps/ocr_hand"
 189 /*#include "bitmaps/ocr_sizeall"*/
 190 /*#include "bitmaps/ocr_icocur"*/
 191 #include "bitmaps/ocr_no"
 192 #include "bitmaps/ocr_appstarting"
 193 #include "bitmaps/ocr_help"
 194
 195 /* Cursor are not all contiguous (go figure...) */
 196 #define OCR_FIRST0 OCR_BUMMER
 197 #define OCR_LAST0  OCR_DRAGOBJECT
 198 #define OCR_BASE0       0
 199
 200 #define OCR_FIRST1 OCR_NORMAL
 201 #define OCR_LAST1  OCR_UP
 202 #define OCR_BASE1       (OCR_BASE0 + OCR_LAST0 - OCR_FIRST0 + 1)
 203
 204 #define OCR_FIRST2 OCR_SIZE
 205 #define OCR_LAST2  OCR_SIZEALL
 206 #define OCR_BASE2       (OCR_BASE1 + OCR_LAST1 - OCR_FIRST1 + 1)
 207
 208 #define OCR_FIRST3 OCR_NO
 209 #define OCR_LAST3  OCR_APPSTARTING
 210 #define OCR_BASE3       (OCR_BASE2 + OCR_LAST2 - OCR_FIRST2 + 1)
 211
 212 #define OCR_FIRST4 OCR_HELP
 213 #define OCR_LAST4  OCR_HELP
 214 #define OCR_BASE4       (OCR_BASE3 + OCR_LAST3 - OCR_FIRST3 + 1)
 215
 216 #define NB_CURSORS (OCR_BASE4 + OCR_LAST4 - OCR_FIRST4 + 1)
 217 static char **OBM_Cursors_Data[NB_CURSORS] =
 218 {
 219     ocr_bummer,      /* OCR_BUMMER */
 220     ocr_dragobject,  /* OCR_DRAGOBJECT */
 221     ocr_normal,      /* OCR_NORMAL */
 222     ocr_ibeam,       /* OCR_IBEAM */
 223     ocr_wait,        /* OCR_WAIT */
 224     ocr_cross,       /* OCR_CROSS */
 225     ocr_up,          /* OCR_UP */
 226     ocr_size,        /* OCR_SIZE */
 227     ocr_icon,        /* OCR_ICON */
 228     ocr_sizenwse,    /* OCR_SIZENWSE */
 229     ocr_sizenesw,    /* OCR_SIZENESW */
 230     ocr_sizewe,      /* OCR_SIZEWE */
 231     ocr_sizens,      /* OCR_SIZENS */
 232     ocr_size,        /* OCR_SIZEALL */ /* Re-used the same one as OCR_SIZE for now */
 233 #if 0
 234     ocr_icocur       /* OCR_ICOCUR */
 235 #endif
 236     ocr_no,          /* OCR_NO */
 237     ocr_hand,        /* OCR_HAND */
 238     ocr_appstarting, /* OCR_APPSTARTING */
 239     ocr_help         /* OCR_HELP */
 240 };
 241
 242 static HGLOBAL16 OBM_Cursors[NB_CURSORS];
 243
 244
 245   /* All the colors used in the xpm files must be included in this   */
 246   /* list, to make sure that the loaded bitmaps only use colors from */
 247   /* the Windows colormap. Note: the PALETTEINDEX() are not really   */
 248   /* palette indexes, but system colors that will be converted to    */
 249   /* indexes later on.                                               */
 250
 251 #ifdef HAVE_LIBXXPM
 252 static XpmColorSymbol
 253 #else /* defined(HAVE_LIBXXPM) */
 254 static struct
 255 {
 256     char  *name;
 257     char  *value;
 258     Pixel  pixel;
 259 }
 260 #endif /* defined(HAVE_LIBXXPM) */
 261 OBM_Colors[] =
 262 {
 263     { "black",            NULL, (Pixel)RGB(0,0,0) },
 264     { "white",            NULL, (Pixel)RGB(255,255,255) },
 265     { "red",              NULL, (Pixel)RGB(255,0,0) },
 266     { "green",            NULL, (Pixel)RGB(0,255,0) },
 267     { "blue",             NULL, (Pixel)RGB(0,0,255) },
 268     { "yellow",           NULL, (Pixel)RGB(255,255,0) },
 269     { "cyan",             NULL, (Pixel)RGB(0,255,255) },
 270     { "dkyellow",         NULL, (Pixel)RGB(128,128,0) },
 271     { "purple",           NULL, (Pixel)RGB(128,0,128) },
 272     { "ltgray",           NULL, (Pixel)RGB(192,192,192) },
 273     { "dkgray",           NULL, (Pixel)RGB(128,128,128) },
 274     { "button_face",      NULL, (Pixel)PALETTEINDEX(COLOR_BTNFACE) },
 275     { "button_shadow",    NULL, (Pixel)PALETTEINDEX(COLOR_BTNSHADOW) },
 276     { "button_highlight", NULL, (Pixel)PALETTEINDEX(COLOR_BTNHIGHLIGHT) },
 277     { "button_edge",      NULL, (Pixel)PALETTEINDEX(COLOR_BTNHIGHLIGHT) },
 278     { "button_text",      NULL, (Pixel)PALETTEINDEX(COLOR_BTNTEXT) },
 279     { "window_frame",     NULL, (Pixel)PALETTEINDEX(COLOR_WINDOWFRAME) }
 280 };
 281
 282 #define NB_COLOR_SYMBOLS (sizeof(OBM_Colors)/sizeof(OBM_Colors[0]))
 283
 284   /* These are the symbolic colors for monochrome bitmaps   */
 285   /* This is needed to make sure that black is always 0 and */
 286   /* white always 1, as required by Windows.                */
 287
 288 #ifdef HAVE_LIBXXPM
 289 static XpmColorSymbol OBM_BlackAndWhite[2] =
 290 {
 291     { "black", NULL, 0 },
 292     { "white", NULL, 0xffffffff }
 293 };
 294 #endif /* defined(HAVE_LIBXXPM) */
 295
 296
 297
 298 /***********************************************************************
 299  *           OBM_InitColorSymbols
 300  */
 301 static BOOL OBM_InitColorSymbols()
 302 {
 303     static BOOL initialized = FALSE;
 304     int i;
 305
 306     if (initialized) return TRUE;  /* Already initialised */
 307     initialized = TRUE;
 308
 309     for (i = 0; i < NB_COLOR_SYMBOLS; i++)
 310     {
 311         if (OBM_Colors[i].pixel & 0xff000000)  /* PALETTEINDEX */
 312             OBM_Colors[i].pixel = X11DRV_PALETTE_ToPhysical( NULL,
 313                                     GetSysColor(OBM_Colors[i].pixel & 0xff));
 314         else  /* RGB*/
 315             OBM_Colors[i].pixel = X11DRV_PALETTE_ToPhysical( NULL, OBM_Colors[i].pixel);
 316     }
 317     return TRUE;
 318 }
 319
 320
 321 /***********************************************************************
 322  *           OBM_MakeBitmap
 323  *
 324  * Allocate a GDI bitmap.
 325  */
 326 #ifdef HAVE_LIBXXPM
 327 static HBITMAP16 OBM_MakeBitmap( WORD width, WORD height,
 328                                  WORD bpp, Pixmap pixmap )
 329 {
 330     HBITMAP hbitmap;
 331     BITMAPOBJ * bmpObjPtr;
 332
 333     if (!pixmap) return 0;
 334
 335     if (!(bmpObjPtr = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC, &hbitmap ))) return 0;
 336     bmpObjPtr->size.cx = width;
 337     bmpObjPtr->size.cy = height;
 338     bmpObjPtr->bitmap.bmType       = 0;
 339     bmpObjPtr->bitmap.bmWidth      = width;
 340     bmpObjPtr->bitmap.bmHeight     = height;
 341     bmpObjPtr->bitmap.bmWidthBytes = BITMAP_GetWidthBytes( width, bpp );
 342     bmpObjPtr->bitmap.bmPlanes     = 1;
 343     bmpObjPtr->bitmap.bmBitsPixel  = bpp;
 344     bmpObjPtr->bitmap.bmBits       = NULL;
 345     bmpObjPtr->dib                 = NULL;
 346
 347     bmpObjPtr->funcs = &X11DRV_DC_Funcs;
 348     bmpObjPtr->physBitmap = (void *)pixmap;
 349
 350     GDI_ReleaseObj( hbitmap );
 351     return hbitmap;
 352 }
 353 #endif /* defined(HAVE_LIBXXPM) */
 354
 355 /***********************************************************************
 356  *           OBM_CreatePixmaps
 357  *
 358  * Create the 2 pixmaps from XPM data.
 359  *
 360  * The Xlib critical section must be entered before calling this function.
 361  */
 362 #ifdef HAVE_LIBXXPM
 363
 364 typedef struct
 365 {
 366     char         **data;
 367     XpmAttributes *attrs;
 368     Pixmap         pixmap;
 369     Pixmap         pixmask;
 370 } OBM_PIXMAP_DESCR;
 371
 372 static int OBM_CreatePixmaps( OBM_PIXMAP_DESCR *descr )
 373 {
 374     return XpmCreatePixmapFromData( display, X11DRV_GetXRootWindow(), descr->data,
 375                                     &descr->pixmap, &descr->pixmask, descr->attrs );
 376 }
 377 #endif /* defined(HAVE_LIBXXPM) */
 378
 379
 380 /***********************************************************************
 381  *           OBM_CreateBitmaps
 382  *
 383  * Create the 2 bitmaps from XPM data.
 384  */
 385 static BOOL OBM_CreateBitmaps( char **data, BOOL color,
 386                                HBITMAP16 *bitmap, HBITMAP16 *mask, POINT *hotspot )
 387 {
 388 #ifdef HAVE_LIBXXPM
 389     OBM_PIXMAP_DESCR descr;
 390     int err;
 391
 392     descr.attrs = (XpmAttributes *)HeapAlloc( GetProcessHeap(), 0,
 393                                               XpmAttributesSize() );
 394     if (descr.attrs == NULL) return FALSE;
 395     descr.attrs->valuemask    = XpmColormap | XpmDepth | XpmColorSymbols | XpmHotspot;
 396     descr.attrs->colormap     = X11DRV_PALETTE_PaletteXColormap;
 397     descr.attrs->depth        = color ? X11DRV_GetDepth() : 1;
 398     descr.attrs->colorsymbols = (descr.attrs->depth > 1) ? OBM_Colors : OBM_BlackAndWhite;
 399     descr.attrs->numsymbols   = (descr.attrs->depth > 1) ? NB_COLOR_SYMBOLS : 2;
 400
 401     descr.data = data;
 402
 403     EnterCriticalSection( &X11DRV_CritSection );
 404     err = CALL_LARGE_STACK( OBM_CreatePixmaps, &descr );
 405     LeaveCriticalSection( &X11DRV_CritSection );
 406
 407     if (err != XpmSuccess)
 408     {
 409         HeapFree( GetProcessHeap(), 0, descr.attrs );
 410         return FALSE;
 411     }
 412
 413     if (hotspot)
 414     {
 415         hotspot->x = descr.attrs->x_hotspot;
 416         hotspot->y = descr.attrs->y_hotspot;
 417     }
 418
 419     if (bitmap)
 420         *bitmap = OBM_MakeBitmap( descr.attrs->width, descr.attrs->height,
 421                                   descr.attrs->depth, descr.pixmap );
 422
 423     if (mask)
 424         *mask = OBM_MakeBitmap( descr.attrs->width, descr.attrs->height,
 425                                 1, descr.pixmask );
 426
 427     HeapFree( GetProcessHeap(), 0, descr.attrs );
 428
 429     if (descr.pixmap && (!bitmap || !*bitmap))
 430         TSXFreePixmap( display, descr.pixmap );
 431     if (descr.pixmask && (!mask || !*mask))
 432         TSXFreePixmap( display, descr.pixmask );
 433
 434     if (bitmap && !*bitmap)
 435     {
 436         if (mask && *mask) DeleteObject( *mask );
 437         return FALSE;
 438     }
 439     return TRUE;
 440 #else /* defined(HAVE_LIBXXPM) */
 441     FIXME_(x11drv)(
 442         "Xpm support not in the binary, "
 443         "please install the Xpm and Xpm-devel packages and recompile\n"
 444     );
 445     return FALSE;
 446 #endif /* defined(HAVE_LIBXXPM) */
 447 }
 448
 449
 450 /***********************************************************************
 451  *           OBM_LoadBitmap
 452  */
 453 static HBITMAP16 OBM_LoadBitmap( WORD id )
 454 {
 455     HBITMAP16 bitmap;
 456
 457     if ((id < OBM_FIRST) || (id > OBM_LAST)) return 0;
 458     id -= OBM_FIRST;
 459
 460     if (!OBM_InitColorSymbols()) return 0;
 461
 462     if (!OBM_CreateBitmaps( OBM_Pixmaps_Data[id].data, OBM_Pixmaps_Data[id].color,
 463                             &bitmap, NULL, NULL ))
 464     {
 465         WARN_(bitmap)("Error creating OEM bitmap %d\n", OBM_FIRST+id );
 466         return 0;
 467     }
 468     return bitmap;
 469 }
 470
 471
 472 /***********************************************************************
 473  *           OBM_LoadCursorIcon
 474  */
 475 static HGLOBAL16 OBM_LoadCursorIcon( WORD id, BOOL fCursor )
 476 {
 477     HBITMAP16 bitmap, mask;
 478     POINT hotspot;
 479     HGLOBAL16 handle;
 480     CURSORICONINFO *pInfo;
 481     BITMAPOBJ *bmpXor, *bmpAnd;
 482     int sizeXor, sizeAnd;
 483
 484     if (fCursor)
 485     {
 486         if ((id >= OCR_FIRST1) && (id <= OCR_LAST1))
 487              id = OCR_BASE1 + id - OCR_FIRST1;
 488         else if ((id >= OCR_FIRST2) && (id <= OCR_LAST2))
 489                   id = OCR_BASE2 + id - OCR_FIRST2;
 490              else if ((id >= OCR_FIRST0) && (id <= OCR_LAST0))
 491                        id = OCR_BASE0 + id - OCR_FIRST0;
 492                   else if ((id >= OCR_FIRST3) && (id <= OCR_LAST3))
 493                             id = OCR_BASE3 + id - OCR_FIRST3;
 494                        else if ((id >= OCR_FIRST4) && (id <= OCR_LAST4))
 495                                  id = OCR_BASE4 + id - OCR_FIRST4;
 496         else return 0;
 497         if (OBM_Cursors[id]) return OBM_Cursors[id];
 498     }
 499     else
 500     {
 501         if ((id < OIC_FIRST) || (id > OIC_LAST)) return 0;
 502         id -= OIC_FIRST;
 503     }
 504
 505     if (!OBM_InitColorSymbols()) return 0;
 506
 507     if (!OBM_CreateBitmaps( fCursor ? OBM_Cursors_Data[id] : OBM_Icons_Data[id],
 508                             !fCursor, &bitmap, &mask, &hotspot ))
 509     {
 510         WARN_(cursor)("Error creating OEM cursor/icon %d\n", id );
 511         return 0;
 512     }
 513
 514     bmpXor = (BITMAPOBJ *) GDI_GetObjPtr( bitmap, BITMAP_MAGIC );
 515     bmpAnd = (BITMAPOBJ *) GDI_GetObjPtr( mask, BITMAP_MAGIC );
 516     sizeXor = bmpXor->bitmap.bmHeight * bmpXor->bitmap.bmWidthBytes;
 517     sizeAnd = bmpXor->bitmap.bmHeight *
 518                         BITMAP_GetWidthBytes( bmpXor->bitmap.bmWidth, 1 );
 519
 520     if (!(handle = GlobalAlloc16( GMEM_MOVEABLE,
 521                                   sizeof(CURSORICONINFO) + sizeXor + sizeAnd)))
 522         goto done;
 523
 524     pInfo = (CURSORICONINFO *)GlobalLock16( handle );
 525     pInfo->ptHotSpot.x   = hotspot.x;
 526     pInfo->ptHotSpot.y   = hotspot.y;
 527     pInfo->nWidth        = bmpXor->bitmap.bmWidth;
 528     pInfo->nHeight       = bmpXor->bitmap.bmHeight;
 529     pInfo->nWidthBytes   = bmpXor->bitmap.bmWidthBytes;
 530     pInfo->bPlanes       = bmpXor->bitmap.bmPlanes;
 531     pInfo->bBitsPerPixel = bmpXor->bitmap.bmBitsPixel;
 532
 533     if (mask)
 534     {
 535           /* Invert the mask */
 536
 537         TSXSetFunction( display, BITMAP_monoGC, GXinvert );
 538         TSXFillRectangle( display, (Pixmap)bmpAnd->physBitmap, BITMAP_monoGC, 0, 0,
 539                         bmpAnd->bitmap.bmWidth, bmpAnd->bitmap.bmHeight );
 540         TSXSetFunction( display, BITMAP_monoGC, GXcopy );
 541
 542           /* Set the masked pixels to black */
 543
 544         if (bmpXor->bitmap.bmBitsPixel != 1)
 545         {
 546             TSXSetForeground( display, BITMAP_colorGC,
 547                             X11DRV_PALETTE_ToPhysical( NULL, RGB(0,0,0) ));
 548             TSXSetBackground( display, BITMAP_colorGC, 0 );
 549             TSXSetFunction( display, BITMAP_colorGC, GXor );
 550             TSXCopyPlane(display, (Pixmap)bmpAnd->physBitmap, (Pixmap)bmpXor->physBitmap,
 551                          BITMAP_colorGC, 0, 0, bmpXor->bitmap.bmWidth, bmpXor->bitmap.bmHeight,
 552                          0, 0, 1 );
 553             TSXSetFunction( display, BITMAP_colorGC, GXcopy );
 554         }
 555     }
 556
 557     if (mask) GetBitmapBits( mask, sizeAnd, (char *)(pInfo + 1));
 558     else memset( (char *)(pInfo + 1), 0xff, sizeAnd );
 559     GetBitmapBits( bitmap, sizeXor, (char *)(pInfo + 1) + sizeAnd );
 560     if (fCursor) OBM_Cursors[id] = handle;
 561  done:
 562     GDI_ReleaseObj( mask );
 563     GDI_ReleaseObj( bitmap );
 564     DeleteObject( bitmap );
 565     DeleteObject( mask );
 566     return handle;
 567 }
 568
 569 /***********************************************************************
 570  *           X11DRV_LoadOEMResource
 571  *
 572  */
 573 HANDLE X11DRV_LoadOEMResource(WORD resid, WORD type)
 574 {
 575     switch(type) {
 576     case OEM_BITMAP:
 577         return OBM_LoadBitmap(resid);
 578
 579     case OEM_CURSOR:
 580         return OBM_LoadCursorIcon(resid, TRUE);
 581
 582     case OEM_ICON:
 583         return OBM_LoadCursorIcon(resid, FALSE);
 584
 585     default:
 586         ERR_(x11drv)("Unknown type\n");
 587     }
 588     return 0;
 589 }
 590
 591
 592 /***********************************************************************
 593  *           X11DRV_OBM_Init
 594  *
 595  * Initializes the OBM_Pixmaps_Data and OBM_Icons_Data struct
 596  */
 597 BOOL X11DRV_OBM_Init(void)
 598 {
 599     if (TWEAK_WineLook == WIN31_LOOK) {
 600         OBM_Pixmaps_Data[OBM_ZOOMD - OBM_FIRST].data = obm_zoomd;
 601         OBM_Pixmaps_Data[OBM_REDUCED - OBM_FIRST].data = obm_reduced;
 602         OBM_Pixmaps_Data[OBM_ZOOM - OBM_FIRST].data = obm_zoom;
 603         OBM_Pixmaps_Data[OBM_REDUCE - OBM_FIRST].data = obm_reduce;
 604         OBM_Pixmaps_Data[OBM_CLOSE - OBM_FIRST].data = obm_close;
 605         OBM_Pixmaps_Data[OBM_RESTORE - OBM_FIRST].data = obm_restore;
 606         OBM_Pixmaps_Data[OBM_RESTORED - OBM_FIRST].data = obm_restored;
 607
 608         OBM_Icons_Data[OIC_HAND - OIC_FIRST] = oic_hand;
 609         OBM_Icons_Data[OIC_QUES - OIC_FIRST] = oic_ques;
 610         OBM_Icons_Data[OIC_BANG - OIC_FIRST] = oic_bang;
 611         OBM_Icons_Data[OIC_NOTE - OIC_FIRST] = oic_note;
 612     }
 613     else {
 614         OBM_Pixmaps_Data[OBM_ZOOMD - OBM_FIRST].data = obm_zoomd_95;
 615         OBM_Pixmaps_Data[OBM_REDUCED - OBM_FIRST].data = obm_reduced_95;
 616         OBM_Pixmaps_Data[OBM_ZOOM - OBM_FIRST].data = obm_zoom_95;
 617         OBM_Pixmaps_Data[OBM_REDUCE - OBM_FIRST].data = obm_reduce_95;
 618         OBM_Pixmaps_Data[OBM_CLOSE - OBM_FIRST].data = obm_close_95;
 619         OBM_Pixmaps_Data[OBM_RESTORE - OBM_FIRST].data = obm_restore_95;
 620         OBM_Pixmaps_Data[OBM_RESTORED - OBM_FIRST].data = obm_restored_95;
 621
 622         OBM_Icons_Data[OIC_HAND - OIC_FIRST] = oic_hand_95;
 623         OBM_Icons_Data[OIC_QUES - OIC_FIRST] = oic_ques_95;
 624         OBM_Icons_Data[OIC_BANG - OIC_FIRST] = oic_bang_95;
 625         OBM_Icons_Data[OIC_NOTE - OIC_FIRST] = oic_note_95;
 626     }
 627
 628     return 1;
 629 }
 630