dlls/gdi32/bitmap.c

   1 /*
   2  * GDI bitmap objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1998 Huw D M Davies
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "gdi_private.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(bitmap);
  33
  34
  35 static HGDIOBJ BITMAP_SelectObject( HGDIOBJ handle, HDC hdc );
  36 static INT BITMAP_GetObject( HGDIOBJ handle, INT count, LPVOID buffer );
  37 static BOOL BITMAP_DeleteObject( HGDIOBJ handle );
  38
  39 static const struct gdi_obj_funcs bitmap_funcs =
  40 {
  41     BITMAP_SelectObject,  /* pSelectObject */
  42     BITMAP_GetObject,     /* pGetObjectA */
  43     BITMAP_GetObject,     /* pGetObjectW */
  44     NULL,                 /* pUnrealizeObject */
  45     BITMAP_DeleteObject   /* pDeleteObject */
  46 };
  47
  48
  49 /******************************************************************************
  50  * CreateBitmap [GDI32.@]
  51  *
  52  * Creates a bitmap with the specified info.
  53  *
  54  * PARAMS
  55  *    width  [I] bitmap width
  56  *    height [I] bitmap height
  57  *    planes [I] Number of color planes
  58  *    bpp    [I] Number of bits to identify a color
  59  *    bits   [I] Pointer to array containing color data
  60  *
  61  * RETURNS
  62  *    Success: Handle to bitmap
  63  *    Failure: 0
  64  */
  65 HBITMAP WINAPI CreateBitmap( INT width, INT height, UINT planes,
  66                              UINT bpp, LPCVOID bits )
  67 {
  68     BITMAP bm;
  69
  70     bm.bmType = 0;
  71     bm.bmWidth = width;
  72     bm.bmHeight = height;
  73     bm.bmWidthBytes = get_bitmap_stride( width, bpp );
  74     bm.bmPlanes = planes;
  75     bm.bmBitsPixel = bpp;
  76     bm.bmBits = (LPVOID)bits;
  77
  78     return CreateBitmapIndirect( &bm );
  79 }
  80
  81 /******************************************************************************
  82  * CreateCompatibleBitmap [GDI32.@]
  83  *
  84  * Creates a bitmap compatible with the DC.
  85  *
  86  * PARAMS
  87  *    hdc    [I] Handle to device context
  88  *    width  [I] Width of bitmap
  89  *    height [I] Height of bitmap
  90  *
  91  * RETURNS
  92  *    Success: Handle to bitmap
  93  *    Failure: 0
  94  */
  95 HBITMAP WINAPI CreateCompatibleBitmap( HDC hdc, INT width, INT height)
  96 {
  97     char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
  98     BITMAPINFO *bi = (BITMAPINFO *)buffer;
  99     DIBSECTION dib;
 100
 101     TRACE("(%p,%d,%d)\n", hdc, width, height);
 102
 103     if (GetObjectType( hdc ) != OBJ_MEMDC)
 104         return CreateBitmap( width, height,
 105                              GetDeviceCaps(hdc, PLANES), GetDeviceCaps(hdc, BITSPIXEL), NULL );
 106
 107     switch (GetObjectW( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(dib), &dib ))
 108     {
 109     case sizeof(BITMAP): /* A device-dependent bitmap is selected in the DC */
 110         return CreateBitmap( width, height, dib.dsBm.bmPlanes, dib.dsBm.bmBitsPixel, NULL );
 111
 112     case sizeof(DIBSECTION): /* A DIB section is selected in the DC */
 113         bi->bmiHeader = dib.dsBmih;
 114         bi->bmiHeader.biWidth  = width;
 115         bi->bmiHeader.biHeight = height;
 116         if (dib.dsBmih.biCompression == BI_BITFIELDS)  /* copy the color masks */
 117             memcpy(bi->bmiColors, dib.dsBitfields, sizeof(dib.dsBitfields));
 118         else if (dib.dsBmih.biBitCount <= 8)  /* copy the color table */
 119             GetDIBColorTable(hdc, 0, 256, bi->bmiColors);
 120         return CreateDIBSection( hdc, bi, DIB_RGB_COLORS, NULL, NULL, 0 );
 121
 122     default:
 123         return 0;
 124     }
 125 }
 126
 127
 128 /******************************************************************************
 129  * CreateBitmapIndirect [GDI32.@]
 130  *
 131  * Creates a bitmap with the specified info.
 132  *
 133  * PARAMS
 134  *  bmp [I] Pointer to the bitmap info describing the bitmap
 135  *
 136  * RETURNS
 137  *    Success: Handle to bitmap
 138  *    Failure: NULL. Use GetLastError() to determine the cause.
 139  *
 140  * NOTES
 141  *  If a width or height of 0 is given, a 1x1 monochrome bitmap is returned.
 142  */
 143 HBITMAP WINAPI CreateBitmapIndirect( const BITMAP *bmp )
 144 {
 145     BITMAP bm;
 146     BITMAPOBJ *bmpobj;
 147     HBITMAP hbitmap;
 148     INT dib_stride;
 149     SIZE_T size;
 150
 151     if (!bmp || bmp->bmType)
 152     {
 153         SetLastError( ERROR_INVALID_PARAMETER );
 154         return NULL;
 155     }
 156
 157     if (bmp->bmWidth > 0x7ffffff || bmp->bmHeight > 0x7ffffff)
 158     {
 159         SetLastError( ERROR_INVALID_PARAMETER );
 160         return 0;
 161     }
 162
 163     bm = *bmp;
 164
 165     if (!bm.bmWidth || !bm.bmHeight)
 166     {
 167         return GetStockObject( DEFAULT_BITMAP );
 168     }
 169     else
 170     {
 171         if (bm.bmHeight < 0)
 172             bm.bmHeight = -bm.bmHeight;
 173         if (bm.bmWidth < 0)
 174             bm.bmWidth = -bm.bmWidth;
 175     }
 176
 177     if (bm.bmPlanes != 1)
 178     {
 179         FIXME("planes = %d\n", bm.bmPlanes);
 180         SetLastError( ERROR_INVALID_PARAMETER );
 181         return NULL;
 182     }
 183
 184     /* Windows only uses 1, 4, 8, 16, 24 and 32 bpp */
 185     if(bm.bmBitsPixel == 1)         bm.bmBitsPixel = 1;
 186     else if(bm.bmBitsPixel <= 4)    bm.bmBitsPixel = 4;
 187     else if(bm.bmBitsPixel <= 8)    bm.bmBitsPixel = 8;
 188     else if(bm.bmBitsPixel <= 16)   bm.bmBitsPixel = 16;
 189     else if(bm.bmBitsPixel <= 24)   bm.bmBitsPixel = 24;
 190     else if(bm.bmBitsPixel <= 32)   bm.bmBitsPixel = 32;
 191     else {
 192         WARN("Invalid bmBitsPixel %d, returning ERROR_INVALID_PARAMETER\n", bm.bmBitsPixel);
 193         SetLastError(ERROR_INVALID_PARAMETER);
 194         return NULL;
 195     }
 196
 197     /* Windows ignores the provided bm.bmWidthBytes */
 198     bm.bmWidthBytes = get_bitmap_stride( bm.bmWidth, bm.bmBitsPixel );
 199
 200     dib_stride = get_dib_stride( bm.bmWidth, bm.bmBitsPixel );
 201     size = dib_stride * bm.bmHeight;
 202     /* Check for overflow (dib_stride itself must be ok because of the constraint on bm.bmWidth above). */
 203     if (dib_stride != size / bm.bmHeight)
 204     {
 205         SetLastError( ERROR_INVALID_PARAMETER );
 206         return 0;
 207     }
 208
 209     /* Create the BITMAPOBJ */
 210     if (!(bmpobj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*bmpobj) )))
 211     {
 212         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 213         return 0;
 214     }
 215
 216     bmpobj->dib.dsBm = bm;
 217     bmpobj->dib.dsBm.bmBits = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
 218     if (!bmpobj->dib.dsBm.bmBits)
 219     {
 220         HeapFree( GetProcessHeap(), 0, bmpobj );
 221         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 222         return 0;
 223     }
 224
 225     if (!(hbitmap = alloc_gdi_handle( bmpobj, OBJ_BITMAP, &bitmap_funcs )))
 226     {
 227         HeapFree( GetProcessHeap(), 0, bmpobj->dib.dsBm.bmBits );
 228         HeapFree( GetProcessHeap(), 0, bmpobj );
 229         return 0;
 230     }
 231
 232     if (bm.bmBits)
 233         SetBitmapBits( hbitmap, bm.bmHeight * bm.bmWidthBytes, bm.bmBits );
 234
 235     TRACE("%dx%d, bpp %d planes %d: returning %p\n", bm.bmWidth, bm.bmHeight,
 236           bm.bmBitsPixel, bm.bmPlanes, hbitmap);
 237
 238     return hbitmap;
 239 }
 240
 241
 242 /***********************************************************************
 243  * GetBitmapBits [GDI32.@]
 244  *
 245  * Copies bitmap bits of bitmap to buffer.
 246  *
 247  * RETURNS
 248  *    Success: Number of bytes copied
 249  *    Failure: 0
 250  */
 251 LONG WINAPI GetBitmapBits(
 252     HBITMAP hbitmap, /* [in]  Handle to bitmap */
 253     LONG count,        /* [in]  Number of bytes to copy */
 254     LPVOID bits)       /* [out] Pointer to buffer to receive bits */
 255 {
 256     char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
 257     BITMAPINFO *info = (BITMAPINFO *)buffer;
 258     struct gdi_image_bits src_bits;
 259     struct bitblt_coords src;
 260     int dst_stride, max, ret;
 261     BITMAPOBJ *bmp = GDI_GetObjPtr( hbitmap, OBJ_BITMAP );
 262
 263     if (!bmp) return 0;
 264
 265     dst_stride = get_bitmap_stride( bmp->dib.dsBm.bmWidth, bmp->dib.dsBm.bmBitsPixel );
 266     ret = max = dst_stride * bmp->dib.dsBm.bmHeight;
 267     if (!bits) goto done;
 268     if (count < 0 || count > max) count = max;
 269     ret = count;
 270
 271     src.visrect.left = 0;
 272     src.visrect.right = bmp->dib.dsBm.bmWidth;
 273     src.visrect.top = 0;
 274     src.visrect.bottom = (count + dst_stride - 1) / dst_stride;
 275     src.x = src.y = 0;
 276     src.width = src.visrect.right - src.visrect.left;
 277     src.height = src.visrect.bottom - src.visrect.top;
 278
 279     if (!get_image_from_bitmap( bmp, info, &src_bits, &src ))
 280     {
 281         const char *src_ptr = src_bits.ptr;
 282         int src_stride = info->bmiHeader.biSizeImage / abs( info->bmiHeader.biHeight );
 283
 284         /* GetBitmapBits returns 16-bit aligned data */
 285
 286         if (info->bmiHeader.biHeight > 0)
 287         {
 288             src_ptr += (info->bmiHeader.biHeight - 1) * src_stride;
 289             src_stride = -src_stride;
 290         }
 291         src_ptr += src.visrect.top * src_stride;
 292
 293         if (src_stride == dst_stride) memcpy( bits, src_ptr, count );
 294         else while (count > 0)
 295         {
 296             memcpy( bits, src_ptr, min( count, dst_stride ) );
 297             src_ptr += src_stride;
 298             bits = (char *)bits + dst_stride;
 299             count -= dst_stride;
 300         }
 301         if (src_bits.free) src_bits.free( &src_bits );
 302     }
 303     else ret = 0;
 304
 305 done:
 306     GDI_ReleaseObj( hbitmap );
 307     return ret;
 308 }
 309
 310
 311 /******************************************************************************
 312  * SetBitmapBits [GDI32.@]
 313  *
 314  * Sets bits of color data for a bitmap.
 315  *
 316  * RETURNS
 317  *    Success: Number of bytes used in setting the bitmap bits
 318  *    Failure: 0
 319  */
 320 LONG WINAPI SetBitmapBits(
 321     HBITMAP hbitmap, /* [in] Handle to bitmap */
 322     LONG count,        /* [in] Number of bytes in bitmap array */
 323     LPCVOID bits)      /* [in] Address of array with bitmap bits */
 324 {
 325     char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
 326     BITMAPINFO *info = (BITMAPINFO *)buffer;
 327     BITMAPOBJ *bmp;
 328     DWORD err;
 329     int i, src_stride, dst_stride;
 330     struct bitblt_coords src, dst;
 331     struct gdi_image_bits src_bits;
 332     HRGN clip = NULL;
 333
 334     if (!bits) return 0;
 335
 336     bmp = GDI_GetObjPtr( hbitmap, OBJ_BITMAP );
 337     if (!bmp) return 0;
 338
 339     if (count < 0) {
 340         WARN("(%d): Negative number of bytes passed???\n", count );
 341         count = -count;
 342     }
 343
 344     src_stride = get_bitmap_stride( bmp->dib.dsBm.bmWidth, bmp->dib.dsBm.bmBitsPixel );
 345     count = min( count, src_stride * bmp->dib.dsBm.bmHeight );
 346
 347     dst_stride = get_dib_stride( bmp->dib.dsBm.bmWidth, bmp->dib.dsBm.bmBitsPixel );
 348
 349     src.visrect.left   = src.x = 0;
 350     src.visrect.top    = src.y = 0;
 351     src.visrect.right  = src.width = bmp->dib.dsBm.bmWidth;
 352     src.visrect.bottom = src.height = (count + src_stride - 1 ) / src_stride;
 353     dst = src;
 354
 355     if (count % src_stride)
 356     {
 357         HRGN last_row;
 358         int extra_pixels = ((count % src_stride) << 3) / bmp->dib.dsBm.bmBitsPixel;
 359
 360         if ((count % src_stride << 3) % bmp->dib.dsBm.bmBitsPixel)
 361             FIXME( "Unhandled partial pixel\n" );
 362         clip = CreateRectRgn( src.visrect.left, src.visrect.top,
 363                               src.visrect.right, src.visrect.bottom - 1 );
 364         last_row = CreateRectRgn( src.visrect.left, src.visrect.bottom - 1,
 365                                   src.visrect.left + extra_pixels, src.visrect.bottom );
 366         CombineRgn( clip, clip, last_row, RGN_OR );
 367         DeleteObject( last_row );
 368     }
 369
 370     TRACE("(%p, %d, %p) %dx%d %d bpp fetched height: %d\n",
 371           hbitmap, count, bits, bmp->dib.dsBm.bmWidth, bmp->dib.dsBm.bmHeight,
 372           bmp->dib.dsBm.bmBitsPixel, src.height );
 373
 374     if (src_stride == dst_stride)
 375     {
 376         src_bits.ptr = (void *)bits;
 377         src_bits.is_copy = FALSE;
 378         src_bits.free = NULL;
 379     }
 380     else
 381     {
 382         if (!(src_bits.ptr = HeapAlloc( GetProcessHeap(), 0, dst.height * dst_stride )))
 383         {
 384             GDI_ReleaseObj( hbitmap );
 385             return 0;
 386         }
 387         src_bits.is_copy = TRUE;
 388         src_bits.free = free_heap_bits;
 389         for (i = 0; i < count / src_stride; i++)
 390             memcpy( (char *)src_bits.ptr + i * dst_stride, (char *)bits + i * src_stride, src_stride );
 391         if (count % src_stride)
 392             memcpy( (char *)src_bits.ptr + i * dst_stride, (char *)bits + i * src_stride, count % src_stride );
 393     }
 394
 395     /* query the color info */
 396     info->bmiHeader.biSize          = sizeof(info->bmiHeader);
 397     info->bmiHeader.biPlanes        = 1;
 398     info->bmiHeader.biBitCount      = bmp->dib.dsBm.bmBitsPixel;
 399     info->bmiHeader.biCompression   = BI_RGB;
 400     info->bmiHeader.biXPelsPerMeter = 0;
 401     info->bmiHeader.biYPelsPerMeter = 0;
 402     info->bmiHeader.biClrUsed       = 0;
 403     info->bmiHeader.biClrImportant  = 0;
 404     info->bmiHeader.biWidth         = 0;
 405     info->bmiHeader.biHeight        = 0;
 406     info->bmiHeader.biSizeImage     = 0;
 407     err = put_image_into_bitmap( bmp, 0, info, NULL, NULL, NULL );
 408
 409     if (!err || err == ERROR_BAD_FORMAT)
 410     {
 411         info->bmiHeader.biWidth     = bmp->dib.dsBm.bmWidth;
 412         info->bmiHeader.biHeight    = -dst.height;
 413         info->bmiHeader.biSizeImage = dst.height * dst_stride;
 414         err = put_image_into_bitmap( bmp, clip, info, &src_bits, &src, &dst );
 415     }
 416     if (err) count = 0;
 417
 418     if (clip) DeleteObject( clip );
 419     if (src_bits.free) src_bits.free( &src_bits );
 420     GDI_ReleaseObj( hbitmap );
 421     return count;
 422 }
 423
 424
 425 /***********************************************************************
 426  *           BITMAP_SelectObject
 427  */
 428 static HGDIOBJ BITMAP_SelectObject( HGDIOBJ handle, HDC hdc )
 429 {
 430     HGDIOBJ ret;
 431     BITMAPOBJ *bitmap;
 432     DC *dc;
 433     PHYSDEV physdev;
 434
 435     if (!(dc = get_dc_ptr( hdc ))) return 0;
 436
 437     if (GetObjectType( hdc ) != OBJ_MEMDC)
 438     {
 439         ret = 0;
 440         goto done;
 441     }
 442     ret = dc->hBitmap;
 443     if (handle == dc->hBitmap) goto done;  /* nothing to do */
 444
 445     if (!(bitmap = GDI_GetObjPtr( handle, OBJ_BITMAP )))
 446     {
 447         ret = 0;
 448         goto done;
 449     }
 450
 451     if (handle != GetStockObject(DEFAULT_BITMAP) && GDI_get_ref_count( handle ))
 452     {
 453         WARN( "Bitmap already selected in another DC\n" );
 454         GDI_ReleaseObj( handle );
 455         ret = 0;
 456         goto done;
 457     }
 458
 459     if (bitmap->dib.dsBm.bmBitsPixel != 1 &&
 460         bitmap->dib.dsBm.bmBitsPixel != GetDeviceCaps( hdc, BITSPIXEL ))
 461     {
 462         WARN( "Wrong format bitmap %u bpp\n", bitmap->dib.dsBm.bmBitsPixel );
 463         GDI_ReleaseObj( handle );
 464         ret = 0;
 465         goto done;
 466     }
 467
 468     physdev = GET_DC_PHYSDEV( dc, pSelectBitmap );
 469     if (!physdev->funcs->pSelectBitmap( physdev, handle ))
 470     {
 471         GDI_ReleaseObj( handle );
 472         ret = 0;
 473     }
 474     else
 475     {
 476         dc->hBitmap = handle;
 477         GDI_inc_ref_count( handle );
 478         dc->dirty = 0;
 479         dc->vis_rect.left   = 0;
 480         dc->vis_rect.top    = 0;
 481         dc->vis_rect.right  = bitmap->dib.dsBm.bmWidth;
 482         dc->vis_rect.bottom = bitmap->dib.dsBm.bmHeight;
 483         dc->device_rect = dc->vis_rect;
 484         GDI_ReleaseObj( handle );
 485         DC_InitDC( dc );
 486         GDI_dec_ref_count( ret );
 487     }
 488
 489  done:
 490     release_dc_ptr( dc );
 491     return ret;
 492 }
 493
 494
 495 /***********************************************************************
 496  *           BITMAP_DeleteObject
 497  */
 498 static BOOL BITMAP_DeleteObject( HGDIOBJ handle )
 499 {
 500     BITMAPOBJ *bmp = free_gdi_handle( handle );
 501
 502     if (!bmp) return FALSE;
 503     HeapFree( GetProcessHeap(), 0, bmp->dib.dsBm.bmBits );
 504     HeapFree( GetProcessHeap(), 0, bmp );
 505     return TRUE;
 506 }
 507
 508
 509 /***********************************************************************
 510  *           BITMAP_GetObject
 511  */
 512 static INT BITMAP_GetObject( HGDIOBJ handle, INT count, LPVOID buffer )
 513 {
 514     INT ret = 0;
 515     BITMAPOBJ *bmp = GDI_GetObjPtr( handle, OBJ_BITMAP );
 516
 517     if (!bmp) return 0;
 518
 519     if (!buffer) ret = sizeof(BITMAP);
 520     else if (count >= sizeof(BITMAP))
 521     {
 522         BITMAP *bitmap = buffer;
 523         *bitmap = bmp->dib.dsBm;
 524         bitmap->bmBits = NULL;
 525         ret = sizeof(BITMAP);
 526     }
 527     GDI_ReleaseObj( handle );
 528     return ret;
 529 }
 530
 531
 532 /******************************************************************************
 533  * CreateDiscardableBitmap [GDI32.@]
 534  *
 535  * Creates a discardable bitmap.
 536  *
 537  * RETURNS
 538  *    Success: Handle to bitmap
 539  *    Failure: NULL
 540  */
 541 HBITMAP WINAPI CreateDiscardableBitmap(
 542     HDC hdc,    /* [in] Handle to device context */
 543     INT width,  /* [in] Bitmap width */
 544     INT height) /* [in] Bitmap height */
 545 {
 546     return CreateCompatibleBitmap( hdc, width, height );
 547 }
 548
 549
 550 /******************************************************************************
 551  * GetBitmapDimensionEx [GDI32.@]
 552  *
 553  * Retrieves dimensions of a bitmap.
 554  *
 555  * RETURNS
 556  *    Success: TRUE
 557  *    Failure: FALSE
 558  */
 559 BOOL WINAPI GetBitmapDimensionEx(
 560     HBITMAP hbitmap, /* [in]  Handle to bitmap */
 561     LPSIZE size)     /* [out] Address of struct receiving dimensions */
 562 {
 563     BITMAPOBJ * bmp = GDI_GetObjPtr( hbitmap, OBJ_BITMAP );
 564     if (!bmp) return FALSE;
 565     *size = bmp->size;
 566     GDI_ReleaseObj( hbitmap );
 567     return TRUE;
 568 }
 569
 570
 571 /******************************************************************************
 572  * SetBitmapDimensionEx [GDI32.@]
 573  *
 574  * Assigns dimensions to a bitmap.
 575  * MSDN says that this function will fail if hbitmap is a handle created by
 576  * CreateDIBSection, but that's not true on Windows 2000.
 577  *
 578  * RETURNS
 579  *    Success: TRUE
 580  *    Failure: FALSE
 581  */
 582 BOOL WINAPI SetBitmapDimensionEx(
 583     HBITMAP hbitmap, /* [in]  Handle to bitmap */
 584     INT x,           /* [in]  Bitmap width */
 585     INT y,           /* [in]  Bitmap height */
 586     LPSIZE prevSize) /* [out] Address of structure for orig dims */
 587 {
 588     BITMAPOBJ * bmp = GDI_GetObjPtr( hbitmap, OBJ_BITMAP );
 589     if (!bmp) return FALSE;
 590     if (prevSize) *prevSize = bmp->size;
 591     bmp->size.cx = x;
 592     bmp->size.cy = y;
 593     GDI_ReleaseObj( hbitmap );
 594     return TRUE;
 595 }