4 * Copyright 1993 Alexandre Julliard
15 #include "sysmetrics.h"
16 #include "cursoricon.h"
21 /***********************************************************************
24 * Return number of bytes to pad a scanline of 16-bit aligned Windows DDB data.
26 INT32 BITMAP_GetPadding( int bmWidth, int bpp )
33 pad = ((bmWidth-1) & 8) ? 0 : 1;
37 pad = (2 - (bmWidth & 1)) & 1;
41 pad = (bmWidth*3) & 1;
47 pad = 0; /* we have 16bit alignment already */
51 if (!(bmWidth & 3)) pad = 0;
52 else pad = ((4 - (bmWidth & 3)) + 1) / 2;
56 WARN(bitmap,"Unknown depth %d, please report.\n", bpp );
62 /***********************************************************************
63 * BITMAP_GetWidthBytes
65 * Return number of bytes taken by a scanline of 16-bit aligned Windows DDB
68 INT32 BITMAP_GetWidthBytes( INT32 bmWidth, INT32 bpp )
73 return 2 * ((bmWidth+15) >> 4);
76 bmWidth *= 3; /* fall through */
78 return bmWidth + (bmWidth & 1);
88 return 2 * ((bmWidth+3) >> 2);
91 WARN(bitmap,"Unknown depth %d, please report.\n", bpp );
96 /***********************************************************************
97 * CreateUserBitmap16 (GDI.407)
99 HBITMAP16 WINAPI CreateUserBitmap16( INT16 width, INT16 height, UINT16 planes,
100 UINT16 bpp, LPCVOID bits )
102 return CreateBitmap16( width, height, planes, bpp, bits );
105 /***********************************************************************
106 * CreateUserDiscardableBitmap16 (GDI.409)
108 HBITMAP16 WINAPI CreateUserDiscardableBitmap16( WORD dummy,
109 INT16 width, INT16 height )
111 return CreateUserBitmap16( width, height, 1, screenDepth, NULL );
115 /***********************************************************************
116 * CreateBitmap16 (GDI.48)
118 HBITMAP16 WINAPI CreateBitmap16( INT16 width, INT16 height, UINT16 planes,
119 UINT16 bpp, LPCVOID bits )
121 return CreateBitmap32( width, height, planes, bpp, bits );
125 /******************************************************************************
126 * CreateBitmap32 [GDI32.25] Creates a bitmap with the specified info
129 * width [I] bitmap width
130 * height [I] bitmap height
131 * planes [I] Number of color planes
132 * bpp [I] Number of bits to identify a color
133 * bits [I] Pointer to array containing color data
136 * Success: Handle to bitmap
139 HBITMAP32 WINAPI CreateBitmap32( INT32 width, INT32 height, UINT32 planes,
140 UINT32 bpp, LPCVOID bits )
145 planes = (BYTE)planes;
149 /* Check parameters */
150 if (!height || !width) return 0;
152 FIXME(bitmap, "planes = %d\n", planes);
155 if (height < 0) height = -height;
156 if (width < 0) width = -width;
158 /* Create the BITMAPOBJ */
159 hbitmap = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC );
160 if (!hbitmap) return 0;
162 TRACE(bitmap, "%dx%d, %d colors returning %08x\n", width, height,
163 1 << (planes*bpp), hbitmap);
165 bmp = (BITMAPOBJ *) GDI_HEAP_LOCK( hbitmap );
169 bmp->bitmap.bmType = 0;
170 bmp->bitmap.bmWidth = width;
171 bmp->bitmap.bmHeight = height;
172 bmp->bitmap.bmPlanes = planes;
173 bmp->bitmap.bmBitsPixel = bpp;
174 bmp->bitmap.bmWidthBytes = BITMAP_GetWidthBytes( width, bpp );
175 bmp->bitmap.bmBits = NULL;
177 bmp->DDBitmap = NULL;
180 if (bits) /* Set bitmap bits */
181 SetBitmapBits32( hbitmap, height * bmp->bitmap.bmWidthBytes,
183 GDI_HEAP_UNLOCK( hbitmap );
188 /***********************************************************************
189 * CreateCompatibleBitmap16 (GDI.51)
191 HBITMAP16 WINAPI CreateCompatibleBitmap16(HDC16 hdc, INT16 width, INT16 height)
193 return CreateCompatibleBitmap32( hdc, width, height );
197 /******************************************************************************
198 * CreateCompatibleBitmap32 [GDI32.30] Creates a bitmap compatible with the DC
201 * hdc [I] Handle to device context
202 * width [I] Width of bitmap
203 * height [I] Height of bitmap
206 * Success: Handle to bitmap
209 HBITMAP32 WINAPI CreateCompatibleBitmap32( HDC32 hdc, INT32 width, INT32 height)
211 HBITMAP32 hbmpRet = 0;
214 TRACE(bitmap, "(%04x,%d,%d) = \n", hdc, width, height );
215 if (!(dc = DC_GetDCPtr( hdc ))) return 0;
216 if ((width >0x1000) || (height > 0x1000)) {
217 FIXME(bitmap,"got bad width %d or height %d, please look for reason\n",
221 hbmpRet = CreateBitmap32( width, height, 1, dc->w.bitsPerPixel, NULL );
223 if(dc->funcs->pCreateBitmap)
224 dc->funcs->pCreateBitmap( hbmpRet );
226 TRACE(bitmap,"\t\t%04x\n", hbmpRet);
231 /***********************************************************************
232 * CreateBitmapIndirect16 (GDI.49)
234 HBITMAP16 WINAPI CreateBitmapIndirect16( const BITMAP16 * bmp )
236 return CreateBitmap16( bmp->bmWidth, bmp->bmHeight, bmp->bmPlanes,
237 bmp->bmBitsPixel, PTR_SEG_TO_LIN( bmp->bmBits ) );
241 /******************************************************************************
242 * CreateBitmapIndirect32 [GDI32.26] Creates a bitmap with the specifies info
245 * Success: Handle to bitmap
248 HBITMAP32 WINAPI CreateBitmapIndirect32(
249 const BITMAP32 * bmp) /* [in] Pointer to the bitmap data */
251 return CreateBitmap32( bmp->bmWidth, bmp->bmHeight, bmp->bmPlanes,
252 bmp->bmBitsPixel, bmp->bmBits );
256 /***********************************************************************
257 * GetBitmapBits16 (GDI.74)
259 LONG WINAPI GetBitmapBits16( HBITMAP16 hbitmap, LONG count, LPVOID buffer )
261 return GetBitmapBits32( hbitmap, count, buffer );
265 /***********************************************************************
266 * GetBitmapBits32 [GDI32.143] Copies bitmap bits of bitmap to buffer
269 * Success: Number of bytes copied
272 LONG WINAPI GetBitmapBits32(
273 HBITMAP32 hbitmap, /* [in] Handle to bitmap */
274 LONG count, /* [in] Number of bytes to copy */
275 LPVOID bits) /* [out] Pointer to buffer to receive bits */
277 BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
283 WARN(bitmap, "(%ld): Negative number of bytes passed???\n", count );
287 /* Only get entire lines */
288 height = count / bmp->bitmap.bmWidthBytes;
289 if (height > bmp->bitmap.bmHeight) height = bmp->bitmap.bmHeight;
290 count = height * bmp->bitmap.bmWidthBytes;
292 TRACE(bitmap, "(%08x, %ld, %p) %dx%d %d colors fetched height: %ld\n",
293 hbitmap, count, bits, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
294 1 << bmp->bitmap.bmBitsPixel, height );
298 TRACE(bitmap, "Calling device specific BitmapBits\n");
299 if(bmp->DDBitmap->funcs->pBitmapBits)
300 ret = bmp->DDBitmap->funcs->pBitmapBits(hbitmap, bits, count,
303 ERR(bitmap, "BitmapBits == NULL??\n");
309 if(!bmp->bitmap.bmBits) {
310 WARN(bitmap, "Bitmap is empty\n");
313 memcpy(bits, bmp->bitmap.bmBits, count);
319 GDI_HEAP_UNLOCK( hbitmap );
324 /***********************************************************************
325 * SetBitmapBits16 (GDI.106)
327 LONG WINAPI SetBitmapBits16( HBITMAP16 hbitmap, LONG count, LPCVOID buffer )
329 return SetBitmapBits32( hbitmap, count, buffer );
333 /******************************************************************************
334 * SetBitmapBits32 [GDI32.303] Sets bits of color data for a bitmap
337 * Success: Number of bytes used in setting the bitmap bits
340 LONG WINAPI SetBitmapBits32(
341 HBITMAP32 hbitmap, /* [in] Handle to bitmap */
342 LONG count, /* [in] Number of bytes in bitmap array */
343 LPCVOID bits) /* [in] Address of array with bitmap bits */
345 BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
351 WARN(bitmap, "(%ld): Negative number of bytes passed???\n", count );
355 /* Only get entire lines */
356 height = count / bmp->bitmap.bmWidthBytes;
357 if (height > bmp->bitmap.bmHeight) height = bmp->bitmap.bmHeight;
358 count = height * bmp->bitmap.bmWidthBytes;
360 TRACE(bitmap, "(%08x, %ld, %p) %dx%d %d colors fetched height: %ld\n",
361 hbitmap, count, bits, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
362 1 << bmp->bitmap.bmBitsPixel, height );
366 TRACE(bitmap, "Calling device specific BitmapBits\n");
367 if(bmp->DDBitmap->funcs->pBitmapBits)
368 ret = bmp->DDBitmap->funcs->pBitmapBits(hbitmap, (void *) bits,
371 ERR(bitmap, "BitmapBits == NULL??\n");
377 if(!bmp->bitmap.bmBits) /* Alloc enough for entire bitmap */
378 bmp->bitmap.bmBits = HeapAlloc( GetProcessHeap(), 0, count );
379 if(!bmp->bitmap.bmBits) {
380 WARN(bitmap, "Unable to allocate bit buffer\n");
383 memcpy(bmp->bitmap.bmBits, bits, count);
388 GDI_HEAP_UNLOCK( hbitmap );
392 /***********************************************************************
393 * LoadImage16 [USER.389]
396 HANDLE16 WINAPI LoadImage16( HINSTANCE16 hinst, LPCSTR name, UINT16 type,
397 INT16 desiredx, INT16 desiredy, UINT16 loadflags)
400 TRACE(resource,"(0x%04x,%s,%d,%d,%d,0x%08x)\n",
401 hinst,(char *)PTR_SEG_TO_LIN(name),type,desiredx,desiredy,loadflags);
403 TRACE(resource,"LoadImage16(0x%04x,%p,%d,%d,%d,0x%08x)\n",
404 hinst,name,type,desiredx,desiredy,loadflags);
408 return LoadBitmap16(hinst,(SEGPTR)name);
410 return LoadIcon16(hinst,(SEGPTR)name);
412 return LoadCursor16(hinst,(SEGPTR)name);
418 /**********************************************************************
419 * LoadImage32A (USER32.365)
421 * FIXME: implementation lacks some features, see LR_ defines in windows.h
424 HANDLE32 WINAPI LoadImage32A( HINSTANCE32 hinst, LPCSTR name, UINT32 type,
425 INT32 desiredx, INT32 desiredy, UINT32 loadflags)
430 if (HIWORD(name)) u_name = HEAP_strdupAtoW(GetProcessHeap(), 0, name);
431 else u_name=(LPWSTR)name;
432 res = LoadImage32W(hinst, u_name, type, desiredx, desiredy, loadflags);
433 if (HIWORD(name)) HeapFree(GetProcessHeap(), 0, u_name);
438 /******************************************************************************
439 * LoadImage32W [USER32.366] Loads an icon, cursor, or bitmap
442 * hinst [I] Handle of instance that contains image
443 * name [I] Name of image
444 * type [I] Type of image
445 * desiredx [I] Desired width
446 * desiredy [I] Desired height
447 * loadflags [I] Load flags
450 * Success: Handle to newly loaded image
453 * FIXME: Implementation lacks some features, see LR_ defines in windows.h
455 HANDLE32 WINAPI LoadImage32W( HINSTANCE32 hinst, LPCWSTR name, UINT32 type,
456 INT32 desiredx, INT32 desiredy, UINT32 loadflags )
459 TRACE(resource,"(0x%04x,%p,%d,%d,%d,0x%08x)\n",
460 hinst,name,type,desiredx,desiredy,loadflags
463 TRACE(resource,"(0x%04x,%p,%d,%d,%d,0x%08x)\n",
464 hinst,name,type,desiredx,desiredy,loadflags
467 if (loadflags & LR_DEFAULTSIZE)
468 if (type == IMAGE_ICON) {
469 if (!desiredx) desiredx = SYSMETRICS_CXICON;
470 if (!desiredy) desiredy = SYSMETRICS_CYICON;
471 } else if (type == IMAGE_CURSOR) {
472 if (!desiredx) desiredx = SYSMETRICS_CXCURSOR;
473 if (!desiredy) desiredy = SYSMETRICS_CYCURSOR;
475 if (loadflags & LR_LOADFROMFILE) loadflags &= ~LR_SHARED;
478 return BITMAP_LoadBitmap32W(hinst, name, loadflags);
480 return CURSORICON_Load32(hinst, name, desiredx, desiredy,
481 MIN(16, COLOR_GetSystemPaletteSize()), FALSE, loadflags);
483 return CURSORICON_Load32(hinst, name, desiredx, desiredy, 1, TRUE,
490 /**********************************************************************
494 HBITMAP32 BITMAP_CopyBitmap(HBITMAP32 hbitmap)
496 BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
504 res = CreateBitmapIndirect32(&bm);
507 char *buf = HeapAlloc( GetProcessHeap(), 0, bm.bmWidthBytes *
509 GetBitmapBits32 (hbitmap, bm.bmWidthBytes * bm.bmHeight, buf);
510 SetBitmapBits32 (res, bm.bmWidthBytes * bm.bmHeight, buf);
511 HeapFree( GetProcessHeap(), 0, buf );
514 GDI_HEAP_UNLOCK( hbitmap );
519 /******************************************************************************
520 * CopyImage32 [USER32.61] Creates new image and copies attributes to it
523 * hnd [I] Handle to image to copy
524 * type [I] Type of image to copy
525 * desiredx [I] Desired width of new image
526 * desiredy [I] Desired height of new image
527 * flags [I] Copy flags
530 * Success: Handle to newly created image
533 * FIXME: implementation still lacks nearly all features, see LR_*
534 * defines in windows.h
536 HICON32 WINAPI CopyImage32( HANDLE32 hnd, UINT32 type, INT32 desiredx,
537 INT32 desiredy, UINT32 flags )
542 return BITMAP_CopyBitmap(hnd);
544 return CopyIcon32(hnd);
546 return CopyCursor32(hnd);
551 /**********************************************************************
552 * LoadBitmap16 (USER.175)
555 * Can this call LoadBitmap32?
557 HBITMAP16 WINAPI LoadBitmap16( HINSTANCE16 instance, SEGPTR name )
559 HBITMAP32 hbitmap = 0;
567 char *str = (char *)PTR_SEG_TO_LIN( name );
568 TRACE(bitmap, "(%04x,'%s')\n", instance, str );
569 if (str[0] == '#') name = (SEGPTR)(DWORD)(WORD)atoi( str + 1 );
572 TRACE(bitmap, "(%04x,%04x)\n",
573 instance, LOWORD(name) );
575 if (!instance) /* OEM bitmap */
577 if (HIWORD((int)name)) return 0;
578 return OBM_LoadBitmap( LOWORD((int)name) );
581 if (!(hRsrc = FindResource16( instance, name, RT_BITMAP16 ))) return 0;
582 if (!(handle = LoadResource16( instance, hRsrc ))) return 0;
584 info = (BITMAPINFO *)LockResource16( handle );
585 if ((hdc = GetDC32(0)) != 0)
587 char *bits = (char *)info + DIB_BitmapInfoSize( info, DIB_RGB_COLORS );
588 hbitmap = CreateDIBitmap32( hdc, &info->bmiHeader, CBM_INIT,
589 bits, info, DIB_RGB_COLORS );
590 ReleaseDC32( 0, hdc );
592 FreeResource16( handle );
597 /**********************************************************************
598 * BITMAP_LoadBitmap32W
600 HBITMAP32 BITMAP_LoadBitmap32W(HINSTANCE32 instance,LPCWSTR name,
603 HBITMAP32 hbitmap = 0;
608 BITMAPINFO *info, *fix_info=NULL;
612 if (!(loadflags & LR_LOADFROMFILE)) {
613 if (!instance) /* OEM bitmap */
615 if (HIWORD((int)name)) return 0;
616 return OBM_LoadBitmap( LOWORD((int)name) );
619 if (!(hRsrc = FindResource32W( instance, name, RT_BITMAP32W ))) return 0;
620 if (!(handle = LoadResource32( instance, hRsrc ))) return 0;
622 if ((info = (BITMAPINFO *)LockResource32( handle )) == NULL) return 0;
626 if (!(ptr = (char *)VIRTUAL_MapFileW( name ))) return 0;
627 info = (BITMAPINFO *)(ptr + sizeof(BITMAPFILEHEADER));
629 size = DIB_BitmapInfoSize(info, DIB_RGB_COLORS);
630 if ((hFix = GlobalAlloc32(0, size))) fix_info=GlobalLock32(hFix);
634 memcpy(fix_info, info, size);
635 pix = *((LPBYTE)info+DIB_BitmapInfoSize(info, DIB_RGB_COLORS));
636 DIB_FixColorsToLoadflags(fix_info, loadflags, pix);
637 if ((hdc = GetDC32(0)) != 0) {
638 if (loadflags & LR_CREATEDIBSECTION)
639 hbitmap = CreateDIBSection32(hdc, fix_info, DIB_RGB_COLORS, NULL, 0, 0);
641 char *bits = (char *)info + size;;
642 hbitmap = CreateDIBitmap32( hdc, &fix_info->bmiHeader, CBM_INIT,
643 bits, fix_info, DIB_RGB_COLORS );
645 ReleaseDC32( 0, hdc );
647 GlobalUnlock32(hFix);
650 if (loadflags & LR_LOADFROMFILE) UnmapViewOfFile( ptr );
655 /******************************************************************************
656 * LoadBitmap32W [USER32.358] Loads bitmap from the executable file
659 * Success: Handle to specified bitmap
662 HBITMAP32 WINAPI LoadBitmap32W(
663 HINSTANCE32 instance, /* [in] Handle to application instance */
664 LPCWSTR name) /* [in] Address of bitmap resource name */
666 return BITMAP_LoadBitmap32W(instance, name, 0);
670 /**********************************************************************
671 * LoadBitmap32A (USER32.357)
673 HBITMAP32 WINAPI LoadBitmap32A( HINSTANCE32 instance, LPCSTR name )
676 if (!HIWORD(name)) res = LoadBitmap32W( instance, (LPWSTR)name );
679 LPWSTR uni = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
680 res = LoadBitmap32W( instance, uni );
681 HeapFree( GetProcessHeap(), 0, uni );
687 /***********************************************************************
688 * BITMAP_DeleteObject
690 BOOL32 BITMAP_DeleteObject( HBITMAP16 hbitmap, BITMAPOBJ * bmp )
692 if( bmp->DDBitmap ) {
693 if( bmp->DDBitmap->funcs->pDeleteObject )
694 bmp->DDBitmap->funcs->pDeleteObject( hbitmap );
697 if( bmp->bitmap.bmBits )
698 HeapFree( GetProcessHeap(), 0, bmp->bitmap.bmBits );
700 DIB_DeleteDIBSection( bmp );
702 return GDI_FreeObject( hbitmap );
706 /***********************************************************************
709 INT16 BITMAP_GetObject16( BITMAPOBJ * bmp, INT16 count, LPVOID buffer )
713 if ( count <= sizeof(BITMAP16) )
715 BITMAP32 *bmp32 = &bmp->dib->dibSection.dsBm;
717 bmp16.bmType = bmp32->bmType;
718 bmp16.bmWidth = bmp32->bmWidth;
719 bmp16.bmHeight = bmp32->bmHeight;
720 bmp16.bmWidthBytes = bmp32->bmWidthBytes;
721 bmp16.bmPlanes = bmp32->bmPlanes;
722 bmp16.bmBitsPixel = bmp32->bmBitsPixel;
723 bmp16.bmBits = (SEGPTR)0;
724 memcpy( buffer, &bmp16, count );
729 FIXME(bitmap, "not implemented for DIBs: count %d\n", count);
736 bmp16.bmType = bmp->bitmap.bmType;
737 bmp16.bmWidth = bmp->bitmap.bmWidth;
738 bmp16.bmHeight = bmp->bitmap.bmHeight;
739 bmp16.bmWidthBytes = bmp->bitmap.bmWidthBytes;
740 bmp16.bmPlanes = bmp->bitmap.bmPlanes;
741 bmp16.bmBitsPixel = bmp->bitmap.bmBitsPixel;
742 bmp16.bmBits = (SEGPTR)0;
743 if (count > sizeof(bmp16)) count = sizeof(bmp16);
744 memcpy( buffer, &bmp16, count );
750 /***********************************************************************
753 INT32 BITMAP_GetObject32( BITMAPOBJ * bmp, INT32 count, LPVOID buffer )
757 if (count < sizeof(DIBSECTION))
759 if (count > sizeof(BITMAP32)) count = sizeof(BITMAP32);
763 if (count > sizeof(DIBSECTION)) count = sizeof(DIBSECTION);
766 memcpy( buffer, &bmp->dib->dibSection, count );
771 if (count > sizeof(BITMAP32)) count = sizeof(BITMAP32);
772 memcpy( buffer, &bmp->bitmap, count );
778 /***********************************************************************
779 * CreateDiscardableBitmap16 (GDI.156)
781 HBITMAP16 WINAPI CreateDiscardableBitmap16( HDC16 hdc, INT16 width,
784 return CreateCompatibleBitmap16( hdc, width, height );
788 /******************************************************************************
789 * CreateDiscardableBitmap32 [GDI32.38] Creates a discardable bitmap
792 * Success: Handle to bitmap
795 HBITMAP32 WINAPI CreateDiscardableBitmap32(
796 HDC32 hdc, /* [in] Handle to device context */
797 INT32 width, /* [in] Bitmap width */
798 INT32 height) /* [in] Bitmap height */
800 return CreateCompatibleBitmap32( hdc, width, height );
804 /***********************************************************************
805 * GetBitmapDimensionEx16 (GDI.468)
808 * Can this call GetBitmapDimensionEx32?
810 BOOL16 WINAPI GetBitmapDimensionEx16( HBITMAP16 hbitmap, LPSIZE16 size )
812 BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
813 if (!bmp) return FALSE;
814 CONV_SIZE32TO16( &bmp->size, size );
815 GDI_HEAP_UNLOCK( hbitmap );
820 /******************************************************************************
821 * GetBitmapDimensionEx32 [GDI32.144] Retrieves dimensions of a bitmap
827 BOOL32 WINAPI GetBitmapDimensionEx32(
828 HBITMAP32 hbitmap, /* [in] Handle to bitmap */
829 LPSIZE32 size) /* [out] Address of struct receiving dimensions */
831 BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
832 if (!bmp) return FALSE;
834 GDI_HEAP_UNLOCK( hbitmap );
839 /***********************************************************************
840 * GetBitmapDimension (GDI.162)
842 DWORD WINAPI GetBitmapDimension( HBITMAP16 hbitmap )
845 if (!GetBitmapDimensionEx16( hbitmap, &size )) return 0;
846 return MAKELONG( size.cx, size.cy );
850 /***********************************************************************
851 * SetBitmapDimensionEx16 (GDI.478)
853 BOOL16 WINAPI SetBitmapDimensionEx16( HBITMAP16 hbitmap, INT16 x, INT16 y,
856 BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
857 if (!bmp) return FALSE;
858 if (prevSize) CONV_SIZE32TO16( &bmp->size, prevSize );
861 GDI_HEAP_UNLOCK( hbitmap );
866 /******************************************************************************
867 * SetBitmapDimensionEx32 [GDI32.304] Assignes dimensions to a bitmap
873 BOOL32 WINAPI SetBitmapDimensionEx32(
874 HBITMAP32 hbitmap, /* [in] Handle to bitmap */
875 INT32 x, /* [in] Bitmap width */
876 INT32 y, /* [in] Bitmap height */
877 LPSIZE32 prevSize) /* [out] Address of structure for orig dims */
879 BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
880 if (!bmp) return FALSE;
881 if (prevSize) *prevSize = bmp->size;
884 GDI_HEAP_UNLOCK( hbitmap );
889 /***********************************************************************
890 * SetBitmapDimension (GDI.163)
892 DWORD WINAPI SetBitmapDimension( HBITMAP16 hbitmap, INT16 x, INT16 y )
895 if (!SetBitmapDimensionEx16( hbitmap, x, y, &size )) return 0;
896 return MAKELONG( size.cx, size.cy );