objects/bitmap.c

   1 /*
   2  * GDI bitmap objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
   8
   9 #include "gdi.h"
  10
  11 /* A GDI bitmap object contains a handle to a packed BITMAP,
  12  * which is stored on the global heap.
  13  * A packed BITMAP is a BITMAP structure followed by the bitmap bits.
  14  */
  15
  16   /* Handle of the bitmap selected by default in a memory DC */
  17 HBITMAP BITMAP_hbitmapMemDC;
  18
  19   /* List of supported depths */
  20 static int depthCount;
  21 static int * depthList;
  22
  23   /* List of GC used for bitmap to pixmap operations (one for each depth) */
  24 static GC * bitmapGC;
  25
  26
  27 /***********************************************************************
  28  *           BITMAP_Init
  29  */
  30 BOOL BITMAP_Init()
  31 {
  32     int i;
  33     Pixmap tmpPixmap;
  34
  35     depthList = XListDepths( XT_display, DefaultScreen(XT_display),
  36                              &depthCount );
  37     if (!depthList || !depthCount) return FALSE;
  38     if (!(bitmapGC = (GC *) malloc( depthCount * sizeof(GC) ))) return FALSE;
  39
  40       /* Create the necessary GCs */
  41
  42     for (i = 0; i < depthCount; i++)
  43     {
  44         tmpPixmap = XCreatePixmap( XT_display, DefaultRootWindow(XT_display),
  45                                   1, 1, depthList[i] );
  46         if (tmpPixmap)
  47         {
  48             bitmapGC[i] = XCreateGC( XT_display, tmpPixmap, 0, NULL );
  49             XSetGraphicsExposures( XT_display, bitmapGC[i], False );
  50             XFreePixmap( XT_display, tmpPixmap );
  51         }
  52         else bitmapGC[i] = 0;
  53     }
  54
  55     BITMAP_hbitmapMemDC = CreateBitmap( 1, 1, 1, 1, NULL );
  56     return (BITMAP_hbitmapMemDC != 0);
  57 }
  58
  59
  60 /***********************************************************************
  61  *           BITMAP_FindGCForDepth
  62  *
  63  * Return a GC appropriate for operations with the given depth.
  64  */
  65 GC BITMAP_FindGCForDepth( int depth )
  66 {
  67     int i;
  68     for (i = 0; i < depthCount; i++)
  69         if (depthList[i] == depth) return bitmapGC[i];
  70     return 0;
  71 }
  72
  73
  74 /***********************************************************************
  75  *           BITMAP_BmpToImage
  76  *
  77  * Create an XImage pointing to the bitmap data.
  78  */
  79 XImage * BITMAP_BmpToImage( BITMAP * bmp, void * bmpData )
  80 {
  81     XImage * image;
  82
  83     image = XCreateImage( XT_display, DefaultVisualOfScreen(XT_screen),
  84                           bmp->bmBitsPixel, ZPixmap, 0, bmpData,
  85                           bmp->bmWidth, bmp->bmHeight, 16, bmp->bmWidthBytes );
  86     if (!image) return 0;
  87     image->byte_order = MSBFirst;
  88     image->bitmap_bit_order = MSBFirst;
  89     image->bitmap_unit = 16;
  90     _XInitImageFuncPtrs(image);
  91     return image;
  92 }
  93
  94
  95 /***********************************************************************
  96  *           BITMAP_CopyToPixmap
  97  *
  98  * Copy the content of the bitmap to the pixmap. Both must have the same depth.
  99  */
 100 BOOL BITMAP_CopyToPixmap( BITMAP * bmp, Pixmap pixmap,
 101                           int x, int y, int width, int height )
 102 {
 103     GC gc;
 104     XImage * image;
 105
 106     gc = BITMAP_FindGCForDepth( bmp->bmBitsPixel );
 107     if (!gc) return FALSE;
 108
 109     image = BITMAP_BmpToImage( bmp, ((char *)bmp) + sizeof(BITMAP) );
 110     if (!image) return FALSE;
 111
 112 #ifdef DEBUG_GDI
 113     printf( "BITMAP_CopyToPixmap: %dx%d %d colors -> %d,%d %dx%d\n",
 114             bmp->bmWidth, bmp->bmHeight, 1 << bmp->bmBitsPixel, x, y, width, height );
 115 #endif
 116     XPutImage(XT_display, pixmap, gc, image, 0, 0, x, y, width, height);
 117     image->data = NULL;
 118     XDestroyImage( image );
 119     return TRUE;
 120 }
 121
 122
 123 /***********************************************************************
 124  *           BITMAP_CopyFromPixmap
 125  *
 126  * Copy the content of the pixmap to the bitmap. Both must have
 127  * the same dimensions and depth.
 128  */
 129 BOOL BITMAP_CopyFromPixmap( BITMAP * bmp, Pixmap pixmap )
 130 {
 131     XImage *image = BITMAP_BmpToImage( bmp, ((char *)bmp) + sizeof(BITMAP) );
 132     if (!image) return FALSE;
 133
 134 #ifdef DEBUG_GDI
 135     printf( "BITMAP_CopyFromPixmap: %dx%d %d colors\n",
 136             bmp->bmWidth, bmp->bmHeight, 1 << bmp->bmBitsPixel );
 137 #endif
 138     XGetSubImage( XT_display, pixmap, 0, 0, bmp->bmWidth, bmp->bmHeight,
 139                   AllPlanes, ZPixmap, image, 0, 0 );
 140     image->data = NULL;
 141     XDestroyImage( image );
 142     return TRUE;
 143 }
 144
 145
 146 /***********************************************************************
 147  *           CreateBitmap    (GDI.48)
 148  */
 149 HBITMAP CreateBitmap( short width, short height,
 150                       BYTE planes, BYTE bpp, LPSTR bits )
 151 {
 152     BITMAP bitmap = { 0, width, height, 0, planes, bpp, bits };
 153 #ifdef DEBUG_GDI
 154     printf( "CreateBitmap: %dx%d, %d colors\n",
 155              width, height, 1 << (planes*bpp) );
 156 #endif
 157     if (!width || !height) return 0;
 158     if ((planes != 1) && (bpp != 1)) return 0;
 159     bitmap.bmWidthBytes = (width * bpp + 15) / 16 * 2;
 160     return CreateBitmapIndirect( &bitmap );
 161 }
 162
 163
 164 /***********************************************************************
 165  *           CreateCompatibleBitmap    (GDI.51)
 166  */
 167 HBITMAP CreateCompatibleBitmap( HDC hdc, short width, short height )
 168 {
 169     HBITMAP hbitmap;
 170     DC * dc;
 171 #ifdef DEBUG_GDI
 172     printf( "CreateCompatibleBitmap: %d %dx%d\n", hdc, width, height );
 173 #endif
 174     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 175     if (!dc) return 0;
 176     hbitmap = CreateBitmap( width, height, dc->w.planes, dc->w.bitsPerPixel, NULL);
 177     return hbitmap;
 178 }
 179
 180
 181 /***********************************************************************
 182  *           CreateBitmapIndirect    (GDI.49)
 183  */
 184 HBITMAP CreateBitmapIndirect( BITMAP * bmp )
 185 {
 186     BITMAPOBJ * bmpObjPtr;
 187     char * bmpPtr;
 188     HBITMAP hbitmap;
 189     int size = bmp->bmPlanes * bmp->bmHeight * bmp->bmWidthBytes;
 190
 191       /* Create the BITMAPOBJ */
 192
 193     hbitmap = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC );
 194     if (!hbitmap) return 0;
 195     bmpObjPtr = (BITMAPOBJ *) GDI_HEAP_ADDR( hbitmap );
 196
 197       /* Create the bitmap in global heap */
 198
 199     bmpObjPtr->hBitmap = GlobalAlloc( GMEM_MOVEABLE, sizeof(BITMAP) + size );
 200     if (!bmpObjPtr->hBitmap)
 201     {
 202         GDI_FreeObject( hbitmap );
 203         return 0;
 204     }
 205     bmpPtr = (char *) GlobalLock( bmpObjPtr->hBitmap );
 206     memcpy( bmpPtr, bmp, sizeof(BITMAP) );
 207     ((BITMAP *)bmpPtr)->bmBits = NULL;
 208     if (bmp->bmBits) memcpy( bmpPtr + sizeof(BITMAP), bmp->bmBits, size );
 209     GlobalUnlock( bmpObjPtr->hBitmap );
 210
 211     bmpObjPtr->bSelected = FALSE;
 212     bmpObjPtr->hdc       = 0;
 213     bmpObjPtr->size.cx   = 0;
 214     bmpObjPtr->size.cy   = 0;
 215     return hbitmap;
 216 }
 217
 218
 219 /***********************************************************************
 220  *           BITMAP_GetSetBitmapBits
 221  */
 222 LONG BITMAP_GetSetBitmapBits( HBITMAP hbitmap, LONG count,
 223                               LPSTR buffer, int set )
 224 {
 225     BITMAPOBJ * bmpObjPtr;
 226     BITMAP * bmp;
 227     DC * dc = NULL;
 228     int maxSize;
 229
 230     if (!count) return 0;
 231     bmpObjPtr = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 232     if (!bmpObjPtr) return 0;
 233     if (!(bmp = (BITMAP *) GlobalLock( bmpObjPtr->hBitmap ))) return 0;
 234
 235     if (bmpObjPtr->bSelected)
 236         dc = (DC *) GDI_GetObjPtr( bmpObjPtr->hdc, DC_MAGIC );
 237
 238     maxSize = bmp->bmPlanes * bmp->bmHeight * bmp->bmWidthBytes;
 239     if (count > maxSize) count = maxSize;
 240
 241     if (set)
 242     {
 243         memcpy( bmp+1, buffer, count );
 244         if (dc) BITMAP_CopyToPixmap( bmp, dc->u.x.drawable,
 245                                      0, 0, bmp->bmWidth, bmp->bmHeight );
 246     }
 247     else
 248     {
 249         if (dc) BITMAP_CopyFromPixmap( bmp, dc->u.x.drawable );
 250         memcpy( buffer, bmp+1, count );
 251     }
 252     GlobalUnlock( bmpObjPtr->hBitmap );
 253     return hbitmap;
 254 }
 255
 256
 257 /***********************************************************************
 258  *           GetBitmapBits    (GDI.74)
 259  */
 260 LONG GetBitmapBits( HBITMAP hbitmap, LONG count, LPSTR buffer )
 261 {
 262     return BITMAP_GetSetBitmapBits( hbitmap, count, buffer, 0 );
 263 }
 264
 265
 266 /***********************************************************************
 267  *           SetBitmapBits    (GDI.106)
 268  */
 269 LONG SetBitmapBits( HBITMAP hbitmap, LONG count, LPSTR buffer )
 270 {
 271     return BITMAP_GetSetBitmapBits( hbitmap, count, buffer, 1 );
 272 }
 273
 274
 275 /***********************************************************************
 276  *           BMP_DeleteObject
 277  */
 278 BOOL BMP_DeleteObject( HBITMAP hbitmap, BITMAPOBJ * bitmap )
 279 {
 280       /* Free bitmap on global heap */
 281     GlobalFree( bitmap->hBitmap );
 282     return GDI_FreeObject( hbitmap );
 283 }
 284
 285
 286 /***********************************************************************
 287  *           BMP_GetObject
 288  */
 289 int BMP_GetObject( BITMAPOBJ * bitmap, int count, LPSTR buffer )
 290 {
 291     char * bmpPtr = (char *) GlobalLock( bitmap->hBitmap );
 292     if (count > sizeof(BITMAP)) count = sizeof(BITMAP);
 293     memcpy( buffer, bmpPtr, count );
 294     GlobalUnlock( bitmap->hBitmap );
 295     return count;
 296 }
 297
 298
 299 /***********************************************************************
 300  *           BITMAP_UnselectBitmap
 301  *
 302  * Unselect the bitmap from the DC. Used by SelectObject and DeleteDC.
 303  */
 304 BOOL BITMAP_UnselectBitmap( DC * dc )
 305 {
 306     BITMAPOBJ * bmp;
 307     BITMAP * bmpPtr;
 308
 309     if (!dc->w.hBitmap) return TRUE;
 310     bmp = (BITMAPOBJ *) GDI_GetObjPtr( dc->w.hBitmap, BITMAP_MAGIC );
 311     if (!bmp) return FALSE;
 312
 313     if (!(bmpPtr = (BITMAP *) GlobalLock( bmp->hBitmap ))) return FALSE;
 314
 315     BITMAP_CopyFromPixmap( bmpPtr, dc->u.x.drawable );
 316     XFreePixmap( XT_display, dc->u.x.drawable );
 317     bmp->bSelected = FALSE;
 318     bmp->hdc       = 0;
 319     GlobalUnlock( bmp->hBitmap );
 320     return TRUE;
 321 }
 322
 323
 324 /***********************************************************************
 325  *           BITMAP_SelectObject
 326  */
 327 HBITMAP BITMAP_SelectObject( HDC hdc, DC * dc, HBITMAP hbitmap,
 328                              BITMAPOBJ * bitmap )
 329 {
 330     BITMAP * bmp;
 331     HBITMAP prevHandle = dc->w.hBitmap;
 332
 333     if (!(dc->w.flags & DC_MEMORY)) return 0;
 334     if (bitmap->bSelected && hbitmap != BITMAP_hbitmapMemDC) return 0;
 335     if (!(bmp = (BITMAP *) GlobalLock( bitmap->hBitmap ))) return 0;
 336
 337       /* Make sure the bitmap has the right format */
 338
 339     if ((bmp->bmPlanes != 1) || !BITMAP_FindGCForDepth( bmp->bmBitsPixel ))
 340     {
 341         GlobalUnlock( bitmap->hBitmap );
 342         return 0;
 343     }
 344
 345       /* Unselect the previous bitmap */
 346
 347     if (!BITMAP_UnselectBitmap( dc ))
 348     {
 349         GlobalUnlock( bitmap->hBitmap );
 350         return 0;
 351     }
 352
 353       /* Create the pixmap */
 354
 355     dc->u.x.drawable   = XCreatePixmap( XT_display,
 356                                         DefaultRootWindow( XT_display ),
 357                                         bmp->bmWidth, bmp->bmHeight,
 358                                         bmp->bmBitsPixel );
 359     dc->w.DCSizeX      = bmp->bmWidth;
 360     dc->w.DCSizeY      = bmp->bmHeight;
 361     BITMAP_CopyToPixmap( bmp, dc->u.x.drawable,
 362                          0, 0, bmp->bmWidth, bmp->bmHeight );
 363
 364       /* Change GC depth if needed */
 365
 366     if (dc->w.bitsPerPixel != bmp->bmBitsPixel)
 367     {
 368         XFreeGC( XT_display, dc->u.x.gc );
 369         dc->u.x.gc = XCreateGC( XT_display, dc->u.x.drawable, 0, NULL );
 370         dc->w.bitsPerPixel = bmp->bmBitsPixel;
 371         DC_SetDeviceInfo( hdc, dc );
 372     }
 373
 374     GlobalUnlock( bitmap->hBitmap );
 375     dc->w.hBitmap     = hbitmap;
 376     bitmap->bSelected = TRUE;
 377     bitmap->hdc       = hdc;
 378     return prevHandle;
 379 }
 380
 381
 382 /***********************************************************************
 383  *           GetBitmapDimensionEx    (GDI.468)
 384  */
 385 BOOL GetBitmapDimensionEx( HBITMAP hbitmap, LPSIZE size )
 386 {
 387     BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 388     if (!bmp) return FALSE;
 389     *size = bmp->size;
 390     return TRUE;
 391 }
 392
 393
 394 /***********************************************************************
 395  *           GetBitmapDimension    (GDI.162)
 396  */
 397 DWORD GetBitmapDimension( HBITMAP hbitmap )
 398 {
 399     SIZE size;
 400     if (!GetBitmapDimensionEx( hbitmap, &size )) return 0;
 401     return size.cx | (size.cy << 16);
 402 }
 403
 404 /***********************************************************************
 405  *           SetBitmapDimensionEx    (GDI.478)
 406  */
 407 BOOL SetBitmapDimensionEx( HBITMAP hbitmap, short x, short y, LPSIZE prevSize )
 408 {
 409     BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 410     if (!bmp) return FALSE;
 411     if (prevSize) *prevSize = bmp->size;
 412     bmp->size.cx = x;
 413     bmp->size.cy = y;
 414     return TRUE;
 415 }
 416
 417
 418 /***********************************************************************
 419  *           SetBitmapDimension    (GDI.163)
 420  */
 421 DWORD SetBitmapDimension( HBITMAP hbitmap, short x, short y )
 422 {
 423     SIZE size;
 424     if (!SetBitmapDimensionEx( hbitmap, x, y, &size )) return 0;
 425     return size.cx | (size.cy << 16);
 426 }