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