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