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 "wine/winbase16.h"
30 #include "gdi_private.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(bitmap);
34
35
36 static HGDIOBJ BITMAP_SelectObject( HGDIOBJ handle, HDC hdc );
37 static INT BITMAP_GetObject( HGDIOBJ handle, void *obj, INT count, LPVOID buffer );
38 static BOOL BITMAP_DeleteObject( HGDIOBJ handle, void *obj );
39
40 static const struct gdi_obj_funcs bitmap_funcs =
41 {
42 BITMAP_SelectObject, /* pSelectObject */
43 BITMAP_GetObject, /* pGetObjectA */
44 BITMAP_GetObject, /* pGetObjectW */
45 NULL, /* pUnrealizeObject */
46 BITMAP_DeleteObject /* pDeleteObject */
47 };
48
49 /***********************************************************************
50 * BITMAP_GetWidthBytes
51 *
52 * Return number of bytes taken by a scanline of 16-bit aligned Windows DDB
53 * data.
54 */
55 INT BITMAP_GetWidthBytes( INT bmWidth, INT bpp )
56 {
57 switch(bpp)
58 {
59 case 1:
60 return 2 * ((bmWidth+15) >> 4);
61
62 case 24:
63 bmWidth *= 3; /* fall through */
64 case 8:
65 return bmWidth + (bmWidth & 1);
66
67 case 32:
68 return bmWidth * 4;
69
70 case 16:
71 case 15:
72 return bmWidth * 2;
73
74 case 4:
75 return 2 * ((bmWidth+3) >> 2);
76
77 default:
78 WARN("Unknown depth %d, please report.\n", bpp );
79 }
80 return -1;
81 }
82
83
84 /******************************************************************************
85 * CreateBitmap [GDI32.@]
86 *
87 * Creates a bitmap with the specified info.
88 *
89 * PARAMS
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
95 *
96 * RETURNS
97 * Success: Handle to bitmap
98 * Failure: 0
99 */
100 HBITMAP WINAPI CreateBitmap( INT width, INT height, UINT planes,
101 UINT bpp, LPCVOID bits )
102 {
103 BITMAP bm;
104
105 bm.bmType = 0;
106 bm.bmWidth = width;
107 bm.bmHeight = height;
108 bm.bmWidthBytes = BITMAP_GetWidthBytes( width, bpp );
109 bm.bmPlanes = planes;
110 bm.bmBitsPixel = bpp;
111 bm.bmBits = (LPVOID)bits;
112
113 return CreateBitmapIndirect( &bm );
114 }
115
116 /******************************************************************************
117 * CreateCompatibleBitmap [GDI32.@]
118 *
119 * Creates a bitmap compatible with the DC.
120 *
121 * PARAMS
122 * hdc [I] Handle to device context
123 * width [I] Width of bitmap
124 * height [I] Height of bitmap
125 *
126 * RETURNS
127 * Success: Handle to bitmap
128 * Failure: 0
129 */
130 HBITMAP WINAPI CreateCompatibleBitmap( HDC hdc, INT width, INT height)
131 {
132 HBITMAP hbmpRet = 0;
133
134 TRACE("(%p,%d,%d) =\n", hdc, width, height);
135
136 if (GetObjectType( hdc ) != OBJ_MEMDC)
137 {
138 hbmpRet = CreateBitmap(width, height,
139 GetDeviceCaps(hdc, PLANES),
140 GetDeviceCaps(hdc, BITSPIXEL),
141 NULL);
142 }
143 else /* Memory DC */
144 {
145 DIBSECTION dib;
146 HBITMAP bitmap = GetCurrentObject( hdc, OBJ_BITMAP );
147 INT size = GetObjectW( bitmap, sizeof(dib), &dib );
148
149 if (!size) return 0;
150
151 if (size == sizeof(BITMAP))
152 {
153 /* A device-dependent bitmap is selected in the DC */
154 hbmpRet = CreateBitmap(width, height,
155 dib.dsBm.bmPlanes,
156 dib.dsBm.bmBitsPixel,
157 NULL);
158 }
159 else
160 {
161 /* A DIB section is selected in the DC */
162 BITMAPINFO *bi;
163 void *bits;
164
165 /* Allocate memory for a BITMAPINFOHEADER structure and a
166 color table. The maximum number of colors in a color table
167 is 256 which corresponds to a bitmap with depth 8.
168 Bitmaps with higher depths don't have color tables. */
169 bi = HeapAlloc(GetProcessHeap(), 0, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
170
171 if (bi)
172 {
173 bi->bmiHeader.biSize = sizeof(bi->bmiHeader);
174 bi->bmiHeader.biWidth = width;
175 bi->bmiHeader.biHeight = height;
176 bi->bmiHeader.biPlanes = dib.dsBmih.biPlanes;
177 bi->bmiHeader.biBitCount = dib.dsBmih.biBitCount;
178 bi->bmiHeader.biCompression = dib.dsBmih.biCompression;
179 bi->bmiHeader.biSizeImage = 0;
180 bi->bmiHeader.biXPelsPerMeter = dib.dsBmih.biXPelsPerMeter;
181 bi->bmiHeader.biYPelsPerMeter = dib.dsBmih.biYPelsPerMeter;
182 bi->bmiHeader.biClrUsed = dib.dsBmih.biClrUsed;
183 bi->bmiHeader.biClrImportant = dib.dsBmih.biClrImportant;
184
185 if (bi->bmiHeader.biCompression == BI_BITFIELDS)
186 {
187 /* Copy the color masks */
188 CopyMemory(bi->bmiColors, dib.dsBitfields, 3 * sizeof(DWORD));
189 }
190 else if (bi->bmiHeader.biBitCount <= 8)
191 {
192 /* Copy the color table */
193 GetDIBColorTable(hdc, 0, 256, bi->bmiColors);
194 }
195
196 hbmpRet = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
197 HeapFree(GetProcessHeap(), 0, bi);
198 }
199 }
200 }
201
202 TRACE("\t\t%p\n", hbmpRet);
203 return hbmpRet;
204 }
205
206
207 /******************************************************************************
208 * CreateBitmapIndirect [GDI32.@]
209 *
210 * Creates a bitmap with the specified info.
211 *
212 * PARAMS
213 * bmp [I] Pointer to the bitmap info describing the bitmap
214 *
215 * RETURNS
216 * Success: Handle to bitmap
217 * Failure: NULL. Use GetLastError() to determine the cause.
218 *
219 * NOTES
220 * If a width or height of 0 are given, a 1x1 monochrome bitmap is returned.
221 */
222 HBITMAP WINAPI CreateBitmapIndirect( const BITMAP *bmp )
223 {
224 BITMAP bm;
225 BITMAPOBJ *bmpobj;
226 HBITMAP hbitmap;
227
228 if (!bmp || bmp->bmType)
229 {
230 SetLastError( ERROR_INVALID_PARAMETER );
231 return NULL;
232 }
233
234 if (bmp->bmWidth > 0x7ffffff || bmp->bmHeight > 0x7ffffff)
235 {
236 SetLastError( ERROR_INVALID_PARAMETER );
237 return 0;
238 }
239
240 bm = *bmp;
241
242 if (!bm.bmWidth || !bm.bmHeight)
243 {
244 return GetStockObject( DEFAULT_BITMAP );
245 }
246 else
247 {
248 if (bm.bmHeight < 0)
249 bm.bmHeight = -bm.bmHeight;
250 if (bm.bmWidth < 0)
251 bm.bmWidth = -bm.bmWidth;
252 }
253
254 if (bm.bmPlanes != 1)
255 {
256 FIXME("planes = %d\n", bm.bmPlanes);
257 SetLastError( ERROR_INVALID_PARAMETER );
258 return NULL;
259 }
260
261 /* Windows only uses 1, 4, 8, 16, 24 and 32 bpp */
262 if(bm.bmBitsPixel == 1) bm.bmBitsPixel = 1;
263 else if(bm.bmBitsPixel <= 4) bm.bmBitsPixel = 4;
264 else if(bm.bmBitsPixel <= 8) bm.bmBitsPixel = 8;
265 else if(bm.bmBitsPixel <= 16) bm.bmBitsPixel = 16;
266 else if(bm.bmBitsPixel <= 24) bm.bmBitsPixel = 24;
267 else if(bm.bmBitsPixel <= 32) bm.bmBitsPixel = 32;
268 else {
269 WARN("Invalid bmBitsPixel %d, returning ERROR_INVALID_PARAMETER\n", bm.bmBitsPixel);
270 SetLastError(ERROR_INVALID_PARAMETER);
271 return NULL;
272 }
273
274 /* Windows ignores the provided bm.bmWidthBytes */
275 bm.bmWidthBytes = BITMAP_GetWidthBytes( bm.bmWidth, bm.bmBitsPixel );
276 /* XP doesn't allow to create bitmaps larger than 128 Mb */
277 if (bm.bmHeight * bm.bmWidthBytes > 128 * 1024 * 1024)
278 {
279 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
280 return 0;
281 }
282
283 /* Create the BITMAPOBJ */
284 bmpobj = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC,
285 (HGDIOBJ *)&hbitmap, &bitmap_funcs );
286
287 if (!bmpobj)
288 {
289 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
290 return NULL;
291 }
292
293 TRACE("%dx%d, %d colors returning %p\n", bm.bmWidth, bm.bmHeight,
294 1 << (bm.bmPlanes * bm.bmBitsPixel), hbitmap);
295
296 bmpobj->size.cx = 0;
297 bmpobj->size.cy = 0;
298 bmpobj->bitmap = bm;
299 bmpobj->bitmap.bmBits = NULL;
300 bmpobj->funcs = NULL;
301 bmpobj->dib = NULL;
302 bmpobj->segptr_bits = 0;
303 bmpobj->color_table = NULL;
304 bmpobj->nb_colors = 0;
305
306 if (bm.bmBits)
307 SetBitmapBits( hbitmap, bm.bmHeight * bm.bmWidthBytes, bm.bmBits );
308
309 GDI_ReleaseObj( hbitmap );
310 return hbitmap;
311 }
312
313
314 /***********************************************************************
315 * GetBitmapBits [GDI32.@]
316 *
317 * Copies bitmap bits of bitmap to buffer.
318 *
319 * RETURNS
320 * Success: Number of bytes copied
321 * Failure: 0
322 */
323 LONG WINAPI GetBitmapBits(
324 HBITMAP hbitmap, /* [in] Handle to bitmap */
325 LONG count, /* [in] Number of bytes to copy */
326 LPVOID bits) /* [out] Pointer to buffer to receive bits */
327 {
328 BITMAPOBJ *bmp = GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
329 LONG height, ret;
330
331 if (!bmp) return 0;
332
333 if (bmp->dib) /* simply copy the bits from the DIB */
334 {
335 DIBSECTION *dib = bmp->dib;
336 const char *src = dib->dsBm.bmBits;
337 INT width_bytes = BITMAP_GetWidthBytes(dib->dsBm.bmWidth, dib->dsBm.bmBitsPixel);
338 LONG max = width_bytes * bmp->bitmap.bmHeight;
339
340 if (!bits)
341 {
342 ret = max;
343 goto done;
344 }
345
346 if (count > max) count = max;
347 ret = count;
348
349 /* GetBitmapBits returns not 32-bit aligned data */
350
351 if (bmp->dib->dsBmih.biHeight >= 0) /* not top-down, need to flip contents vertically */
352 {
353 src += dib->dsBm.bmWidthBytes * dib->dsBm.bmHeight;
354 while (count > 0)
355 {
356 src -= dib->dsBm.bmWidthBytes;
357 memcpy( bits, src, min( count, width_bytes ) );
358 bits = (char *)bits + width_bytes;
359 count -= width_bytes;
360 }
361 }
362 else
363 {
364 while (count > 0)
365 {
366 memcpy( bits, src, min( count, width_bytes ) );
367 src += dib->dsBm.bmWidthBytes;
368 bits = (char *)bits + width_bytes;
369 count -= width_bytes;
370 }
371 }
372 goto done;
373 }
374
375 /* If the bits vector is null, the function should return the read size */
376 if(bits == NULL)
377 {
378 ret = bmp->bitmap.bmWidthBytes * bmp->bitmap.bmHeight;
379 goto done;
380 }
381
382 if (count < 0) {
383 WARN("(%d): Negative number of bytes passed???\n", count );
384 count = -count;
385 }
386
387 /* Only get entire lines */
388 height = count / bmp->bitmap.bmWidthBytes;
389 if (height > bmp->bitmap.bmHeight) height = bmp->bitmap.bmHeight;
390 count = height * bmp->bitmap.bmWidthBytes;
391 if (count == 0)
392 {
393 WARN("Less than one entire line requested\n");
394 ret = 0;
395 goto done;
396 }
397
398
399 TRACE("(%p, %d, %p) %dx%d %d colors fetched height: %d\n",
400 hbitmap, count, bits, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
401 1 << bmp->bitmap.bmBitsPixel, height );
402
403 if(bmp->funcs && bmp->funcs->pGetBitmapBits)
404 {
405 TRACE("Calling device specific BitmapBits\n");
406 ret = bmp->funcs->pGetBitmapBits(hbitmap, bits, count);
407 } else {
408
409 if(!bmp->bitmap.bmBits) {
410 TRACE("Bitmap is empty\n");
411 memset(bits, 0, count);
412 ret = count;
413 } else {
414 memcpy(bits, bmp->bitmap.bmBits, count);
415 ret = count;
416 }
417
418 }
419 done:
420 GDI_ReleaseObj( hbitmap );
421 return ret;
422 }
423
424
425 /******************************************************************************
426 * SetBitmapBits [GDI32.@]
427 *
428 * Sets bits of color data for a bitmap.
429 *
430 * RETURNS
431 * Success: Number of bytes used in setting the bitmap bits
432 * Failure: 0
433 */
434 LONG WINAPI SetBitmapBits(
435 HBITMAP hbitmap, /* [in] Handle to bitmap */
436 LONG count, /* [in] Number of bytes in bitmap array */
437 LPCVOID bits) /* [in] Address of array with bitmap bits */
438 {
439 BITMAPOBJ *bmp = GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
440 LONG height, ret;
441
442 if ((!bmp) || (!bits))
443 return 0;
444
445 if (count < 0) {
446 WARN("(%d): Negative number of bytes passed???\n", count );
447 count = -count;
448 }
449
450 if (bmp->dib) /* simply copy the bits into the DIB */
451 {
452 DIBSECTION *dib = bmp->dib;
453 char *dest = dib->dsBm.bmBits;
454 LONG max = dib->dsBm.bmWidthBytes * dib->dsBm.bmHeight;
455 if (count > max) count = max;
456 ret = count;
457
458 if (bmp->dib->dsBmih.biHeight >= 0) /* not top-down, need to flip contents vertically */
459 {
460 dest += dib->dsBm.bmWidthBytes * dib->dsBm.bmHeight;
461 while (count > 0)
462 {
463 dest -= dib->dsBm.bmWidthBytes;
464 memcpy( dest, bits, min( count, dib->dsBm.bmWidthBytes ) );
465 bits = (const char *)bits + dib->dsBm.bmWidthBytes;
466 count -= dib->dsBm.bmWidthBytes;
467 }
468 }
469 else memcpy( dest, bits, count );
470
471 GDI_ReleaseObj( hbitmap );
472 return ret;
473 }
474
475 /* Only get entire lines */
476 height = count / bmp->bitmap.bmWidthBytes;
477 if (height > bmp->bitmap.bmHeight) height = bmp->bitmap.bmHeight;
478 count = height * bmp->bitmap.bmWidthBytes;
479
480 TRACE("(%p, %d, %p) %dx%d %d colors fetched height: %d\n",
481 hbitmap, count, bits, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
482 1 << bmp->bitmap.bmBitsPixel, height );
483
484 if(bmp->funcs && bmp->funcs->pSetBitmapBits) {
485
486 TRACE("Calling device specific BitmapBits\n");
487 ret = bmp->funcs->pSetBitmapBits(hbitmap, bits, count);
488 } else {
489
490 if(!bmp->bitmap.bmBits) /* Alloc enough for entire bitmap */
491 bmp->bitmap.bmBits = HeapAlloc( GetProcessHeap(), 0, count );
492 if(!bmp->bitmap.bmBits) {
493 WARN("Unable to allocate bit buffer\n");
494 ret = 0;
495 } else {
496 memcpy(bmp->bitmap.bmBits, bits, count);
497 ret = count;
498 }
499 }
500
501 GDI_ReleaseObj( hbitmap );
502 return ret;
503 }
504
505 /**********************************************************************
506 * BITMAP_CopyBitmap
507 *
508 */
509 HBITMAP BITMAP_CopyBitmap(HBITMAP hbitmap)
510 {
511 HBITMAP res = 0;
512 BITMAP bm;
513
514 if (!GetObjectW( hbitmap, sizeof(bm), &bm )) return 0;
515 res = CreateBitmapIndirect(&bm);
516
517 if(res) {
518 char *buf = HeapAlloc( GetProcessHeap(), 0, bm.bmWidthBytes *
519 bm.bmHeight );
520 GetBitmapBits (hbitmap, bm.bmWidthBytes * bm.bmHeight, buf);
521 SetBitmapBits (res, bm.bmWidthBytes * bm.bmHeight, buf);
522 HeapFree( GetProcessHeap(), 0, buf );
523 }
524 return res;
525 }
526
527
528 /***********************************************************************
529 * BITMAP_SetOwnerDC
530 *
531 * Set the type of DC that owns the bitmap. This is used when the
532 * bitmap is selected into a device to initialize the bitmap function
533 * table.
534 */
535 BOOL BITMAP_SetOwnerDC( HBITMAP hbitmap, DC *dc )
536 {
537 BITMAPOBJ *bitmap;
538 BOOL ret;
539
540 /* never set the owner of the stock bitmap since it can be selected in multiple DCs */
541 if (hbitmap == GetStockObject(DEFAULT_BITMAP)) return TRUE;
542
543 if (!(bitmap = GDI_GetObjPtr( hbitmap, BITMAP_MAGIC ))) return FALSE;
544
545 ret = TRUE;
546 if (!bitmap->funcs) /* not owned by a DC yet */
547 {
548 if (dc->funcs->pCreateBitmap) ret = dc->funcs->pCreateBitmap( dc->physDev, hbitmap,
549 bitmap->bitmap.bmBits );
550 if (ret) bitmap->funcs = dc->funcs;
551 }
552 else if (bitmap->funcs != dc->funcs)
553 {
554 FIXME( "Trying to select bitmap %p in different DC type\n", hbitmap );
555 ret = FALSE;
556 }
557 GDI_ReleaseObj( hbitmap );
558 return ret;
559 }
560
561
562 /***********************************************************************
563 * BITMAP_SelectObject
564 */
565 static HGDIOBJ BITMAP_SelectObject( HGDIOBJ handle, HDC hdc )
566 {
567 HGDIOBJ ret;
568 BITMAPOBJ *bitmap;
569 DC *dc;
570
571 if (!(dc = get_dc_ptr( hdc ))) return 0;
572
573 if (GetObjectType( hdc ) != OBJ_MEMDC)
574 {
575 ret = 0;
576 goto done;
577 }
578 ret = dc->hBitmap;
579 if (handle == dc->hBitmap) goto done; /* nothing to do */
580
581 if (!(bitmap = GDI_GetObjPtr( handle, BITMAP_MAGIC )))
582 {
583 ret = 0;
584 goto done;
585 }
586
587 if (bitmap->header.dwCount && (handle != GetStockObject(DEFAULT_BITMAP)))
588 {
589 WARN( "Bitmap already selected in another DC\n" );
590 GDI_ReleaseObj( handle );
591 ret = 0;
592 goto done;
593 }
594
595 if (!bitmap->funcs && !BITMAP_SetOwnerDC( handle, dc ))
596 {
597 GDI_ReleaseObj( handle );
598 ret = 0;
599 goto done;
600 }
601
602 if (dc->funcs->pSelectBitmap && !dc->funcs->pSelectBitmap( dc->physDev, handle ))
603 {
604 GDI_ReleaseObj( handle );
605 ret = 0;
606 }
607 else
608 {
609 dc->hBitmap = handle;
610 GDI_inc_ref_count( handle );
611 dc->dirty = 0;
612 SetRectRgn( dc->hVisRgn, 0, 0, bitmap->bitmap.bmWidth, bitmap->bitmap.bmHeight);
613 GDI_ReleaseObj( handle );
614 DC_InitDC( dc );
615 GDI_dec_ref_count( ret );
616 }
617
618 done:
619 release_dc_ptr( dc );
620 return ret;
621 }
622
623
624 /***********************************************************************
625 * BITMAP_DeleteObject
626 */
627 static BOOL BITMAP_DeleteObject( HGDIOBJ handle, void *obj )
628 {
629 BITMAPOBJ * bmp = obj;
630
631 if (bmp->funcs && bmp->funcs->pDeleteBitmap)
632 bmp->funcs->pDeleteBitmap( handle );
633
634 HeapFree( GetProcessHeap(), 0, bmp->bitmap.bmBits );
635
636 if (bmp->dib)
637 {
638 DIBSECTION *dib = bmp->dib;
639
640 if (dib->dsBm.bmBits)
641 {
642 if (dib->dshSection)
643 {
644 SYSTEM_INFO SystemInfo;
645 GetSystemInfo( &SystemInfo );
646 UnmapViewOfFile( (char *)dib->dsBm.bmBits -
647 (dib->dsOffset % SystemInfo.dwAllocationGranularity) );
648 }
649 else if (!dib->dsOffset)
650 VirtualFree(dib->dsBm.bmBits, 0L, MEM_RELEASE );
651 }
652 HeapFree(GetProcessHeap(), 0, dib);
653 bmp->dib = NULL;
654 if (bmp->segptr_bits)
655 { /* free its selector array */
656 WORD sel = SELECTOROF(bmp->segptr_bits);
657 WORD count = (GetSelectorLimit16(sel) / 0x10000) + 1;
658 int i;
659
660 for (i = 0; i < count; i++) FreeSelector16(sel + (i << __AHSHIFT));
661 }
662 HeapFree(GetProcessHeap(), 0, bmp->color_table);
663 }
664 return GDI_FreeObject( handle, obj );
665 }
666
667
668 /***********************************************************************
669 * BITMAP_GetObject
670 */
671 static INT BITMAP_GetObject( HGDIOBJ handle, void *obj, INT count, LPVOID buffer )
672 {
673 BITMAPOBJ *bmp = obj;
674
675 if( !buffer ) return sizeof(BITMAP);
676 if (count < sizeof(BITMAP)) return 0;
677
678 if (bmp->dib)
679 {
680 if (count >= sizeof(DIBSECTION))
681 {
682 memcpy( buffer, bmp->dib, sizeof(DIBSECTION) );
683 return sizeof(DIBSECTION);
684 }
685 else /* if (count >= sizeof(BITMAP)) */
686 {
687 DIBSECTION *dib = bmp->dib;
688 memcpy( buffer, &dib->dsBm, sizeof(BITMAP) );
689 return sizeof(BITMAP);
690 }
691 }
692 else
693 {
694 memcpy( buffer, &bmp->bitmap, sizeof(BITMAP) );
695 ((BITMAP *) buffer)->bmBits = NULL;
696 return sizeof(BITMAP);
697 }
698 }
699
700
701 /******************************************************************************
702 * CreateDiscardableBitmap [GDI32.@]
703 *
704 * Creates a discardable bitmap.
705 *
706 * RETURNS
707 * Success: Handle to bitmap
708 * Failure: NULL
709 */
710 HBITMAP WINAPI CreateDiscardableBitmap(
711 HDC hdc, /* [in] Handle to device context */
712 INT width, /* [in] Bitmap width */
713 INT height) /* [in] Bitmap height */
714 {
715 return CreateCompatibleBitmap( hdc, width, height );
716 }
717
718
719 /******************************************************************************
720 * GetBitmapDimensionEx [GDI32.@]
721 *
722 * Retrieves dimensions of a bitmap.
723 *
724 * RETURNS
725 * Success: TRUE
726 * Failure: FALSE
727 */
728 BOOL WINAPI GetBitmapDimensionEx(
729 HBITMAP hbitmap, /* [in] Handle to bitmap */
730 LPSIZE size) /* [out] Address of struct receiving dimensions */
731 {
732 BITMAPOBJ * bmp = GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
733 if (!bmp) return FALSE;
734 *size = bmp->size;
735 GDI_ReleaseObj( hbitmap );
736 return TRUE;
737 }
738
739
740 /******************************************************************************
741 * SetBitmapDimensionEx [GDI32.@]
742 *
743 * Assigns dimensions to a bitmap.
744 * MSDN says that this function will fail if hbitmap is a handle created by
745 * CreateDIBSection, but that's not true on Windows 2000.
746 *
747 * RETURNS
748 * Success: TRUE
749 * Failure: FALSE
750 */
751 BOOL WINAPI SetBitmapDimensionEx(
752 HBITMAP hbitmap, /* [in] Handle to bitmap */
753 INT x, /* [in] Bitmap width */
754 INT y, /* [in] Bitmap height */
755 LPSIZE prevSize) /* [out] Address of structure for orig dims */
756 {
757 BITMAPOBJ * bmp = GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
758 if (!bmp) return FALSE;
759 if (prevSize) *prevSize = bmp->size;
760 bmp->size.cx = x;
761 bmp->size.cy = y;
762 GDI_ReleaseObj( hbitmap );
763 return TRUE;
764 }
765
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.