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