4 * Copyright 1993 Alexandre Julliard
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.
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.
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
25 #include "wine/winbase16.h"
26 #include "wine/wingdi16.h"
28 #include "gdi_private.h"
29 #include "wine/debug.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(bitmap
);
34 static HGDIOBJ
BITMAP_SelectObject( HGDIOBJ handle
, void *obj
, HDC hdc
);
35 static INT
BITMAP_GetObject16( HGDIOBJ handle
, void *obj
, INT count
, LPVOID buffer
);
36 static INT
BITMAP_GetObject( HGDIOBJ handle
, void *obj
, INT count
, LPVOID buffer
);
37 static BOOL
BITMAP_DeleteObject( HGDIOBJ handle
, void *obj
);
39 static const struct gdi_obj_funcs bitmap_funcs
=
41 BITMAP_SelectObject
, /* pSelectObject */
42 BITMAP_GetObject16
, /* pGetObject16 */
43 BITMAP_GetObject
, /* pGetObjectA */
44 BITMAP_GetObject
, /* pGetObjectW */
45 NULL
, /* pUnrealizeObject */
46 BITMAP_DeleteObject
/* pDeleteObject */
49 /***********************************************************************
50 * BITMAP_GetWidthBytes
52 * Return number of bytes taken by a scanline of 16-bit aligned Windows DDB
55 INT
BITMAP_GetWidthBytes( INT bmWidth
, INT bpp
)
60 return 2 * ((bmWidth
+15) >> 4);
63 bmWidth
*= 3; /* fall through */
65 return bmWidth
+ (bmWidth
& 1);
75 return 2 * ((bmWidth
+3) >> 2);
78 WARN("Unknown depth %d, please report.\n", bpp
);
84 /******************************************************************************
85 * CreateBitmap [GDI32.@]
87 * Creates a bitmap with the specified info.
90 * width [I] bitmap width
91 * height [I] bitmap height
92 * planes [I] Number of color planes
93 * bpp [I] Number of bits to identify a color
94 * bits [I] Pointer to array containing color data
97 * Success: Handle to bitmap
100 HBITMAP WINAPI
CreateBitmap( INT width
, INT height
, UINT planes
,
101 UINT bpp
, LPCVOID bits
)
107 bm
.bmHeight
= height
;
108 bm
.bmWidthBytes
= BITMAP_GetWidthBytes( width
, bpp
);
109 bm
.bmPlanes
= planes
;
110 bm
.bmBitsPixel
= bpp
;
111 bm
.bmBits
= (LPVOID
)bits
;
113 return CreateBitmapIndirect( &bm
);
116 /******************************************************************************
117 * CreateCompatibleBitmap [GDI32.@]
119 * Creates a bitmap compatible with the DC.
122 * hdc [I] Handle to device context
123 * width [I] Width of bitmap
124 * height [I] Height of bitmap
127 * Success: Handle to bitmap
130 HBITMAP WINAPI
CreateCompatibleBitmap( HDC hdc
, INT width
, INT height
)
135 TRACE("(%p,%d,%d) =\n", hdc
, width
, height
);
137 if ((width
>= 0x10000) || (height
>= 0x10000))
139 FIXME("got bad width %d or height %d, please look for reason\n",
144 if (!(dc
= DC_GetDCPtr(hdc
))) return 0;
146 if (GDIMAGIC( dc
->header
.wMagic
) != MEMORY_DC_MAGIC
)
148 hbmpRet
= CreateBitmap(width
, height
,
149 GetDeviceCaps(hdc
, PLANES
),
150 GetDeviceCaps(hdc
, BITSPIXEL
),
155 BITMAPOBJ
*bmp
= GDI_GetObjPtr( dc
->hBitmap
, BITMAP_MAGIC
);
159 /* A device-dependent bitmap is selected in the DC */
160 hbmpRet
= CreateBitmap(width
, height
,
161 bmp
->bitmap
.bmPlanes
,
162 bmp
->bitmap
.bmBitsPixel
,
167 /* A DIB section is selected in the DC */
171 /* Allocate memory for a BITMAPINFOHEADER structure and a
172 color table. The maximum number of colors in a color table
173 is 256 which corresponds to a bitmap with depth 8.
174 Bitmaps with higher depths don't have color tables. */
175 bi
= HeapAlloc(GetProcessHeap(), 0, sizeof(BITMAPINFOHEADER
) + 256 * sizeof(RGBQUAD
));
179 bi
->bmiHeader
.biSize
= sizeof(bi
->bmiHeader
);
180 bi
->bmiHeader
.biWidth
= width
;
181 bi
->bmiHeader
.biHeight
= height
;
182 bi
->bmiHeader
.biPlanes
= bmp
->dib
->dsBmih
.biPlanes
;
183 bi
->bmiHeader
.biBitCount
= bmp
->dib
->dsBmih
.biBitCount
;
184 bi
->bmiHeader
.biCompression
= bmp
->dib
->dsBmih
.biCompression
;
185 bi
->bmiHeader
.biSizeImage
= 0;
186 bi
->bmiHeader
.biXPelsPerMeter
= bmp
->dib
->dsBmih
.biXPelsPerMeter
;
187 bi
->bmiHeader
.biYPelsPerMeter
= bmp
->dib
->dsBmih
.biYPelsPerMeter
;
188 bi
->bmiHeader
.biClrUsed
= bmp
->dib
->dsBmih
.biClrUsed
;
189 bi
->bmiHeader
.biClrImportant
= bmp
->dib
->dsBmih
.biClrImportant
;
191 if (bi
->bmiHeader
.biCompression
== BI_BITFIELDS
)
193 /* Copy the color masks */
194 CopyMemory(bi
->bmiColors
, bmp
->dib
->dsBitfields
, 3 * sizeof(DWORD
));
196 else if (bi
->bmiHeader
.biBitCount
<= 8)
198 /* Copy the color table */
199 GetDIBColorTable(hdc
, 0, 256, bi
->bmiColors
);
202 hbmpRet
= CreateDIBSection(hdc
, bi
, DIB_RGB_COLORS
, &bits
, NULL
, 0);
203 HeapFree(GetProcessHeap(), 0, bi
);
206 GDI_ReleaseObj(dc
->hBitmap
);
211 TRACE("\t\t%p\n", hbmpRet
);
216 /******************************************************************************
217 * CreateBitmapIndirect [GDI32.@]
219 * Creates a bitmap with the specified info.
222 * bmp [I] Pointer to the bitmap info describing the bitmap
225 * Success: Handle to bitmap
226 * Failure: NULL. Use GetLastError() to determine the cause.
229 * If a width or height of 0 are given, a 1x1 monochrome bitmap is returned.
231 HBITMAP WINAPI
CreateBitmapIndirect( const BITMAP
*bmp
)
237 if (!bmp
|| bmp
->bmType
|| bmp
->bmPlanes
!= 1)
239 if (bmp
&& bmp
->bmPlanes
!= 1)
240 FIXME("planes = %d\n", bmp
->bmPlanes
);
241 SetLastError( ERROR_INVALID_PARAMETER
);
247 if (!bm
.bmWidth
|| !bm
.bmHeight
)
249 bm
.bmWidth
= bm
.bmHeight
= 1;
250 bm
.bmPlanes
= bm
.bmBitsPixel
= 1;
257 bm
.bmHeight
= -bm
.bmHeight
;
259 bm
.bmWidth
= -bm
.bmWidth
;
262 /* Create the BITMAPOBJ */
263 bmpobj
= GDI_AllocObject( sizeof(BITMAPOBJ
), BITMAP_MAGIC
,
264 (HGDIOBJ
*)&hbitmap
, &bitmap_funcs
);
268 SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
272 TRACE("%dx%d, %d colors returning %p\n", bm
.bmWidth
, bm
.bmHeight
,
273 1 << (bm
.bmPlanes
* bm
.bmBitsPixel
), hbitmap
);
278 bmpobj
->bitmap
.bmBits
= NULL
;
279 bmpobj
->funcs
= NULL
;
281 bmpobj
->segptr_bits
= 0;
282 bmpobj
->color_table
= NULL
;
283 bmpobj
->nb_colors
= 0;
286 SetBitmapBits( hbitmap
, bm
.bmHeight
* bm
.bmWidthBytes
, bm
.bmBits
);
288 GDI_ReleaseObj( hbitmap
);
293 /***********************************************************************
294 * GetBitmapBits [GDI32.@]
296 * Copies bitmap bits of bitmap to buffer.
299 * Success: Number of bytes copied
302 LONG WINAPI
GetBitmapBits(
303 HBITMAP hbitmap
, /* [in] Handle to bitmap */
304 LONG count
, /* [in] Number of bytes to copy */
305 LPVOID bits
) /* [out] Pointer to buffer to receive bits */
307 BITMAPOBJ
*bmp
= (BITMAPOBJ
*) GDI_GetObjPtr( hbitmap
, BITMAP_MAGIC
);
312 if (bmp
->dib
) /* simply copy the bits from the DIB */
314 DIBSECTION
*dib
= bmp
->dib
;
315 const char *src
= dib
->dsBm
.bmBits
;
316 INT width_bytes
= BITMAP_GetWidthBytes(dib
->dsBm
.bmWidth
, dib
->dsBm
.bmBitsPixel
);
317 DWORD max
= width_bytes
* bmp
->bitmap
.bmHeight
;
325 if (count
> max
) count
= max
;
328 /* GetBitmapBits returns not 32-bit aligned data */
330 if (bmp
->dib
->dsBmih
.biHeight
>= 0) /* not top-down, need to flip contents vertically */
332 src
+= dib
->dsBm
.bmWidthBytes
* dib
->dsBm
.bmHeight
;
335 src
-= dib
->dsBm
.bmWidthBytes
;
336 memcpy( bits
, src
, min( count
, width_bytes
) );
337 bits
= (char *)bits
+ width_bytes
;
338 count
-= width_bytes
;
345 memcpy( bits
, src
, min( count
, width_bytes
) );
346 src
+= dib
->dsBm
.bmWidthBytes
;
347 bits
= (char *)bits
+ width_bytes
;
348 count
-= width_bytes
;
354 /* If the bits vector is null, the function should return the read size */
357 ret
= bmp
->bitmap
.bmWidthBytes
* bmp
->bitmap
.bmHeight
;
362 WARN("(%d): Negative number of bytes passed???\n", count
);
366 /* Only get entire lines */
367 height
= count
/ bmp
->bitmap
.bmWidthBytes
;
368 if (height
> bmp
->bitmap
.bmHeight
) height
= bmp
->bitmap
.bmHeight
;
369 count
= height
* bmp
->bitmap
.bmWidthBytes
;
372 WARN("Less than one entire line requested\n");
378 TRACE("(%p, %d, %p) %dx%d %d colors fetched height: %d\n",
379 hbitmap
, count
, bits
, bmp
->bitmap
.bmWidth
, bmp
->bitmap
.bmHeight
,
380 1 << bmp
->bitmap
.bmBitsPixel
, height
);
382 if(bmp
->funcs
&& bmp
->funcs
->pGetBitmapBits
)
384 TRACE("Calling device specific BitmapBits\n");
385 ret
= bmp
->funcs
->pGetBitmapBits(hbitmap
, bits
, count
);
388 if(!bmp
->bitmap
.bmBits
) {
389 TRACE("Bitmap is empty\n");
390 memset(bits
, 0, count
);
393 memcpy(bits
, bmp
->bitmap
.bmBits
, count
);
399 GDI_ReleaseObj( hbitmap
);
404 /******************************************************************************
405 * SetBitmapBits [GDI32.@]
407 * Sets bits of color data for a bitmap.
410 * Success: Number of bytes used in setting the bitmap bits
413 LONG WINAPI
SetBitmapBits(
414 HBITMAP hbitmap
, /* [in] Handle to bitmap */
415 LONG count
, /* [in] Number of bytes in bitmap array */
416 LPCVOID bits
) /* [in] Address of array with bitmap bits */
418 BITMAPOBJ
*bmp
= (BITMAPOBJ
*) GDI_GetObjPtr( hbitmap
, BITMAP_MAGIC
);
421 if ((!bmp
) || (!bits
))
425 WARN("(%d): Negative number of bytes passed???\n", count
);
429 if (bmp
->dib
) /* simply copy the bits into the DIB */
431 DIBSECTION
*dib
= bmp
->dib
;
432 char *dest
= dib
->dsBm
.bmBits
;
433 DWORD max
= dib
->dsBm
.bmWidthBytes
* dib
->dsBm
.bmHeight
;
434 if (count
> max
) count
= max
;
437 if (bmp
->dib
->dsBmih
.biHeight
>= 0) /* not top-down, need to flip contents vertically */
439 dest
+= dib
->dsBm
.bmWidthBytes
* dib
->dsBm
.bmHeight
;
442 dest
-= dib
->dsBm
.bmWidthBytes
;
443 memcpy( dest
, bits
, min( count
, dib
->dsBm
.bmWidthBytes
) );
444 bits
= (const char *)bits
+ dib
->dsBm
.bmWidthBytes
;
445 count
-= dib
->dsBm
.bmWidthBytes
;
448 else memcpy( dest
, bits
, count
);
450 GDI_ReleaseObj( hbitmap
);
454 /* Only get entire lines */
455 height
= count
/ bmp
->bitmap
.bmWidthBytes
;
456 if (height
> bmp
->bitmap
.bmHeight
) height
= bmp
->bitmap
.bmHeight
;
457 count
= height
* bmp
->bitmap
.bmWidthBytes
;
459 TRACE("(%p, %d, %p) %dx%d %d colors fetched height: %d\n",
460 hbitmap
, count
, bits
, bmp
->bitmap
.bmWidth
, bmp
->bitmap
.bmHeight
,
461 1 << bmp
->bitmap
.bmBitsPixel
, height
);
463 if(bmp
->funcs
&& bmp
->funcs
->pSetBitmapBits
) {
465 TRACE("Calling device specific BitmapBits\n");
466 ret
= bmp
->funcs
->pSetBitmapBits(hbitmap
, bits
, count
);
469 if(!bmp
->bitmap
.bmBits
) /* Alloc enough for entire bitmap */
470 bmp
->bitmap
.bmBits
= HeapAlloc( GetProcessHeap(), 0, count
);
471 if(!bmp
->bitmap
.bmBits
) {
472 WARN("Unable to allocate bit buffer\n");
475 memcpy(bmp
->bitmap
.bmBits
, bits
, count
);
480 GDI_ReleaseObj( hbitmap
);
484 /**********************************************************************
488 HBITMAP
BITMAP_CopyBitmap(HBITMAP hbitmap
)
490 BITMAPOBJ
*bmp
= (BITMAPOBJ
*) GDI_GetObjPtr( hbitmap
, BITMAP_MAGIC
);
498 res
= CreateBitmapIndirect(&bm
);
501 char *buf
= HeapAlloc( GetProcessHeap(), 0, bm
.bmWidthBytes
*
503 GetBitmapBits (hbitmap
, bm
.bmWidthBytes
* bm
.bmHeight
, buf
);
504 SetBitmapBits (res
, bm
.bmWidthBytes
* bm
.bmHeight
, buf
);
505 HeapFree( GetProcessHeap(), 0, buf
);
508 GDI_ReleaseObj( hbitmap
);
513 /***********************************************************************
516 * Set the type of DC that owns the bitmap. This is used when the
517 * bitmap is selected into a device to initialize the bitmap function
520 BOOL
BITMAP_SetOwnerDC( HBITMAP hbitmap
, DC
*dc
)
525 /* never set the owner of the stock bitmap since it can be selected in multiple DCs */
526 if (hbitmap
== GetStockObject(DEFAULT_BITMAP
)) return TRUE
;
528 if (!(bitmap
= GDI_GetObjPtr( hbitmap
, BITMAP_MAGIC
))) return FALSE
;
531 if (!bitmap
->funcs
) /* not owned by a DC yet */
533 if (dc
->funcs
->pCreateBitmap
) ret
= dc
->funcs
->pCreateBitmap( dc
->physDev
, hbitmap
,
534 bitmap
->bitmap
.bmBits
);
535 if (ret
) bitmap
->funcs
= dc
->funcs
;
537 else if (bitmap
->funcs
!= dc
->funcs
)
539 FIXME( "Trying to select bitmap %p in different DC type\n", hbitmap
);
542 GDI_ReleaseObj( hbitmap
);
547 /***********************************************************************
548 * BITMAP_SelectObject
550 static HGDIOBJ
BITMAP_SelectObject( HGDIOBJ handle
, void *obj
, HDC hdc
)
553 BITMAPOBJ
*bitmap
= obj
;
554 DC
*dc
= DC_GetDCPtr( hdc
);
557 if (GetObjectType( hdc
) != OBJ_MEMDC
)
559 GDI_ReleaseObj( hdc
);
563 if (handle
== dc
->hBitmap
) goto done
; /* nothing to do */
565 if (bitmap
->header
.dwCount
&& (handle
!= GetStockObject(DEFAULT_BITMAP
)))
567 WARN( "Bitmap already selected in another DC\n" );
568 GDI_ReleaseObj( hdc
);
572 if (!bitmap
->funcs
&& !BITMAP_SetOwnerDC( handle
, dc
))
574 GDI_ReleaseObj( hdc
);
578 if (dc
->funcs
->pSelectBitmap
) handle
= dc
->funcs
->pSelectBitmap( dc
->physDev
, handle
);
582 dc
->hBitmap
= handle
;
583 dc
->flags
&= ~DC_DIRTY
;
584 SetRectRgn( dc
->hVisRgn
, 0, 0, bitmap
->bitmap
.bmWidth
, bitmap
->bitmap
.bmHeight
);
590 GDI_ReleaseObj( hdc
);
595 /***********************************************************************
596 * BITMAP_DeleteObject
598 static BOOL
BITMAP_DeleteObject( HGDIOBJ handle
, void *obj
)
600 BITMAPOBJ
* bmp
= obj
;
602 if (bmp
->funcs
&& bmp
->funcs
->pDeleteBitmap
)
603 bmp
->funcs
->pDeleteBitmap( handle
);
605 HeapFree( GetProcessHeap(), 0, bmp
->bitmap
.bmBits
);
609 DIBSECTION
*dib
= bmp
->dib
;
611 if (dib
->dsBm
.bmBits
)
615 SYSTEM_INFO SystemInfo
;
616 GetSystemInfo( &SystemInfo
);
617 UnmapViewOfFile( (char *)dib
->dsBm
.bmBits
-
618 (dib
->dsOffset
% SystemInfo
.dwAllocationGranularity
) );
620 else if (!dib
->dsOffset
)
621 VirtualFree(dib
->dsBm
.bmBits
, 0L, MEM_RELEASE
);
623 HeapFree(GetProcessHeap(), 0, dib
);
625 if (bmp
->segptr_bits
)
626 { /* free its selector array */
627 WORD sel
= SELECTOROF(bmp
->segptr_bits
);
628 WORD count
= (GetSelectorLimit16(sel
) / 0x10000) + 1;
631 for (i
= 0; i
< count
; i
++) FreeSelector16(sel
+ (i
<< __AHSHIFT
));
633 HeapFree(GetProcessHeap(), 0, bmp
->color_table
);
635 return GDI_FreeObject( handle
, obj
);
639 /***********************************************************************
642 static INT
BITMAP_GetObject16( HGDIOBJ handle
, void *obj
, INT count
, LPVOID buffer
)
644 BITMAPOBJ
*bmp
= obj
;
648 if ( count
<= sizeof(BITMAP16
) )
650 BITMAP
*bmp32
= &bmp
->dib
->dsBm
;
652 bmp16
.bmType
= bmp32
->bmType
;
653 bmp16
.bmWidth
= bmp32
->bmWidth
;
654 bmp16
.bmHeight
= bmp32
->bmHeight
;
655 bmp16
.bmWidthBytes
= bmp32
->bmWidthBytes
;
656 bmp16
.bmPlanes
= bmp32
->bmPlanes
;
657 bmp16
.bmBitsPixel
= bmp32
->bmBitsPixel
;
658 bmp16
.bmBits
= (SEGPTR
)0;
659 memcpy( buffer
, &bmp16
, count
);
664 FIXME("not implemented for DIBs: count %d\n", count
);
671 bmp16
.bmType
= bmp
->bitmap
.bmType
;
672 bmp16
.bmWidth
= bmp
->bitmap
.bmWidth
;
673 bmp16
.bmHeight
= bmp
->bitmap
.bmHeight
;
674 bmp16
.bmWidthBytes
= bmp
->bitmap
.bmWidthBytes
;
675 bmp16
.bmPlanes
= bmp
->bitmap
.bmPlanes
;
676 bmp16
.bmBitsPixel
= bmp
->bitmap
.bmBitsPixel
;
677 bmp16
.bmBits
= (SEGPTR
)0;
678 if (count
< sizeof(bmp16
)) return 0;
679 memcpy( buffer
, &bmp16
, sizeof(bmp16
) );
680 return sizeof(bmp16
);
685 /***********************************************************************
688 static INT
BITMAP_GetObject( HGDIOBJ handle
, void *obj
, INT count
, LPVOID buffer
)
690 BITMAPOBJ
*bmp
= obj
;
692 if( !buffer
) return sizeof(BITMAP
);
693 if (count
< sizeof(BITMAP
)) return 0;
697 if (count
>= sizeof(DIBSECTION
))
699 memcpy( buffer
, bmp
->dib
, sizeof(DIBSECTION
) );
700 return sizeof(DIBSECTION
);
702 else /* if (count >= sizeof(BITMAP)) */
704 DIBSECTION
*dib
= bmp
->dib
;
705 memcpy( buffer
, &dib
->dsBm
, sizeof(BITMAP
) );
706 return sizeof(BITMAP
);
711 memcpy( buffer
, &bmp
->bitmap
, sizeof(BITMAP
) );
712 ((BITMAP
*) buffer
)->bmBits
= NULL
;
713 return sizeof(BITMAP
);
718 /******************************************************************************
719 * CreateDiscardableBitmap [GDI32.@]
721 * Creates a discardable bitmap.
724 * Success: Handle to bitmap
727 HBITMAP WINAPI
CreateDiscardableBitmap(
728 HDC hdc
, /* [in] Handle to device context */
729 INT width
, /* [in] Bitmap width */
730 INT height
) /* [in] Bitmap height */
732 return CreateCompatibleBitmap( hdc
, width
, height
);
736 /******************************************************************************
737 * GetBitmapDimensionEx [GDI32.@]
739 * Retrieves dimensions of a bitmap.
745 BOOL WINAPI
GetBitmapDimensionEx(
746 HBITMAP hbitmap
, /* [in] Handle to bitmap */
747 LPSIZE size
) /* [out] Address of struct receiving dimensions */
749 BITMAPOBJ
* bmp
= (BITMAPOBJ
*) GDI_GetObjPtr( hbitmap
, BITMAP_MAGIC
);
750 if (!bmp
) return FALSE
;
752 GDI_ReleaseObj( hbitmap
);
757 /******************************************************************************
758 * SetBitmapDimensionEx [GDI32.@]
760 * Assigns dimensions to a bitmap.
761 * MSDN says that this function will fail if hbitmap is a handle created by
762 * CreateDIBSection, but that's not true on Windows 2000.
768 BOOL WINAPI
SetBitmapDimensionEx(
769 HBITMAP hbitmap
, /* [in] Handle to bitmap */
770 INT x
, /* [in] Bitmap width */
771 INT y
, /* [in] Bitmap height */
772 LPSIZE prevSize
) /* [out] Address of structure for orig dims */
774 BITMAPOBJ
* bmp
= (BITMAPOBJ
*) GDI_GetObjPtr( hbitmap
, BITMAP_MAGIC
);
775 if (!bmp
) return FALSE
;
776 if (prevSize
) *prevSize
= bmp
->size
;
779 GDI_ReleaseObj( hbitmap
);