?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shlwapi: Use proper helpers for iface calls.
[wine/multimedia.git] / dlls / oleaut32 / olepicture.c
blobdb3b85273868efeccce83fb6819775ae1d003f94
1 /*
2 * OLE Picture object
3 *
4 * Implementation of OLE IPicture and related interfaces
5 *
6 * Copyright 2000 Huw D M Davies for CodeWeavers.
7 * Copyright 2001 Marcus Meissner
8 * Copyright 2008 Kirill K. Smirnov
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 *
24 * BUGS
25 *
26 * Support PICTYPE_BITMAP and PICTYPE_ICON, although only bitmaps very well..
27 * Lots of methods are just stubs.
28 *
29 *
30 * NOTES (or things that msdn doesn't tell you)
31 *
32 * The width and height properties are returned in HIMETRIC units (0.01mm)
33 * IPicture::Render also uses these to select a region of the src picture.
34 * A bitmap's size is converted into these units by using the screen resolution
35 * thus an 8x8 bitmap on a 96dpi screen has a size of 212x212 (8/96 * 2540).
36 *
37 */
38
39 #include "config.h"
40 #include "wine/port.h"
41
42 #ifdef HAVE_UNISTD_H
43 # include <unistd.h>
44 #endif
45 #include <stdarg.h>
46 #include <stdio.h>
47 #include <string.h>
48
49 #define COBJMACROS
50 #define NONAMELESSUNION
51 #define NONAMELESSSTRUCT
52
53 #include "winerror.h"
54 #include "windef.h"
55 #include "winbase.h"
56 #include "wingdi.h"
57 #include "winuser.h"
58 #include "ole2.h"
59 #include "olectl.h"
60 #include "oleauto.h"
61 #include "connpt.h"
62 #include "urlmon.h"
63 #include "initguid.h"
64 #include "wincodec.h"
65 #include "wine/debug.h"
66 #include "wine/unicode.h"
67 #include "wine/library.h"
68
69 WINE_DEFAULT_DEBUG_CHANNEL(olepicture);
70
71 #define BITMAP_FORMAT_BMP 0x4d42 /* "BM" */
72 #define BITMAP_FORMAT_JPEG 0xd8ff
73 #define BITMAP_FORMAT_GIF 0x4947
74 #define BITMAP_FORMAT_PNG 0x5089
75 #define BITMAP_FORMAT_APM 0xcdd7
76
77 #include "pshpack1.h"
78
79 /* Header for Aldus Placable Metafiles - a standard metafile follows */
80 typedef struct _APM_HEADER
81 {
82 DWORD key;
83 WORD handle;
84 SHORT left;
85 SHORT top;
86 SHORT right;
87 SHORT bottom;
88 WORD inch;
89 DWORD reserved;
90 WORD checksum;
91 } APM_HEADER;
92
93 typedef struct {
94 BYTE bWidth;
95 BYTE bHeight;
96 BYTE bColorCount;
97 BYTE bReserved;
98 WORD xHotspot;
99 WORD yHotspot;
100 DWORD dwDIBSize;
101 DWORD dwDIBOffset;
102 } CURSORICONFILEDIRENTRY;
103
104 typedef struct
105 {
106 WORD idReserved;
107 WORD idType;
108 WORD idCount;
109 CURSORICONFILEDIRENTRY idEntries[1];
110 } CURSORICONFILEDIR;
111
112 #include "poppack.h"
113
114 /*************************************************************************
115 * Declaration of implementation class
116 */
117
118 typedef struct OLEPictureImpl {
119
120 /*
121 * IPicture handles IUnknown
122 */
123
124 IPicture IPicture_iface;
125 IDispatch IDispatch_iface;
126 IPersistStream IPersistStream_iface;
127 IConnectionPointContainer IConnectionPointContainer_iface;
128
129 /* Object reference count */
130 LONG ref;
131
132 /* We own the object and must destroy it ourselves */
133 BOOL fOwn;
134
135 /* Picture description */
136 PICTDESC desc;
137
138 /* These are the pixel size of a bitmap */
139 DWORD origWidth;
140 DWORD origHeight;
141
142 /* And these are the size of the picture converted into HIMETRIC units */
143 OLE_XSIZE_HIMETRIC himetricWidth;
144 OLE_YSIZE_HIMETRIC himetricHeight;
145
146 IConnectionPoint *pCP;
147
148 BOOL keepOrigFormat;
149 HDC hDCCur;
150 HBITMAP stock_bitmap;
151
152 /* Bitmap transparency mask */
153 HBITMAP hbmMask;
154 HBITMAP hbmXor;
155 COLORREF rgbTrans;
156
157 /* data */
158 void* data;
159 int datalen;
160 BOOL bIsDirty; /* Set to TRUE if picture has changed */
161 unsigned int loadtime_magic; /* If a length header was found, saves value */
162 unsigned int loadtime_format; /* for PICTYPE_BITMAP only, keeps track of image format (GIF/BMP/JPEG) */
163 } OLEPictureImpl;
164
165 static inline OLEPictureImpl *impl_from_IPicture(IPicture *iface)
166 {
167 return CONTAINING_RECORD(iface, OLEPictureImpl, IPicture_iface);
168 }
169
170 static inline OLEPictureImpl *impl_from_IDispatch( IDispatch *iface )
171 {
172 return CONTAINING_RECORD(iface, OLEPictureImpl, IDispatch_iface);
173 }
174
175 static inline OLEPictureImpl *impl_from_IPersistStream( IPersistStream *iface )
176 {
177 return CONTAINING_RECORD(iface, OLEPictureImpl, IPersistStream_iface);
178 }
179
180 static inline OLEPictureImpl *impl_from_IConnectionPointContainer( IConnectionPointContainer *iface )
181 {
182 return CONTAINING_RECORD(iface, OLEPictureImpl, IConnectionPointContainer_iface);
183 }
184
185 /*
186 * Predeclare VTables. They get initialized at the end.
187 */
188 static const IPictureVtbl OLEPictureImpl_VTable;
189 static const IDispatchVtbl OLEPictureImpl_IDispatch_VTable;
190 static const IPersistStreamVtbl OLEPictureImpl_IPersistStream_VTable;
191 static const IConnectionPointContainerVtbl OLEPictureImpl_IConnectionPointContainer_VTable;
192
193 /* pixels to HIMETRIC units conversion */
194 static inline OLE_XSIZE_HIMETRIC xpixels_to_himetric(INT pixels, HDC hdc)
195 {
196 return MulDiv(pixels, 2540, GetDeviceCaps(hdc, LOGPIXELSX));
197 }
198
199 static inline OLE_YSIZE_HIMETRIC ypixels_to_himetric(INT pixels, HDC hdc)
200 {
201 return MulDiv(pixels, 2540, GetDeviceCaps(hdc, LOGPIXELSY));
202 }
203
204 /***********************************************************************
205 * Implementation of the OLEPictureImpl class.
206 */
207
208 static void OLEPictureImpl_SetBitmap(OLEPictureImpl *This)
209 {
210 BITMAP bm;
211 HDC hdcRef;
212
213 TRACE("bitmap handle %p\n", This->desc.u.bmp.hbitmap);
214 if(GetObjectW(This->desc.u.bmp.hbitmap, sizeof(bm), &bm) != sizeof(bm)) {
215 ERR("GetObject fails\n");
216 return;
217 }
218 This->origWidth = bm.bmWidth;
219 This->origHeight = bm.bmHeight;
220
221 TRACE("width %d, height %d, bpp %d\n", bm.bmWidth, bm.bmHeight, bm.bmBitsPixel);
222
223 /* The width and height are stored in HIMETRIC units (0.01 mm),
224 so we take our pixel width divide by pixels per inch and
225 multiply by 25.4 * 100 */
226 /* Should we use GetBitmapDimension if available? */
227 hdcRef = CreateCompatibleDC(0);
228
229 This->himetricWidth = xpixels_to_himetric(bm.bmWidth, hdcRef);
230 This->himetricHeight = ypixels_to_himetric(bm.bmHeight, hdcRef);
231 This->stock_bitmap = GetCurrentObject( hdcRef, OBJ_BITMAP );
232
233 This->loadtime_format = BITMAP_FORMAT_BMP;
234
235 DeleteDC(hdcRef);
236 }
237
238 static void OLEPictureImpl_SetIcon(OLEPictureImpl * This)
239 {
240 ICONINFO infoIcon;
241
242 TRACE("icon handle %p\n", This->desc.u.icon.hicon);
243 if (GetIconInfo(This->desc.u.icon.hicon, &infoIcon)) {
244 HDC hdcRef;
245 BITMAP bm;
246
247 TRACE("bitmap handle for icon is %p\n", infoIcon.hbmColor);
248 if(GetObjectW(infoIcon.hbmColor ? infoIcon.hbmColor : infoIcon.hbmMask, sizeof(bm), &bm) != sizeof(bm)) {
249 ERR("GetObject fails on icon bitmap\n");
250 return;
251 }
252
253 This->origWidth = bm.bmWidth;
254 This->origHeight = infoIcon.hbmColor ? bm.bmHeight : bm.bmHeight / 2;
255 /* see comment on HIMETRIC on OLEPictureImpl_SetBitmap() */
256 hdcRef = GetDC(0);
257
258 This->himetricWidth = xpixels_to_himetric(This->origWidth, hdcRef);
259 This->himetricHeight = ypixels_to_himetric(This->origHeight, hdcRef);
260
261 ReleaseDC(0, hdcRef);
262
263 DeleteObject(infoIcon.hbmMask);
264 if (infoIcon.hbmColor) DeleteObject(infoIcon.hbmColor);
265 } else {
266 ERR("GetIconInfo() fails on icon %p\n", This->desc.u.icon.hicon);
267 }
268 }
269
270 /************************************************************************
271 * OLEPictureImpl_Construct
272 *
273 * This method will construct a new instance of the OLEPictureImpl
274 * class.
275 *
276 * The caller of this method must release the object when it's
277 * done with it.
278 */
279 static OLEPictureImpl* OLEPictureImpl_Construct(LPPICTDESC pictDesc, BOOL fOwn)
280 {
281 OLEPictureImpl* newObject = 0;
282
283 if (pictDesc)
284 TRACE("(%p) type = %d\n", pictDesc, pictDesc->picType);
285
286 /*
287 * Allocate space for the object.
288 */
289 newObject = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(OLEPictureImpl));
290
291 if (newObject==0)
292 return newObject;
293
294 /*
295 * Initialize the virtual function table.
296 */
297 newObject->IPicture_iface.lpVtbl = &OLEPictureImpl_VTable;
298 newObject->IDispatch_iface.lpVtbl = &OLEPictureImpl_IDispatch_VTable;
299 newObject->IPersistStream_iface.lpVtbl = &OLEPictureImpl_IPersistStream_VTable;
300 newObject->IConnectionPointContainer_iface.lpVtbl = &OLEPictureImpl_IConnectionPointContainer_VTable;
301
302 newObject->pCP = NULL;
303 CreateConnectionPoint((IUnknown*)newObject,&IID_IPropertyNotifySink,&newObject->pCP);
304 if (!newObject->pCP)
305 {
306 HeapFree(GetProcessHeap(), 0, newObject);
307 return NULL;
308 }
309
310 /*
311 * Start with one reference count. The caller of this function
312 * must release the interface pointer when it is done.
313 */
314 newObject->ref = 1;
315 newObject->hDCCur = 0;
316
317 newObject->fOwn = fOwn;
318
319 /* dunno about original value */
320 newObject->keepOrigFormat = TRUE;
321
322 newObject->hbmMask = NULL;
323 newObject->hbmXor = NULL;
324 newObject->loadtime_magic = 0xdeadbeef;
325 newObject->loadtime_format = 0;
326 newObject->bIsDirty = FALSE;
327
328 if (pictDesc) {
329 newObject->desc = *pictDesc;
330
331 switch(pictDesc->picType) {
332 case PICTYPE_BITMAP:
333 OLEPictureImpl_SetBitmap(newObject);
334 break;
335
336 case PICTYPE_METAFILE:
337 TRACE("metafile handle %p\n", pictDesc->u.wmf.hmeta);
338 newObject->himetricWidth = pictDesc->u.wmf.xExt;
339 newObject->himetricHeight = pictDesc->u.wmf.yExt;
340 break;
341
342 case PICTYPE_NONE:
343 /* not sure what to do here */
344 newObject->himetricWidth = newObject->himetricHeight = 0;
345 break;
346
347 case PICTYPE_ICON:
348 OLEPictureImpl_SetIcon(newObject);
349 break;
350 case PICTYPE_ENHMETAFILE:
351 default:
352 FIXME("Unsupported type %d\n", pictDesc->picType);
353 newObject->himetricWidth = newObject->himetricHeight = 0;
354 break;
355 }
356 } else {
357 newObject->desc.picType = PICTYPE_UNINITIALIZED;
358 }
359
360 TRACE("returning %p\n", newObject);
361 return newObject;
362 }
363
364 /************************************************************************
365 * OLEPictureImpl_Destroy
366 *
367 * This method is called by the Release method when the reference
368 * count goes down to 0. It will free all resources used by
369 * this object. */
370 static void OLEPictureImpl_Destroy(OLEPictureImpl* Obj)
371 {
372 TRACE("(%p)\n", Obj);
373
374 if (Obj->pCP)
375 IConnectionPoint_Release(Obj->pCP);
376
377 if(Obj->fOwn) { /* We need to destroy the picture */
378 switch(Obj->desc.picType) {
379 case PICTYPE_BITMAP:
380 DeleteObject(Obj->desc.u.bmp.hbitmap);
381 if (Obj->hbmMask != NULL) DeleteObject(Obj->hbmMask);
382 if (Obj->hbmXor != NULL) DeleteObject(Obj->hbmXor);
383 break;
384 case PICTYPE_METAFILE:
385 DeleteMetaFile(Obj->desc.u.wmf.hmeta);
386 break;
387 case PICTYPE_ICON:
388 DestroyIcon(Obj->desc.u.icon.hicon);
389 break;
390 case PICTYPE_ENHMETAFILE:
391 DeleteEnhMetaFile(Obj->desc.u.emf.hemf);
392 break;
393 case PICTYPE_NONE:
394 case PICTYPE_UNINITIALIZED:
395 /* Nothing to do */
396 break;
397 default:
398 FIXME("Unsupported type %d - unable to delete\n", Obj->desc.picType);
399 break;
400 }
401 }
402 HeapFree(GetProcessHeap(), 0, Obj->data);
403 HeapFree(GetProcessHeap(), 0, Obj);
404 }
405
406
407 /************************************************************************
408 * OLEPictureImpl_AddRef (IUnknown)
409 *
410 * See Windows documentation for more details on IUnknown methods.
411 */
412 static ULONG WINAPI OLEPictureImpl_AddRef(
413 IPicture* iface)
414 {
415 OLEPictureImpl *This = impl_from_IPicture(iface);
416 ULONG refCount = InterlockedIncrement(&This->ref);
417
418 TRACE("(%p)->(ref before=%d)\n", This, refCount - 1);
419
420 return refCount;
421 }
422
423 /************************************************************************
424 * OLEPictureImpl_Release (IUnknown)
425 *
426 * See Windows documentation for more details on IUnknown methods.
427 */
428 static ULONG WINAPI OLEPictureImpl_Release(
429 IPicture* iface)
430 {
431 OLEPictureImpl *This = impl_from_IPicture(iface);
432 ULONG refCount = InterlockedDecrement(&This->ref);
433
434 TRACE("(%p)->(ref before=%d)\n", This, refCount + 1);
435
436 /*
437 * If the reference count goes down to 0, perform suicide.
438 */
439 if (!refCount) OLEPictureImpl_Destroy(This);
440
441 return refCount;
442 }
443
444 /************************************************************************
445 * OLEPictureImpl_QueryInterface (IUnknown)
446 *
447 * See Windows documentation for more details on IUnknown methods.
448 */
449 static HRESULT WINAPI OLEPictureImpl_QueryInterface(
450 IPicture* iface,
451 REFIID riid,
452 void** ppvObject)
453 {
454 OLEPictureImpl *This = impl_from_IPicture(iface);
455
456 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
457
458 if (!ppvObject)
459 return E_INVALIDARG;
460
461 *ppvObject = 0;
462
463 if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IPicture, riid))
464 *ppvObject = This;
465 else if (IsEqualIID(&IID_IDispatch, riid))
466 *ppvObject = &This->IDispatch_iface;
467 else if (IsEqualIID(&IID_IPictureDisp, riid))
468 *ppvObject = &This->IDispatch_iface;
469 else if (IsEqualIID(&IID_IPersist, riid) || IsEqualIID(&IID_IPersistStream, riid))
470 *ppvObject = &This->IPersistStream_iface;
471 else if (IsEqualIID(&IID_IConnectionPointContainer, riid))
472 *ppvObject = &This->IConnectionPointContainer_iface;
473
474 if (!*ppvObject)
475 {
476 FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid));
477 return E_NOINTERFACE;
478 }
479
480 IPicture_AddRef(iface);
481
482 return S_OK;
483 }
484
485 /***********************************************************************
486 * OLEPicture_SendNotify (internal)
487 *
488 * Sends notification messages of changed properties to any interested
489 * connections.
490 */
491 static void OLEPicture_SendNotify(OLEPictureImpl* this, DISPID dispID)
492 {
493 IEnumConnections *pEnum;
494 CONNECTDATA CD;
495
496 if (IConnectionPoint_EnumConnections(this->pCP, &pEnum) != S_OK)
497 return;
498 while(IEnumConnections_Next(pEnum, 1, &CD, NULL) == S_OK) {
499 IPropertyNotifySink *sink;
500
501 IUnknown_QueryInterface(CD.pUnk, &IID_IPropertyNotifySink, (LPVOID)&sink);
502 IPropertyNotifySink_OnChanged(sink, dispID);
503 IPropertyNotifySink_Release(sink);
504 IUnknown_Release(CD.pUnk);
505 }
506 IEnumConnections_Release(pEnum);
507 }
508
509 /************************************************************************
510 * OLEPictureImpl_get_Handle
511 */
512 static HRESULT WINAPI OLEPictureImpl_get_Handle(IPicture *iface,
513 OLE_HANDLE *phandle)
514 {
515 OLEPictureImpl *This = impl_from_IPicture(iface);
516 TRACE("(%p)->(%p)\n", This, phandle);
517
518 if(!phandle)
519 return E_POINTER;
520
521 switch(This->desc.picType) {
522 case PICTYPE_NONE:
523 case PICTYPE_UNINITIALIZED:
524 *phandle = 0;
525 break;
526 case PICTYPE_BITMAP:
527 *phandle = HandleToUlong(This->desc.u.bmp.hbitmap);
528 break;
529 case PICTYPE_METAFILE:
530 *phandle = HandleToUlong(This->desc.u.wmf.hmeta);
531 break;
532 case PICTYPE_ICON:
533 *phandle = HandleToUlong(This->desc.u.icon.hicon);
534 break;
535 case PICTYPE_ENHMETAFILE:
536 *phandle = HandleToUlong(This->desc.u.emf.hemf);
537 break;
538 default:
539 FIXME("Unimplemented type %d\n", This->desc.picType);
540 return E_NOTIMPL;
541 }
542 TRACE("returning handle %08x\n", *phandle);
543 return S_OK;
544 }
545
546 /************************************************************************
547 * OLEPictureImpl_get_hPal
548 */
549 static HRESULT WINAPI OLEPictureImpl_get_hPal(IPicture *iface,
550 OLE_HANDLE *phandle)
551 {
552 OLEPictureImpl *This = impl_from_IPicture(iface);
553 HRESULT hres;
554 TRACE("(%p)->(%p)\n", This, phandle);
555
556 if (!phandle)
557 return E_POINTER;
558
559 switch (This->desc.picType) {
560 case (UINT)PICTYPE_UNINITIALIZED:
561 case PICTYPE_NONE:
562 *phandle = 0;
563 hres = S_FALSE;
564 break;
565 case PICTYPE_BITMAP:
566 *phandle = HandleToUlong(This->desc.u.bmp.hpal);
567 hres = S_OK;
568 break;
569 case PICTYPE_METAFILE:
570 hres = E_FAIL;
571 break;
572 case PICTYPE_ICON:
573 case PICTYPE_ENHMETAFILE:
574 default:
575 FIXME("unimplemented for type %d. Returning 0 palette.\n",
576 This->desc.picType);
577 *phandle = 0;
578 hres = S_OK;
579 }
580
581 TRACE("returning 0x%08x, palette handle %08x\n", hres, *phandle);
582 return hres;
583 }
584
585 /************************************************************************
586 * OLEPictureImpl_get_Type
587 */
588 static HRESULT WINAPI OLEPictureImpl_get_Type(IPicture *iface,
589 short *ptype)
590 {
591 OLEPictureImpl *This = impl_from_IPicture(iface);
592 TRACE("(%p)->(%p): type is %d\n", This, ptype, This->desc.picType);
593
594 if(!ptype)
595 return E_POINTER;
596
597 *ptype = This->desc.picType;
598 return S_OK;
599 }
600
601 /************************************************************************
602 * OLEPictureImpl_get_Width
603 */
604 static HRESULT WINAPI OLEPictureImpl_get_Width(IPicture *iface,
605 OLE_XSIZE_HIMETRIC *pwidth)
606 {
607 OLEPictureImpl *This = impl_from_IPicture(iface);
608 TRACE("(%p)->(%p): width is %d\n", This, pwidth, This->himetricWidth);
609 *pwidth = This->himetricWidth;
610 return S_OK;
611 }
612
613 /************************************************************************
614 * OLEPictureImpl_get_Height
615 */
616 static HRESULT WINAPI OLEPictureImpl_get_Height(IPicture *iface,
617 OLE_YSIZE_HIMETRIC *pheight)
618 {
619 OLEPictureImpl *This = impl_from_IPicture(iface);
620 TRACE("(%p)->(%p): height is %d\n", This, pheight, This->himetricHeight);
621 *pheight = This->himetricHeight;
622 return S_OK;
623 }
624
625 /************************************************************************
626 * OLEPictureImpl_Render
627 */
628 static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
629 LONG x, LONG y, LONG cx, LONG cy,
630 OLE_XPOS_HIMETRIC xSrc,
631 OLE_YPOS_HIMETRIC ySrc,
632 OLE_XSIZE_HIMETRIC cxSrc,
633 OLE_YSIZE_HIMETRIC cySrc,
634 LPCRECT prcWBounds)
635 {
636 OLEPictureImpl *This = impl_from_IPicture(iface);
637 TRACE("(%p)->(%p, (%d,%d), (%d,%d) <- (%d,%d), (%d,%d), %p)\n",
638 This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, prcWBounds);
639 if(prcWBounds)
640 TRACE("prcWBounds (%d,%d) - (%d,%d)\n", prcWBounds->left, prcWBounds->top,
641 prcWBounds->right, prcWBounds->bottom);
642
643 if(cx == 0 || cy == 0 || cxSrc == 0 || cySrc == 0){
644 return CTL_E_INVALIDPROPERTYVALUE;
645 }
646
647 /*
648 * While the documentation suggests this to be here (or after rendering?)
649 * it does cause an endless recursion in my sample app. -MM 20010804
650 OLEPicture_SendNotify(This,DISPID_PICT_RENDER);
651 */
652
653 switch(This->desc.picType) {
654 case PICTYPE_UNINITIALIZED:
655 case PICTYPE_NONE:
656 /* nothing to do */
657 return S_OK;
658 case PICTYPE_BITMAP:
659 {
660 HBITMAP hbmpOld;
661 HDC hdcBmp;
662
663 /* Set a mapping mode that maps bitmap pixels into HIMETRIC units.
664 NB y-axis gets flipped */
665
666 hdcBmp = CreateCompatibleDC(0);
667 SetMapMode(hdcBmp, MM_ANISOTROPIC);
668 SetWindowOrgEx(hdcBmp, 0, 0, NULL);
669 SetWindowExtEx(hdcBmp, This->himetricWidth, This->himetricHeight, NULL);
670 SetViewportOrgEx(hdcBmp, 0, This->origHeight, NULL);
671 SetViewportExtEx(hdcBmp, This->origWidth, -This->origHeight, NULL);
672
673 if (This->hbmMask) {
674 HDC hdcMask = CreateCompatibleDC(0);
675 HBITMAP hOldbm = SelectObject(hdcMask, This->hbmMask);
676
677 hbmpOld = SelectObject(hdcBmp, This->hbmXor);
678
679 SetMapMode(hdcMask, MM_ANISOTROPIC);
680 SetWindowOrgEx(hdcMask, 0, 0, NULL);
681 SetWindowExtEx(hdcMask, This->himetricWidth, This->himetricHeight, NULL);
682 SetViewportOrgEx(hdcMask, 0, This->origHeight, NULL);
683 SetViewportExtEx(hdcMask, This->origWidth, -This->origHeight, NULL);
684
685 SetBkColor(hdc, RGB(255, 255, 255));
686 SetTextColor(hdc, RGB(0, 0, 0));
687 StretchBlt(hdc, x, y, cx, cy, hdcMask, xSrc, ySrc, cxSrc, cySrc, SRCAND);
688 StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc, cxSrc, cySrc, SRCPAINT);
689
690 SelectObject(hdcMask, hOldbm);
691 DeleteDC(hdcMask);
692 } else {
693 hbmpOld = SelectObject(hdcBmp, This->desc.u.bmp.hbitmap);
694 StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc, cxSrc, cySrc, SRCCOPY);
695 }
696
697 SelectObject(hdcBmp, hbmpOld);
698 DeleteDC(hdcBmp);
699 }
700 break;
701 case PICTYPE_ICON:
702 FIXME("Not quite correct implementation of rendering icons...\n");
703 DrawIconEx(hdc, x, y, This->desc.u.icon.hicon, cx, cy, 0, NULL, DI_NORMAL);
704 break;
705
706 case PICTYPE_METAFILE:
707 {
708 POINT prevOrg, prevWndOrg;
709 SIZE prevExt, prevWndExt;
710 int oldmode;
711
712 /* Render the WMF to the appropriate location by setting the
713 appropriate ratio between "device units" and "logical units" */
714 oldmode = SetMapMode(hdc, MM_ANISOTROPIC);
715 /* For the "source rectangle" the y-axis must be inverted */
716 SetWindowOrgEx(hdc, xSrc, This->himetricHeight-ySrc, &prevWndOrg);
717 SetWindowExtEx(hdc, cxSrc, -cySrc, &prevWndExt);
718 /* For the "destination rectangle" no inversion is necessary */
719 SetViewportOrgEx(hdc, x, y, &prevOrg);
720 SetViewportExtEx(hdc, cx, cy, &prevExt);
721
722 if (!PlayMetaFile(hdc, This->desc.u.wmf.hmeta))
723 ERR("PlayMetaFile failed!\n");
724
725 /* We're done, restore the DC to the previous settings for converting
726 logical units to device units */
727 SetWindowExtEx(hdc, prevWndExt.cx, prevWndExt.cy, NULL);
728 SetWindowOrgEx(hdc, prevWndOrg.x, prevWndOrg.y, NULL);
729 SetViewportExtEx(hdc, prevExt.cx, prevExt.cy, NULL);
730 SetViewportOrgEx(hdc, prevOrg.x, prevOrg.y, NULL);
731 SetMapMode(hdc, oldmode);
732 break;
733 }
734
735 case PICTYPE_ENHMETAFILE:
736 {
737 RECT rc = { x, y, x + cx, y + cy };
738 PlayEnhMetaFile(hdc, This->desc.u.emf.hemf, &rc);
739 break;
740 }
741
742 default:
743 FIXME("type %d not implemented\n", This->desc.picType);
744 return E_NOTIMPL;
745 }
746 return S_OK;
747 }
748
749 /************************************************************************
750 * OLEPictureImpl_set_hPal
751 */
752 static HRESULT WINAPI OLEPictureImpl_set_hPal(IPicture *iface,
753 OLE_HANDLE hpal)
754 {
755 OLEPictureImpl *This = impl_from_IPicture(iface);
756 FIXME("(%p)->(%08x): stub\n", This, hpal);
757 OLEPicture_SendNotify(This,DISPID_PICT_HPAL);
758 return E_NOTIMPL;
759 }
760
761 /************************************************************************
762 * OLEPictureImpl_get_CurDC
763 */
764 static HRESULT WINAPI OLEPictureImpl_get_CurDC(IPicture *iface,
765 HDC *phdc)
766 {
767 OLEPictureImpl *This = impl_from_IPicture(iface);
768 TRACE("(%p), returning %p\n", This, This->hDCCur);
769 if (phdc) *phdc = This->hDCCur;
770 return S_OK;
771 }
772
773 /************************************************************************
774 * OLEPictureImpl_SelectPicture
775 */
776 static HRESULT WINAPI OLEPictureImpl_SelectPicture(IPicture *iface,
777 HDC hdcIn,
778 HDC *phdcOut,
779 OLE_HANDLE *phbmpOut)
780 {
781 OLEPictureImpl *This = impl_from_IPicture(iface);
782 TRACE("(%p)->(%p, %p, %p)\n", This, hdcIn, phdcOut, phbmpOut);
783 if (This->desc.picType == PICTYPE_BITMAP) {
784 if (phdcOut)
785 *phdcOut = This->hDCCur;
786 if (This->hDCCur) SelectObject(This->hDCCur,This->stock_bitmap);
787 if (hdcIn) SelectObject(hdcIn,This->desc.u.bmp.hbitmap);
788 This->hDCCur = hdcIn;
789 if (phbmpOut)
790 *phbmpOut = HandleToUlong(This->desc.u.bmp.hbitmap);
791 return S_OK;
792 } else {
793 FIXME("Don't know how to select picture type %d\n",This->desc.picType);
794 return E_FAIL;
795 }
796 }
797
798 /************************************************************************
799 * OLEPictureImpl_get_KeepOriginalFormat
800 */
801 static HRESULT WINAPI OLEPictureImpl_get_KeepOriginalFormat(IPicture *iface,
802 BOOL *pfKeep)
803 {
804 OLEPictureImpl *This = impl_from_IPicture(iface);
805 TRACE("(%p)->(%p)\n", This, pfKeep);
806 if (!pfKeep)
807 return E_POINTER;
808 *pfKeep = This->keepOrigFormat;
809 return S_OK;
810 }
811
812 /************************************************************************
813 * OLEPictureImpl_put_KeepOriginalFormat
814 */
815 static HRESULT WINAPI OLEPictureImpl_put_KeepOriginalFormat(IPicture *iface,
816 BOOL keep)
817 {
818 OLEPictureImpl *This = impl_from_IPicture(iface);
819 TRACE("(%p)->(%d)\n", This, keep);
820 This->keepOrigFormat = keep;
821 /* FIXME: what DISPID notification here? */
822 return S_OK;
823 }
824
825 /************************************************************************
826 * OLEPictureImpl_PictureChanged
827 */
828 static HRESULT WINAPI OLEPictureImpl_PictureChanged(IPicture *iface)
829 {
830 OLEPictureImpl *This = impl_from_IPicture(iface);
831 TRACE("(%p)->()\n", This);
832 OLEPicture_SendNotify(This,DISPID_PICT_HANDLE);
833 This->bIsDirty = TRUE;
834 return S_OK;
835 }
836
837 /************************************************************************
838 * OLEPictureImpl_SaveAsFile
839 */
840 static HRESULT WINAPI OLEPictureImpl_SaveAsFile(IPicture *iface,
841 IStream *pstream,
842 BOOL SaveMemCopy,
843 LONG *pcbSize)
844 {
845 OLEPictureImpl *This = impl_from_IPicture(iface);
846 FIXME("(%p)->(%p, %d, %p), hacked stub.\n", This, pstream, SaveMemCopy, pcbSize);
847 return IStream_Write(pstream,This->data,This->datalen,(ULONG*)pcbSize);
848 }
849
850 /************************************************************************
851 * OLEPictureImpl_get_Attributes
852 */
853 static HRESULT WINAPI OLEPictureImpl_get_Attributes(IPicture *iface,
854 DWORD *pdwAttr)
855 {
856 OLEPictureImpl *This = impl_from_IPicture(iface);
857 TRACE("(%p)->(%p).\n", This, pdwAttr);
858
859 if(!pdwAttr)
860 return E_POINTER;
861
862 *pdwAttr = 0;
863 switch (This->desc.picType) {
864 case PICTYPE_UNINITIALIZED:
865 case PICTYPE_NONE: break;
866 case PICTYPE_BITMAP: if (This->hbmMask) *pdwAttr = PICTURE_TRANSPARENT; break; /* not 'truly' scalable, see MSDN. */
867 case PICTYPE_ICON: *pdwAttr = PICTURE_TRANSPARENT;break;
868 case PICTYPE_ENHMETAFILE: /* fall through */
869 case PICTYPE_METAFILE: *pdwAttr = PICTURE_TRANSPARENT|PICTURE_SCALABLE;break;
870 default:FIXME("Unknown pictype %d\n",This->desc.picType);break;
871 }
872 return S_OK;
873 }
874
875
876 /************************************************************************
877 * IConnectionPointContainer
878 */
879 static HRESULT WINAPI OLEPictureImpl_IConnectionPointContainer_QueryInterface(
880 IConnectionPointContainer* iface,
881 REFIID riid,
882 VOID** ppvoid)
883 {
884 OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
885
886 return IPicture_QueryInterface(&This->IPicture_iface,riid,ppvoid);
887 }
888
889 static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_AddRef(
890 IConnectionPointContainer* iface)
891 {
892 OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
893
894 return IPicture_AddRef(&This->IPicture_iface);
895 }
896
897 static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_Release(
898 IConnectionPointContainer* iface)
899 {
900 OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
901
902 return IPicture_Release(&This->IPicture_iface);
903 }
904
905 static HRESULT WINAPI OLEPictureImpl_EnumConnectionPoints(
906 IConnectionPointContainer* iface,
907 IEnumConnectionPoints** ppEnum)
908 {
909 OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
910
911 FIXME("(%p,%p), stub!\n",This,ppEnum);
912 return E_NOTIMPL;
913 }
914
915 static HRESULT WINAPI OLEPictureImpl_FindConnectionPoint(
916 IConnectionPointContainer* iface,
917 REFIID riid,
918 IConnectionPoint **ppCP)
919 {
920 OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
921 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppCP);
922 if (!ppCP)
923 return E_POINTER;
924 *ppCP = NULL;
925 if (IsEqualGUID(riid,&IID_IPropertyNotifySink))
926 return IConnectionPoint_QueryInterface(This->pCP,&IID_IConnectionPoint,(LPVOID)ppCP);
927 FIXME("no connection point for %s\n",debugstr_guid(riid));
928 return CONNECT_E_NOCONNECTION;
929 }
930
931
932 /************************************************************************
933 * IPersistStream
934 */
935
936 /************************************************************************
937 * OLEPictureImpl_IPersistStream_QueryInterface (IUnknown)
938 *
939 * See Windows documentation for more details on IUnknown methods.
940 */
941 static HRESULT WINAPI OLEPictureImpl_IPersistStream_QueryInterface(
942 IPersistStream* iface,
943 REFIID riid,
944 VOID** ppvoid)
945 {
946 OLEPictureImpl *This = impl_from_IPersistStream(iface);
947
948 return IPicture_QueryInterface(&This->IPicture_iface, riid, ppvoid);
949 }
950
951 /************************************************************************
952 * OLEPictureImpl_IPersistStream_AddRef (IUnknown)
953 *
954 * See Windows documentation for more details on IUnknown methods.
955 */
956 static ULONG WINAPI OLEPictureImpl_IPersistStream_AddRef(
957 IPersistStream* iface)
958 {
959 OLEPictureImpl *This = impl_from_IPersistStream(iface);
960
961 return IPicture_AddRef(&This->IPicture_iface);
962 }
963
964 /************************************************************************
965 * OLEPictureImpl_IPersistStream_Release (IUnknown)
966 *
967 * See Windows documentation for more details on IUnknown methods.
968 */
969 static ULONG WINAPI OLEPictureImpl_IPersistStream_Release(
970 IPersistStream* iface)
971 {
972 OLEPictureImpl *This = impl_from_IPersistStream(iface);
973
974 return IPicture_Release(&This->IPicture_iface);
975 }
976
977 /************************************************************************
978 * OLEPictureImpl_IPersistStream_GetClassID
979 */
980 static HRESULT WINAPI OLEPictureImpl_GetClassID(
981 IPersistStream* iface,CLSID* pClassID)
982 {
983 TRACE("(%p)\n", pClassID);
984 *pClassID = CLSID_StdPicture;
985 return S_OK;
986 }
987
988 /************************************************************************
989 * OLEPictureImpl_IPersistStream_IsDirty
990 */
991 static HRESULT WINAPI OLEPictureImpl_IsDirty(
992 IPersistStream* iface)
993 {
994 OLEPictureImpl *This = impl_from_IPersistStream(iface);
995 FIXME("(%p),stub!\n",This);
996 return E_NOTIMPL;
997 }
998
999 static HRESULT OLEPictureImpl_LoadDIB(OLEPictureImpl *This, BYTE *xbuf, ULONG xread)
1000 {
1001 BITMAPFILEHEADER *bfh = (BITMAPFILEHEADER*)xbuf;
1002 BITMAPINFO *bi = (BITMAPINFO*)(bfh+1);
1003 HDC hdcref;
1004
1005 /* Does not matter whether this is a coreheader or not, we only use
1006 * components which are in both
1007 */
1008 hdcref = GetDC(0);
1009 This->desc.u.bmp.hbitmap = CreateDIBitmap(
1010 hdcref,
1011 &(bi->bmiHeader),
1012 CBM_INIT,
1013 xbuf+bfh->bfOffBits,
1014 bi,
1015 DIB_RGB_COLORS
1016 );
1017 ReleaseDC(0, hdcref);
1018 if (This->desc.u.bmp.hbitmap == 0)
1019 return E_FAIL;
1020 This->desc.picType = PICTYPE_BITMAP;
1021 OLEPictureImpl_SetBitmap(This);
1022 return S_OK;
1023 }
1024
1025 static HRESULT OLEPictureImpl_LoadWICSource(OLEPictureImpl *This, IWICBitmapSource *src)
1026 {
1027 HRESULT hr;
1028 BITMAPINFOHEADER bih;
1029 HDC hdcref;
1030 UINT width, height;
1031 UINT stride, buffersize;
1032 LPBYTE bits=NULL;
1033 WICRect rc;
1034 IWICBitmapSource *real_source;
1035 UINT x, y;
1036 COLORREF white = RGB(255, 255, 255), black = RGB(0, 0, 0);
1037 BOOL has_alpha=FALSE;
1038
1039 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, src, &real_source);
1040 if (FAILED(hr)) return hr;
1041
1042 hr = IWICBitmapSource_GetSize(real_source, &width, &height);
1043 if (FAILED(hr)) goto end;
1044
1045 bih.biSize = sizeof(bih);
1046 bih.biWidth = width;
1047 bih.biHeight = -height;
1048 bih.biPlanes = 1;
1049 bih.biBitCount = 32;
1050 bih.biCompression = BI_RGB;
1051 bih.biSizeImage = 0;
1052 bih.biXPelsPerMeter = 4085; /* olepicture ignores the stored resolution */
1053 bih.biYPelsPerMeter = 4085;
1054 bih.biClrUsed = 0;
1055 bih.biClrImportant = 0;
1056
1057 stride = 4 * width;
1058 buffersize = stride * height;
1059
1060 bits = HeapAlloc(GetProcessHeap(), 0, buffersize);
1061 if (!bits)
1062 {
1063 hr = E_OUTOFMEMORY;
1064 goto end;
1065 }
1066
1067 rc.X = 0;
1068 rc.Y = 0;
1069 rc.Width = width;
1070 rc.Height = height;
1071 hr = IWICBitmapSource_CopyPixels(real_source, &rc, stride, buffersize, bits);
1072 if (FAILED(hr))
1073 goto end;
1074
1075 hdcref = GetDC(0);
1076 This->desc.u.bmp.hbitmap = CreateDIBitmap(
1077 hdcref,
1078 &bih,
1079 CBM_INIT,
1080 bits,
1081 (BITMAPINFO*)&bih,
1082 DIB_RGB_COLORS);
1083
1084 if (This->desc.u.bmp.hbitmap == 0)
1085 {
1086 hr = E_FAIL;
1087 ReleaseDC(0, hdcref);
1088 goto end;
1089 }
1090
1091 This->desc.picType = PICTYPE_BITMAP;
1092 OLEPictureImpl_SetBitmap(This);
1093
1094 /* set transparent pixels to black, all others to white */
1095 for(y = 0; y < height; y++){
1096 for(x = 0; x < width; x++){
1097 DWORD *pixel = (DWORD*)(bits + stride*y + 4*x);
1098 if((*pixel & 0x80000000) == 0)
1099 {
1100 has_alpha = TRUE;
1101 *pixel = black;
1102 }
1103 else
1104 *pixel = white;
1105 }
1106 }
1107
1108 if (has_alpha)
1109 {
1110 HDC hdcBmp, hdcXor, hdcMask;
1111 HBITMAP hbmoldBmp, hbmoldXor, hbmoldMask;
1112
1113 This->hbmXor = CreateDIBitmap(
1114 hdcref,
1115 &bih,
1116 CBM_INIT,
1117 bits,
1118 (BITMAPINFO*)&bih,
1119 DIB_RGB_COLORS
1120 );
1121
1122 This->hbmMask = CreateBitmap(width,-height,1,1,NULL);
1123 hdcBmp = CreateCompatibleDC(NULL);
1124 hdcXor = CreateCompatibleDC(NULL);
1125 hdcMask = CreateCompatibleDC(NULL);
1126
1127 hbmoldBmp = SelectObject(hdcBmp,This->desc.u.bmp.hbitmap);
1128 hbmoldXor = SelectObject(hdcXor,This->hbmXor);
1129 hbmoldMask = SelectObject(hdcMask,This->hbmMask);
1130
1131 SetBkColor(hdcXor,black);
1132 BitBlt(hdcMask,0,0,width,height,hdcXor,0,0,SRCCOPY);
1133 BitBlt(hdcXor,0,0,width,height,hdcBmp,0,0,SRCAND);
1134
1135 SelectObject(hdcBmp,hbmoldBmp);
1136 SelectObject(hdcXor,hbmoldXor);
1137 SelectObject(hdcMask,hbmoldMask);
1138
1139 DeleteDC(hdcBmp);
1140 DeleteDC(hdcXor);
1141 DeleteDC(hdcMask);
1142 }
1143
1144 ReleaseDC(0, hdcref);
1145
1146 end:
1147 HeapFree(GetProcessHeap(), 0, bits);
1148 IWICBitmapSource_Release(real_source);
1149 return hr;
1150 }
1151
1152 static HRESULT OLEPictureImpl_LoadWICDecoder(OLEPictureImpl *This, REFCLSID decoder_clsid, BYTE *xbuf, ULONG xread)
1153 {
1154 HRESULT hr;
1155 IWICImagingFactory *factory;
1156 IWICBitmapDecoder *decoder;
1157 IWICBitmapFrameDecode *framedecode;
1158 HRESULT initresult;
1159 IWICStream *stream;
1160
1161 initresult = CoInitialize(NULL);
1162
1163 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1164 &IID_IWICImagingFactory, (void**)&factory);
1165 if (SUCCEEDED(hr)) /* created factory */
1166 {
1167 hr = IWICImagingFactory_CreateStream(factory, &stream);
1168 IWICImagingFactory_Release(factory);
1169 }
1170
1171 if (SUCCEEDED(hr)) /* created stream */
1172 {
1173 hr = IWICStream_InitializeFromMemory(stream, xbuf, xread);
1174
1175 if (SUCCEEDED(hr)) /* initialized stream */
1176 {
1177 hr = CoCreateInstance(decoder_clsid, NULL, CLSCTX_INPROC_SERVER,
1178 &IID_IWICBitmapDecoder, (void**)&decoder);
1179 if (SUCCEEDED(hr)) /* created decoder */
1180 {
1181 hr = IWICBitmapDecoder_Initialize(decoder, (IStream*)stream, WICDecodeMetadataCacheOnLoad);
1182
1183 if (SUCCEEDED(hr)) /* initialized decoder */
1184 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
1185
1186 IWICBitmapDecoder_Release(decoder);
1187 }
1188 }
1189
1190 IWICStream_Release(stream);
1191 }
1192
1193 if (SUCCEEDED(hr)) /* got framedecode */
1194 {
1195 hr = OLEPictureImpl_LoadWICSource(This, (IWICBitmapSource*)framedecode);
1196 IWICBitmapFrameDecode_Release(framedecode);
1197 }
1198
1199 if (SUCCEEDED(initresult)) CoUninitialize();
1200 return hr;
1201 }
1202
1203 /*****************************************************
1204 * start of Icon-specific code
1205 */
1206
1207 static HRESULT OLEPictureImpl_LoadIcon(OLEPictureImpl *This, BYTE *xbuf, ULONG xread)
1208 {
1209 HICON hicon;
1210 CURSORICONFILEDIR *cifd = (CURSORICONFILEDIR*)xbuf;
1211 HDC hdcRef;
1212 int i;
1213
1214 /*
1215 FIXME("icon.idReserved=%d\n",cifd->idReserved);
1216 FIXME("icon.idType=%d\n",cifd->idType);
1217 FIXME("icon.idCount=%d\n",cifd->idCount);
1218
1219 for (i=0;i<cifd->idCount;i++) {
1220 FIXME("[%d] width %d\n",i,cifd->idEntries[i].bWidth);
1221 FIXME("[%d] height %d\n",i,cifd->idEntries[i].bHeight);
1222 FIXME("[%d] bColorCount %d\n",i,cifd->idEntries[i].bColorCount);
1223 FIXME("[%d] bReserved %d\n",i,cifd->idEntries[i].bReserved);
1224 FIXME("[%d] xHotspot %d\n",i,cifd->idEntries[i].xHotspot);
1225 FIXME("[%d] yHotspot %d\n",i,cifd->idEntries[i].yHotspot);
1226 FIXME("[%d] dwDIBSize %d\n",i,cifd->idEntries[i].dwDIBSize);
1227 FIXME("[%d] dwDIBOffset %d\n",i,cifd->idEntries[i].dwDIBOffset);
1228 }
1229 */
1230 i=0;
1231 /* If we have more than one icon, try to find the best.
1232 * this currently means '32 pixel wide'.
1233 */
1234 if (cifd->idCount!=1) {
1235 for (i=0;i<cifd->idCount;i++) {
1236 if (cifd->idEntries[i].bWidth == 32)
1237 break;
1238 }
1239 if (i==cifd->idCount) i=0;
1240 }
1241 if (cifd->idType == 2)
1242 {
1243 LPBYTE buf = HeapAlloc(GetProcessHeap(), 0, cifd->idEntries[i].dwDIBSize + 4);
1244 memcpy(buf, &cifd->idEntries[i].xHotspot, 4);
1245 memcpy(buf + 4, xbuf+cifd->idEntries[i].dwDIBOffset, cifd->idEntries[i].dwDIBSize);
1246 hicon = CreateIconFromResourceEx(
1247 buf,
1248 cifd->idEntries[i].dwDIBSize + 4,
1249 FALSE, /* is cursor */
1250 0x00030000,
1251 cifd->idEntries[i].bWidth,
1252 cifd->idEntries[i].bHeight,
1253 0
1254 );
1255 HeapFree(GetProcessHeap(), 0, buf);
1256 }
1257 else
1258 {
1259 hicon = CreateIconFromResourceEx(
1260 xbuf+cifd->idEntries[i].dwDIBOffset,
1261 cifd->idEntries[i].dwDIBSize,
1262 TRUE, /* is icon */
1263 0x00030000,
1264 cifd->idEntries[i].bWidth,
1265 cifd->idEntries[i].bHeight,
1266 0
1267 );
1268 }
1269 if (!hicon) {
1270 ERR("CreateIcon failed.\n");
1271 return E_FAIL;
1272 } else {
1273 This->desc.picType = PICTYPE_ICON;
1274 This->desc.u.icon.hicon = hicon;
1275 This->origWidth = cifd->idEntries[i].bWidth;
1276 This->origHeight = cifd->idEntries[i].bHeight;
1277 hdcRef = CreateCompatibleDC(0);
1278 This->himetricWidth = xpixels_to_himetric(cifd->idEntries[i].bWidth, hdcRef);
1279 This->himetricHeight= ypixels_to_himetric(cifd->idEntries[i].bHeight, hdcRef);
1280 DeleteDC(hdcRef);
1281 return S_OK;
1282 }
1283 }
1284
1285 static HRESULT OLEPictureImpl_LoadEnhMetafile(OLEPictureImpl *This,
1286 const BYTE *data, ULONG size)
1287 {
1288 HENHMETAFILE hemf;
1289 ENHMETAHEADER hdr;
1290
1291 hemf = SetEnhMetaFileBits(size, data);
1292 if (!hemf) return E_FAIL;
1293
1294 GetEnhMetaFileHeader(hemf, sizeof(hdr), &hdr);
1295
1296 This->desc.picType = PICTYPE_ENHMETAFILE;
1297 This->desc.u.emf.hemf = hemf;
1298
1299 This->origWidth = 0;
1300 This->origHeight = 0;
1301 This->himetricWidth = hdr.rclFrame.right - hdr.rclFrame.left;
1302 This->himetricHeight = hdr.rclFrame.bottom - hdr.rclFrame.top;
1303
1304 return S_OK;
1305 }
1306
1307 static HRESULT OLEPictureImpl_LoadAPM(OLEPictureImpl *This,
1308 const BYTE *data, ULONG size)
1309 {
1310 const APM_HEADER *header = (const APM_HEADER *)data;
1311 HMETAFILE hmf;
1312
1313 if (size < sizeof(APM_HEADER))
1314 return E_FAIL;
1315 if (header->key != 0x9ac6cdd7)
1316 return E_FAIL;
1317
1318 /* SetMetaFileBitsEx performs data check on its own */
1319 hmf = SetMetaFileBitsEx(size - sizeof(*header), data + sizeof(*header));
1320 if (!hmf) return E_FAIL;
1321
1322 This->desc.picType = PICTYPE_METAFILE;
1323 This->desc.u.wmf.hmeta = hmf;
1324 This->desc.u.wmf.xExt = 0;
1325 This->desc.u.wmf.yExt = 0;
1326
1327 This->origWidth = 0;
1328 This->origHeight = 0;
1329 This->himetricWidth = MulDiv((INT)header->right - header->left, 2540, header->inch);
1330 This->himetricHeight = MulDiv((INT)header->bottom - header->top, 2540, header->inch);
1331 return S_OK;
1332 }
1333
1334 /************************************************************************
1335 * OLEPictureImpl_IPersistStream_Load (IUnknown)
1336 *
1337 * Loads the binary data from the IStream. Starts at current position.
1338 * There appears to be an 2 DWORD header:
1339 * DWORD magic;
1340 * DWORD len;
1341 *
1342 * Currently implemented: BITMAP, ICON, CURSOR, JPEG, GIF, WMF, EMF
1343 */
1344 static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm) {
1345 HRESULT hr;
1346 BOOL headerisdata;
1347 BOOL statfailed = FALSE;
1348 ULONG xread, toread;
1349 ULONG headerread;
1350 BYTE *xbuf;
1351 DWORD header[2];
1352 WORD magic;
1353 STATSTG statstg;
1354 OLEPictureImpl *This = impl_from_IPersistStream(iface);
1355
1356 TRACE("(%p,%p)\n",This,pStm);
1357
1358 /****************************************************************************************
1359 * Part 1: Load the data
1360 */
1361 /* Sometimes we have a header, sometimes we don't. Apply some guesses to find
1362 * out whether we do.
1363 *
1364 * UPDATE: the IStream can be mapped to a plain file instead of a stream in a
1365 * compound file. This may explain most, if not all, of the cases of "no
1366 * header", and the header validation should take this into account.
1367 * At least in Visual Basic 6, resource streams, valid headers are
1368 * header[0] == "lt\0\0",
1369 * header[1] == length_of_stream.
1370 *
1371 * Also handle streams where we do not have a working "Stat" method by
1372 * reading all data until the end of the stream.
1373 */
1374 hr = IStream_Stat(pStm,&statstg,STATFLAG_NONAME);
1375 if (hr != S_OK) {
1376 TRACE("stat failed with hres %x, proceeding to read all data.\n",hr);
1377 statfailed = TRUE;
1378 /* we will read at least 8 byte ... just right below */
1379 statstg.cbSize.QuadPart = 8;
1380 }
1381
1382 toread = 0;
1383 headerread = 0;
1384 headerisdata = FALSE;
1385 do {
1386 hr = IStream_Read(pStm, header, 8, &xread);
1387 if (hr != S_OK || xread!=8) {
1388 ERR("Failure while reading picture header (hr is %x, nread is %d).\n",hr,xread);
1389 return (hr?hr:E_FAIL);
1390 }
1391 headerread += xread;
1392 xread = 0;
1393
1394 if (!memcmp(&(header[0]),"lt\0\0", 4) && (statfailed || (header[1] + headerread <= statstg.cbSize.QuadPart))) {
1395 if (toread != 0 && toread != header[1])
1396 FIXME("varying lengths of image data (prev=%u curr=%u), only last one will be used\n",
1397 toread, header[1]);
1398 toread = header[1];
1399 if (toread == 0) break;
1400 } else {
1401 if (!memcmp(&(header[0]), "GIF8", 4) || /* GIF header */
1402 !memcmp(&(header[0]), "BM", 2) || /* BMP header */
1403 !memcmp(&(header[0]), "\xff\xd8", 2) || /* JPEG header */
1404 (header[0] == EMR_HEADER) || /* EMF header */
1405 (header[0] == 0x10000) || /* icon: idReserved 0, idType 1 */
1406 (header[0] == 0x20000) || /* cursor: idReserved 0, idType 2 */
1407 (header[1] > statstg.cbSize.QuadPart)|| /* invalid size */
1408 (header[1]==0)
1409 ) {/* Found start of bitmap data */
1410 headerisdata = TRUE;
1411 if (toread == 0)
1412 toread = statstg.cbSize.QuadPart-8;
1413 else toread -= 8;
1414 xread = 8;
1415 } else {
1416 FIXME("Unknown stream header magic: %08x\n", header[0]);
1417 toread = header[1];
1418 }
1419 }
1420 } while (!headerisdata);
1421
1422 if (statfailed) { /* we don't know the size ... read all we get */
1423 int sizeinc = 4096;
1424 int origsize = sizeinc;
1425 ULONG nread = 42;
1426
1427 TRACE("Reading all data from stream.\n");
1428 xbuf = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, origsize);
1429 if (headerisdata)
1430 memcpy (xbuf, header, 8);
1431 while (1) {
1432 while (xread < origsize) {
1433 hr = IStream_Read(pStm,xbuf+xread,origsize-xread,&nread);
1434 xread += nread;
1435 if (hr != S_OK || !nread)
1436 break;
1437 }
1438 if (!nread || hr != S_OK) /* done, or error */
1439 break;
1440 if (xread == origsize) {
1441 origsize += sizeinc;
1442 sizeinc = 2*sizeinc; /* exponential increase */
1443 xbuf = HeapReAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, xbuf, origsize);
1444 }
1445 }
1446 if (hr != S_OK)
1447 TRACE("hr in no-stat loader case is %08x\n", hr);
1448 TRACE("loaded %d bytes.\n", xread);
1449 This->datalen = xread;
1450 This->data = xbuf;
1451 } else {
1452 This->datalen = toread+(headerisdata?8:0);
1453 xbuf = This->data = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, This->datalen);
1454 if (!xbuf)
1455 return E_OUTOFMEMORY;
1456
1457 if (headerisdata)
1458 memcpy (xbuf, header, 8);
1459
1460 while (xread < This->datalen) {
1461 ULONG nread;
1462 hr = IStream_Read(pStm,xbuf+xread,This->datalen-xread,&nread);
1463 xread += nread;
1464 if (hr != S_OK || !nread)
1465 break;
1466 }
1467 if (xread != This->datalen)
1468 ERR("Could only read %d of %d bytes out of stream?\n",xread,This->datalen);
1469 }
1470 if (This->datalen == 0) { /* Marks the "NONE" picture */
1471 This->desc.picType = PICTYPE_NONE;
1472 return S_OK;
1473 }
1474
1475
1476 /****************************************************************************************
1477 * Part 2: Process the loaded data
1478 */
1479
1480 magic = xbuf[0] + (xbuf[1]<<8);
1481 This->loadtime_format = magic;
1482
1483 switch (magic) {
1484 case BITMAP_FORMAT_GIF: /* GIF */
1485 hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICGifDecoder, xbuf, xread);
1486 break;
1487 case BITMAP_FORMAT_JPEG: /* JPEG */
1488 hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICJpegDecoder, xbuf, xread);
1489 break;
1490 case BITMAP_FORMAT_BMP: /* Bitmap */
1491 hr = OLEPictureImpl_LoadDIB(This, xbuf, xread);
1492 break;
1493 case BITMAP_FORMAT_PNG: /* PNG */
1494 hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICPngDecoder, xbuf, xread);
1495 break;
1496 case BITMAP_FORMAT_APM: /* APM */
1497 hr = OLEPictureImpl_LoadAPM(This, xbuf, xread);
1498 break;
1499 case 0x0000: { /* ICON or CURSOR, first word is dwReserved */
1500 hr = OLEPictureImpl_LoadIcon(This, xbuf, xread);
1501 break;
1502 }
1503 default:
1504 {
1505 unsigned int i;
1506
1507 /* let's see if it's a EMF */
1508 hr = OLEPictureImpl_LoadEnhMetafile(This, xbuf, xread);
1509 if (hr == S_OK) break;
1510
1511 FIXME("Unknown magic %04x, %d read bytes:\n",magic,xread);
1512 hr=E_FAIL;
1513 for (i=0;i<xread+8;i++) {
1514 if (i<8) MESSAGE("%02x ",((unsigned char*)header)[i]);
1515 else MESSAGE("%02x ",xbuf[i-8]);
1516 if (i % 10 == 9) MESSAGE("\n");
1517 }
1518 MESSAGE("\n");
1519 break;
1520 }
1521 }
1522 This->bIsDirty = FALSE;
1523
1524 /* FIXME: this notify is not really documented */
1525 if (hr==S_OK)
1526 OLEPicture_SendNotify(This,DISPID_PICT_TYPE);
1527 return hr;
1528 }
1529
1530 static int serializeBMP(HBITMAP hBitmap, void ** ppBuffer, unsigned int * pLength)
1531 {
1532 int iSuccess = 0;
1533 HDC hDC;
1534 BITMAPINFO * pInfoBitmap;
1535 int iNumPaletteEntries;
1536 unsigned char * pPixelData;
1537 BITMAPFILEHEADER * pFileHeader;
1538 BITMAPINFO * pInfoHeader;
1539
1540 pInfoBitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1541 sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1542
1543 /* Find out bitmap size and padded length */
1544 hDC = GetDC(0);
1545 pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
1546 GetDIBits(hDC, hBitmap, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
1547
1548 /* Fetch bitmap palette & pixel data */
1549
1550 pPixelData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pInfoBitmap->bmiHeader.biSizeImage);
1551 GetDIBits(hDC, hBitmap, 0, pInfoBitmap->bmiHeader.biHeight, pPixelData, pInfoBitmap, DIB_RGB_COLORS);
1552
1553 /* Calculate the total length required for the BMP data */
1554 if (pInfoBitmap->bmiHeader.biClrUsed != 0) {
1555 iNumPaletteEntries = pInfoBitmap->bmiHeader.biClrUsed;
1556 if (iNumPaletteEntries > 256) iNumPaletteEntries = 256;
1557 } else {
1558 if (pInfoBitmap->bmiHeader.biBitCount <= 8)
1559 iNumPaletteEntries = 1 << pInfoBitmap->bmiHeader.biBitCount;
1560 else
1561 iNumPaletteEntries = 0;
1562 }
1563 *pLength =
1564 sizeof(BITMAPFILEHEADER) +
1565 sizeof(BITMAPINFOHEADER) +
1566 iNumPaletteEntries * sizeof(RGBQUAD) +
1567 pInfoBitmap->bmiHeader.biSizeImage;
1568 *ppBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *pLength);
1569
1570 /* Fill the BITMAPFILEHEADER */
1571 pFileHeader = *ppBuffer;
1572 pFileHeader->bfType = BITMAP_FORMAT_BMP;
1573 pFileHeader->bfSize = *pLength;
1574 pFileHeader->bfOffBits =
1575 sizeof(BITMAPFILEHEADER) +
1576 sizeof(BITMAPINFOHEADER) +
1577 iNumPaletteEntries * sizeof(RGBQUAD);
1578
1579 /* Fill the BITMAPINFOHEADER and the palette data */
1580 pInfoHeader = (BITMAPINFO *)((unsigned char *)(*ppBuffer) + sizeof(BITMAPFILEHEADER));
1581 memcpy(pInfoHeader, pInfoBitmap, sizeof(BITMAPINFOHEADER) + iNumPaletteEntries * sizeof(RGBQUAD));
1582 memcpy(
1583 (unsigned char *)(*ppBuffer) +
1584 sizeof(BITMAPFILEHEADER) +
1585 sizeof(BITMAPINFOHEADER) +
1586 iNumPaletteEntries * sizeof(RGBQUAD),
1587 pPixelData, pInfoBitmap->bmiHeader.biSizeImage);
1588 iSuccess = 1;
1589
1590 HeapFree(GetProcessHeap(), 0, pPixelData);
1591 HeapFree(GetProcessHeap(), 0, pInfoBitmap);
1592 return iSuccess;
1593 }
1594
1595 static int serializeIcon(HICON hIcon, void ** ppBuffer, unsigned int * pLength)
1596 {
1597 ICONINFO infoIcon;
1598 int iSuccess = 0;
1599
1600 *ppBuffer = NULL; *pLength = 0;
1601 if (GetIconInfo(hIcon, &infoIcon)) {
1602 HDC hDC;
1603 BITMAPINFO * pInfoBitmap;
1604 unsigned char * pIconData = NULL;
1605 unsigned int iDataSize = 0;
1606
1607 pInfoBitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1608
1609 /* Find out icon size */
1610 hDC = GetDC(0);
1611 pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
1612 GetDIBits(hDC, infoIcon.hbmColor, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
1613 if (1) {
1614 /* Auxiliary pointers */
1615 CURSORICONFILEDIR * pIconDir;
1616 CURSORICONFILEDIRENTRY * pIconEntry;
1617 BITMAPINFOHEADER * pIconBitmapHeader;
1618 unsigned int iOffsetPalette;
1619 unsigned int iOffsetColorData;
1620 unsigned int iOffsetMaskData;
1621
1622 unsigned int iLengthScanLineMask;
1623 unsigned int iNumEntriesPalette;
1624
1625 iLengthScanLineMask = ((pInfoBitmap->bmiHeader.biWidth + 31) >> 5) << 2;
1626 /*
1627 FIXME("DEBUG: bitmap size is %d x %d\n",
1628 pInfoBitmap->bmiHeader.biWidth,
1629 pInfoBitmap->bmiHeader.biHeight);
1630 FIXME("DEBUG: bitmap bpp is %d\n",
1631 pInfoBitmap->bmiHeader.biBitCount);
1632 FIXME("DEBUG: bitmap nplanes is %d\n",
1633 pInfoBitmap->bmiHeader.biPlanes);
1634 FIXME("DEBUG: bitmap biSizeImage is %u\n",
1635 pInfoBitmap->bmiHeader.biSizeImage);
1636 */
1637 /* Let's start with one CURSORICONFILEDIR and one CURSORICONFILEDIRENTRY */
1638 iDataSize += 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY) + sizeof(BITMAPINFOHEADER);
1639 pIconData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, iDataSize);
1640
1641 /* Fill out the CURSORICONFILEDIR */
1642 pIconDir = (CURSORICONFILEDIR *)pIconData;
1643 pIconDir->idType = 1;
1644 pIconDir->idCount = 1;
1645 pIconDir->idReserved = 0;
1646
1647 /* Fill out the CURSORICONFILEDIRENTRY */
1648 pIconEntry = (CURSORICONFILEDIRENTRY *)(pIconData + 3 * sizeof(WORD));
1649 pIconEntry->bWidth = (unsigned char)pInfoBitmap->bmiHeader.biWidth;
1650 pIconEntry->bHeight = (unsigned char)pInfoBitmap->bmiHeader.biHeight;
1651 pIconEntry->bColorCount =
1652 (pInfoBitmap->bmiHeader.biBitCount < 8)
1653 ? 1 << pInfoBitmap->bmiHeader.biBitCount
1654 : 0;
1655 pIconEntry->xHotspot = pInfoBitmap->bmiHeader.biPlanes;
1656 pIconEntry->yHotspot = pInfoBitmap->bmiHeader.biBitCount;
1657 pIconEntry->dwDIBSize = 0;
1658 pIconEntry->dwDIBOffset = 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY);
1659
1660 /* Fill out the BITMAPINFOHEADER */
1661 pIconBitmapHeader = (BITMAPINFOHEADER *)(pIconData + 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
1662 *pIconBitmapHeader = pInfoBitmap->bmiHeader;
1663
1664 /* Find out whether a palette exists for the bitmap */
1665 if ( (pInfoBitmap->bmiHeader.biBitCount == 16 && pInfoBitmap->bmiHeader.biCompression == BI_RGB)
1666 || (pInfoBitmap->bmiHeader.biBitCount == 24)
1667 || (pInfoBitmap->bmiHeader.biBitCount == 32 && pInfoBitmap->bmiHeader.biCompression == BI_RGB)) {
1668 iNumEntriesPalette = pInfoBitmap->bmiHeader.biClrUsed;
1669 if (iNumEntriesPalette > 256) iNumEntriesPalette = 256;
1670 } else if ((pInfoBitmap->bmiHeader.biBitCount == 16 || pInfoBitmap->bmiHeader.biBitCount == 32)
1671 && pInfoBitmap->bmiHeader.biCompression == BI_BITFIELDS) {
1672 iNumEntriesPalette = 3;
1673 } else if (pInfoBitmap->bmiHeader.biBitCount <= 8) {
1674 iNumEntriesPalette = 1 << pInfoBitmap->bmiHeader.biBitCount;
1675 } else {
1676 iNumEntriesPalette = 0;
1677 }
1678
1679 /* Add bitmap size and header size to icon data size. */
1680 iOffsetPalette = iDataSize;
1681 iDataSize += iNumEntriesPalette * sizeof(DWORD);
1682 iOffsetColorData = iDataSize;
1683 iDataSize += pIconBitmapHeader->biSizeImage;
1684 iOffsetMaskData = iDataSize;
1685 iDataSize += pIconBitmapHeader->biHeight * iLengthScanLineMask;
1686 pIconBitmapHeader->biSizeImage += pIconBitmapHeader->biHeight * iLengthScanLineMask;
1687 pIconBitmapHeader->biHeight *= 2;
1688 pIconData = HeapReAlloc(GetProcessHeap(), 0, pIconData, iDataSize);
1689 pIconEntry = (CURSORICONFILEDIRENTRY *)(pIconData + 3 * sizeof(WORD));
1690 pIconBitmapHeader = (BITMAPINFOHEADER *)(pIconData + 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
1691 pIconEntry->dwDIBSize = iDataSize - (3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
1692
1693 /* Get the actual bitmap data from the icon bitmap */
1694 GetDIBits(hDC, infoIcon.hbmColor, 0, pInfoBitmap->bmiHeader.biHeight,
1695 pIconData + iOffsetColorData, pInfoBitmap, DIB_RGB_COLORS);
1696 if (iNumEntriesPalette > 0) {
1697 memcpy(pIconData + iOffsetPalette, pInfoBitmap->bmiColors,
1698 iNumEntriesPalette * sizeof(RGBQUAD));
1699 }
1700
1701 /* Reset all values so that GetDIBits call succeeds */
1702 memset(pIconData + iOffsetMaskData, 0, iDataSize - iOffsetMaskData);
1703 memset(pInfoBitmap, 0, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1704 pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
1705 /*
1706 if (!(GetDIBits(hDC, infoIcon.hbmMask, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS)
1707 && GetDIBits(hDC, infoIcon.hbmMask, 0, pIconEntry->bHeight,
1708 pIconData + iOffsetMaskData, pInfoBitmap, DIB_RGB_COLORS))) {
1709
1710 printf("ERROR: unable to get bitmap mask (error %u)\n",
1711 GetLastError());
1712
1713 }
1714 */
1715 GetDIBits(hDC, infoIcon.hbmMask, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
1716 GetDIBits(hDC, infoIcon.hbmMask, 0, pIconEntry->bHeight, pIconData + iOffsetMaskData, pInfoBitmap, DIB_RGB_COLORS);
1717
1718 /* Write out everything produced so far to the stream */
1719 *ppBuffer = pIconData; *pLength = iDataSize;
1720 iSuccess = 1;
1721 } else {
1722 /*
1723 printf("ERROR: unable to get bitmap information via GetDIBits() (error %u)\n",
1724 GetLastError());
1725 */
1726 }
1727 /*
1728 Remarks (from MSDN entry on GetIconInfo):
1729
1730 GetIconInfo creates bitmaps for the hbmMask and hbmColor
1731 members of ICONINFO. The calling application must manage
1732 these bitmaps and delete them when they are no longer
1733 necessary.
1734 */
1735 if (hDC) ReleaseDC(0, hDC);
1736 DeleteObject(infoIcon.hbmMask);
1737 if (infoIcon.hbmColor) DeleteObject(infoIcon.hbmColor);
1738 HeapFree(GetProcessHeap(), 0, pInfoBitmap);
1739 } else {
1740 printf("ERROR: Unable to get icon information (error %u)\n",
1741 GetLastError());
1742 }
1743 return iSuccess;
1744 }
1745
1746 static HRESULT WINAPI OLEPictureImpl_Save(
1747 IPersistStream* iface,IStream*pStm,BOOL fClearDirty)
1748 {
1749 HRESULT hResult = E_NOTIMPL;
1750 void * pIconData;
1751 unsigned int iDataSize;
1752 DWORD header[2];
1753 ULONG dummy;
1754 int iSerializeResult = 0;
1755 OLEPictureImpl *This = impl_from_IPersistStream(iface);
1756
1757 TRACE("%p %p %d\n", This, pStm, fClearDirty);
1758
1759 switch (This->desc.picType) {
1760 case PICTYPE_ICON:
1761 if (This->bIsDirty || !This->data) {
1762 if (!serializeIcon(This->desc.u.icon.hicon, &pIconData, &iDataSize)) {
1763 ERR("(%p,%p,%d), serializeIcon() failed\n", This, pStm, fClearDirty);
1764 hResult = E_FAIL;
1765 break;
1766 }
1767 HeapFree(GetProcessHeap(), 0, This->data);
1768 This->data = pIconData;
1769 This->datalen = iDataSize;
1770 }
1771
1772 header[0] = (This->loadtime_magic != 0xdeadbeef) ? This->loadtime_magic : 0x0000746c;
1773 header[1] = This->datalen;
1774 IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
1775 IStream_Write(pStm, This->data, This->datalen, &dummy);
1776 hResult = S_OK;
1777 break;
1778 case PICTYPE_BITMAP:
1779 if (This->bIsDirty || !This->data) {
1780 switch (This->keepOrigFormat ? This->loadtime_format : BITMAP_FORMAT_BMP) {
1781 case BITMAP_FORMAT_BMP:
1782 iSerializeResult = serializeBMP(This->desc.u.bmp.hbitmap, &pIconData, &iDataSize);
1783 break;
1784 case BITMAP_FORMAT_JPEG:
1785 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format JPEG) not implemented!\n",This,pStm,fClearDirty);
1786 break;
1787 case BITMAP_FORMAT_GIF:
1788 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format GIF) not implemented!\n",This,pStm,fClearDirty);
1789 break;
1790 case BITMAP_FORMAT_PNG:
1791 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format PNG) not implemented!\n",This,pStm,fClearDirty);
1792 break;
1793 default:
1794 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format UNKNOWN, using BMP?) not implemented!\n",This,pStm,fClearDirty);
1795 break;
1796 }
1797
1798 if (!iSerializeResult)
1799 {
1800 hResult = E_FAIL;
1801 break;
1802 }
1803
1804 HeapFree(GetProcessHeap(), 0, This->data);
1805 This->data = pIconData;
1806 This->datalen = iDataSize;
1807 }
1808
1809 header[0] = (This->loadtime_magic != 0xdeadbeef) ? This->loadtime_magic : 0x0000746c;
1810 header[1] = This->datalen;
1811 IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
1812 IStream_Write(pStm, This->data, This->datalen, &dummy);
1813 hResult = S_OK;
1814 break;
1815 case PICTYPE_METAFILE:
1816 FIXME("(%p,%p,%d), PICTYPE_METAFILE not implemented!\n",This,pStm,fClearDirty);
1817 break;
1818 case PICTYPE_ENHMETAFILE:
1819 FIXME("(%p,%p,%d),PICTYPE_ENHMETAFILE not implemented!\n",This,pStm,fClearDirty);
1820 break;
1821 default:
1822 FIXME("(%p,%p,%d), [unknown type] not implemented!\n",This,pStm,fClearDirty);
1823 break;
1824 }
1825 if (hResult == S_OK && fClearDirty) This->bIsDirty = FALSE;
1826 return hResult;
1827 }
1828
1829 static HRESULT WINAPI OLEPictureImpl_GetSizeMax(
1830 IPersistStream* iface,ULARGE_INTEGER*pcbSize)
1831 {
1832 OLEPictureImpl *This = impl_from_IPersistStream(iface);
1833 FIXME("(%p,%p),stub!\n",This,pcbSize);
1834 return E_NOTIMPL;
1835 }
1836
1837
1838 /************************************************************************
1839 * IDispatch
1840 */
1841
1842 /************************************************************************
1843 * OLEPictureImpl_IDispatch_QueryInterface (IUnknown)
1844 *
1845 * See Windows documentation for more details on IUnknown methods.
1846 */
1847 static HRESULT WINAPI OLEPictureImpl_IDispatch_QueryInterface(
1848 IDispatch* iface,
1849 REFIID riid,
1850 VOID** ppvoid)
1851 {
1852 OLEPictureImpl *This = impl_from_IDispatch(iface);
1853
1854 return IPicture_QueryInterface(&This->IPicture_iface, riid, ppvoid);
1855 }
1856
1857 /************************************************************************
1858 * OLEPictureImpl_IDispatch_AddRef (IUnknown)
1859 *
1860 * See Windows documentation for more details on IUnknown methods.
1861 */
1862 static ULONG WINAPI OLEPictureImpl_IDispatch_AddRef(
1863 IDispatch* iface)
1864 {
1865 OLEPictureImpl *This = impl_from_IDispatch(iface);
1866
1867 return IPicture_AddRef(&This->IPicture_iface);
1868 }
1869
1870 /************************************************************************
1871 * OLEPictureImpl_IDispatch_Release (IUnknown)
1872 *
1873 * See Windows documentation for more details on IUnknown methods.
1874 */
1875 static ULONG WINAPI OLEPictureImpl_IDispatch_Release(
1876 IDispatch* iface)
1877 {
1878 OLEPictureImpl *This = impl_from_IDispatch(iface);
1879
1880 return IPicture_Release(&This->IPicture_iface);
1881 }
1882
1883 /************************************************************************
1884 * OLEPictureImpl_GetTypeInfoCount (IDispatch)
1885 *
1886 * See Windows documentation for more details on IDispatch methods.
1887 */
1888 static HRESULT WINAPI OLEPictureImpl_GetTypeInfoCount(
1889 IDispatch* iface,
1890 unsigned int* pctinfo)
1891 {
1892 TRACE("(%p)\n", pctinfo);
1893
1894 *pctinfo = 1;
1895
1896 return S_OK;
1897 }
1898
1899 /************************************************************************
1900 * OLEPictureImpl_GetTypeInfo (IDispatch)
1901 *
1902 * See Windows documentation for more details on IDispatch methods.
1903 */
1904 static HRESULT WINAPI OLEPictureImpl_GetTypeInfo(
1905 IDispatch* iface,
1906 UINT iTInfo,
1907 LCID lcid,
1908 ITypeInfo** ppTInfo)
1909 {
1910 static const WCHAR stdole2tlb[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
1911 ITypeLib *tl;
1912 HRESULT hres;
1913
1914 TRACE("(iTInfo=%d, lcid=%04x, %p)\n", iTInfo, (int)lcid, ppTInfo);
1915
1916 if (iTInfo != 0)
1917 return E_FAIL;
1918
1919 hres = LoadTypeLib(stdole2tlb, &tl);
1920 if (FAILED(hres))
1921 {
1922 ERR("Could not load stdole2.tlb\n");
1923 return hres;
1924 }
1925
1926 hres = ITypeLib_GetTypeInfoOfGuid(tl, &IID_IPictureDisp, ppTInfo);
1927 if (FAILED(hres))
1928 ERR("Did not get IPictureDisp typeinfo from typelib, hres %x\n", hres);
1929
1930 return hres;
1931 }
1932
1933 /************************************************************************
1934 * OLEPictureImpl_GetIDsOfNames (IDispatch)
1935 *
1936 * See Windows documentation for more details on IDispatch methods.
1937 */
1938 static HRESULT WINAPI OLEPictureImpl_GetIDsOfNames(
1939 IDispatch* iface,
1940 REFIID riid,
1941 LPOLESTR* rgszNames,
1942 UINT cNames,
1943 LCID lcid,
1944 DISPID* rgDispId)
1945 {
1946 ITypeInfo * pTInfo;
1947 HRESULT hres;
1948
1949 TRACE("(%p,%s,%p,cNames=%d,lcid=%04x,%p)\n", iface, debugstr_guid(riid),
1950 rgszNames, cNames, (int)lcid, rgDispId);
1951
1952 if (cNames == 0)
1953 {
1954 return E_INVALIDARG;
1955 }
1956 else
1957 {
1958 /* retrieve type information */
1959 hres = OLEPictureImpl_GetTypeInfo(iface, 0, lcid, &pTInfo);
1960
1961 if (FAILED(hres))
1962 {
1963 ERR("GetTypeInfo failed.\n");
1964 return hres;
1965 }
1966
1967 /* convert names to DISPIDs */
1968 hres = DispGetIDsOfNames (pTInfo, rgszNames, cNames, rgDispId);
1969 ITypeInfo_Release(pTInfo);
1970
1971 return hres;
1972 }
1973 }
1974
1975 /************************************************************************
1976 * OLEPictureImpl_Invoke (IDispatch)
1977 *
1978 * See Windows documentation for more details on IDispatch methods.
1979 */
1980 static HRESULT WINAPI OLEPictureImpl_Invoke(
1981 IDispatch* iface,
1982 DISPID dispIdMember,
1983 REFIID riid,
1984 LCID lcid,
1985 WORD wFlags,
1986 DISPPARAMS* pDispParams,
1987 VARIANT* pVarResult,
1988 EXCEPINFO* pExepInfo,
1989 UINT* puArgErr)
1990 {
1991 OLEPictureImpl *This = impl_from_IDispatch(iface);
1992
1993 /* validate parameters */
1994
1995 if (!IsEqualIID(riid, &IID_NULL))
1996 {
1997 ERR("riid was %s instead of IID_NULL\n", debugstr_guid(riid));
1998 return DISP_E_UNKNOWNNAME;
1999 }
2000
2001 if (!pDispParams)
2002 {
2003 ERR("null pDispParams not allowed\n");
2004 return DISP_E_PARAMNOTOPTIONAL;
2005 }
2006
2007 if (wFlags & DISPATCH_PROPERTYGET)
2008 {
2009 if (pDispParams->cArgs != 0)
2010 {
2011 ERR("param count for DISPATCH_PROPERTYGET was %d instead of 0\n", pDispParams->cArgs);
2012 return DISP_E_BADPARAMCOUNT;
2013 }
2014 if (!pVarResult)
2015 {
2016 ERR("null pVarResult not allowed when DISPATCH_PROPERTYGET specified\n");
2017 return DISP_E_PARAMNOTOPTIONAL;
2018 }
2019 }
2020 else if (wFlags & DISPATCH_PROPERTYPUT)
2021 {
2022 if (pDispParams->cArgs != 1)
2023 {
2024 ERR("param count for DISPATCH_PROPERTYPUT was %d instead of 1\n", pDispParams->cArgs);
2025 return DISP_E_BADPARAMCOUNT;
2026 }
2027 }
2028
2029 switch (dispIdMember)
2030 {
2031 case DISPID_PICT_HANDLE:
2032 if (wFlags & DISPATCH_PROPERTYGET)
2033 {
2034 TRACE("DISPID_PICT_HANDLE\n");
2035 V_VT(pVarResult) = VT_I4;
2036 return IPicture_get_Handle(&This->IPicture_iface, &V_UINT(pVarResult));
2037 }
2038 break;
2039 case DISPID_PICT_HPAL:
2040 if (wFlags & DISPATCH_PROPERTYGET)
2041 {
2042 TRACE("DISPID_PICT_HPAL\n");
2043 V_VT(pVarResult) = VT_I4;
2044 return IPicture_get_hPal(&This->IPicture_iface, &V_UINT(pVarResult));
2045 }
2046 else if (wFlags & DISPATCH_PROPERTYPUT)
2047 {
2048 VARIANTARG vararg;
2049 HRESULT hr;
2050 TRACE("DISPID_PICT_HPAL\n");
2051
2052 VariantInit(&vararg);
2053 hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_I4);
2054 if (FAILED(hr))
2055 return hr;
2056
2057 hr = IPicture_set_hPal(&This->IPicture_iface, V_I4(&vararg));
2058
2059 VariantClear(&vararg);
2060 return hr;
2061 }
2062 break;
2063 case DISPID_PICT_TYPE:
2064 if (wFlags & DISPATCH_PROPERTYGET)
2065 {
2066 TRACE("DISPID_PICT_TYPE\n");
2067 V_VT(pVarResult) = VT_I2;
2068 return OLEPictureImpl_get_Type(&This->IPicture_iface, &V_I2(pVarResult));
2069 }
2070 break;
2071 case DISPID_PICT_WIDTH:
2072 if (wFlags & DISPATCH_PROPERTYGET)
2073 {
2074 TRACE("DISPID_PICT_WIDTH\n");
2075 V_VT(pVarResult) = VT_I4;
2076 return IPicture_get_Width(&This->IPicture_iface, &V_I4(pVarResult));
2077 }
2078 break;
2079 case DISPID_PICT_HEIGHT:
2080 if (wFlags & DISPATCH_PROPERTYGET)
2081 {
2082 TRACE("DISPID_PICT_HEIGHT\n");
2083 V_VT(pVarResult) = VT_I4;
2084 return IPicture_get_Height(&This->IPicture_iface, &V_I4(pVarResult));
2085 }
2086 break;
2087 }
2088
2089 ERR("invalid dispid 0x%x or wFlags 0x%x\n", dispIdMember, wFlags);
2090 return DISP_E_MEMBERNOTFOUND;
2091 }
2092
2093
2094 static const IPictureVtbl OLEPictureImpl_VTable =
2095 {
2096 OLEPictureImpl_QueryInterface,
2097 OLEPictureImpl_AddRef,
2098 OLEPictureImpl_Release,
2099 OLEPictureImpl_get_Handle,
2100 OLEPictureImpl_get_hPal,
2101 OLEPictureImpl_get_Type,
2102 OLEPictureImpl_get_Width,
2103 OLEPictureImpl_get_Height,
2104 OLEPictureImpl_Render,
2105 OLEPictureImpl_set_hPal,
2106 OLEPictureImpl_get_CurDC,
2107 OLEPictureImpl_SelectPicture,
2108 OLEPictureImpl_get_KeepOriginalFormat,
2109 OLEPictureImpl_put_KeepOriginalFormat,
2110 OLEPictureImpl_PictureChanged,
2111 OLEPictureImpl_SaveAsFile,
2112 OLEPictureImpl_get_Attributes
2113 };
2114
2115 static const IDispatchVtbl OLEPictureImpl_IDispatch_VTable =
2116 {
2117 OLEPictureImpl_IDispatch_QueryInterface,
2118 OLEPictureImpl_IDispatch_AddRef,
2119 OLEPictureImpl_IDispatch_Release,
2120 OLEPictureImpl_GetTypeInfoCount,
2121 OLEPictureImpl_GetTypeInfo,
2122 OLEPictureImpl_GetIDsOfNames,
2123 OLEPictureImpl_Invoke
2124 };
2125
2126 static const IPersistStreamVtbl OLEPictureImpl_IPersistStream_VTable =
2127 {
2128 OLEPictureImpl_IPersistStream_QueryInterface,
2129 OLEPictureImpl_IPersistStream_AddRef,
2130 OLEPictureImpl_IPersistStream_Release,
2131 OLEPictureImpl_GetClassID,
2132 OLEPictureImpl_IsDirty,
2133 OLEPictureImpl_Load,
2134 OLEPictureImpl_Save,
2135 OLEPictureImpl_GetSizeMax
2136 };
2137
2138 static const IConnectionPointContainerVtbl OLEPictureImpl_IConnectionPointContainer_VTable =
2139 {
2140 OLEPictureImpl_IConnectionPointContainer_QueryInterface,
2141 OLEPictureImpl_IConnectionPointContainer_AddRef,
2142 OLEPictureImpl_IConnectionPointContainer_Release,
2143 OLEPictureImpl_EnumConnectionPoints,
2144 OLEPictureImpl_FindConnectionPoint
2145 };
2146
2147 /***********************************************************************
2148 * OleCreatePictureIndirect (OLEAUT32.419)
2149 */
2150 HRESULT WINAPI OleCreatePictureIndirect(LPPICTDESC lpPictDesc, REFIID riid,
2151 BOOL Own, void **ppvObj )
2152 {
2153 OLEPictureImpl* newPict;
2154 HRESULT hr;
2155
2156 TRACE("(%p,%s,%d,%p)\n", lpPictDesc, debugstr_guid(riid), Own, ppvObj);
2157
2158 *ppvObj = NULL;
2159
2160 newPict = OLEPictureImpl_Construct(lpPictDesc, Own);
2161
2162 if (newPict == NULL)
2163 return E_OUTOFMEMORY;
2164
2165 /*
2166 * Make sure it supports the interface required by the caller.
2167 */
2168 hr = IPicture_QueryInterface(&newPict->IPicture_iface, riid, ppvObj);
2169
2170 /*
2171 * Release the reference obtained in the constructor. If
2172 * the QueryInterface was unsuccessful, it will free the class.
2173 */
2174 IPicture_Release(&newPict->IPicture_iface);
2175
2176 return hr;
2177 }
2178
2179
2180 /***********************************************************************
2181 * OleLoadPicture (OLEAUT32.418)
2182 */
2183 HRESULT WINAPI OleLoadPicture( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
2184 REFIID riid, LPVOID *ppvObj )
2185 {
2186 LPPERSISTSTREAM ps;
2187 IPicture *newpic;
2188 HRESULT hr;
2189
2190 TRACE("(%p,%d,%d,%s,%p), partially implemented.\n",
2191 lpstream, lSize, fRunmode, debugstr_guid(riid), ppvObj);
2192
2193 hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
2194 if (hr != S_OK)
2195 return hr;
2196 hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
2197 if (hr != S_OK) {
2198 ERR("Could not get IPersistStream iface from Ole Picture?\n");
2199 IPicture_Release(newpic);
2200 *ppvObj = NULL;
2201 return hr;
2202 }
2203 hr = IPersistStream_Load(ps,lpstream);
2204 IPersistStream_Release(ps);
2205 if (FAILED(hr))
2206 {
2207 ERR("IPersistStream_Load failed\n");
2208 IPicture_Release(newpic);
2209 *ppvObj = NULL;
2210 return hr;
2211 }
2212 hr = IPicture_QueryInterface(newpic,riid,ppvObj);
2213 if (hr != S_OK)
2214 ERR("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
2215 IPicture_Release(newpic);
2216 return hr;
2217 }
2218
2219 /***********************************************************************
2220 * OleLoadPictureEx (OLEAUT32.401)
2221 */
2222 HRESULT WINAPI OleLoadPictureEx( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
2223 REFIID riid, DWORD xsiz, DWORD ysiz, DWORD flags, LPVOID *ppvObj )
2224 {
2225 LPPERSISTSTREAM ps;
2226 IPicture *newpic;
2227 HRESULT hr;
2228
2229 FIXME("(%p,%d,%d,%s,x=%d,y=%d,f=%x,%p), partially implemented.\n",
2230 lpstream, lSize, fRunmode, debugstr_guid(riid), xsiz, ysiz, flags, ppvObj);
2231
2232 hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
2233 if (hr != S_OK)
2234 return hr;
2235 hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
2236 if (hr != S_OK) {
2237 ERR("Could not get IPersistStream iface from Ole Picture?\n");
2238 IPicture_Release(newpic);
2239 *ppvObj = NULL;
2240 return hr;
2241 }
2242 hr = IPersistStream_Load(ps,lpstream);
2243 IPersistStream_Release(ps);
2244 if (FAILED(hr))
2245 {
2246 ERR("IPersistStream_Load failed\n");
2247 IPicture_Release(newpic);
2248 *ppvObj = NULL;
2249 return hr;
2250 }
2251 hr = IPicture_QueryInterface(newpic,riid,ppvObj);
2252 if (hr != S_OK)
2253 ERR("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
2254 IPicture_Release(newpic);
2255 return hr;
2256 }
2257
2258 /***********************************************************************
2259 * OleLoadPicturePath (OLEAUT32.424)
2260 */
2261 HRESULT WINAPI OleLoadPicturePath( LPOLESTR szURLorPath, LPUNKNOWN punkCaller,
2262 DWORD dwReserved, OLE_COLOR clrReserved, REFIID riid,
2263 LPVOID *ppvRet )
2264 {
2265 static const WCHAR file[] = { 'f','i','l','e',':',0 };
2266 IPicture *ipicture;
2267 HANDLE hFile;
2268 DWORD dwFileSize;
2269 HGLOBAL hGlobal = NULL;
2270 DWORD dwBytesRead = 0;
2271 IStream *stream;
2272 BOOL bRead;
2273 IPersistStream *pStream;
2274 HRESULT hRes;
2275 HRESULT init_res;
2276 WCHAR *file_candidate;
2277 WCHAR path_buf[MAX_PATH];
2278
2279 TRACE("(%s,%p,%d,%08x,%s,%p): stub\n",
2280 debugstr_w(szURLorPath), punkCaller, dwReserved, clrReserved,
2281 debugstr_guid(riid), ppvRet);
2282
2283 if (!szURLorPath || !ppvRet)
2284 return E_INVALIDARG;
2285
2286 *ppvRet = NULL;
2287
2288 /* Convert file URLs to DOS paths. */
2289 if (strncmpW(szURLorPath, file, 5) == 0) {
2290 DWORD size;
2291 hRes = CoInternetParseUrl(szURLorPath, PARSE_PATH_FROM_URL, 0, path_buf,
2292 sizeof(path_buf)/sizeof(WCHAR), &size, 0);
2293 if (FAILED(hRes))
2294 return hRes;
2295
2296 file_candidate = path_buf;
2297 }
2298 else
2299 file_candidate = szURLorPath;
2300
2301 /* Handle candidate DOS paths separately. */
2302 if (file_candidate[1] == ':') {
2303 hFile = CreateFileW(file_candidate, GENERIC_READ, 0, NULL, OPEN_EXISTING,
2304 0, NULL);
2305 if (hFile == INVALID_HANDLE_VALUE)
2306 return INET_E_RESOURCE_NOT_FOUND;
2307
2308 dwFileSize = GetFileSize(hFile, NULL);
2309 if (dwFileSize != INVALID_FILE_SIZE )
2310 {
2311 hGlobal = GlobalAlloc(GMEM_FIXED,dwFileSize);
2312 if ( hGlobal)
2313 {
2314 bRead = ReadFile(hFile, hGlobal, dwFileSize, &dwBytesRead, NULL);
2315 if (!bRead)
2316 {
2317 GlobalFree(hGlobal);
2318 hGlobal = 0;
2319 }
2320 }
2321 }
2322 CloseHandle(hFile);
2323
2324 if (!hGlobal)
2325 return INET_E_RESOURCE_NOT_FOUND;
2326
2327 hRes = CreateStreamOnHGlobal(hGlobal, TRUE, &stream);
2328 if (FAILED(hRes))
2329 {
2330 GlobalFree(hGlobal);
2331 return hRes;
2332 }
2333 } else {
2334 IMoniker *pmnk;
2335 IBindCtx *pbc;
2336
2337 hRes = CreateBindCtx(0, &pbc);
2338 if (SUCCEEDED(hRes))
2339 {
2340 hRes = CreateURLMoniker(NULL, szURLorPath, &pmnk);
2341 if (SUCCEEDED(hRes))
2342 {
2343 hRes = IMoniker_BindToStorage(pmnk, pbc, NULL, &IID_IStream, (LPVOID*)&stream);
2344 IMoniker_Release(pmnk);
2345 }
2346 IBindCtx_Release(pbc);
2347 }
2348 if (FAILED(hRes))
2349 return hRes;
2350 }
2351
2352 init_res = CoInitialize(NULL);
2353
2354 hRes = CoCreateInstance(&CLSID_StdPicture, punkCaller, CLSCTX_INPROC_SERVER,
2355 &IID_IPicture, (LPVOID*)&ipicture);
2356 if (SUCCEEDED(hRes)) {
2357 hRes = IPicture_QueryInterface(ipicture, &IID_IPersistStream, (LPVOID*)&pStream);
2358
2359 if (SUCCEEDED(hRes)) {
2360 hRes = IPersistStream_Load(pStream, stream);
2361
2362 if (SUCCEEDED(hRes)) {
2363 hRes = IPicture_QueryInterface(ipicture, riid, ppvRet);
2364
2365 if (FAILED(hRes))
2366 ERR("Failed to get interface %s from IPicture.\n", debugstr_guid(riid));
2367 }
2368 IPersistStream_Release(pStream);
2369 }
2370 IPicture_Release(ipicture);
2371 }
2372
2373 IStream_Release(stream);
2374
2375 if (SUCCEEDED(init_res))
2376 CoUninitialize();
2377
2378 return hRes;
2379 }
2380
2381 /*******************************************************************************
2382 * StdPic ClassFactory
2383 */
2384 typedef struct
2385 {
2386 /* IUnknown fields */
2387 IClassFactory IClassFactory_iface;
2388 LONG ref;
2389 } IClassFactoryImpl;
2390
2391 static inline IClassFactoryImpl *impl_from_IClassFactory(IClassFactory *iface)
2392 {
2393 return CONTAINING_RECORD(iface, IClassFactoryImpl, IClassFactory_iface);
2394 }
2395
2396 static HRESULT WINAPI
2397 SPCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
2398 IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2399
2400 FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
2401 return E_NOINTERFACE;
2402 }
2403
2404 static ULONG WINAPI
2405 SPCF_AddRef(LPCLASSFACTORY iface) {
2406 IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2407 return InterlockedIncrement(&This->ref);
2408 }
2409
2410 static ULONG WINAPI SPCF_Release(LPCLASSFACTORY iface) {
2411 IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2412 /* static class, won't be freed */
2413 return InterlockedDecrement(&This->ref);
2414 }
2415
2416 static HRESULT WINAPI SPCF_CreateInstance(
2417 LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
2418 ) {
2419 /* Creates an uninitialized picture */
2420 return OleCreatePictureIndirect(NULL,riid,TRUE,ppobj);
2421
2422 }
2423
2424 static HRESULT WINAPI SPCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
2425 IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2426 FIXME("(%p)->(%d),stub!\n",This,dolock);
2427 return S_OK;
2428 }
2429
2430 static const IClassFactoryVtbl SPCF_Vtbl = {
2431 SPCF_QueryInterface,
2432 SPCF_AddRef,
2433 SPCF_Release,
2434 SPCF_CreateInstance,
2435 SPCF_LockServer
2436 };
2437 static IClassFactoryImpl STDPIC_CF = {{&SPCF_Vtbl}, 1 };
2438
2439 void _get_STDPIC_CF(LPVOID *ppv) { *ppv = &STDPIC_CF; }
Maarten's multimedia branch