msvcrt/tests: Remove a space before a '\n'.
[wine/gsoc-2012-control.git] / dlls / gdiplus / image.c
blob02f8f5a5655c2b40172c9ba5c87820f330030ebd
1 /*
2 * Copyright (C) 2007 Google (Evan Stade)
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 #include <stdarg.h>
21 #include "windef.h"
22 #include "winbase.h"
23 #include "winuser.h"
24 #include "wingdi.h"
26 #define COBJMACROS
27 #include "objbase.h"
28 #include "olectl.h"
29 #include "ole2.h"
31 #include "initguid.h"
32 #include "gdiplus.h"
33 #include "gdiplus_private.h"
34 #include "wine/debug.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
38 #define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
40 static INT ipicture_pixel_height(IPicture *pic)
42 HDC hdcref;
43 OLE_YSIZE_HIMETRIC y;
45 IPicture_get_Height(pic, &y);
47 hdcref = GetDC(0);
49 y = MulDiv(y, GetDeviceCaps(hdcref, LOGPIXELSY), INCH_HIMETRIC);
50 ReleaseDC(0, hdcref);
52 return y;
55 static INT ipicture_pixel_width(IPicture *pic)
57 HDC hdcref;
58 OLE_XSIZE_HIMETRIC x;
60 IPicture_get_Width(pic, &x);
62 hdcref = GetDC(0);
64 x = MulDiv(x, GetDeviceCaps(hdcref, LOGPIXELSX), INCH_HIMETRIC);
66 ReleaseDC(0, hdcref);
68 return x;
71 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
72 ARGB *color)
74 static int calls;
75 TRACE("%p %d %d %p\n", bitmap, x, y, color);
77 if(!bitmap || !color)
78 return InvalidParameter;
80 if(!(calls++))
81 FIXME("not implemented\n");
83 *color = 0xdeadbeef;
85 return NotImplemented;
88 /* This function returns a pointer to an array of pixels that represents the
89 * bitmap. The *entire* bitmap is locked according to the lock mode specified by
90 * flags. It is correct behavior that a user who calls this function with write
91 * privileges can write to the whole bitmap (not just the area in rect).
93 * FIXME: only used portion of format is bits per pixel. */
94 GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
95 UINT flags, PixelFormat format, BitmapData* lockeddata)
97 BOOL bm_is_selected;
98 INT stride, bitspp = PIXELFORMATBPP(format);
99 HDC hdc;
100 HBITMAP hbm, old = NULL;
101 BITMAPINFO *pbmi;
102 BYTE *buff = NULL;
103 UINT abs_height;
104 GpRect act_rect; /* actual rect to be used */
106 TRACE("%p %p %d %d %p\n", bitmap, rect, flags, format, lockeddata);
108 if(!lockeddata || !bitmap)
109 return InvalidParameter;
111 if(rect){
112 if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
113 (rect->Y + rect->Height > bitmap->height) || !flags)
114 return InvalidParameter;
116 act_rect = *rect;
118 else{
119 act_rect.X = act_rect.Y = 0;
120 act_rect.Width = bitmap->width;
121 act_rect.Height = bitmap->height;
124 if(flags & ImageLockModeUserInputBuf)
125 return NotImplemented;
127 if(bitmap->lockmode)
128 return WrongState;
130 IPicture_get_Handle(bitmap->image.picture, (OLE_HANDLE*)&hbm);
131 IPicture_get_CurDC(bitmap->image.picture, &hdc);
132 bm_is_selected = (hdc != 0);
134 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
135 if (!pbmi)
136 return OutOfMemory;
137 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
138 pbmi->bmiHeader.biBitCount = 0;
140 if(!bm_is_selected){
141 hdc = CreateCompatibleDC(0);
142 old = SelectObject(hdc, hbm);
145 /* fill out bmi */
146 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
148 abs_height = abs(pbmi->bmiHeader.biHeight);
149 stride = pbmi->bmiHeader.biWidth * bitspp / 8;
150 stride = (stride + 3) & ~3;
152 buff = GdipAlloc(stride * abs_height);
154 pbmi->bmiHeader.biBitCount = bitspp;
156 if(buff)
157 GetDIBits(hdc, hbm, 0, abs_height, buff, pbmi, DIB_RGB_COLORS);
159 if(!bm_is_selected){
160 SelectObject(hdc, old);
161 DeleteDC(hdc);
164 if(!buff){
165 GdipFree(pbmi);
166 return OutOfMemory;
169 lockeddata->Width = act_rect.Width;
170 lockeddata->Height = act_rect.Height;
171 lockeddata->PixelFormat = format;
172 lockeddata->Reserved = flags;
174 if(pbmi->bmiHeader.biHeight > 0){
175 lockeddata->Stride = -stride;
176 lockeddata->Scan0 = buff + (bitspp / 8) * act_rect.X +
177 stride * (abs_height - 1 - act_rect.Y);
179 else{
180 lockeddata->Stride = stride;
181 lockeddata->Scan0 = buff + (bitspp / 8) * act_rect.X + stride * act_rect.Y;
184 bitmap->lockmode = flags;
185 bitmap->numlocks++;
187 bitmap->bitmapbits = buff;
189 GdipFree(pbmi);
190 return Ok;
193 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
194 BitmapData* lockeddata)
196 HDC hdc;
197 HBITMAP hbm, old = NULL;
198 BOOL bm_is_selected;
199 BITMAPINFO *pbmi;
201 if(!bitmap || !lockeddata)
202 return InvalidParameter;
204 if(!bitmap->lockmode)
205 return WrongState;
207 if(lockeddata->Reserved & ImageLockModeUserInputBuf)
208 return NotImplemented;
210 if(lockeddata->Reserved & ImageLockModeRead){
211 if(!(--bitmap->numlocks))
212 bitmap->lockmode = 0;
214 GdipFree(bitmap->bitmapbits);
215 bitmap->bitmapbits = NULL;
216 return Ok;
219 IPicture_get_Handle(bitmap->image.picture, (OLE_HANDLE*)&hbm);
220 IPicture_get_CurDC(bitmap->image.picture, &hdc);
221 bm_is_selected = (hdc != 0);
223 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
224 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
225 pbmi->bmiHeader.biBitCount = 0;
227 if(!bm_is_selected){
228 hdc = CreateCompatibleDC(0);
229 old = SelectObject(hdc, hbm);
232 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
233 pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(lockeddata->PixelFormat);
234 SetDIBits(hdc, hbm, 0, abs(pbmi->bmiHeader.biHeight),
235 bitmap->bitmapbits, pbmi, DIB_RGB_COLORS);
237 if(!bm_is_selected){
238 SelectObject(hdc, old);
239 DeleteDC(hdc);
242 GdipFree(pbmi);
243 GdipFree(bitmap->bitmapbits);
244 bitmap->bitmapbits = NULL;
245 bitmap->lockmode = 0;
247 return Ok;
250 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
252 IStream* stream;
253 HRESULT hr;
254 INT size;
255 LARGE_INTEGER move;
256 GpStatus stat = GenericError;
258 TRACE("%p, %p\n", image, cloneImage);
260 if (!image || !cloneImage)
261 return InvalidParameter;
263 hr = CreateStreamOnHGlobal(0, TRUE, &stream);
264 if (FAILED(hr))
265 return GenericError;
267 hr = IPicture_SaveAsFile(image->picture, stream, FALSE, &size);
268 if(FAILED(hr))
270 WARN("Failed to save image on stream\n");
271 goto out;
274 /* Set seek pointer back to the beginning of the picture */
275 move.QuadPart = 0;
276 hr = IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
277 if (FAILED(hr))
278 goto out;
280 stat = GdipLoadImageFromStream(stream, cloneImage);
281 if (stat != Ok) WARN("Failed to load image from stream\n");
283 out:
284 IStream_Release(stream);
285 return stat;
288 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
289 GpBitmap **bitmap)
291 GpStatus stat;
292 IStream *stream;
294 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
296 if(!filename || !bitmap)
297 return InvalidParameter;
299 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
301 if(stat != Ok)
302 return stat;
304 stat = GdipCreateBitmapFromStream(stream, bitmap);
306 IStream_Release(stream);
308 return stat;
311 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
312 VOID *bits, GpBitmap **bitmap)
314 DWORD height, stride;
315 PixelFormat format;
317 FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
319 height = abs(info->bmiHeader.biHeight);
320 stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
322 if(info->bmiHeader.biHeight > 0) /* bottom-up */
324 bits = (BYTE*)bits + (height - 1) * stride;
325 stride = -stride;
328 switch(info->bmiHeader.biBitCount) {
329 case 1:
330 format = PixelFormat1bppIndexed;
331 break;
332 case 4:
333 format = PixelFormat4bppIndexed;
334 break;
335 case 8:
336 format = PixelFormat8bppIndexed;
337 break;
338 case 24:
339 format = PixelFormat24bppRGB;
340 break;
341 default:
342 FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
343 *bitmap = NULL;
344 return InvalidParameter;
347 return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
348 bits, bitmap);
352 /* FIXME: no icm */
353 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
354 GpBitmap **bitmap)
356 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
358 return GdipCreateBitmapFromFile(filename, bitmap);
361 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
362 GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
364 HBITMAP hbm;
365 GpStatus stat = InvalidParameter;
367 TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
369 if(!lpBitmapName || !bitmap)
370 return InvalidParameter;
372 /* load DIB */
373 hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
374 LR_CREATEDIBSECTION);
376 if(hbm){
377 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
378 DeleteObject(hbm);
381 return stat;
384 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
385 HBITMAP* hbmReturn, ARGB background)
387 FIXME("stub\n");
389 hbmReturn = NULL;
391 return NotImplemented;
394 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
395 GpMetafile* metafile, BOOL* succ, EmfType emfType,
396 const WCHAR* description, GpMetafile** out_metafile)
398 static int calls;
400 if(!ref || !metafile || !out_metafile)
401 return InvalidParameter;
403 *succ = FALSE;
404 *out_metafile = NULL;
406 if(!(calls++))
407 FIXME("not implemented\n");
409 return NotImplemented;
412 /* FIXME: this should create a bitmap in the given size with the attributes
413 * (resolution etc.) of the graphics object */
414 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
415 GpGraphics* target, GpBitmap** bitmap)
417 static int calls;
418 GpStatus ret;
420 if(!target || !bitmap)
421 return InvalidParameter;
423 if(!(calls++))
424 FIXME("hacked stub\n");
426 ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat24bppRGB,
427 NULL, bitmap);
429 return ret;
432 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
433 PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
435 BITMAPFILEHEADER *bmfh;
436 BITMAPINFOHEADER *bmih;
437 BYTE *buff;
438 INT datalen, size;
439 IStream *stream;
441 TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
443 if (!bitmap) return InvalidParameter;
445 if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
446 *bitmap = NULL;
447 return InvalidParameter;
450 if(scan0 && !stride)
451 return InvalidParameter;
453 /* FIXME: windows allows negative stride (reads backwards from scan0) */
454 if(stride < 0){
455 FIXME("negative stride\n");
456 return InvalidParameter;
459 *bitmap = GdipAlloc(sizeof(GpBitmap));
460 if(!*bitmap) return OutOfMemory;
462 if(stride == 0){
463 stride = width * (PIXELFORMATBPP(format) / 8);
464 stride = (stride + 3) & ~3;
467 datalen = abs(stride * height);
468 size = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + datalen;
469 buff = GdipAlloc(size);
470 if(!buff){
471 GdipFree(*bitmap);
472 return OutOfMemory;
475 bmfh = (BITMAPFILEHEADER*) buff;
476 bmih = (BITMAPINFOHEADER*) (bmfh + 1);
478 bmfh->bfType = (((WORD)'M') << 8) + (WORD)'B';
479 bmfh->bfSize = size;
480 bmfh->bfOffBits = size - datalen;
482 bmih->biSize = sizeof(BITMAPINFOHEADER);
483 bmih->biWidth = width;
484 bmih->biHeight = -height;
485 /* FIXME: use the rest of the data from format */
486 bmih->biBitCount = PIXELFORMATBPP(format);
487 bmih->biCompression = BI_RGB;
488 bmih->biSizeImage = datalen;
490 if(scan0)
491 memcpy(bmih + 1, scan0, datalen);
492 else
493 memset(bmih + 1, 0, datalen);
495 if(CreateStreamOnHGlobal(buff, TRUE, &stream) != S_OK){
496 ERR("could not make stream\n");
497 GdipFree(*bitmap);
498 GdipFree(buff);
499 return GenericError;
502 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
503 (LPVOID*) &((*bitmap)->image.picture)) != S_OK){
504 TRACE("Could not load picture\n");
505 IStream_Release(stream);
506 GdipFree(*bitmap);
507 GdipFree(buff);
508 return GenericError;
511 (*bitmap)->image.type = ImageTypeBitmap;
512 (*bitmap)->image.flags = ImageFlagsNone;
513 (*bitmap)->width = width;
514 (*bitmap)->height = height;
515 (*bitmap)->format = format;
517 return Ok;
520 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
521 GpBitmap **bitmap)
523 GpStatus stat;
525 TRACE("%p %p\n", stream, bitmap);
527 stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
529 if(stat != Ok)
530 return stat;
532 if((*bitmap)->image.type != ImageTypeBitmap){
533 IPicture_Release((*bitmap)->image.picture);
534 GdipFree(bitmap);
535 return GenericError; /* FIXME: what error to return? */
538 return Ok;
541 /* FIXME: no icm */
542 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
543 GpBitmap **bitmap)
545 TRACE("%p %p\n", stream, bitmap);
547 return GdipCreateBitmapFromStream(stream, bitmap);
550 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
551 GpCachedBitmap **cachedbmp)
553 GpStatus stat;
555 TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
557 if(!bitmap || !graphics || !cachedbmp)
558 return InvalidParameter;
560 *cachedbmp = GdipAlloc(sizeof(GpCachedBitmap));
561 if(!*cachedbmp)
562 return OutOfMemory;
564 stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
565 if(stat != Ok){
566 GdipFree(*cachedbmp);
567 return stat;
570 return Ok;
573 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
575 TRACE("%p\n", cachedbmp);
577 if(!cachedbmp)
578 return InvalidParameter;
580 GdipDisposeImage(cachedbmp->image);
581 GdipFree(cachedbmp);
583 return Ok;
586 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
587 GpCachedBitmap *cachedbmp, INT x, INT y)
589 TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
591 if(!graphics || !cachedbmp)
592 return InvalidParameter;
594 return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
597 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
599 HDC hdc;
601 TRACE("%p\n", image);
603 if(!image)
604 return InvalidParameter;
606 IPicture_get_CurDC(image->picture, &hdc);
607 DeleteDC(hdc);
608 IPicture_Release(image->picture);
609 if (image->type == ImageTypeBitmap)
610 GdipFree(((GpBitmap*)image)->bitmapbits);
611 GdipFree(image);
613 return Ok;
616 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
618 if(!image || !item)
619 return InvalidParameter;
621 return NotImplemented;
624 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
625 GpUnit *srcUnit)
627 TRACE("%p %p %p\n", image, srcRect, srcUnit);
629 if(!image || !srcRect || !srcUnit)
630 return InvalidParameter;
631 if(image->type == ImageTypeMetafile){
632 *srcRect = ((GpMetafile*)image)->bounds;
633 *srcUnit = ((GpMetafile*)image)->unit;
635 else if(image->type == ImageTypeBitmap){
636 srcRect->X = srcRect->Y = 0.0;
637 srcRect->Width = (REAL) ((GpBitmap*)image)->width;
638 srcRect->Height = (REAL) ((GpBitmap*)image)->height;
639 *srcUnit = UnitPixel;
641 else{
642 srcRect->X = srcRect->Y = 0.0;
643 srcRect->Width = ipicture_pixel_width(image->picture);
644 srcRect->Height = ipicture_pixel_height(image->picture);
645 *srcUnit = UnitPixel;
648 TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
649 srcRect->Width, srcRect->Height, *srcUnit);
651 return Ok;
654 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
655 REAL *height)
657 TRACE("%p %p %p\n", image, width, height);
659 if(!image || !height || !width)
660 return InvalidParameter;
662 if(image->type == ImageTypeMetafile){
663 HDC hdc = GetDC(0);
665 *height = convert_unit(hdc, ((GpMetafile*)image)->unit) *
666 ((GpMetafile*)image)->bounds.Height;
668 *width = convert_unit(hdc, ((GpMetafile*)image)->unit) *
669 ((GpMetafile*)image)->bounds.Width;
671 ReleaseDC(0, hdc);
674 else if(image->type == ImageTypeBitmap){
675 *height = ((GpBitmap*)image)->height;
676 *width = ((GpBitmap*)image)->width;
678 else{
679 *height = ipicture_pixel_height(image->picture);
680 *width = ipicture_pixel_width(image->picture);
683 TRACE("returning (%f, %f)\n", *height, *width);
684 return Ok;
687 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
688 GpGraphics **graphics)
690 HDC hdc;
692 TRACE("%p %p\n", image, graphics);
694 if(!image || !graphics)
695 return InvalidParameter;
697 if(image->type != ImageTypeBitmap){
698 FIXME("not implemented for image type %d\n", image->type);
699 return NotImplemented;
702 IPicture_get_CurDC(image->picture, &hdc);
704 if(!hdc){
705 hdc = CreateCompatibleDC(0);
706 IPicture_SelectPicture(image->picture, hdc, NULL, NULL);
709 return GdipCreateFromHDC(hdc, graphics);
712 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
714 TRACE("%p %p\n", image, height);
716 if(!image || !height)
717 return InvalidParameter;
719 if(image->type == ImageTypeMetafile){
720 HDC hdc = GetDC(0);
722 *height = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
723 ((GpMetafile*)image)->bounds.Height);
725 ReleaseDC(0, hdc);
727 else if(image->type == ImageTypeBitmap)
728 *height = ((GpBitmap*)image)->height;
729 else
730 *height = ipicture_pixel_height(image->picture);
732 TRACE("returning %d\n", *height);
734 return Ok;
737 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
739 static int calls;
741 if(!image || !res)
742 return InvalidParameter;
744 if(!(calls++))
745 FIXME("not implemented\n");
747 return NotImplemented;
750 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
752 FIXME("%p %p\n", image, size);
754 if(!image || !size)
755 return InvalidParameter;
757 return NotImplemented;
760 /* FIXME: test this function for non-bitmap types */
761 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
763 TRACE("%p %p\n", image, format);
765 if(!image || !format)
766 return InvalidParameter;
768 if(image->type != ImageTypeBitmap)
769 *format = PixelFormat24bppRGB;
770 else
771 *format = ((GpBitmap*) image)->format;
773 return Ok;
776 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
778 static int calls;
780 if(!image || !format)
781 return InvalidParameter;
783 if(!(calls++))
784 FIXME("stub\n");
786 /* FIXME: should be detected from embedded picture or stored separately */
787 switch (image->type)
789 case ImageTypeBitmap: *format = ImageFormatBMP; break;
790 case ImageTypeMetafile: *format = ImageFormatEMF; break;
791 default:
792 WARN("unknown type %u\n", image->type);
793 *format = ImageFormatUndefined;
795 return Ok;
798 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
800 TRACE("%p %p\n", image, type);
802 if(!image || !type)
803 return InvalidParameter;
805 *type = image->type;
807 return Ok;
810 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
812 static int calls;
814 if(!image || !res)
815 return InvalidParameter;
817 if(!(calls++))
818 FIXME("not implemented\n");
820 return NotImplemented;
823 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
825 TRACE("%p %p\n", image, width);
827 if(!image || !width)
828 return InvalidParameter;
830 if(image->type == ImageTypeMetafile){
831 HDC hdc = GetDC(0);
833 *width = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
834 ((GpMetafile*)image)->bounds.Width);
836 ReleaseDC(0, hdc);
838 else if(image->type == ImageTypeBitmap)
839 *width = ((GpBitmap*)image)->width;
840 else
841 *width = ipicture_pixel_width(image->picture);
843 TRACE("returning %d\n", *width);
845 return Ok;
848 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
849 MetafileHeader * header)
851 static int calls;
853 if(!metafile || !header)
854 return InvalidParameter;
856 if(!(calls++))
857 FIXME("not implemented\n");
859 return Ok;
862 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
863 UINT num, PropertyItem* items)
865 static int calls;
867 if(!(calls++))
868 FIXME("not implemented\n");
870 return InvalidParameter;
873 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT* num)
875 static int calls;
877 if(!(calls++))
878 FIXME("not implemented\n");
880 return InvalidParameter;
883 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID* list)
885 static int calls;
887 if(!(calls++))
888 FIXME("not implemented\n");
890 return InvalidParameter;
893 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID id, UINT size,
894 PropertyItem* buffer)
896 static int calls;
898 if(!(calls++))
899 FIXME("not implemented\n");
901 return InvalidParameter;
904 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
905 UINT* size)
907 static int calls;
909 TRACE("%p %x %p\n", image, pid, size);
911 if(!size || !image)
912 return InvalidParameter;
914 if(!(calls++))
915 FIXME("not implemented\n");
917 return NotImplemented;
920 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT* size, UINT* num)
922 static int calls;
924 if(!(calls++))
925 FIXME("not implemented\n");
927 return InvalidParameter;
930 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
931 GDIPCONST GUID* dimensionID, UINT* count)
933 static int calls;
935 if(!image || !dimensionID || !count)
936 return InvalidParameter;
938 if(!(calls++))
939 FIXME("not implemented\n");
941 return NotImplemented;
944 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
945 UINT* count)
947 if(!image || !count)
948 return InvalidParameter;
950 *count = 1;
952 FIXME("stub\n");
954 return Ok;
957 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
958 GUID* dimensionIDs, UINT count)
960 static int calls;
962 if(!image || !dimensionIDs)
963 return InvalidParameter;
965 if(!(calls++))
966 FIXME("not implemented\n");
968 return Ok;
971 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image,
972 GDIPCONST GUID* dimensionID, UINT frameidx)
974 static int calls;
976 if(!image || !dimensionID)
977 return InvalidParameter;
979 if(!(calls++))
980 FIXME("not implemented\n");
982 return Ok;
985 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
986 GpImage **image)
988 GpStatus stat;
989 IStream *stream;
991 TRACE("(%s) %p\n", debugstr_w(filename), image);
993 if (!filename || !image)
994 return InvalidParameter;
996 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
998 if (stat != Ok)
999 return stat;
1001 stat = GdipLoadImageFromStream(stream, image);
1003 IStream_Release(stream);
1005 return stat;
1008 /* FIXME: no icm handling */
1009 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
1011 TRACE("(%s) %p\n", debugstr_w(filename), image);
1013 return GdipLoadImageFromFile(filename, image);
1016 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
1018 IPicture *pic;
1019 short type;
1021 TRACE("%p %p\n", stream, image);
1023 if(!stream || !image)
1024 return InvalidParameter;
1026 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1027 (LPVOID*) &pic) != S_OK){
1028 TRACE("Could not load picture\n");
1029 return GenericError;
1032 IPicture_get_Type(pic, &type);
1034 if(type == PICTYPE_BITMAP){
1035 BITMAPINFO *pbmi;
1036 BITMAPCOREHEADER* bmch;
1037 HBITMAP hbm;
1038 HDC hdc;
1040 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1041 if (!pbmi)
1042 return OutOfMemory;
1043 *image = GdipAlloc(sizeof(GpBitmap));
1044 if(!*image){
1045 GdipFree(pbmi);
1046 return OutOfMemory;
1048 (*image)->type = ImageTypeBitmap;
1050 (*((GpBitmap**) image))->width = ipicture_pixel_width(pic);
1051 (*((GpBitmap**) image))->height = ipicture_pixel_height(pic);
1053 /* get the pixel format */
1054 IPicture_get_Handle(pic, (OLE_HANDLE*)&hbm);
1055 IPicture_get_CurDC(pic, &hdc);
1057 bmch = (BITMAPCOREHEADER*) (&pbmi->bmiHeader);
1058 bmch->bcSize = sizeof(BITMAPCOREHEADER);
1060 if(!hdc){
1061 HBITMAP old;
1062 hdc = CreateCompatibleDC(0);
1063 old = SelectObject(hdc, hbm);
1064 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
1065 SelectObject(hdc, old);
1066 DeleteDC(hdc);
1068 else
1069 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
1071 switch(bmch->bcBitCount)
1073 case 1:
1074 (*((GpBitmap**) image))->format = PixelFormat1bppIndexed;
1075 break;
1076 case 4:
1077 (*((GpBitmap**) image))->format = PixelFormat4bppIndexed;
1078 break;
1079 case 8:
1080 (*((GpBitmap**) image))->format = PixelFormat8bppIndexed;
1081 break;
1082 case 16:
1083 (*((GpBitmap**) image))->format = PixelFormat16bppRGB565;
1084 break;
1085 case 24:
1086 (*((GpBitmap**) image))->format = PixelFormat24bppRGB;
1087 break;
1088 case 32:
1089 (*((GpBitmap**) image))->format = PixelFormat32bppRGB;
1090 break;
1091 case 48:
1092 (*((GpBitmap**) image))->format = PixelFormat48bppRGB;
1093 break;
1094 default:
1095 FIXME("Bit depth %d is not fully supported yet\n", bmch->bcBitCount);
1096 (*((GpBitmap**) image))->format = (bmch->bcBitCount << 8) | PixelFormatGDI;
1097 break;
1100 GdipFree(pbmi);
1102 else if(type == PICTYPE_METAFILE || type == PICTYPE_ENHMETAFILE){
1103 /* FIXME: missing initialization code */
1104 *image = GdipAlloc(sizeof(GpMetafile));
1105 if(!*image) return OutOfMemory;
1106 (*image)->type = ImageTypeMetafile;
1108 else{
1109 *image = GdipAlloc(sizeof(GpImage));
1110 if(!*image) return OutOfMemory;
1111 (*image)->type = ImageTypeUnknown;
1114 (*image)->picture = pic;
1115 (*image)->flags = ImageFlagsNone;
1117 return Ok;
1120 /* FIXME: no ICM */
1121 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
1123 TRACE("%p %p\n", stream, image);
1125 return GdipLoadImageFromStream(stream, image);
1128 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
1130 static int calls;
1132 if(!image)
1133 return InvalidParameter;
1135 if(!(calls++))
1136 FIXME("not implemented\n");
1138 return NotImplemented;
1141 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
1143 static int calls;
1145 if(!(calls++))
1146 FIXME("not implemented\n");
1148 return NotImplemented;
1151 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
1152 GDIPCONST CLSID *clsidEncoder,
1153 GDIPCONST EncoderParameters *encoderParams)
1155 GpStatus stat;
1156 IStream *stream;
1158 TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
1160 if (!image || !filename|| !clsidEncoder)
1161 return InvalidParameter;
1163 if (!(image->picture))
1164 return InvalidParameter;
1166 stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
1167 if (stat != Ok)
1168 return GenericError;
1170 stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
1172 IStream_Release(stream);
1173 return stat;
1176 /*************************************************************************
1177 * Encoding functions -
1178 * These functions encode an image in different image file formats.
1180 #define BITMAP_FORMAT_BMP 0x4d42 /* "BM" */
1181 #define BITMAP_FORMAT_JPEG 0xd8ff
1182 #define BITMAP_FORMAT_GIF 0x4947
1183 #define BITMAP_FORMAT_PNG 0x5089
1184 #define BITMAP_FORMAT_APM 0xcdd7
1186 static GpStatus encode_image_BMP(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
1187 void **output, unsigned int *output_size)
1189 int num_palette_entries;
1190 BITMAPFILEHEADER *bmp_file_hdr;
1191 BITMAPINFO *bmp_info_hdr;
1193 if (bitmap_info->bmiHeader.biClrUsed) {
1194 num_palette_entries = bitmap_info->bmiHeader.biClrUsed;
1195 if (num_palette_entries > 256) num_palette_entries = 256;
1196 } else {
1197 if (bitmap_info->bmiHeader.biBitCount <= 8)
1198 num_palette_entries = 1 << bitmap_info->bmiHeader.biBitCount;
1199 else
1200 num_palette_entries = 0;
1203 *output_size =
1204 sizeof(BITMAPFILEHEADER) +
1205 sizeof(BITMAPINFOHEADER) +
1206 num_palette_entries * sizeof(RGBQUAD) +
1207 bitmap_info->bmiHeader.biSizeImage;
1209 *output = GdipAlloc(*output_size);
1211 bmp_file_hdr = *output;
1212 bmp_file_hdr->bfType = BITMAP_FORMAT_BMP;
1213 bmp_file_hdr->bfSize = *output_size;
1214 bmp_file_hdr->bfOffBits =
1215 sizeof(BITMAPFILEHEADER) +
1216 sizeof(BITMAPINFOHEADER) +
1217 num_palette_entries * sizeof (RGBQUAD);
1219 bmp_info_hdr = (BITMAPINFO*) ((unsigned char*)(*output) + sizeof(BITMAPFILEHEADER));
1220 memcpy(bmp_info_hdr, bitmap_info, sizeof(BITMAPINFOHEADER) + num_palette_entries * sizeof(RGBQUAD));
1221 memcpy((unsigned char *)(*output) +
1222 sizeof(BITMAPFILEHEADER) +
1223 sizeof(BITMAPINFOHEADER) +
1224 num_palette_entries * sizeof(RGBQUAD),
1225 bitmap_bits, bitmap_info->bmiHeader.biSizeImage);
1227 return Ok;
1230 typedef GpStatus encode_image_func(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
1231 void **output, unsigned int *output_size);
1233 typedef enum {
1234 BMP,
1235 NUM_ENCODERS_SUPPORTED
1236 } ImageFormat;
1238 static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED];
1239 static encode_image_func *const encode_image_funcs[NUM_ENCODERS_SUPPORTED] = {
1240 encode_image_BMP,
1243 /*****************************************************************************
1244 * GdipSaveImageToStream [GDIPLUS.@]
1246 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
1247 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
1249 GpStatus stat;
1250 HRESULT hr;
1251 short type;
1252 HBITMAP hbmp;
1253 HBITMAP old_hbmp;
1254 HDC hdc;
1255 int bm_is_selected;
1256 BITMAPINFO bmp_info;
1257 LPVOID bmp_bits;
1258 encode_image_func* encode_image;
1259 LPVOID output;
1260 unsigned int output_size;
1261 unsigned int dummy;
1262 int i;
1264 old_hbmp = 0;
1265 output = NULL;
1266 output_size = 0;
1268 TRACE("%p %p %p %p\n", image, stream, clsid, params);
1270 if(!image || !stream)
1271 return InvalidParameter;
1273 if (!image->picture)
1274 return GenericError;
1276 hr = IPicture_get_Type(image->picture, &type);
1277 if (FAILED(hr) || type != PICTYPE_BITMAP)
1278 return GenericError;
1280 /* select correct encoder */
1281 encode_image = NULL;
1282 for (i = 0; i < NUM_ENCODERS_SUPPORTED; i++) {
1283 if (IsEqualCLSID(clsid, &codecs[i].Clsid))
1284 encode_image = encode_image_funcs[i];
1286 if (encode_image == NULL)
1287 return UnknownImageFormat;
1289 /* extract underlying hbitmap representation from the IPicture */
1290 hr = IPicture_get_Handle(image->picture, (OLE_HANDLE*)&hbmp);
1291 if (FAILED(hr) || !hbmp)
1292 return GenericError;
1293 hr = IPicture_get_CurDC(image->picture, &hdc);
1294 if (FAILED(hr))
1295 return GenericError;
1296 bm_is_selected = (hdc != 0);
1297 if (!bm_is_selected) {
1298 hdc = CreateCompatibleDC(0);
1299 old_hbmp = SelectObject(hdc, hbmp);
1302 /* get bits from HBITMAP */
1303 bmp_info.bmiHeader.biSize = sizeof(bmp_info.bmiHeader);
1304 bmp_info.bmiHeader.biBitCount = 0;
1305 GetDIBits(hdc, hbmp, 0, 0, NULL, &bmp_info, DIB_RGB_COLORS);
1307 bmp_bits = GdipAlloc(bmp_info.bmiHeader.biSizeImage);
1309 if (bmp_bits)
1310 GetDIBits(hdc, hbmp, 0, abs(bmp_info.bmiHeader.biHeight), bmp_bits, &bmp_info, DIB_RGB_COLORS);
1312 if (!bm_is_selected) {
1313 SelectObject(hdc, old_hbmp);
1314 DeleteDC(hdc);
1317 if (!bmp_bits)
1318 return OutOfMemory;
1320 stat = encode_image(bmp_bits, &bmp_info, &output, &output_size);
1321 if (stat == Ok)
1322 IStream_Write(stream, output, output_size, &dummy);
1324 GdipFree(output);
1325 GdipFree(bmp_bits);
1327 return stat;
1330 /*****************************************************************************
1331 * GdipSetImagePalette [GDIPLUS.@]
1333 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
1334 GDIPCONST ColorPalette *palette)
1336 static int calls;
1338 if(!image || !palette)
1339 return InvalidParameter;
1341 if(!(calls++))
1342 FIXME("not implemented\n");
1344 return NotImplemented;
1347 /*************************************************************************
1348 * Encoders -
1349 * Structures that represent which formats we support for encoding.
1352 /* ImageCodecInfo creation routines taken from libgdiplus */
1353 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
1354 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
1355 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
1356 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
1357 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
1358 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
1360 static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED] =
1362 { /* BMP */
1363 /* Clsid */ { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
1364 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
1365 /* CodecName */ bmp_codecname,
1366 /* DllName */ NULL,
1367 /* FormatDescription */ bmp_format,
1368 /* FilenameExtension */ bmp_extension,
1369 /* MimeType */ bmp_mimetype,
1370 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
1371 /* Version */ 1,
1372 /* SigCount */ 1,
1373 /* SigSize */ 2,
1374 /* SigPattern */ bmp_sig_pattern,
1375 /* SigMask */ bmp_sig_mask,
1379 /*****************************************************************************
1380 * GdipGetImageDecodersSize [GDIPLUS.@]
1382 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
1384 FIXME("%p %p stub!\n", numDecoders, size);
1386 if (!numDecoders || !size)
1387 return InvalidParameter;
1389 *numDecoders = 0;
1390 *size = 0;
1392 return Ok;
1395 /*****************************************************************************
1396 * GdipGetImageDecoders [GDIPLUS.@]
1398 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
1400 FIXME("%u %u %p stub!\n", numDecoders, size, decoders);
1402 if (!decoders)
1403 return GenericError;
1405 return NotImplemented;
1408 /*****************************************************************************
1409 * GdipGetImageEncodersSize [GDIPLUS.@]
1411 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
1413 TRACE("%p %p\n", numEncoders, size);
1415 if (!numEncoders || !size)
1416 return InvalidParameter;
1418 *numEncoders = NUM_ENCODERS_SUPPORTED;
1419 *size = sizeof (codecs);
1421 return Ok;
1424 /*****************************************************************************
1425 * GdipGetImageEncoders [GDIPLUS.@]
1427 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
1429 TRACE("%u %u %p\n", numEncoders, size, encoders);
1431 if (!encoders ||
1432 (numEncoders != NUM_ENCODERS_SUPPORTED) ||
1433 (size != sizeof (codecs)))
1434 return GenericError;
1436 memcpy(encoders, codecs, sizeof (codecs));
1438 return Ok;
1441 /*****************************************************************************
1442 * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
1444 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
1446 BITMAP bm;
1447 GpStatus retval;
1448 PixelFormat format;
1450 TRACE("%p %p %p\n", hbm, hpal, bitmap);
1452 if(!hbm || !bitmap)
1453 return InvalidParameter;
1455 /* TODO: Support for device-dependent bitmaps */
1456 if(hpal){
1457 FIXME("no support for device-dependent bitmaps\n");
1458 return NotImplemented;
1461 if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
1462 return InvalidParameter;
1464 /* TODO: Figure out the correct format for 16, 32, 64 bpp */
1465 switch(bm.bmBitsPixel) {
1466 case 1:
1467 format = PixelFormat1bppIndexed;
1468 break;
1469 case 4:
1470 format = PixelFormat4bppIndexed;
1471 break;
1472 case 8:
1473 format = PixelFormat8bppIndexed;
1474 break;
1475 case 24:
1476 format = PixelFormat24bppRGB;
1477 break;
1478 case 32:
1479 format = PixelFormat32bppRGB;
1480 break;
1481 case 48:
1482 format = PixelFormat48bppRGB;
1483 break;
1484 default:
1485 FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
1486 return InvalidParameter;
1489 retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes,
1490 format, bm.bmBits, bitmap);
1492 return retval;
1495 /*****************************************************************************
1496 * GdipSetEffectParameters [GDIPLUS.@]
1498 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
1499 const VOID *params, const UINT size)
1501 static int calls;
1503 if(!(calls++))
1504 FIXME("not implemented\n");
1506 return NotImplemented;
1509 /*****************************************************************************
1510 * GdipGetImageFlags [GDIPLUS.@]
1512 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
1514 TRACE("%p %p\n", image, flags);
1516 if(!image || !flags)
1517 return InvalidParameter;
1519 *flags = image->flags;
1521 return Ok;
1524 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
1526 TRACE("(%d, %p)\n", control, param);
1528 switch(control){
1529 case TestControlForceBilinear:
1530 if(param)
1531 FIXME("TestControlForceBilinear not handled\n");
1532 break;
1533 case TestControlNoICM:
1534 if(param)
1535 FIXME("TestControlNoICM not handled\n");
1536 break;
1537 case TestControlGetBuildNumber:
1538 *((DWORD*)param) = 3102;
1539 break;
1542 return Ok;
1545 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
1546 HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
1547 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
1548 GpMetafile **metafile)
1550 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
1551 frameUnit, debugstr_w(desc), metafile);
1553 return NotImplemented;
1556 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
1557 GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
1558 GDIPCONST WCHAR *desc, GpMetafile **metafile)
1560 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
1561 frameUnit, debugstr_w(desc), metafile);
1563 return NotImplemented;
1566 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
1568 FIXME("%p\n", image);
1570 return Ok;