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