objects/bitmap.c

   1 /*
   2  * GDI bitmap objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <X11/Xlib.h>
  11 #include <X11/Xutil.h>
  12 #include "gdi.h"
  13 #include "callback.h"
  14 #include "dc.h"
  15 #include "bitmap.h"
  16 #include "heap.h"
  17 #include "stddebug.h"
  18 #include "debug.h"
  19
  20 #ifdef PRELIMINARY_WING16_SUPPORT
  21 #include <sys/types.h>
  22 #include <sys/ipc.h>
  23 #include <sys/shm.h>
  24 #endif
  25
  26   /* GCs used for B&W and color bitmap operations */
  27 GC BITMAP_monoGC = 0, BITMAP_colorGC = 0;
  28
  29 extern void CLIPPING_UpdateGCRegion( DC * dc );  /* objects/clipping.c */
  30
  31
  32 /***********************************************************************
  33  *           XPutImage_wrapper
  34  *
  35  * Wrapper to call XPutImage with CALL_LARGE_STACK.
  36  */
  37
  38 struct XPutImage_descr
  39 {
  40     BITMAPOBJ *bmp;
  41     XImage    *image;
  42     INT32      width;
  43     INT32      height;
  44 };
  45
  46 static int XPutImage_wrapper( const struct XPutImage_descr *descr )
  47 {
  48     return XPutImage( display, descr->bmp->pixmap, BITMAP_GC(descr->bmp),
  49                       descr->image, 0, 0, 0, 0, descr->width, descr->height );
  50 }
  51
  52
  53 /***********************************************************************
  54  *           CreateBitmap16    (GDI.48)
  55  */
  56 HBITMAP16 WINAPI CreateBitmap16( INT16 width, INT16 height, UINT16 planes,
  57                                  UINT16 bpp, LPCVOID bits )
  58 {
  59     return CreateBitmap32( width, height, planes, bpp, bits );
  60 }
  61
  62
  63 /***********************************************************************
  64  *           CreateBitmap32    (GDI32.25)
  65  */
  66 HBITMAP32 WINAPI CreateBitmap32( INT32 width, INT32 height, UINT32 planes,
  67                                  UINT32 bpp, LPCVOID bits )
  68 {
  69     BITMAPOBJ * bmpObjPtr;
  70     HBITMAP32 hbitmap;
  71
  72     planes = (BYTE)planes;
  73     bpp    = (BYTE)bpp;
  74
  75     dprintf_gdi( stddeb, "CreateBitmap: %dx%d, %d colors\n",
  76                  width, height, 1 << (planes*bpp) );
  77
  78       /* Check parameters */
  79     if (!height || !width || planes != 1) return 0;
  80     if ((bpp != 1) && (bpp != screenDepth)) return 0;
  81     if (height < 0) height = -height;
  82     if (width < 0) width = -width;
  83
  84       /* Create the BITMAPOBJ */
  85     hbitmap = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC );
  86     if (!hbitmap) return 0;
  87     bmpObjPtr = (BITMAPOBJ *) GDI_HEAP_LOCK( hbitmap );
  88
  89     bmpObjPtr->size.cx = 0;
  90     bmpObjPtr->size.cy = 0;
  91     bmpObjPtr->bitmap.bmType = 0;
  92     bmpObjPtr->bitmap.bmWidth = (INT16)width;
  93     bmpObjPtr->bitmap.bmHeight = (INT16)height;
  94     bmpObjPtr->bitmap.bmPlanes = (BYTE)planes;
  95     bmpObjPtr->bitmap.bmBitsPixel = (BYTE)bpp;
  96     bmpObjPtr->bitmap.bmWidthBytes = (INT16)BITMAP_WIDTH_BYTES( width, bpp );
  97     bmpObjPtr->bitmap.bmBits = NULL;
  98
  99       /* Create the pixmap */
 100     bmpObjPtr->pixmap = XCreatePixmap(display, rootWindow, width, height, bpp);
 101     if (!bmpObjPtr->pixmap)
 102     {
 103         GDI_HEAP_FREE( hbitmap );
 104         hbitmap = 0;
 105     }
 106     else if (bits)  /* Set bitmap bits */
 107         SetBitmapBits32( hbitmap, height * bmpObjPtr->bitmap.bmWidthBytes,
 108                          bits );
 109     GDI_HEAP_UNLOCK( hbitmap );
 110     return hbitmap;
 111 }
 112
 113
 114 /***********************************************************************
 115  *           CreateCompatibleBitmap16    (GDI.51)
 116  */
 117 HBITMAP16 WINAPI CreateCompatibleBitmap16(HDC16 hdc, INT16 width, INT16 height)
 118 {
 119     return CreateCompatibleBitmap32( hdc, width, height );
 120 }
 121
 122
 123 /***********************************************************************
 124  *           CreateCompatibleBitmap32    (GDI32.30)
 125  */
 126 HBITMAP32 WINAPI CreateCompatibleBitmap32(HDC32 hdc, INT32 width, INT32 height)
 127 {
 128     HBITMAP32 hbmpRet = 0;
 129     DC *dc;
 130
 131     dprintf_gdi( stddeb, "CreateCompatibleBitmap(%04x,%d,%d) = \n",
 132                  hdc, width, height );
 133     if (!(dc = DC_GetDCPtr( hdc ))) return 0;
 134     hbmpRet = CreateBitmap32( width, height, 1, dc->w.bitsPerPixel, NULL );
 135     dprintf_gdi(stddeb,"\t\t%04x\n", hbmpRet);
 136     return hbmpRet;
 137 }
 138
 139
 140 /***********************************************************************
 141  *           CreateBitmapIndirect16    (GDI.49)
 142  */
 143 HBITMAP16 WINAPI CreateBitmapIndirect16( const BITMAP16 * bmp )
 144 {
 145     return CreateBitmap16( bmp->bmWidth, bmp->bmHeight, bmp->bmPlanes,
 146                            bmp->bmBitsPixel, PTR_SEG_TO_LIN( bmp->bmBits ) );
 147 }
 148
 149
 150 /***********************************************************************
 151  *           CreateBitmapIndirect32    (GDI32.26)
 152  */
 153 HBITMAP32 WINAPI CreateBitmapIndirect32( const BITMAP32 * bmp )
 154 {
 155     return CreateBitmap32( bmp->bmWidth, bmp->bmHeight, bmp->bmPlanes,
 156                            bmp->bmBitsPixel, bmp->bmBits );
 157 }
 158
 159
 160 /***********************************************************************
 161  *           BITMAP_GetXImage
 162  *
 163  * Get an X image for a bitmap. For use with CALL_LARGE_STACK.
 164  */
 165 XImage *BITMAP_GetXImage( const BITMAPOBJ *bmp )
 166 {
 167     return XGetImage( display, bmp->pixmap, 0, 0, bmp->bitmap.bmWidth,
 168                       bmp->bitmap.bmHeight, AllPlanes, ZPixmap );
 169 }
 170
 171
 172 /***********************************************************************
 173  *           GetBitmapBits16    (GDI.74)
 174  */
 175 LONG WINAPI GetBitmapBits16( HBITMAP16 hbitmap, LONG count, LPVOID buffer )
 176 {
 177     return GetBitmapBits32( hbitmap, count, buffer );
 178 }
 179
 180
 181 /***********************************************************************
 182  *           GetBitmapBits32    (GDI32.143)
 183  */
 184 LONG WINAPI GetBitmapBits32( HBITMAP32 hbitmap, LONG count, LPVOID buffer )
 185 {
 186     BITMAPOBJ * bmp;
 187     LONG height, old_height;
 188     XImage * image;
 189     LPBYTE tbuf;
 190     int h,w,pad;
 191
 192     /* KLUDGE! */
 193     if (count < 0) {
 194         fprintf(stderr, "Negative number of bytes (%ld) passed to GetBitmapBits???\n", count );
 195         count = -count;
 196     }
 197     bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 198     if (!bmp) return 0;
 199
 200       /* Only get entire lines */
 201     height = count / bmp->bitmap.bmWidthBytes;
 202     if (height > bmp->bitmap.bmHeight) height = bmp->bitmap.bmHeight;
 203     dprintf_bitmap(stddeb, "GetBitmapBits: %dx%d %d colors %p fetched height: %ld\n",
 204             bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
 205             1 << bmp->bitmap.bmBitsPixel, buffer, height );
 206     if (!height)
 207     {
 208       GDI_HEAP_UNLOCK( hbitmap );
 209       return 0;
 210     }
 211
 212     switch (bmp->bitmap.bmBitsPixel) {
 213     case 1:
 214         if (!(bmp->bitmap.bmWidth & 15))
 215                 pad = 0;
 216         else
 217                 pad = ((16 - (bmp->bitmap.bmWidth & 15)) + 7) / 8;
 218         break;
 219     case 4:
 220         if (!(bmp->bitmap.bmWidth & 3))
 221             pad = 0;
 222         else
 223             pad = ((4 - (bmp->bitmap.bmWidth & 3)) + 1) / 2;
 224         break;
 225     case 8:
 226         pad = (2 - (bmp->bitmap.bmWidth & 1)) & 1;
 227         break;
 228     case 15:
 229     case 16:
 230         pad = 0; /* we have 16bit alignment already */
 231         break;
 232     case 24:
 233         pad = (bmp->bitmap.bmWidth*3) & 1;
 234         break;
 235     default:
 236         fprintf(stderr,"GetBitMapBits32: unknown depth %d, please report.\n",
 237                 bmp->bitmap.bmBitsPixel
 238         );
 239         GDI_HEAP_UNLOCK( hbitmap );
 240         return 0;
 241     }
 242
 243     /* Hack: change the bitmap height temporarily to avoid */
 244     /*       getting unnecessary bitmap rows. */
 245     old_height = bmp->bitmap.bmHeight;
 246     bmp->bitmap.bmHeight = height;
 247     image = (XImage *)CALL_LARGE_STACK( BITMAP_GetXImage, bmp );
 248     bmp->bitmap.bmHeight = old_height;
 249
 250     /* copy XImage to 16 bit padded image buffer with real bitsperpixel */
 251
 252     tbuf = buffer;
 253     switch (bmp->bitmap.bmBitsPixel)
 254     {
 255     case 1:
 256         for (h=0;h<height;h++)
 257         {
 258             *tbuf = 0;
 259             for (w=0;w<bmp->bitmap.bmWidth;w++)
 260             {
 261                 if ((w%8) == 0)
 262                     *tbuf = 0;
 263                 *tbuf |= XGetPixel(image,w,h)<<(7-(w&7));
 264                 if ((w&7) == 7) ++tbuf;
 265             }
 266             tbuf += pad;
 267         }
 268         break;
 269     case 4:
 270         for (h=0;h<height;h++)
 271         {
 272             for (w=0;w<bmp->bitmap.bmWidth;w++)
 273             {
 274                 if (!(w & 1)) *tbuf = XGetPixel( image, w, h) << 4;
 275                 else *tbuf++ |= XGetPixel( image, w, h) & 0x0f;
 276             }
 277             tbuf += pad;
 278         }
 279         break;
 280     case 8:
 281         for (h=0;h<height;h++)
 282         {
 283             for (w=0;w<bmp->bitmap.bmWidth;w++)
 284                 *tbuf++ = XGetPixel(image,w,h);
 285             tbuf += pad;
 286         }
 287         break;
 288     case 15:
 289     case 16:
 290         for (h=0;h<height;h++)
 291         {
 292             for (w=0;w<bmp->bitmap.bmWidth;w++)
 293             {
 294                 long pixel = XGetPixel(image,w,h);
 295
 296                 *tbuf++ = pixel & 0xff;
 297                 *tbuf++ = (pixel>>8) & 0xff;
 298             }
 299         }
 300         break;
 301     case 24:
 302         for (h=0;h<height;h++)
 303         {
 304             for (w=0;w<bmp->bitmap.bmWidth;w++)
 305             {
 306                 long pixel = XGetPixel(image,w,h);
 307
 308                 *tbuf++ = pixel & 0xff;
 309                 *tbuf++ = (pixel>> 8) & 0xff;
 310                 *tbuf++ = (pixel>>16) & 0xff;
 311             }
 312             tbuf += pad;
 313         }
 314     }
 315     XDestroyImage( image );
 316     GDI_HEAP_UNLOCK( hbitmap );
 317     return height * bmp->bitmap.bmWidthBytes;
 318 }
 319
 320
 321 /***********************************************************************
 322  *           SetBitmapBits16    (GDI.106)
 323  */
 324 LONG WINAPI SetBitmapBits16( HBITMAP16 hbitmap, LONG count, LPCVOID buffer )
 325 {
 326     return SetBitmapBits32( hbitmap, count, buffer );
 327 }
 328
 329
 330 /***********************************************************************
 331  *           SetBitmapBits32    (GDI32.303)
 332  */
 333 LONG WINAPI SetBitmapBits32( HBITMAP32 hbitmap, LONG count, LPCVOID buffer )
 334 {
 335     struct XPutImage_descr descr;
 336     BITMAPOBJ * bmp;
 337     LONG height;
 338     XImage * image;
 339     LPBYTE sbuf,tmpbuffer;
 340     int w,h,pad,widthbytes;
 341
 342     /* KLUDGE! */
 343     if (count < 0) {
 344         fprintf(stderr, "Negative number of bytes (%ld) passed to SetBitmapBits???\n", count );
 345         count = -count;
 346     }
 347     bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 348     if (!bmp) return 0;
 349
 350     dprintf_bitmap(stddeb, "SetBitmapBits: %dx%d %d colors %p\n",
 351             bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
 352             1 << bmp->bitmap.bmBitsPixel, buffer );
 353
 354       /* Only set entire lines */
 355     height = count / bmp->bitmap.bmWidthBytes;
 356     if (height > bmp->bitmap.bmHeight) height = bmp->bitmap.bmHeight;
 357     if (!height)
 358     {
 359       GDI_HEAP_UNLOCK( hbitmap );
 360       return 0;
 361     }
 362
 363     switch (bmp->bitmap.bmBitsPixel) {
 364     case 1:
 365         if (!(bmp->bitmap.bmWidth & 15))
 366                 pad = 0;
 367         else
 368                 pad = ((16 - (bmp->bitmap.bmWidth & 15)) + 7) / 8;
 369         break;
 370     case 4:
 371         if (!(bmp->bitmap.bmWidth & 3))
 372             pad = 0;
 373         else
 374             pad = ((4 - (bmp->bitmap.bmWidth & 3)) + 1) / 2;
 375         break;
 376     case 8:
 377         pad = (2 - (bmp->bitmap.bmWidth & 1)) & 1;
 378         break;
 379     case 15:
 380     case 16:
 381         pad = 0; /* we have 16bit alignment already */
 382         break;
 383     case 24:
 384         pad = (bmp->bitmap.bmWidth*3) & 1;
 385         break;
 386     default:
 387         fprintf(stderr,"SetBitMapBits32: unknown depth %d, please report.\n",
 388                 bmp->bitmap.bmBitsPixel
 389         );
 390         return 0;
 391     }
 392     sbuf = (LPBYTE)buffer;
 393
 394     widthbytes  = DIB_GetXImageWidthBytes(bmp->bitmap.bmWidth,bmp->bitmap.bmBitsPixel);
 395     tmpbuffer   = (LPBYTE)xmalloc(widthbytes*height);
 396     image = XCreateImage( display, DefaultVisualOfScreen(screen),
 397                   bmp->bitmap.bmBitsPixel, ZPixmap, 0, tmpbuffer,
 398                   bmp->bitmap.bmWidth,height,32,widthbytes
 399     );
 400
 401     /* copy 16 bit padded image buffer with real bitsperpixel to XImage */
 402     sbuf = (LPBYTE)buffer;
 403     switch (bmp->bitmap.bmBitsPixel)
 404     {
 405     case 1:
 406         for (h=0;h<height;h++)
 407         {
 408             for (w=0;w<bmp->bitmap.bmWidth;w++)
 409             {
 410                 XPutPixel(image,w,h,(sbuf[0]>>(7-(w&7))) & 1);
 411                 if ((w&7) == 7)
 412                     sbuf++;
 413             }
 414             sbuf += pad;
 415         }
 416         break;
 417     case 4:
 418         for (h=0;h<height;h++)
 419         {
 420             for (w=0;w<bmp->bitmap.bmWidth;w++)
 421             {
 422                 if (!(w & 1)) XPutPixel( image, w, h, *sbuf >> 4 );
 423                 else XPutPixel( image, w, h, *sbuf++ & 0xf );
 424             }
 425             sbuf += pad;
 426         }
 427         break;
 428     case 8:
 429         for (h=0;h<height;h++)
 430         {
 431             for (w=0;w<bmp->bitmap.bmWidth;w++)
 432                 XPutPixel(image,w,h,*sbuf++);
 433             sbuf += pad;
 434         }
 435         break;
 436     case 15:
 437     case 16:
 438         for (h=0;h<height;h++)
 439         {
 440             for (w=0;w<bmp->bitmap.bmWidth;w++)
 441             {
 442                 XPutPixel(image,w,h,sbuf[1]*256+sbuf[0]);
 443                 sbuf+=2;
 444             }
 445         }
 446         break;
 447     case 24:
 448         for (h=0;h<height;h++)
 449         {
 450             for (w=0;w<bmp->bitmap.bmWidth;w++)
 451             {
 452                 XPutPixel(image,w,h,(sbuf[2]<<16)+(sbuf[1]<<8)+sbuf[0]);
 453                 sbuf += 3;
 454             }
 455             sbuf += pad;
 456         }
 457         break;
 458     }
 459
 460     descr.bmp    = bmp;
 461     descr.image  = image;
 462     descr.width  = bmp->bitmap.bmWidth;
 463     descr.height = height;
 464     CALL_LARGE_STACK( XPutImage_wrapper, &descr );
 465
 466     XDestroyImage( image ); /* frees tmpbuffer too */
 467     GDI_HEAP_UNLOCK( hbitmap );
 468     return height * bmp->bitmap.bmWidthBytes;
 469 }
 470
 471 /**********************************************************************
 472  *          LoadImageA    (USER32.364)
 473  * FIXME: implementation still lacks nearly all features, see LR_*
 474  * defines in windows.h
 475  */
 476
 477 HANDLE32 WINAPI LoadImage32A( HINSTANCE32 hinst, LPCSTR name, UINT32 type,
 478                               INT32 desiredx, INT32 desiredy, UINT32 loadflags)
 479 {
 480         if (HIWORD(name)) {
 481                 dprintf_resource(stddeb,"LoadImage32A(0x%04x,%s,%d,%d,%d,0x%08x)\n",
 482                         hinst,name,type,desiredx,desiredy,loadflags
 483                 );
 484         } else {
 485                 dprintf_resource(stddeb,"LoadImage32A(0x%04x,%p,%d,%d,%d,0x%08x)\n",
 486                         hinst,name,type,desiredx,desiredy,loadflags
 487                 );
 488         }
 489         switch (type) {
 490         case IMAGE_BITMAP:
 491                 return LoadBitmap32A(hinst,name);
 492         case IMAGE_ICON:
 493                 return LoadIcon32A(hinst,name);
 494         case IMAGE_CURSOR:
 495                 return LoadCursor32A(hinst,name);
 496         }
 497         return 0;
 498 }
 499
 500 /**********************************************************************
 501  *          CopyImage32    (USER32.60)
 502  *
 503  * FIXME: implementation still lacks nearly all features, see LR_*
 504  * defines in windows.h
 505  */
 506 HANDLE32 WINAPI CopyImage32( HANDLE32 hnd, UINT32 type, INT32 desiredx,
 507                              INT32 desiredy, UINT32 flags )
 508 {
 509     switch (type)
 510     {
 511         case IMAGE_BITMAP:
 512                 return hnd;     /* FIXME ... need to copy here */
 513         case IMAGE_ICON:
 514                 return CopyIcon32(hnd);
 515         case IMAGE_CURSOR:
 516                 return CopyCursor32(hnd);
 517     }
 518     return 0;
 519 }
 520
 521
 522 /**********************************************************************
 523  *          LoadBitmap16    (USER.175)
 524  */
 525 HBITMAP16 WINAPI LoadBitmap16( HINSTANCE16 instance, SEGPTR name )
 526 {
 527     HBITMAP32 hbitmap = 0;
 528     HDC32 hdc;
 529     HRSRC16 hRsrc;
 530     HGLOBAL16 handle;
 531     BITMAPINFO *info;
 532
 533     if (HIWORD(name))
 534     {
 535         char *str = (char *)PTR_SEG_TO_LIN( name );
 536         dprintf_bitmap( stddeb, "LoadBitmap16(%04x,'%s')\n", instance, str );
 537         if (str[0] == '#') name = (SEGPTR)(DWORD)(WORD)atoi( str + 1 );
 538     }
 539     else
 540         dprintf_bitmap( stddeb, "LoadBitmap16(%04x,%04x)\n",
 541                         instance, LOWORD(name) );
 542
 543     if (!instance)  /* OEM bitmap */
 544     {
 545         if (HIWORD((int)name)) return 0;
 546         return OBM_LoadBitmap( LOWORD((int)name) );
 547     }
 548
 549     if (!(hRsrc = FindResource16( instance, name, RT_BITMAP ))) return 0;
 550     if (!(handle = LoadResource16( instance, hRsrc ))) return 0;
 551
 552     info = (BITMAPINFO *)LockResource16( handle );
 553     if ((hdc = GetDC32(0)) != 0)
 554     {
 555         char *bits = (char *)info + DIB_BitmapInfoSize( info, DIB_RGB_COLORS );
 556         hbitmap = CreateDIBitmap32( hdc, &info->bmiHeader, CBM_INIT,
 557                                     bits, info, DIB_RGB_COLORS );
 558         ReleaseDC32( 0, hdc );
 559     }
 560     FreeResource16( handle );
 561     return hbitmap;
 562 }
 563
 564 /**********************************************************************
 565  *          LoadBitmap32W   (USER32.357)
 566  */
 567 HBITMAP32 WINAPI LoadBitmap32W( HINSTANCE32 instance, LPCWSTR name )
 568 {
 569     HBITMAP32 hbitmap = 0;
 570     HDC32 hdc;
 571     HRSRC32 hRsrc;
 572     HGLOBAL32 handle;
 573     BITMAPINFO *info;
 574
 575     if (!instance)  /* OEM bitmap */
 576     {
 577         if (HIWORD((int)name)) return 0;
 578         return OBM_LoadBitmap( LOWORD((int)name) );
 579     }
 580
 581     if (!(hRsrc = FindResource32W( instance, name,
 582                 (LPWSTR)RT_BITMAP ))) return 0;
 583     if (!(handle = LoadResource32( instance, hRsrc ))) return 0;
 584
 585     info = (BITMAPINFO *)LockResource32( handle );
 586     if ((hdc = GetDC32(0)) != 0)
 587     {
 588         char *bits = (char *)info + DIB_BitmapInfoSize( info, DIB_RGB_COLORS );
 589         hbitmap = CreateDIBitmap32( hdc, &info->bmiHeader, CBM_INIT,
 590                                     bits, info, DIB_RGB_COLORS );
 591         ReleaseDC32( 0, hdc );
 592     }
 593     return hbitmap;
 594 }
 595
 596
 597 /**********************************************************************
 598  *          LoadBitmap32A   (USER32.356)
 599  */
 600 HBITMAP32 WINAPI LoadBitmap32A( HINSTANCE32 instance, LPCSTR name )
 601 {
 602     HBITMAP32 res;
 603     if (!HIWORD(name)) res = LoadBitmap32W( instance, (LPWSTR)name );
 604     else
 605     {
 606         LPWSTR uni = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
 607         res = LoadBitmap32W( instance, uni );
 608         HeapFree( GetProcessHeap(), 0, uni );
 609     }
 610     return res;
 611 }
 612
 613
 614 /***********************************************************************
 615  *           BITMAP_DeleteObject
 616  */
 617 BOOL32 BITMAP_DeleteObject( HBITMAP16 hbitmap, BITMAPOBJ * bmp )
 618 {
 619 #ifdef PRELIMINARY_WING16_SUPPORT
 620     if( bmp->bitmap.bmBits )
 621         XShmDetach( display, (XShmSegmentInfo*)bmp->bitmap.bmBits );
 622 #endif
 623
 624     XFreePixmap( display, bmp->pixmap );
 625 #ifdef PRELIMINARY_WING16_SUPPORT
 626     if( bmp->bitmap.bmBits )
 627     {
 628     __ShmBitmapCtl* p = (__ShmBitmapCtl*)bmp->bitmap.bmBits;
 629       WORD          sel = HIWORD(p->bits);
 630       unsigned long l, limit = GetSelectorLimit(sel);
 631
 632       for( l = 0; l < limit; l += 0x10000, sel += __AHINCR )
 633            FreeSelector(sel);
 634       shmctl(p->si.shmid, IPC_RMID, NULL);
 635       shmdt(p->si.shmaddr);  /* already marked for destruction */
 636     }
 637 #endif
 638     return GDI_FreeObject( hbitmap );
 639 }
 640
 641
 642 /***********************************************************************
 643  *           BITMAP_GetObject16
 644  */
 645 INT16 BITMAP_GetObject16( BITMAPOBJ * bmp, INT16 count, LPVOID buffer )
 646 {
 647     if (count > sizeof(bmp->bitmap)) count = sizeof(bmp->bitmap);
 648     memcpy( buffer, &bmp->bitmap, count );
 649     return count;
 650 }
 651
 652
 653 /***********************************************************************
 654  *           BITMAP_GetObject32
 655  */
 656 INT32 BITMAP_GetObject32( BITMAPOBJ * bmp, INT32 count, LPVOID buffer )
 657 {
 658     BITMAP32 bmp32;
 659     bmp32.bmType       = bmp->bitmap.bmType;
 660     bmp32.bmWidth      = bmp->bitmap.bmWidth;
 661     bmp32.bmHeight     = bmp->bitmap.bmHeight;
 662     bmp32.bmWidthBytes = bmp->bitmap.bmWidthBytes;
 663     bmp32.bmPlanes     = bmp->bitmap.bmPlanes;
 664     bmp32.bmBitsPixel  = bmp->bitmap.bmBitsPixel;
 665     bmp32.bmBits       = NULL;
 666     if (count > sizeof(bmp32)) count = sizeof(bmp32);
 667     memcpy( buffer, &bmp32, count );
 668     return count;
 669 }
 670
 671
 672
 673 /***********************************************************************
 674  *           CreateDiscardableBitmap16    (GDI.156)
 675  */
 676 HBITMAP16 WINAPI CreateDiscardableBitmap16( HDC16 hdc, INT16 width,
 677                                             INT16 height )
 678 {
 679     return CreateCompatibleBitmap16( hdc, width, height );
 680 }
 681
 682
 683 /***********************************************************************
 684  *           CreateDiscardableBitmap32    (GDI32.38)
 685  */
 686 HBITMAP32 WINAPI CreateDiscardableBitmap32( HDC32 hdc, INT32 width,
 687                                             INT32 height )
 688 {
 689     return CreateCompatibleBitmap32( hdc, width, height );
 690 }
 691
 692
 693 /***********************************************************************
 694  *           GetBitmapDimensionEx16    (GDI.468)
 695  */
 696 BOOL16 WINAPI GetBitmapDimensionEx16( HBITMAP16 hbitmap, LPSIZE16 size )
 697 {
 698     BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 699     if (!bmp) return FALSE;
 700     *size = bmp->size;
 701     GDI_HEAP_UNLOCK( hbitmap );
 702     return TRUE;
 703 }
 704
 705
 706 /***********************************************************************
 707  *           GetBitmapDimensionEx32    (GDI32.144)
 708  */
 709 BOOL32 WINAPI GetBitmapDimensionEx32( HBITMAP32 hbitmap, LPSIZE32 size )
 710 {
 711     BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 712     if (!bmp) return FALSE;
 713     size->cx = (INT32)bmp->size.cx;
 714     size->cy = (INT32)bmp->size.cy;
 715     GDI_HEAP_UNLOCK( hbitmap );
 716     return TRUE;
 717 }
 718
 719
 720 /***********************************************************************
 721  *           GetBitmapDimension    (GDI.162)
 722  */
 723 DWORD WINAPI GetBitmapDimension( HBITMAP16 hbitmap )
 724 {
 725     SIZE16 size;
 726     if (!GetBitmapDimensionEx16( hbitmap, &size )) return 0;
 727     return MAKELONG( size.cx, size.cy );
 728 }
 729
 730
 731 /***********************************************************************
 732  *           SetBitmapDimensionEx16    (GDI.478)
 733  */
 734 BOOL16 WINAPI SetBitmapDimensionEx16( HBITMAP16 hbitmap, INT16 x, INT16 y,
 735                                       LPSIZE16 prevSize )
 736 {
 737     BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 738     if (!bmp) return FALSE;
 739     if (prevSize) *prevSize = bmp->size;
 740     bmp->size.cx = x;
 741     bmp->size.cy = y;
 742     GDI_HEAP_UNLOCK( hbitmap );
 743     return TRUE;
 744 }
 745
 746
 747 /***********************************************************************
 748  *           SetBitmapDimensionEx32    (GDI32.304)
 749  */
 750 BOOL32 WINAPI SetBitmapDimensionEx32( HBITMAP32 hbitmap, INT32 x, INT32 y,
 751                                       LPSIZE32 prevSize )
 752 {
 753     BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
 754     if (!bmp) return FALSE;
 755     if (prevSize) CONV_SIZE16TO32( &bmp->size, prevSize );
 756     bmp->size.cx = (INT16)x;
 757     bmp->size.cy = (INT16)y;
 758     GDI_HEAP_UNLOCK( hbitmap );
 759     return TRUE;
 760 }
 761
 762
 763 /***********************************************************************
 764  *           SetBitmapDimension    (GDI.163)
 765  */
 766 DWORD WINAPI SetBitmapDimension( HBITMAP16 hbitmap, INT16 x, INT16 y )
 767 {
 768     SIZE16 size;
 769     if (!SetBitmapDimensionEx16( hbitmap, x, y, &size )) return 0;
 770     return MAKELONG( size.cx, size.cy );
 771 }
 772