shlwapi: Added special case for URL_PART_HOSTNAME in UrlGetPart.
[wine] / 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  *           BITMAP_GetWidthBytes
50  *
51  * Return number of bytes taken by a scanline of 16-bit aligned Windows DDB
52  * data.
53  */
54 INT BITMAP_GetWidthBytes( INT bmWidth, INT bpp )
55 {
56     switch(bpp)
57     {
58     case 1:
59         return 2 * ((bmWidth+15) >> 4);
60
61     case 24:
62         bmWidth *= 3; /* fall through */
63     case 8:
64         return bmWidth + (bmWidth & 1);
65
66     case 32:
67         return bmWidth * 4;
68
69     case 16:
70     case 15:
71         return bmWidth * 2;
72
73     case 4:
74         return 2 * ((bmWidth+3) >> 2);
75
76     default:
77         WARN("Unknown depth %d, please report.\n", bpp );
78     }
79     return -1;
80 }
81
82
83 /******************************************************************************
84  * CreateBitmap [GDI32.@]
85  *
86  * Creates a bitmap with the specified info.
87  *
88  * PARAMS
89  *    width  [I] bitmap width
90  *    height [I] bitmap height
91  *    planes [I] Number of color planes
92  *    bpp    [I] Number of bits to identify a color
93  *    bits   [I] Pointer to array containing color data
94  *
95  * RETURNS
96  *    Success: Handle to bitmap
97  *    Failure: 0
98  */
99 HBITMAP WINAPI CreateBitmap( INT width, INT height, UINT planes,
100                              UINT bpp, LPCVOID bits )
101 {
102     BITMAP bm;
103
104     bm.bmType = 0;
105     bm.bmWidth = width;
106     bm.bmHeight = height;
107     bm.bmWidthBytes = BITMAP_GetWidthBytes( width, bpp );
108     bm.bmPlanes = planes;
109     bm.bmBitsPixel = bpp;
110     bm.bmBits = (LPVOID)bits;
111
112     return CreateBitmapIndirect( &bm );
113 }
114
115 /******************************************************************************
116  * CreateCompatibleBitmap [GDI32.@]
117  *
118  * Creates a bitmap compatible with the DC.
119  *
120  * PARAMS
121  *    hdc    [I] Handle to device context
122  *    width  [I] Width of bitmap
123  *    height [I] Height of bitmap
124  *
125  * RETURNS
126  *    Success: Handle to bitmap
127  *    Failure: 0
128  */
129 HBITMAP WINAPI CreateCompatibleBitmap( HDC hdc, INT width, INT height)
130 {
131     HBITMAP hbmpRet = 0;
132
133     TRACE("(%p,%d,%d) =\n", hdc, width, height);
134
135     if (GetObjectType( hdc ) != OBJ_MEMDC)
136     {
137         hbmpRet = CreateBitmap(width, height,
138                                GetDeviceCaps(hdc, PLANES),
139                                GetDeviceCaps(hdc, BITSPIXEL),
140                                NULL);
141     }
142     else  /* Memory DC */
143     {
144         DIBSECTION dib;
145         HBITMAP bitmap = GetCurrentObject( hdc, OBJ_BITMAP );
146         INT size = GetObjectW( bitmap, sizeof(dib), &dib );
147
148         if (!size) return 0;
149
150         if (size == sizeof(BITMAP))
151         {
152             /* A device-dependent bitmap is selected in the DC */
153             hbmpRet = CreateBitmap(width, height,
154                                    dib.dsBm.bmPlanes,
155                                    dib.dsBm.bmBitsPixel,
156                                    NULL);
157         }
158         else
159         {
160             /* A DIB section is selected in the DC */
161             BITMAPINFO *bi;
162             void *bits;
163
164             /* Allocate memory for a BITMAPINFOHEADER structure and a
165                color table. The maximum number of colors in a color table
166                is 256 which corresponds to a bitmap with depth 8.
167                Bitmaps with higher depths don't have color tables. */
168             bi = HeapAlloc(GetProcessHeap(), 0, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
169
170             if (bi)
171             {
172                 bi->bmiHeader.biSize          = sizeof(bi->bmiHeader);
173                 bi->bmiHeader.biWidth         = width;
174                 bi->bmiHeader.biHeight        = height;
175                 bi->bmiHeader.biPlanes        = dib.dsBmih.biPlanes;
176                 bi->bmiHeader.biBitCount      = dib.dsBmih.biBitCount;
177                 bi->bmiHeader.biCompression   = dib.dsBmih.biCompression;
178                 bi->bmiHeader.biSizeImage     = 0;
179                 bi->bmiHeader.biXPelsPerMeter = dib.dsBmih.biXPelsPerMeter;
180                 bi->bmiHeader.biYPelsPerMeter = dib.dsBmih.biYPelsPerMeter;
181                 bi->bmiHeader.biClrUsed       = dib.dsBmih.biClrUsed;
182                 bi->bmiHeader.biClrImportant  = dib.dsBmih.biClrImportant;
183
184                 if (bi->bmiHeader.biCompression == BI_BITFIELDS)
185                 {
186                     /* Copy the color masks */
187                     CopyMemory(bi->bmiColors, dib.dsBitfields, 3 * sizeof(DWORD));
188                 }
189                 else if (bi->bmiHeader.biBitCount <= 8)
190                 {
191                     /* Copy the color table */
192                     GetDIBColorTable(hdc, 0, 256, bi->bmiColors);
193                 }
194
195                 hbmpRet = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
196                 HeapFree(GetProcessHeap(), 0, bi);
197             }
198         }
199     }
200
201     TRACE("\t\t%p\n", hbmpRet);
202     return hbmpRet;
203 }
204
205
206 /******************************************************************************
207  * CreateBitmapIndirect [GDI32.@]
208  *
209  * Creates a bitmap with the specified info.
210  *
211  * PARAMS
212  *  bmp [I] Pointer to the bitmap info describing the bitmap
213  *
214  * RETURNS
215  *    Success: Handle to bitmap
216  *    Failure: NULL. Use GetLastError() to determine the cause.
217  *
218  * NOTES
219  *  If a width or height of 0 are given, a 1x1 monochrome bitmap is returned.
220  */
221 HBITMAP WINAPI CreateBitmapIndirect( const BITMAP *bmp )
222 {
223     BITMAP bm;
224     BITMAPOBJ *bmpobj;
225     HBITMAP hbitmap;
226
227     if (!bmp || bmp->bmType)
228     {
229         SetLastError( ERROR_INVALID_PARAMETER );
230         return NULL;
231     }
232
233     if (bmp->bmWidth > 0x7ffffff || bmp->bmHeight > 0x7ffffff)
234     {
235         SetLastError( ERROR_INVALID_PARAMETER );
236         return 0;
237     }
238
239     bm = *bmp;
240
241     if (!bm.bmWidth || !bm.bmHeight)
242     {
243         return GetStockObject( DEFAULT_BITMAP );
244     }
245     else
246     {
247         if (bm.bmHeight < 0)
248             bm.bmHeight = -bm.bmHeight;
249         if (bm.bmWidth < 0)
250             bm.bmWidth = -bm.bmWidth;
251     }
252
253     if (bm.bmPlanes != 1)
254     {
255         FIXME("planes = %d\n", bm.bmPlanes);
256         SetLastError( ERROR_INVALID_PARAMETER );
257         return NULL;
258     }
259
260     /* Windows only uses 1, 4, 8, 16, 24 and 32 bpp */
261     if(bm.bmBitsPixel == 1)         bm.bmBitsPixel = 1;
262     else if(bm.bmBitsPixel <= 4)    bm.bmBitsPixel = 4;
263     else if(bm.bmBitsPixel <= 8)    bm.bmBitsPixel = 8;
264     else if(bm.bmBitsPixel <= 16)   bm.bmBitsPixel = 16;
265     else if(bm.bmBitsPixel <= 24)   bm.bmBitsPixel = 24;
266     else if(bm.bmBitsPixel <= 32)   bm.bmBitsPixel = 32;
267     else {
268         WARN("Invalid bmBitsPixel %d, returning ERROR_INVALID_PARAMETER\n", bm.bmBitsPixel);
269         SetLastError(ERROR_INVALID_PARAMETER);
270         return NULL;
271     }
272
273     /* Windows ignores the provided bm.bmWidthBytes */
274     bm.bmWidthBytes = BITMAP_GetWidthBytes( bm.bmWidth, bm.bmBitsPixel );
275     /* XP doesn't allow to create bitmaps larger than 128 Mb */
276     if (bm.bmHeight > 128 * 1024 * 1024 / bm.bmWidthBytes)
277     {
278         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
279         return 0;
280     }
281
282     /* Create the BITMAPOBJ */
283     if (!(bmpobj = HeapAlloc( GetProcessHeap(), 0, sizeof(*bmpobj) )))
284     {
285         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
286         return 0;
287     }
288
289     bmpobj->size.cx = 0;
290     bmpobj->size.cy = 0;
291     bmpobj->bitmap = bm;
292     bmpobj->bitmap.bmBits = NULL;
293     bmpobj->funcs = NULL;
294     bmpobj->dib = NULL;
295     bmpobj->color_table = NULL;
296     bmpobj->nb_colors = 0;
297
298     if (!(hbitmap = alloc_gdi_handle( &bmpobj->header, OBJ_BITMAP, &bitmap_funcs )))
299     {
300         HeapFree( GetProcessHeap(), 0, bmpobj );
301         return 0;
302     }
303
304     if (bm.bmBits)
305         SetBitmapBits( hbitmap, bm.bmHeight * bm.bmWidthBytes, bm.bmBits );
306
307     TRACE("%dx%d, %d colors returning %p\n", bm.bmWidth, bm.bmHeight,
308           1 << (bm.bmPlanes * bm.bmBitsPixel), hbitmap);
309
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, OBJ_BITMAP );
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, OBJ_BITMAP );
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, OBJ_BITMAP ))) 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, OBJ_BITMAP )))
582     {
583         ret = 0;
584         goto done;
585     }
586
587     if (bitmap->header.selcount && (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 )
628 {
629     const DC_FUNCTIONS *funcs;
630     BITMAPOBJ *bmp = GDI_GetObjPtr( handle, OBJ_BITMAP );
631
632     if (!bmp) return FALSE;
633     funcs = bmp->funcs;
634     GDI_ReleaseObj( handle );
635
636     if (funcs && funcs->pDeleteBitmap) funcs->pDeleteBitmap( handle );
637
638     if (!(bmp = free_gdi_handle( handle ))) return FALSE;
639
640     HeapFree( GetProcessHeap(), 0, bmp->bitmap.bmBits );
641
642     if (bmp->dib)
643     {
644         DIBSECTION *dib = bmp->dib;
645
646         if (dib->dsBm.bmBits)
647         {
648             if (dib->dshSection)
649             {
650                 SYSTEM_INFO SystemInfo;
651                 GetSystemInfo( &SystemInfo );
652                 UnmapViewOfFile( (char *)dib->dsBm.bmBits -
653                                  (dib->dsOffset % SystemInfo.dwAllocationGranularity) );
654             }
655             else if (!dib->dsOffset)
656                 VirtualFree(dib->dsBm.bmBits, 0L, MEM_RELEASE );
657         }
658         HeapFree(GetProcessHeap(), 0, dib);
659         HeapFree(GetProcessHeap(), 0, bmp->color_table);
660     }
661     return HeapFree( GetProcessHeap(), 0, bmp );
662 }
663
664
665 /***********************************************************************
666  *           BITMAP_GetObject
667  */
668 static INT BITMAP_GetObject( HGDIOBJ handle, INT count, LPVOID buffer )
669 {
670     INT ret;
671     BITMAPOBJ *bmp = GDI_GetObjPtr( handle, OBJ_BITMAP );
672
673     if (!bmp) return 0;
674
675     if (!buffer) ret = sizeof(BITMAP);
676     else if (count < sizeof(BITMAP)) ret = 0;
677     else if (bmp->dib)
678     {
679         if (count >= sizeof(DIBSECTION))
680         {
681             memcpy( buffer, bmp->dib, sizeof(DIBSECTION) );
682             ret = sizeof(DIBSECTION);
683         }
684         else /* if (count >= sizeof(BITMAP)) */
685         {
686             DIBSECTION *dib = bmp->dib;
687             memcpy( buffer, &dib->dsBm, sizeof(BITMAP) );
688             ret = sizeof(BITMAP);
689         }
690     }
691     else
692     {
693         memcpy( buffer, &bmp->bitmap, sizeof(BITMAP) );
694         ((BITMAP *) buffer)->bmBits = NULL;
695         ret = sizeof(BITMAP);
696     }
697     GDI_ReleaseObj( handle );
698     return ret;
699 }
700
701
702 /******************************************************************************
703  * CreateDiscardableBitmap [GDI32.@]
704  *
705  * Creates a discardable bitmap.
706  *
707  * RETURNS
708  *    Success: Handle to bitmap
709  *    Failure: NULL
710  */
711 HBITMAP WINAPI CreateDiscardableBitmap(
712     HDC hdc,    /* [in] Handle to device context */
713     INT width,  /* [in] Bitmap width */
714     INT height) /* [in] Bitmap height */
715 {
716     return CreateCompatibleBitmap( hdc, width, height );
717 }
718
719
720 /******************************************************************************
721  * GetBitmapDimensionEx [GDI32.@]
722  *
723  * Retrieves dimensions of a bitmap.
724  *
725  * RETURNS
726  *    Success: TRUE
727  *    Failure: FALSE
728  */
729 BOOL WINAPI GetBitmapDimensionEx(
730     HBITMAP hbitmap, /* [in]  Handle to bitmap */
731     LPSIZE size)     /* [out] Address of struct receiving dimensions */
732 {
733     BITMAPOBJ * bmp = GDI_GetObjPtr( hbitmap, OBJ_BITMAP );
734     if (!bmp) return FALSE;
735     *size = bmp->size;
736     GDI_ReleaseObj( hbitmap );
737     return TRUE;
738 }
739
740
741 /******************************************************************************
742  * SetBitmapDimensionEx [GDI32.@]
743  *
744  * Assigns dimensions to a bitmap.
745  * MSDN says that this function will fail if hbitmap is a handle created by
746  * CreateDIBSection, but that's not true on Windows 2000.
747  *
748  * RETURNS
749  *    Success: TRUE
750  *    Failure: FALSE
751  */
752 BOOL WINAPI SetBitmapDimensionEx(
753     HBITMAP hbitmap, /* [in]  Handle to bitmap */
754     INT x,           /* [in]  Bitmap width */
755     INT y,           /* [in]  Bitmap height */
756     LPSIZE prevSize) /* [out] Address of structure for orig dims */
757 {
758     BITMAPOBJ * bmp = GDI_GetObjPtr( hbitmap, OBJ_BITMAP );
759     if (!bmp) return FALSE;
760     if (prevSize) *prevSize = bmp->size;
761     bmp->size.cx = x;
762     bmp->size.cy = y;
763     GDI_ReleaseObj( hbitmap );
764     return TRUE;
765 }