4 * Copyright 1993 Alexandre Julliard
15 #include "sysmetrics.h"
16 #include "cursoricon.h"
21 /***********************************************************************
22 * BITMAP_GetBitsPadding
24 * Return number of bytes to pad a scanline of 16-bit aligned Windows DDB data.
26 INT32
BITMAP_GetBitsPadding( int bmWidth
, int bpp
)
33 if (!(bmWidth
& 15)) pad
= 0;
34 else pad
= ((16 - (bmWidth
& 15)) + 7) / 8;
38 pad
= (2 - (bmWidth
& 1)) & 1;
42 pad
= (bmWidth
*3) & 1;
48 pad
= 0; /* we have 16bit alignment already */
52 if (!(bmWidth
& 3)) pad
= 0;
53 else pad
= ((4 - (bmWidth
& 3)) + 1) / 2;
57 WARN(bitmap
,"Unknown depth %d, please report.\n", bpp
);
63 /***********************************************************************
66 * Return number of bytes taken by a scanline of 16-bit aligned Windows DDB data.
68 INT32
BITMAP_GetBitsWidth( int bmWidth
, int 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
= (INT16
)width
;
171 bmp
->bitmap
.bmHeight
= (INT16
)height
;
172 bmp
->bitmap
.bmPlanes
= (BYTE
)planes
;
173 bmp
->bitmap
.bmBitsPixel
= (BYTE
)bpp
;
174 bmp
->bitmap
.bmWidthBytes
= (INT16
)BITMAP_WIDTH_BYTES( 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 HBITMAP32
BITMAP_LoadBitmap32W(HINSTANCE32 instance
,LPCWSTR name
,
600 HBITMAP32 hbitmap
= 0;
605 BITMAPINFO
*info
, *fix_info
=NULL
;
609 if (!(loadflags
& LR_LOADFROMFILE
)) {
610 if (!instance
) /* OEM bitmap */
612 if (HIWORD((int)name
)) return 0;
613 return OBM_LoadBitmap( LOWORD((int)name
) );
616 if (!(hRsrc
= FindResource32W( instance
, name
, RT_BITMAP32W
))) return 0;
617 if (!(handle
= LoadResource32( instance
, hRsrc
))) return 0;
619 if ((info
= (BITMAPINFO
*)LockResource32( handle
)) == NULL
) return 0;
623 if (!(ptr
= (char *)VIRTUAL_MapFileW( name
))) return 0;
624 info
= (BITMAPINFO
*)(ptr
+ sizeof(BITMAPFILEHEADER
));
626 size
= DIB_BitmapInfoSize(info
, DIB_RGB_COLORS
);
627 if ((hFix
= GlobalAlloc32(0, size
))) fix_info
=GlobalLock32(hFix
);
631 memcpy(fix_info
, info
, size
);
632 pix
= *((LPBYTE
)info
+DIB_BitmapInfoSize(info
, DIB_RGB_COLORS
));
633 DIB_FixColorsToLoadflags(fix_info
, loadflags
, pix
);
634 if ((hdc
= GetDC32(0)) != 0) {
635 if (loadflags
& LR_CREATEDIBSECTION
)
636 hbitmap
= CreateDIBSection32(hdc
, fix_info
, DIB_RGB_COLORS
, NULL
, 0, 0);
638 char *bits
= (char *)info
+ size
;;
639 hbitmap
= CreateDIBitmap32( hdc
, &fix_info
->bmiHeader
, CBM_INIT
,
640 bits
, fix_info
, DIB_RGB_COLORS
);
642 ReleaseDC32( 0, hdc
);
644 GlobalUnlock32(hFix
);
647 if (loadflags
& LR_LOADFROMFILE
) UnmapViewOfFile( ptr
);
650 /******************************************************************************
651 * LoadBitmap32W [USER32.358] Loads bitmap from the executable file
654 * Success: Handle to specified bitmap
657 HBITMAP32 WINAPI
LoadBitmap32W(
658 HINSTANCE32 instance
, /* [in] Handle to application instance */
659 LPCWSTR name
) /* [in] Address of bitmap resource name */
661 return BITMAP_LoadBitmap32W(instance
, name
, 0);
665 /**********************************************************************
666 * LoadBitmap32A (USER32.357)
668 HBITMAP32 WINAPI
LoadBitmap32A( HINSTANCE32 instance
, LPCSTR name
)
671 if (!HIWORD(name
)) res
= LoadBitmap32W( instance
, (LPWSTR
)name
);
674 LPWSTR uni
= HEAP_strdupAtoW( GetProcessHeap(), 0, name
);
675 res
= LoadBitmap32W( instance
, uni
);
676 HeapFree( GetProcessHeap(), 0, uni
);
682 /***********************************************************************
683 * BITMAP_DeleteObject
685 BOOL32
BITMAP_DeleteObject( HBITMAP16 hbitmap
, BITMAPOBJ
* bmp
)
687 if( bmp
->DDBitmap
) {
688 if( bmp
->DDBitmap
->funcs
->pDeleteObject
)
689 bmp
->DDBitmap
->funcs
->pDeleteObject( hbitmap
);
692 if( bmp
->bitmap
.bmBits
)
693 HeapFree( GetProcessHeap(), 0, bmp
->bitmap
.bmBits
);
695 DIB_DeleteDIBSection( bmp
);
697 return GDI_FreeObject( hbitmap
);
701 /***********************************************************************
704 INT16
BITMAP_GetObject16( BITMAPOBJ
* bmp
, INT16 count
, LPVOID buffer
)
708 if ( count
<= sizeof(BITMAP16
) )
710 BITMAP32
*bmp32
= &bmp
->dib
->dibSection
.dsBm
;
712 bmp16
.bmType
= bmp32
->bmType
;
713 bmp16
.bmWidth
= bmp32
->bmWidth
;
714 bmp16
.bmHeight
= bmp32
->bmHeight
;
715 bmp16
.bmWidthBytes
= bmp32
->bmWidthBytes
;
716 bmp16
.bmPlanes
= bmp32
->bmPlanes
;
717 bmp16
.bmBitsPixel
= bmp32
->bmBitsPixel
;
718 bmp16
.bmBits
= (SEGPTR
)0;
719 memcpy( buffer
, &bmp16
, count
);
724 FIXME(bitmap
, "not implemented for DIBs: count %d\n", count
);
731 bmp16
.bmType
= bmp
->bitmap
.bmType
;
732 bmp16
.bmWidth
= bmp
->bitmap
.bmWidth
;
733 bmp16
.bmHeight
= bmp
->bitmap
.bmHeight
;
734 bmp16
.bmWidthBytes
= bmp
->bitmap
.bmWidthBytes
;
735 bmp16
.bmPlanes
= bmp
->bitmap
.bmPlanes
;
736 bmp16
.bmBitsPixel
= bmp
->bitmap
.bmBitsPixel
;
737 bmp16
.bmBits
= (SEGPTR
)0;
738 if (count
> sizeof(bmp16
)) count
= sizeof(bmp16
);
739 memcpy( buffer
, &bmp16
, count
);
745 /***********************************************************************
748 INT32
BITMAP_GetObject32( BITMAPOBJ
* bmp
, INT32 count
, LPVOID buffer
)
752 if (count
< sizeof(DIBSECTION
))
754 if (count
> sizeof(BITMAP32
)) count
= sizeof(BITMAP32
);
758 if (count
> sizeof(DIBSECTION
)) count
= sizeof(DIBSECTION
);
761 memcpy( buffer
, &bmp
->dib
->dibSection
, count
);
766 if (count
> sizeof(BITMAP32
)) count
= sizeof(BITMAP32
);
767 memcpy( buffer
, &bmp
->bitmap
, count
);
773 /***********************************************************************
774 * CreateDiscardableBitmap16 (GDI.156)
776 HBITMAP16 WINAPI
CreateDiscardableBitmap16( HDC16 hdc
, INT16 width
,
779 return CreateCompatibleBitmap16( hdc
, width
, height
);
783 /******************************************************************************
784 * CreateDiscardableBitmap32 [GDI32.38] Creates a discardable bitmap
787 * Success: Handle to bitmap
790 HBITMAP32 WINAPI
CreateDiscardableBitmap32(
791 HDC32 hdc
, /* [in] Handle to device context */
792 INT32 width
, /* [in] Bitmap width */
793 INT32 height
) /* [in] Bitmap height */
795 return CreateCompatibleBitmap32( hdc
, width
, height
);
799 /***********************************************************************
800 * GetBitmapDimensionEx16 (GDI.468)
803 * Can this call GetBitmapDimensionEx32?
805 BOOL16 WINAPI
GetBitmapDimensionEx16( HBITMAP16 hbitmap
, LPSIZE16 size
)
807 BITMAPOBJ
* bmp
= (BITMAPOBJ
*) GDI_GetObjPtr( hbitmap
, BITMAP_MAGIC
);
808 if (!bmp
) return FALSE
;
809 CONV_SIZE32TO16( &bmp
->size
, size
);
810 GDI_HEAP_UNLOCK( hbitmap
);
815 /******************************************************************************
816 * GetBitmapDimensionEx32 [GDI32.144] Retrieves dimensions of a bitmap
822 BOOL32 WINAPI
GetBitmapDimensionEx32(
823 HBITMAP32 hbitmap
, /* [in] Handle to bitmap */
824 LPSIZE32 size
) /* [out] Address of struct receiving dimensions */
826 BITMAPOBJ
* bmp
= (BITMAPOBJ
*) GDI_GetObjPtr( hbitmap
, BITMAP_MAGIC
);
827 if (!bmp
) return FALSE
;
829 GDI_HEAP_UNLOCK( hbitmap
);
834 /***********************************************************************
835 * GetBitmapDimension (GDI.162)
837 DWORD WINAPI
GetBitmapDimension( HBITMAP16 hbitmap
)
840 if (!GetBitmapDimensionEx16( hbitmap
, &size
)) return 0;
841 return MAKELONG( size
.cx
, size
.cy
);
845 /***********************************************************************
846 * SetBitmapDimensionEx16 (GDI.478)
848 BOOL16 WINAPI
SetBitmapDimensionEx16( HBITMAP16 hbitmap
, INT16 x
, INT16 y
,
851 BITMAPOBJ
* bmp
= (BITMAPOBJ
*) GDI_GetObjPtr( hbitmap
, BITMAP_MAGIC
);
852 if (!bmp
) return FALSE
;
853 if (prevSize
) CONV_SIZE32TO16( &bmp
->size
, prevSize
);
856 GDI_HEAP_UNLOCK( hbitmap
);
861 /******************************************************************************
862 * SetBitmapDimensionEx32 [GDI32.304] Assignes dimensions to a bitmap
868 BOOL32 WINAPI
SetBitmapDimensionEx32(
869 HBITMAP32 hbitmap
, /* [in] Handle to bitmap */
870 INT32 x
, /* [in] Bitmap width */
871 INT32 y
, /* [in] Bitmap height */
872 LPSIZE32 prevSize
) /* [out] Address of structure for orig dims */
874 BITMAPOBJ
* bmp
= (BITMAPOBJ
*) GDI_GetObjPtr( hbitmap
, BITMAP_MAGIC
);
875 if (!bmp
) return FALSE
;
876 if (prevSize
) *prevSize
= bmp
->size
;
879 GDI_HEAP_UNLOCK( hbitmap
);
884 /***********************************************************************
885 * SetBitmapDimension (GDI.163)
887 DWORD WINAPI
SetBitmapDimension( HBITMAP16 hbitmap
, INT16 x
, INT16 y
)
890 if (!SetBitmapDimensionEx16( hbitmap
, x
, y
, &size
)) return 0;
891 return MAKELONG( size
.cx
, size
.cy
);