graphics/x11drv/bitmap.c

   1 /*
   2  * X11DRV bitmap objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1999 Noel Borthwick
   6  */
   7
   8 #include "config.h"
   9
  10 #ifndef X_DISPLAY_MISSING
  11
  12 #include "ts_xlib.h"
  13 #include "ts_xutil.h"
  14
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include "gdi.h"
  18 #include "callback.h"
  19 #include "dc.h"
  20 #include "bitmap.h"
  21 #include "heap.h"
  22 #include "debugtools.h"
  23 #include "xmalloc.h"
  24 #include "local.h"
  25 #include "x11drv.h"
  26 #include "wingdi.h"
  27 #include "windef.h"
  28 #include "wine/winuser16.h"
  29
  30 DEFAULT_DEBUG_CHANNEL(x11drv);
  31
  32   /* GCs used for B&W and color bitmap operations */
  33 GC BITMAP_monoGC = 0, BITMAP_colorGC = 0;
  34
  35
  36 /***********************************************************************
  37  *           X11DRV_BITMAP_Init
  38  */
  39 BOOL X11DRV_BITMAP_Init(void)
  40 {
  41     Pixmap tmpPixmap;
  42
  43       /* Create the necessary GCs */
  44
  45     if ((tmpPixmap = TSXCreatePixmap(display,
  46                                      X11DRV_GetXRootWindow(),
  47                                      1, 1,
  48                                      1)))
  49     {
  50         BITMAP_monoGC = TSXCreateGC( display, tmpPixmap, 0, NULL );
  51         TSXSetGraphicsExposures( display, BITMAP_monoGC, False );
  52         TSXFreePixmap( display, tmpPixmap );
  53     }
  54
  55     if (X11DRV_GetDepth() != 1)
  56     {
  57         if ((tmpPixmap = TSXCreatePixmap(display, X11DRV_GetXRootWindow(),
  58                                          1, 1, X11DRV_GetDepth())))
  59         {
  60             BITMAP_colorGC = TSXCreateGC( display, tmpPixmap, 0, NULL );
  61             TSXSetGraphicsExposures( display, BITMAP_colorGC, False );
  62             TSXFreePixmap( display, tmpPixmap );
  63         }
  64     }
  65     return TRUE;
  66 }
  67
  68 /***********************************************************************
  69  *           X11DRV_BITMAP_SelectObject
  70  */
  71 HBITMAP X11DRV_BITMAP_SelectObject( DC * dc, HBITMAP hbitmap,
  72                                       BITMAPOBJ * bmp )
  73 {
  74     HRGN hrgn;
  75     HBITMAP prevHandle = dc->w.hBitmap;
  76     X11DRV_PHYSBITMAP *pbitmap;
  77     X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
  78
  79
  80     if (!(dc->w.flags & DC_MEMORY)) return 0;
  81
  82     if(!bmp->DDBitmap)
  83         if(!X11DRV_CreateBitmap(hbitmap))
  84             return 0;
  85
  86     if(bmp->DDBitmap->funcs != dc->funcs) {
  87         WARN("Trying to select non-X11 DDB into an X11 dc\n");
  88         return 0;
  89     }
  90
  91     pbitmap = bmp->DDBitmap->physBitmap;
  92
  93     dc->w.totalExtent.left   = 0;
  94     dc->w.totalExtent.top    = 0;
  95     dc->w.totalExtent.right  = bmp->bitmap.bmWidth;
  96     dc->w.totalExtent.bottom = bmp->bitmap.bmHeight;
  97
  98     if (dc->w.hVisRgn)
  99        SetRectRgn( dc->w.hVisRgn, 0, 0,
 100                      bmp->bitmap.bmWidth, bmp->bitmap.bmHeight );
 101     else
 102     {
 103        hrgn = CreateRectRgn(0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight);
 104        if (!hrgn) return 0;
 105        dc->w.hVisRgn    = hrgn;
 106     }
 107
 108     physDev->drawable = pbitmap->pixmap;
 109     dc->w.hBitmap     = hbitmap;
 110
 111       /* Change GC depth if needed */
 112
 113     if (dc->w.bitsPerPixel != bmp->bitmap.bmBitsPixel)
 114     {
 115         TSXFreeGC( display, physDev->gc );
 116         physDev->gc = TSXCreateGC( display, physDev->drawable, 0, NULL );
 117         TSXSetGraphicsExposures( display, physDev->gc, False );
 118         dc->w.bitsPerPixel = bmp->bitmap.bmBitsPixel;
 119         DC_InitDC( dc );
 120     }
 121     else CLIPPING_UpdateGCRegion( dc );  /* Just update GC clip region */
 122     return prevHandle;
 123 }
 124
 125
 126 /***********************************************************************
 127  *           XPutImage_wrapper
 128  *
 129  * Wrapper to call XPutImage with CALL_LARGE_STACK.
 130  */
 131
 132 struct XPutImage_descr
 133 {
 134     BITMAPOBJ *bmp;
 135     XImage    *image;
 136     INT      width;
 137     INT      height;
 138 };
 139
 140 static int XPutImage_wrapper( const struct XPutImage_descr *descr )
 141 {
 142     return XPutImage( display,
 143                ((X11DRV_PHYSBITMAP *)descr->bmp->DDBitmap->physBitmap)->pixmap,
 144                BITMAP_GC(descr->bmp),
 145                descr->image, 0, 0, 0, 0, descr->width, descr->height );
 146 }
 147
 148
 149 /***************************************************************************
 150  *
 151  *      X11DRV_AllocBitmap
 152  *
 153  * Allocate DDBitmap and physBitmap
 154  *
 155  */
 156 X11DRV_PHYSBITMAP *X11DRV_AllocBitmap( BITMAPOBJ *bmp )
 157 {
 158     X11DRV_PHYSBITMAP *pbitmap;
 159
 160     if(!(bmp->DDBitmap = HeapAlloc(GetProcessHeap(), 0, sizeof(DDBITMAP)))) {
 161         WARN("Can't alloc DDBITMAP\n");
 162         return NULL;
 163     }
 164
 165     if(!(pbitmap = HeapAlloc(GetProcessHeap(), 0,sizeof(X11DRV_PHYSBITMAP)))) {
 166         WARN("Can't alloc X11DRV_PHYSBITMAP\n");
 167         HeapFree(GetProcessHeap(), 0, bmp->DDBitmap);
 168         return NULL;
 169     }
 170
 171     bmp->DDBitmap->physBitmap = pbitmap;
 172     bmp->DDBitmap->funcs = DRIVER_FindDriver( "DISPLAY" );
 173     return pbitmap;
 174 }
 175
 176
 177 /****************************************************************************
 178  *
 179  *        X11DRV_CreateBitmap
 180  *
 181  * Create a device dependent X11 bitmap
 182  *
 183  * Returns TRUE on success else FALSE
 184  *
 185  */
 186
 187 BOOL X11DRV_CreateBitmap( HBITMAP hbitmap )
 188 {
 189     X11DRV_PHYSBITMAP *pbitmap;
 190     BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 191
 192     if(!bmp) {
 193         WARN("Bad bitmap handle %08x\n", hbitmap);
 194         return FALSE;
 195     }
 196
 197       /* Check parameters */
 198     if (bmp->bitmap.bmPlanes != 1) return 0;
 199     if ((bmp->bitmap.bmBitsPixel != 1) &&
 200         (bmp->bitmap.bmBitsPixel != X11DRV_GetDepth()))
 201     {
 202         ERR("Trying to make bitmap with planes=%d, bpp=%d\n",
 203             bmp->bitmap.bmPlanes, bmp->bitmap.bmBitsPixel);
 204         GDI_HEAP_UNLOCK( hbitmap );
 205         return FALSE;
 206     }
 207
 208     TRACE("(%08x) %dx%d %d bpp\n", hbitmap, bmp->bitmap.bmWidth,
 209           bmp->bitmap.bmHeight, bmp->bitmap.bmBitsPixel);
 210
 211     pbitmap = X11DRV_AllocBitmap( bmp );
 212     if(!pbitmap) return FALSE;
 213
 214       /* Create the pixmap */
 215     pbitmap->pixmap = TSXCreatePixmap(display, X11DRV_GetXRootWindow(), bmp->bitmap.bmWidth,
 216                               bmp->bitmap.bmHeight, bmp->bitmap.bmBitsPixel);
 217     if (!pbitmap->pixmap) {
 218         WARN("Can't create Pixmap\n");
 219         HeapFree(GetProcessHeap(), 0, bmp->DDBitmap->physBitmap);
 220         HeapFree(GetProcessHeap(), 0, bmp->DDBitmap);
 221         GDI_HEAP_UNLOCK( hbitmap );
 222         return FALSE;
 223     }
 224
 225     if (bmp->bitmap.bmBits) /* Set bitmap bits */
 226         X11DRV_BitmapBits( hbitmap, bmp->bitmap.bmBits,
 227                            bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes,
 228                            DDB_SET );
 229
 230     GDI_HEAP_UNLOCK( hbitmap );
 231     return TRUE;
 232 }
 233
 234
 235 /***********************************************************************
 236  *           X11DRV_BITMAP_GetXImage
 237  *
 238  * Get an X image for a bitmap. For use with CALL_LARGE_STACK.
 239  */
 240 XImage *X11DRV_BITMAP_GetXImage( const BITMAPOBJ *bmp )
 241 {
 242     return XGetImage( display,
 243                       ((X11DRV_PHYSBITMAP *)bmp->DDBitmap->physBitmap)->pixmap,
 244                       0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
 245                       AllPlanes, ZPixmap );
 246 }
 247
 248
 249 /***********************************************************************
 250  *           X11DRV_GetBitmapBits
 251  *
 252  * RETURNS
 253  *    Success: Number of bytes copied
 254  *    Failure: 0
 255  */
 256 static LONG X11DRV_GetBitmapBits(BITMAPOBJ *bmp, void *buffer, LONG count)
 257 {
 258     LONG old_height, height;
 259     XImage *image;
 260     LPBYTE tbuf, startline;
 261     int h, w;
 262
 263     TRACE("(bmp=%p, buffer=%p, count=0x%lx)\n", bmp, buffer, count);
 264
 265     EnterCriticalSection( &X11DRV_CritSection );
 266
 267     /* Hack: change the bitmap height temporarily to avoid */
 268     /*       getting unnecessary bitmap rows. */
 269
 270     old_height = bmp->bitmap.bmHeight;
 271     height = bmp->bitmap.bmHeight = count / bmp->bitmap.bmWidthBytes;
 272
 273     image = (XImage *)CALL_LARGE_STACK( X11DRV_BITMAP_GetXImage, bmp );
 274
 275     bmp->bitmap.bmHeight = old_height;
 276
 277     /* copy XImage to 16 bit padded image buffer with real bitsperpixel */
 278
 279     startline = buffer;
 280     switch (bmp->bitmap.bmBitsPixel)
 281     {
 282     case 1:
 283         for (h=0;h<height;h++)
 284         {
 285             tbuf = startline;
 286             *tbuf = 0;
 287             for (w=0;w<bmp->bitmap.bmWidth;w++)
 288             {
 289                 if ((w%8) == 0)
 290                     *tbuf = 0;
 291                 *tbuf |= XGetPixel(image,w,h)<<(7-(w&7));
 292                 if ((w&7) == 7) ++tbuf;
 293             }
 294             startline += bmp->bitmap.bmWidthBytes;
 295         }
 296         break;
 297     case 4:
 298         for (h=0;h<height;h++)
 299         {
 300             tbuf = startline;
 301             for (w=0;w<bmp->bitmap.bmWidth;w++)
 302             {
 303                 if (!(w & 1)) *tbuf = XGetPixel( image, w, h) << 4;
 304                 else *tbuf++ |= XGetPixel( image, w, h) & 0x0f;
 305             }
 306             startline += bmp->bitmap.bmWidthBytes;
 307         }
 308         break;
 309     case 8:
 310         for (h=0;h<height;h++)
 311         {
 312             tbuf = startline;
 313             for (w=0;w<bmp->bitmap.bmWidth;w++)
 314                 *tbuf++ = XGetPixel(image,w,h);
 315             startline += bmp->bitmap.bmWidthBytes;
 316         }
 317         break;
 318     case 15:
 319     case 16:
 320         for (h=0;h<height;h++)
 321         {
 322             tbuf = startline;
 323             for (w=0;w<bmp->bitmap.bmWidth;w++)
 324             {
 325                 long pixel = XGetPixel(image,w,h);
 326
 327                 *tbuf++ = pixel & 0xff;
 328                 *tbuf++ = (pixel>>8) & 0xff;
 329             }
 330             startline += bmp->bitmap.bmWidthBytes;
 331         }
 332         break;
 333     case 24:
 334         for (h=0;h<height;h++)
 335         {
 336             tbuf = startline;
 337             for (w=0;w<bmp->bitmap.bmWidth;w++)
 338             {
 339                 long pixel = XGetPixel(image,w,h);
 340
 341                 *tbuf++ = pixel & 0xff;
 342                 *tbuf++ = (pixel>> 8) & 0xff;
 343                 *tbuf++ = (pixel>>16) & 0xff;
 344             }
 345             startline += bmp->bitmap.bmWidthBytes;
 346         }
 347         break;
 348
 349     case 32:
 350         for (h=0;h<height;h++)
 351         {
 352             tbuf = startline;
 353             for (w=0;w<bmp->bitmap.bmWidth;w++)
 354             {
 355                 long pixel = XGetPixel(image,w,h);
 356
 357                 *tbuf++ = pixel & 0xff;
 358                 *tbuf++ = (pixel>> 8) & 0xff;
 359                 *tbuf++ = (pixel>>16) & 0xff;
 360                 *tbuf++ = (pixel>>24) & 0xff;
 361             }
 362             startline += bmp->bitmap.bmWidthBytes;
 363         }
 364         break;
 365     default:
 366         FIXME("Unhandled bits:%d\n", bmp->bitmap.bmBitsPixel);
 367     }
 368     XDestroyImage( image );
 369     LeaveCriticalSection( &X11DRV_CritSection );
 370
 371     return count;
 372 }
 373
 374
 375
 376 /******************************************************************************
 377  *             X11DRV_SetBitmapBits
 378  *
 379  * RETURNS
 380  *    Success: Number of bytes used in setting the bitmap bits
 381  *    Failure: 0
 382  */
 383 static LONG X11DRV_SetBitmapBits(BITMAPOBJ *bmp, void *bits, LONG count)
 384 {
 385     struct XPutImage_descr descr;
 386     LONG height;
 387     XImage *image;
 388     LPBYTE sbuf, startline;
 389     int w, h;
 390
 391     TRACE("(bmp=%p, bits=%p, count=0x%lx)\n", bmp, bits, count);
 392
 393     height = count / bmp->bitmap.bmWidthBytes;
 394
 395     EnterCriticalSection( &X11DRV_CritSection );
 396     image = XCreateImage( display, X11DRV_GetVisual(), bmp->bitmap.bmBitsPixel, ZPixmap, 0, NULL,
 397                           bmp->bitmap.bmWidth, height, 32, 0 );
 398     image->data = (LPBYTE)xmalloc(image->bytes_per_line * height);
 399
 400     /* copy 16 bit padded image buffer with real bitsperpixel to XImage */
 401
 402     startline = bits;
 403
 404     switch (bmp->bitmap.bmBitsPixel)
 405     {
 406     case 1:
 407         for (h=0;h<height;h++)
 408         {
 409             sbuf = startline;
 410             for (w=0;w<bmp->bitmap.bmWidth;w++)
 411             {
 412                 XPutPixel(image,w,h,(sbuf[0]>>(7-(w&7))) & 1);
 413                 if ((w&7) == 7)
 414                     sbuf++;
 415             }
 416             startline += bmp->bitmap.bmWidthBytes;
 417         }
 418         break;
 419     case 4:
 420         for (h=0;h<height;h++)
 421         {
 422             sbuf = startline;
 423             for (w=0;w<bmp->bitmap.bmWidth;w++)
 424             {
 425                 if (!(w & 1)) XPutPixel( image, w, h, *sbuf >> 4 );
 426                 else XPutPixel( image, w, h, *sbuf++ & 0xf );
 427             }
 428             startline += bmp->bitmap.bmWidthBytes;
 429         }
 430         break;
 431     case 8:
 432         for (h=0;h<height;h++)
 433         {
 434             sbuf = startline;
 435             for (w=0;w<bmp->bitmap.bmWidth;w++)
 436                 XPutPixel(image,w,h,*sbuf++);
 437             startline += bmp->bitmap.bmWidthBytes;
 438         }
 439         break;
 440     case 15:
 441     case 16:
 442         for (h=0;h<height;h++)
 443         {
 444             sbuf = startline;
 445             for (w=0;w<bmp->bitmap.bmWidth;w++)
 446             {
 447                 XPutPixel(image,w,h,sbuf[1]*256+sbuf[0]);
 448                 sbuf+=2;
 449             }
 450             startline += bmp->bitmap.bmWidthBytes;
 451         }
 452         break;
 453     case 24:
 454         for (h=0;h<height;h++)
 455         {
 456             sbuf = startline;
 457             for (w=0;w<bmp->bitmap.bmWidth;w++)
 458             {
 459                 XPutPixel(image,w,h,(sbuf[2]<<16)+(sbuf[1]<<8)+sbuf[0]);
 460                 sbuf += 3;
 461             }
 462             startline += bmp->bitmap.bmWidthBytes;
 463         }
 464         break;
 465     case 32:
 466         for (h=0;h<height;h++)
 467         {
 468             sbuf = startline;
 469             for (w=0;w<bmp->bitmap.bmWidth;w++)
 470             {
 471                 XPutPixel(image,w,h,(sbuf[3]<<24)+(sbuf[2]<<16)+(sbuf[1]<<8)+sbuf[0]);
 472                 sbuf += 4;
 473             }
 474             startline += bmp->bitmap.bmWidthBytes;
 475         }
 476         break;
 477     default:
 478       FIXME("Unhandled bits:%d\n", bmp->bitmap.bmBitsPixel);
 479
 480     }
 481
 482     descr.bmp    = bmp;
 483     descr.image  = image;
 484     descr.width  = bmp->bitmap.bmWidth;
 485     descr.height = height;
 486
 487     CALL_LARGE_STACK( XPutImage_wrapper, &descr );
 488     XDestroyImage( image ); /* frees image->data too */
 489     LeaveCriticalSection( &X11DRV_CritSection );
 490
 491     return count;
 492 }
 493
 494 /***********************************************************************
 495  *           X11DRV_BitmapBits
 496  */
 497 LONG X11DRV_BitmapBits(HBITMAP hbitmap, void *bits, LONG count, WORD flags)
 498 {
 499     BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 500     LONG ret;
 501     if(!bmp) {
 502         WARN("Bad bitmap handle %08x\n", hbitmap);
 503         return FALSE;
 504     }
 505
 506     if(flags == DDB_GET)
 507         ret = X11DRV_GetBitmapBits(bmp, bits, count);
 508     else if(flags == DDB_SET)
 509         ret = X11DRV_SetBitmapBits(bmp, bits, count);
 510     else {
 511         ERR("Unknown flags value %d\n", flags);
 512         ret = 0;
 513     }
 514
 515     GDI_HEAP_UNLOCK( hbitmap );
 516     return ret;
 517 }
 518
 519 /***********************************************************************
 520  *           X11DRV_BITMAP_DeleteObject
 521  */
 522 BOOL X11DRV_BITMAP_DeleteObject( HBITMAP hbitmap, BITMAPOBJ * bmp )
 523 {
 524     X11DRV_PHYSBITMAP *pbitmap = bmp->DDBitmap->physBitmap;
 525
 526     TSXFreePixmap( display, pbitmap->pixmap );
 527
 528     HeapFree( GetProcessHeap(), 0, bmp->DDBitmap->physBitmap );
 529     HeapFree( GetProcessHeap(), 0, bmp->DDBitmap );
 530     bmp->DDBitmap = NULL;
 531
 532     return TRUE;
 533 }
 534
 535 /**************************************************************************
 536  *              X11DRV_BITMAP_CreateBitmapHeaderFromPixmap
 537  *
 538  *  Allocates an HBITMAP which references the Pixmap passed in.
 539  *  Note: This function makes the bitmap an owner of the Pixmap so subsequently
 540  *  calling DeleteObject on this will free the Pixmap as well.
 541  */
 542 HBITMAP X11DRV_BITMAP_CreateBitmapHeaderFromPixmap(Pixmap pixmap)
 543 {
 544     HBITMAP hBmp = 0;
 545     BITMAPOBJ *pBmp = NULL;
 546     X11DRV_PHYSBITMAP *pPhysBmp = NULL;
 547     Window root;
 548     int x,y;               /* Unused */
 549     unsigned border_width; /* Unused */
 550     unsigned int depth, width, height;
 551
 552     /* Get the Pixmap dimensions and bit depth */
 553     if ( 0 == TSXGetGeometry(display, pixmap, &root, &x, &y, &width, &height,
 554                              &border_width, &depth) )
 555         goto END;
 556
 557     TRACE("\tPixmap properties: width=%d, height=%d, depth=%d\n",
 558           width, height, depth);
 559
 560     /*
 561      * Create an HBITMAP with the same dimensions and BPP as the pixmap,
 562      * and make it a container for the pixmap passed.
 563      */
 564     hBmp = CreateBitmap( width, height, 1, depth, NULL );
 565
 566     /* Allocate DDBitmap and physBitmap structures in BITMAPOBJ.
 567      * The hBmp is just a filled in BITMAPOBJ header at this point.
 568      */
 569     pBmp = (BITMAPOBJ *)GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
 570     pPhysBmp = X11DRV_AllocBitmap( pBmp );
 571     if( !pPhysBmp )
 572     {
 573         DeleteObject(hBmp);
 574         hBmp = NULL;
 575         goto END;
 576     }
 577
 578     /* Point to our Pixmap in the physical bitmap structure */
 579     pPhysBmp->pixmap = pixmap;
 580
 581 END:
 582     TRACE("\tReturning HBITMAP %x\n", hBmp);
 583     return hBmp;
 584 }
 585
 586
 587 /**************************************************************************
 588  *              X11DRV_BITMAP_CreateBitmapFromPixmap
 589  *
 590  *  Allocates an HBITMAP and copies the Pixmap data into it.
 591  *  If bDeletePixmap is TRUE, the Pixmap passed in is deleted after the conversion.
 592  */
 593 HBITMAP X11DRV_BITMAP_CreateBitmapFromPixmap(Pixmap pixmap, BOOL bDeletePixmap)
 594 {
 595     HBITMAP hBmp = 0, hBmpCopy = 0;
 596     BITMAPOBJ *pBmp = NULL;
 597     unsigned int width, height;
 598
 599     /* Allocate an HBITMAP which references the Pixmap passed to us */
 600     hBmp = X11DRV_BITMAP_CreateBitmapHeaderFromPixmap(pixmap);
 601     if (!hBmp)
 602     {
 603         TRACE("\tCould not create bitmap header for Pixmap\n");
 604         goto END;
 605     }
 606
 607     /* Get the bitmap dimensions */
 608     width = pBmp->bitmap.bmWidth;
 609     height = pBmp->bitmap.bmHeight;
 610
 611     hBmpCopy = CopyImage(hBmp, IMAGE_BITMAP, width, height, LR_CREATEDIBSECTION);
 612
 613     /* We can now get rid of the HBITMAP wrapper we created earlier.
 614      * Note: Simply calling DeleteObject will free the embedded Pixmap as well.
 615      */
 616     if (!bDeletePixmap)
 617     {
 618         /* Manually free the DDBitmap internals to prevent the Pixmap
 619          * from being deleted by DeleteObject.
 620          */
 621         pBmp = (BITMAPOBJ *)GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
 622         HeapFree( GetProcessHeap(), 0, pBmp->DDBitmap->physBitmap );
 623         HeapFree( GetProcessHeap(), 0, pBmp->DDBitmap );
 624         pBmp->DDBitmap = NULL;
 625     }
 626     DeleteObject(hBmp);
 627
 628 END:
 629     TRACE("\tReturning HBITMAP %x\n", hBmpCopy);
 630     return hBmpCopy;
 631 }
 632
 633
 634 /**************************************************************************
 635  *                 X11DRV_BITMAP_CreatePixmapFromBitmap
 636  *
 637  *    Creates a Pixmap from a bitmap
 638  */
 639 Pixmap X11DRV_BITMAP_CreatePixmapFromBitmap( HBITMAP hBmp, HDC hdc )
 640 {
 641     HGLOBAL hPackedDIB = NULL;
 642     Pixmap pixmap = NULL;
 643
 644     /*
 645      * Create a packed DIB from the bitmap passed to us.
 646      * A packed DIB contains a BITMAPINFO structure followed immediately by
 647      * an optional color palette and the pixel data.
 648      */
 649     hPackedDIB = DIB_CreateDIBFromBitmap(hdc, hBmp);
 650
 651     /* Create a Pixmap from the packed DIB */
 652     pixmap = X11DRV_DIB_CreatePixmapFromDIB( hPackedDIB, hdc );
 653
 654     /* Free the temporary packed DIB */
 655     GlobalFree(hPackedDIB);
 656
 657     return pixmap;
 658 }
 659
 660
 661 /***********************************************************************
 662  *           X11DRV_BITMAP_Pixmap
 663  *
 664  * This function exists solely for x11 driver of the window system.
 665  */
 666 BOOL X11DRV_BITMAP_Pixmap(HBITMAP hbitmap)
 667 {
 668     BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 669     return ((X11DRV_PHYSBITMAP *)(bmp->DDBitmap->physBitmap))->pixmap;
 670 }
 671
 672 #endif /* !defined(X_DISPLAY_MISSING) */