source: trunk/src/oleaut32/olepicture.c@ 10010

Last change on this file since 10010 was 9400, checked in by sandervl, 23 years ago

Wine resync
File size: 36.6 KB
Line 
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 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 *
23 * BUGS
24 *
25 * Support PICTYPE_BITMAP and PICTYPE_ICON, altough only bitmaps very well..
26 * Lots of methods are just stubs.
27 *
28 *
29 * NOTES (or things that msdn doesn't tell you)
30 *
31 * The width and height properties are returned in HIMETRIC units (0.01mm)
32 * IPicture::Render also uses these to select a region of the src picture.
33 * A bitmap's size is converted into these units by using the screen resolution
34 * thus an 8x8 bitmap on a 96dpi screen has a size of 212x212 (8/96 * 2540).
35 *
36 */
37
38#include "config.h"
39
40#ifdef HAVE_UNISTD_H
41# include <unistd.h>
42#endif
43#include <stdio.h>
44#include <string.h>
45#include "winerror.h"
46#include "winbase.h"
47#include "wingdi.h"
48#include "winuser.h"
49#include "ole2.h"
50#include "olectl.h"
51#include "oleauto.h"
52#include "wine/obj_picture.h"
53#include "wine/obj_connection.h"
54#include "connpt.h"
55#include "wine/debug.h"
56
57#include "wine/wingdi16.h"
58#include "cursoricon.h"
59
60#ifdef HAVE_LIBJPEG
61/* This is a hack, so jpeglib.h does not redefine INT32 and the like*/
62#define XMD_H
63#define UINT8 JPEG_UINT8
64#define UINT16 JPEG_UINT16
65#ifdef HAVE_JPEGLIB_H
66# include <jpeglib.h>
67#endif
68#undef UINT16
69#endif
70
71WINE_DEFAULT_DEBUG_CHANNEL(ole);
72
73/*************************************************************************
74 * Declaration of implementation class
75 */
76
77typedef struct OLEPictureImpl {
78
79 /*
80 * IPicture handles IUnknown
81 */
82
83 ICOM_VTABLE(IPicture) *lpvtbl1;
84 ICOM_VTABLE(IDispatch) *lpvtbl2;
85 ICOM_VTABLE(IPersistStream) *lpvtbl3;
86 ICOM_VTABLE(IConnectionPointContainer) *lpvtbl4;
87
88 /* Object referenece count */
89 DWORD ref;
90
91 /* We own the object and must destroy it ourselves */
92 BOOL fOwn;
93
94 /* Picture description */
95 PICTDESC desc;
96
97 /* These are the pixel size of a bitmap */
98 DWORD origWidth;
99 DWORD origHeight;
100
101 /* And these are the size of the picture converted into HIMETRIC units */
102 OLE_XSIZE_HIMETRIC himetricWidth;
103 OLE_YSIZE_HIMETRIC himetricHeight;
104
105 IConnectionPoint *pCP;
106
107 BOOL keepOrigFormat;
108 HDC hDCCur;
109
110 /* data */
111 void* data;
112 int datalen;
113} OLEPictureImpl;
114
115/*
116 * Macros to retrieve pointer to IUnknown (IPicture) from the other VTables.
117 */
118#define ICOM_THIS_From_IDispatch(impl, name) \
119 impl *This = (impl*)(((char*)name)-sizeof(void*));
120#define ICOM_THIS_From_IPersistStream(impl, name) \
121 impl *This = (impl*)(((char*)name)-2*sizeof(void*));
122#define ICOM_THIS_From_IConnectionPointContainer(impl, name) \
123 impl *This = (impl*)(((char*)name)-3*sizeof(void*));
124
125/*
126 * Predeclare VTables. They get initialized at the end.
127 */
128static ICOM_VTABLE(IPicture) OLEPictureImpl_VTable;
129static ICOM_VTABLE(IDispatch) OLEPictureImpl_IDispatch_VTable;
130static ICOM_VTABLE(IPersistStream) OLEPictureImpl_IPersistStream_VTable;
131static ICOM_VTABLE(IConnectionPointContainer) OLEPictureImpl_IConnectionPointContainer_VTable;
132
133/***********************************************************************
134 * Implementation of the OLEPictureImpl class.
135 */
136
137static void OLEPictureImpl_SetBitmap(OLEPictureImpl*This) {
138 BITMAP bm;
139 HDC hdcRef;
140
141 TRACE("bitmap handle %p\n", This->desc.u.bmp.hbitmap);
142 if(GetObjectA(This->desc.u.bmp.hbitmap, sizeof(bm), &bm) != sizeof(bm)) {
143 ERR("GetObject fails\n");
144 return;
145 }
146 This->origWidth = bm.bmWidth;
147 This->origHeight = bm.bmHeight;
148 /* The width and height are stored in HIMETRIC units (0.01 mm),
149 so we take our pixel width divide by pixels per inch and
150 multiply by 25.4 * 100 */
151 /* Should we use GetBitmapDimension if available? */
152 hdcRef = CreateCompatibleDC(0);
153 This->himetricWidth =(bm.bmWidth *2540)/GetDeviceCaps(hdcRef, LOGPIXELSX);
154 This->himetricHeight=(bm.bmHeight*2540)/GetDeviceCaps(hdcRef, LOGPIXELSY);
155 DeleteDC(hdcRef);
156}
157
158/************************************************************************
159 * OLEPictureImpl_Construct
160 *
161 * This method will construct a new instance of the OLEPictureImpl
162 * class.
163 *
164 * The caller of this method must release the object when it's
165 * done with it.
166 */
167static OLEPictureImpl* OLEPictureImpl_Construct(LPPICTDESC pictDesc, BOOL fOwn)
168{
169 OLEPictureImpl* newObject = 0;
170
171 if (pictDesc)
172 TRACE("(%p) type = %d\n", pictDesc, pictDesc->picType);
173
174 /*
175 * Allocate space for the object.
176 */
177 newObject = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(OLEPictureImpl));
178
179 if (newObject==0)
180 return newObject;
181
182 /*
183 * Initialize the virtual function table.
184 */
185 newObject->lpvtbl1 = &OLEPictureImpl_VTable;
186 newObject->lpvtbl2 = &OLEPictureImpl_IDispatch_VTable;
187 newObject->lpvtbl3 = &OLEPictureImpl_IPersistStream_VTable;
188 newObject->lpvtbl4 = &OLEPictureImpl_IConnectionPointContainer_VTable;
189
190 CreateConnectionPoint((IUnknown*)newObject,&IID_IPropertyNotifySink,&newObject->pCP);
191
192 /*
193 * Start with one reference count. The caller of this function
194 * must release the interface pointer when it is done.
195 */
196 newObject->ref = 1;
197 newObject->hDCCur = 0;
198
199 newObject->fOwn = fOwn;
200
201 /* dunno about original value */
202 newObject->keepOrigFormat = TRUE;
203
204 if (pictDesc) {
205 if(pictDesc->cbSizeofstruct != sizeof(PICTDESC)) {
206 FIXME("struct size = %d\n", pictDesc->cbSizeofstruct);
207 }
208 memcpy(&newObject->desc, pictDesc, sizeof(PICTDESC));
209
210
211 switch(pictDesc->picType) {
212 case PICTYPE_BITMAP:
213 OLEPictureImpl_SetBitmap(newObject);
214 break;
215
216 case PICTYPE_METAFILE:
217 TRACE("metafile handle %p\n", pictDesc->u.wmf.hmeta);
218 newObject->himetricWidth = pictDesc->u.wmf.xExt;
219 newObject->himetricHeight = pictDesc->u.wmf.yExt;
220 break;
221
222 case PICTYPE_ICON:
223 case PICTYPE_ENHMETAFILE:
224 default:
225 FIXME("Unsupported type %d\n", pictDesc->picType);
226 newObject->himetricWidth = newObject->himetricHeight = 0;
227 break;
228 }
229 } else {
230 newObject->desc.picType = PICTYPE_UNINITIALIZED;
231 }
232
233 TRACE("returning %p\n", newObject);
234 return newObject;
235}
236
237/************************************************************************
238 * OLEPictureImpl_Destroy
239 *
240 * This method is called by the Release method when the reference
241 * count goes down to 0. It will free all resources used by
242 * this object. */
243static void OLEPictureImpl_Destroy(OLEPictureImpl* Obj)
244{
245 TRACE("(%p)\n", Obj);
246
247 if(Obj->fOwn) { /* We need to destroy the picture */
248 switch(Obj->desc.picType) {
249 case PICTYPE_BITMAP:
250 DeleteObject(Obj->desc.u.bmp.hbitmap);
251 break;
252 case PICTYPE_METAFILE:
253 DeleteMetaFile(Obj->desc.u.wmf.hmeta);
254 break;
255 case PICTYPE_ICON:
256 DestroyIcon(Obj->desc.u.icon.hicon);
257 break;
258 case PICTYPE_ENHMETAFILE:
259 DeleteEnhMetaFile(Obj->desc.u.emf.hemf);
260 break;
261 default:
262 FIXME("Unsupported type %d - unable to delete\n", Obj->desc.picType);
263 break;
264 }
265 }
266 if (Obj->data) HeapFree(GetProcessHeap(), 0, Obj->data);
267 HeapFree(GetProcessHeap(), 0, Obj);
268}
269
270static ULONG WINAPI OLEPictureImpl_AddRef(IPicture* iface);
271
272/************************************************************************
273 * OLEPictureImpl_QueryInterface (IUnknown)
274 *
275 * See Windows documentation for more details on IUnknown methods.
276 */
277static HRESULT WINAPI OLEPictureImpl_QueryInterface(
278 IPicture* iface,
279 REFIID riid,
280 void** ppvObject)
281{
282 ICOM_THIS(OLEPictureImpl, iface);
283 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
284
285 /*
286 * Perform a sanity check on the parameters.
287 */
288 if ( (This==0) || (ppvObject==0) )
289 return E_INVALIDARG;
290
291 /*
292 * Initialize the return parameter.
293 */
294 *ppvObject = 0;
295
296 /*
297 * Compare the riid with the interface IDs implemented by this object.
298 */
299 if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
300 {
301 *ppvObject = (IPicture*)This;
302 }
303 else if (memcmp(&IID_IPicture, riid, sizeof(IID_IPicture)) == 0)
304 {
305 *ppvObject = (IPicture*)This;
306 }
307 else if (memcmp(&IID_IDispatch, riid, sizeof(IID_IDispatch)) == 0)
308 {
309 *ppvObject = (IDispatch*)&(This->lpvtbl2);
310 }
311 else if (memcmp(&IID_IPictureDisp, riid, sizeof(IID_IPictureDisp)) == 0)
312 {
313 *ppvObject = (IDispatch*)&(This->lpvtbl2);
314 }
315 else if (memcmp(&IID_IPersistStream, riid, sizeof(IID_IPersistStream)) == 0)
316 {
317 *ppvObject = (IPersistStream*)&(This->lpvtbl3);
318 }
319 else if (memcmp(&IID_IConnectionPointContainer, riid, sizeof(IID_IConnectionPointContainer)) == 0)
320 {
321 *ppvObject = (IConnectionPointContainer*)&(This->lpvtbl4);
322 }
323 /*
324 * Check that we obtained an interface.
325 */
326 if ((*ppvObject)==0)
327 {
328 FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid));
329 return E_NOINTERFACE;
330 }
331
332 /*
333 * Query Interface always increases the reference count by one when it is
334 * successful
335 */
336 OLEPictureImpl_AddRef((IPicture*)This);
337
338 return S_OK;
339}
340/***********************************************************************
341 * OLEPicture_SendNotify (internal)
342 *
343 * Sends notification messages of changed properties to any interested
344 * connections.
345 */
346static void OLEPicture_SendNotify(OLEPictureImpl* this, DISPID dispID)
347{
348 IEnumConnections *pEnum;
349 CONNECTDATA CD;
350
351 if (IConnectionPoint_EnumConnections(this->pCP, &pEnum))
352 return;
353 while(IEnumConnections_Next(pEnum, 1, &CD, NULL) == S_OK) {
354 IPropertyNotifySink *sink;
355
356 IUnknown_QueryInterface(CD.pUnk, &IID_IPropertyNotifySink, (LPVOID)&sink);
357 IPropertyNotifySink_OnChanged(sink, dispID);
358 IPropertyNotifySink_Release(sink);
359 IUnknown_Release(CD.pUnk);
360 }
361 IEnumConnections_Release(pEnum);
362 return;
363}
364
365/************************************************************************
366 * OLEPictureImpl_AddRef (IUnknown)
367 *
368 * See Windows documentation for more details on IUnknown methods.
369 */
370static ULONG WINAPI OLEPictureImpl_AddRef(
371 IPicture* iface)
372{
373 ICOM_THIS(OLEPictureImpl, iface);
374 TRACE("(%p)->(ref=%ld)\n", This, This->ref);
375 This->ref++;
376
377 return This->ref;
378}
379
380/************************************************************************
381 * OLEPictureImpl_Release (IUnknown)
382 *
383 * See Windows documentation for more details on IUnknown methods.
384 */
385static ULONG WINAPI OLEPictureImpl_Release(
386 IPicture* iface)
387{
388 ICOM_THIS(OLEPictureImpl, iface);
389 TRACE("(%p)->(ref=%ld)\n", This, This->ref);
390
391 /*
392 * Decrease the reference count on this object.
393 */
394 This->ref--;
395
396 /*
397 * If the reference count goes down to 0, perform suicide.
398 */
399 if (This->ref==0)
400 {
401 OLEPictureImpl_Destroy(This);
402
403 return 0;
404 }
405
406 return This->ref;
407}
408
409
410/************************************************************************
411 * OLEPictureImpl_get_Handle
412 */
413static HRESULT WINAPI OLEPictureImpl_get_Handle(IPicture *iface,
414 OLE_HANDLE *phandle)
415{
416 ICOM_THIS(OLEPictureImpl, iface);
417 TRACE("(%p)->(%p)\n", This, phandle);
418 switch(This->desc.picType) {
419 case PICTYPE_BITMAP:
420 *phandle = (OLE_HANDLE)This->desc.u.bmp.hbitmap;
421 break;
422 case PICTYPE_METAFILE:
423 *phandle = (OLE_HANDLE)This->desc.u.wmf.hmeta;
424 break;
425 case PICTYPE_ICON:
426 *phandle = (OLE_HANDLE)This->desc.u.icon.hicon;
427 break;
428 case PICTYPE_ENHMETAFILE:
429 *phandle = (OLE_HANDLE)This->desc.u.emf.hemf;
430 break;
431 default:
432 FIXME("Unimplemented type %d\n", This->desc.picType);
433 return E_NOTIMPL;
434 }
435 TRACE("returning handle %08x\n", *phandle);
436 return S_OK;
437}
438
439/************************************************************************
440 * OLEPictureImpl_get_hPal
441 */
442static HRESULT WINAPI OLEPictureImpl_get_hPal(IPicture *iface,
443 OLE_HANDLE *phandle)
444{
445 ICOM_THIS(OLEPictureImpl, iface);
446 FIXME("(%p)->(%p): stub\n", This, phandle);
447 return E_NOTIMPL;
448}
449
450/************************************************************************
451 * OLEPictureImpl_get_Type
452 */
453static HRESULT WINAPI OLEPictureImpl_get_Type(IPicture *iface,
454 short *ptype)
455{
456 ICOM_THIS(OLEPictureImpl, iface);
457 TRACE("(%p)->(%p): type is %d\n", This, ptype, This->desc.picType);
458 *ptype = This->desc.picType;
459 return S_OK;
460}
461
462/************************************************************************
463 * OLEPictureImpl_get_Width
464 */
465static HRESULT WINAPI OLEPictureImpl_get_Width(IPicture *iface,
466 OLE_XSIZE_HIMETRIC *pwidth)
467{
468 ICOM_THIS(OLEPictureImpl, iface);
469 TRACE("(%p)->(%p): width is %ld\n", This, pwidth, This->himetricWidth);
470 *pwidth = This->himetricWidth;
471 return S_OK;
472}
473
474/************************************************************************
475 * OLEPictureImpl_get_Height
476 */
477static HRESULT WINAPI OLEPictureImpl_get_Height(IPicture *iface,
478 OLE_YSIZE_HIMETRIC *pheight)
479{
480 ICOM_THIS(OLEPictureImpl, iface);
481 TRACE("(%p)->(%p): height is %ld\n", This, pheight, This->himetricHeight);
482 *pheight = This->himetricHeight;
483 return S_OK;
484}
485
486/************************************************************************
487 * OLEPictureImpl_Render
488 */
489static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
490 long x, long y, long cx, long cy,
491 OLE_XPOS_HIMETRIC xSrc,
492 OLE_YPOS_HIMETRIC ySrc,
493 OLE_XSIZE_HIMETRIC cxSrc,
494 OLE_YSIZE_HIMETRIC cySrc,
495 LPCRECT prcWBounds)
496{
497 ICOM_THIS(OLEPictureImpl, iface);
498 TRACE("(%p)->(%p, (%ld,%ld), (%ld,%ld) <- (%ld,%ld), (%ld,%ld), %p)\n",
499 This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, prcWBounds);
500 if(prcWBounds)
501 TRACE("prcWBounds (%d,%d) - (%d,%d)\n", prcWBounds->left, prcWBounds->top,
502 prcWBounds->right, prcWBounds->bottom);
503
504 /*
505 * While the documentation suggests this to be here (or after rendering?)
506 * it does cause an endless recursion in my sample app. -MM 20010804
507 OLEPicture_SendNotify(This,DISPID_PICT_RENDER);
508 */
509
510 switch(This->desc.picType) {
511 case PICTYPE_BITMAP:
512 {
513 HBITMAP hbmpOld;
514 HDC hdcBmp;
515
516 /* Set a mapping mode that maps bitmap pixels into HIMETRIC units.
517 NB y-axis gets flipped */
518
519 hdcBmp = CreateCompatibleDC(0);
520 SetMapMode(hdcBmp, MM_ANISOTROPIC);
521 SetWindowOrgEx(hdcBmp, 0, 0, NULL);
522 SetWindowExtEx(hdcBmp, This->himetricWidth, This->himetricHeight, NULL);
523 SetViewportOrgEx(hdcBmp, 0, This->origHeight, NULL);
524 SetViewportExtEx(hdcBmp, This->origWidth, -This->origHeight, NULL);
525
526 hbmpOld = SelectObject(hdcBmp, This->desc.u.bmp.hbitmap);
527
528 StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc, cxSrc, cySrc, SRCCOPY);
529
530 SelectObject(hdcBmp, hbmpOld);
531 DeleteDC(hdcBmp);
532 }
533 break;
534 case PICTYPE_ICON:
535 FIXME("Not quite correct implementation of rendering icons...\n");
536 DrawIcon(hdc,x,y,This->desc.u.icon.hicon);
537 break;
538
539 case PICTYPE_METAFILE:
540 case PICTYPE_ENHMETAFILE:
541 default:
542 FIXME("type %d not implemented\n", This->desc.picType);
543 return E_NOTIMPL;
544 }
545 return S_OK;
546}
547
548/************************************************************************
549 * OLEPictureImpl_set_hPal
550 */
551static HRESULT WINAPI OLEPictureImpl_set_hPal(IPicture *iface,
552 OLE_HANDLE hpal)
553{
554 ICOM_THIS(OLEPictureImpl, iface);
555 FIXME("(%p)->(%08x): stub\n", This, hpal);
556 OLEPicture_SendNotify(This,DISPID_PICT_HPAL);
557 return E_NOTIMPL;
558}
559
560/************************************************************************
561 * OLEPictureImpl_get_CurDC
562 */
563static HRESULT WINAPI OLEPictureImpl_get_CurDC(IPicture *iface,
564 HDC *phdc)
565{
566 ICOM_THIS(OLEPictureImpl, iface);
567 TRACE("(%p), returning %p\n", This, This->hDCCur);
568 if (phdc) *phdc = This->hDCCur;
569 return S_OK;
570}
571
572/************************************************************************
573 * OLEPictureImpl_SelectPicture
574 */
575static HRESULT WINAPI OLEPictureImpl_SelectPicture(IPicture *iface,
576 HDC hdcIn,
577 HDC *phdcOut,
578 OLE_HANDLE *phbmpOut)
579{
580 ICOM_THIS(OLEPictureImpl, iface);
581 TRACE("(%p)->(%p, %p, %p)\n", This, hdcIn, phdcOut, phbmpOut);
582 if (This->desc.picType == PICTYPE_BITMAP) {
583 SelectObject(hdcIn,This->desc.u.bmp.hbitmap);
584
585 if (phdcOut)
586 *phdcOut = This->hDCCur;
587 This->hDCCur = hdcIn;
588 if (phbmpOut)
589 *phbmpOut = (OLE_HANDLE)This->desc.u.bmp.hbitmap;
590 return S_OK;
591 } else {
592 FIXME("Don't know how to select picture type %d\n",This->desc.picType);
593 return E_FAIL;
594 }
595}
596
597/************************************************************************
598 * OLEPictureImpl_get_KeepOriginalFormat
599 */
600static HRESULT WINAPI OLEPictureImpl_get_KeepOriginalFormat(IPicture *iface,
601 BOOL *pfKeep)
602{
603 ICOM_THIS(OLEPictureImpl, iface);
604 TRACE("(%p)->(%p)\n", This, pfKeep);
605 if (!pfKeep)
606 return E_POINTER;
607 *pfKeep = This->keepOrigFormat;
608 return S_OK;
609}
610
611/************************************************************************
612 * OLEPictureImpl_put_KeepOriginalFormat
613 */
614static HRESULT WINAPI OLEPictureImpl_put_KeepOriginalFormat(IPicture *iface,
615 BOOL keep)
616{
617 ICOM_THIS(OLEPictureImpl, iface);
618 TRACE("(%p)->(%d)\n", This, keep);
619 This->keepOrigFormat = keep;
620 /* FIXME: what DISPID notification here? */
621 return S_OK;
622}
623
624/************************************************************************
625 * OLEPictureImpl_PictureChanged
626 */
627static HRESULT WINAPI OLEPictureImpl_PictureChanged(IPicture *iface)
628{
629 ICOM_THIS(OLEPictureImpl, iface);
630 TRACE("(%p)->()\n", This);
631 OLEPicture_SendNotify(This,DISPID_PICT_HANDLE);
632 return S_OK;
633}
634
635/************************************************************************
636 * OLEPictureImpl_SaveAsFile
637 */
638static HRESULT WINAPI OLEPictureImpl_SaveAsFile(IPicture *iface,
639 IStream *pstream,
640 BOOL SaveMemCopy,
641 LONG *pcbSize)
642{
643 ICOM_THIS(OLEPictureImpl, iface);
644 FIXME("(%p)->(%p, %d, %p), hacked stub.\n", This, pstream, SaveMemCopy, pcbSize);
645 return IStream_Write(pstream,This->data,This->datalen,(ULONG*)pcbSize);
646}
647
648/************************************************************************
649 * OLEPictureImpl_get_Attributes
650 */
651static HRESULT WINAPI OLEPictureImpl_get_Attributes(IPicture *iface,
652 DWORD *pdwAttr)
653{
654 ICOM_THIS(OLEPictureImpl, iface);
655 TRACE("(%p)->(%p).\n", This, pdwAttr);
656 *pdwAttr = 0;
657 switch (This->desc.picType) {
658 case PICTYPE_BITMAP: break; /* not 'truely' scalable, see MSDN. */
659 case PICTYPE_ICON: *pdwAttr = PICTURE_TRANSPARENT;break;
660 case PICTYPE_METAFILE: *pdwAttr = PICTURE_TRANSPARENT|PICTURE_SCALABLE;break;
661 default:FIXME("Unknown pictype %d\n",This->desc.picType);break;
662 }
663 return S_OK;
664}
665
666
667/************************************************************************
668 * IConnectionPointContainer
669 */
670
671static HRESULT WINAPI OLEPictureImpl_IConnectionPointContainer_QueryInterface(
672 IConnectionPointContainer* iface,
673 REFIID riid,
674 VOID** ppvoid
675) {
676 ICOM_THIS_From_IConnectionPointContainer(IPicture,iface);
677
678 return IPicture_QueryInterface(This,riid,ppvoid);
679}
680
681static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_AddRef(
682 IConnectionPointContainer* iface)
683{
684 ICOM_THIS_From_IConnectionPointContainer(IPicture, iface);
685
686 return IPicture_AddRef(This);
687}
688
689static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_Release(
690 IConnectionPointContainer* iface)
691{
692 ICOM_THIS_From_IConnectionPointContainer(IPicture, iface);
693
694 return IPicture_Release(This);
695}
696
697static HRESULT WINAPI OLEPictureImpl_EnumConnectionPoints(
698 IConnectionPointContainer* iface,
699 IEnumConnectionPoints** ppEnum
700) {
701 ICOM_THIS_From_IConnectionPointContainer(IPicture, iface);
702
703 FIXME("(%p,%p), stub!\n",This,ppEnum);
704 return E_NOTIMPL;
705}
706
707static HRESULT WINAPI OLEPictureImpl_FindConnectionPoint(
708 IConnectionPointContainer* iface,
709 REFIID riid,
710 IConnectionPoint **ppCP
711) {
712 ICOM_THIS_From_IConnectionPointContainer(OLEPictureImpl, iface);
713 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppCP);
714 if (!ppCP)
715 return E_POINTER;
716 *ppCP = NULL;
717 if (IsEqualGUID(riid,&IID_IPropertyNotifySink))
718 return IConnectionPoint_QueryInterface(This->pCP,&IID_IConnectionPoint,(LPVOID)ppCP);
719 FIXME("tried to find connection point on %s?\n",debugstr_guid(riid));
720 return 0x80040200;
721}
722/************************************************************************
723 * IPersistStream
724 */
725/************************************************************************
726 * OLEPictureImpl_IPersistStream_QueryInterface (IUnknown)
727 *
728 * See Windows documentation for more details on IUnknown methods.
729 */
730static HRESULT WINAPI OLEPictureImpl_IPersistStream_QueryInterface(
731 IPersistStream* iface,
732 REFIID riid,
733 VOID** ppvoid)
734{
735 ICOM_THIS_From_IPersistStream(IPicture, iface);
736
737 return IPicture_QueryInterface(This, riid, ppvoid);
738}
739
740/************************************************************************
741 * OLEPictureImpl_IPersistStream_AddRef (IUnknown)
742 *
743 * See Windows documentation for more details on IUnknown methods.
744 */
745static ULONG WINAPI OLEPictureImpl_IPersistStream_AddRef(
746 IPersistStream* iface)
747{
748 ICOM_THIS_From_IPersistStream(IPicture, iface);
749
750 return IPicture_AddRef(This);
751}
752
753/************************************************************************
754 * OLEPictureImpl_IPersistStream_Release (IUnknown)
755 *
756 * See Windows documentation for more details on IUnknown methods.
757 */
758static ULONG WINAPI OLEPictureImpl_IPersistStream_Release(
759 IPersistStream* iface)
760{
761 ICOM_THIS_From_IPersistStream(IPicture, iface);
762
763 return IPicture_Release(This);
764}
765
766/************************************************************************
767 * OLEPictureImpl_IPersistStream_GetClassID
768 */
769static HRESULT WINAPI OLEPictureImpl_GetClassID(
770 IPersistStream* iface,CLSID* pClassID)
771{
772 ICOM_THIS_From_IPersistStream(IPicture, iface);
773 FIXME("(%p),stub!\n",This);
774 return E_NOTIMPL;
775}
776
777/************************************************************************
778 * OLEPictureImpl_IPersistStream_IsDirty
779 */
780static HRESULT WINAPI OLEPictureImpl_IsDirty(
781 IPersistStream* iface)
782{
783 ICOM_THIS_From_IPersistStream(IPicture, iface);
784 FIXME("(%p),stub!\n",This);
785 return E_NOTIMPL;
786}
787
788#ifdef HAVE_LIBJPEG
789/* for the jpeg decompressor source manager. */
790static void _jpeg_init_source(j_decompress_ptr cinfo) { }
791
792static boolean _jpeg_fill_input_buffer(j_decompress_ptr cinfo) {
793 ERR("(), should not get here.\n");
794 return FALSE;
795}
796
797static void _jpeg_skip_input_data(j_decompress_ptr cinfo,long num_bytes) {
798 ERR("(%ld), should not get here.\n",num_bytes);
799}
800
801static boolean _jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired) {
802 ERR("(desired=%d), should not get here.\n",desired);
803 return FALSE;
804}
805static void _jpeg_term_source(j_decompress_ptr cinfo) { }
806#endif /* HAVE_LIBJPEG */
807
808/************************************************************************
809 * OLEPictureImpl_IPersistStream_Load (IUnknown)
810 *
811 * Loads the binary data from the IStream. Starts at current position.
812 * There appears to be an 2 DWORD header:
813 * DWORD magic;
814 * DWORD len;
815 *
816 * Currently implemented: BITMAP, ICON, JPEG.
817 */
818static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface,IStream*pStm) {
819 HRESULT hr = E_FAIL;
820 ULONG xread;
821 BYTE *xbuf;
822 DWORD header[2];
823 WORD magic;
824 ICOM_THIS_From_IPersistStream(OLEPictureImpl, iface);
825
826 TRACE("(%p,%p)\n",This,pStm);
827
828 hr=IStream_Read(pStm,header,8,&xread);
829 if (hr || xread!=8) {
830 FIXME("Failure while reading picture header (hr is %lx, nread is %ld).\n",hr,xread);
831 return hr;
832 }
833 xread = 0;
834 xbuf = This->data = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,header[1]);
835 This->datalen = header[1];
836 while (xread < header[1]) {
837 ULONG nread;
838 hr = IStream_Read(pStm,xbuf+xread,header[1]-xread,&nread);
839 xread+=nread;
840 if (hr || !nread)
841 break;
842 }
843 if (xread != header[1])
844 FIXME("Could only read %ld of %ld bytes?\n",xread,header[1]);
845
846 magic = xbuf[0] + (xbuf[1]<<8);
847 switch (magic) {
848 case 0xd8ff: { /* JPEG */
849#ifdef HAVE_LIBJPEG
850 struct jpeg_decompress_struct jd;
851 struct jpeg_error_mgr jerr;
852 int ret;
853 JDIMENSION x;
854 JSAMPROW samprow;
855 BITMAPINFOHEADER bmi;
856 LPBYTE bits;
857 HDC hdcref;
858 struct jpeg_source_mgr xjsm;
859
860 /* This is basically so we can use in-memory data for jpeg decompression.
861 * We need to have all the functions.
862 */
863 xjsm.next_input_byte = xbuf;
864 xjsm.bytes_in_buffer = xread;
865 xjsm.init_source = _jpeg_init_source;
866 xjsm.fill_input_buffer = _jpeg_fill_input_buffer;
867 xjsm.skip_input_data = _jpeg_skip_input_data;
868 xjsm.resync_to_restart = _jpeg_resync_to_restart;
869 xjsm.term_source = _jpeg_term_source;
870
871 jd.err = jpeg_std_error(&jerr);
872 jpeg_create_decompress(&jd);
873 jd.src = &xjsm;
874 ret=jpeg_read_header(&jd,TRUE);
875 jpeg_start_decompress(&jd);
876 if (ret != JPEG_HEADER_OK) {
877 ERR("Jpeg image in stream has bad format, read header returned %d.\n",ret);
878 HeapFree(GetProcessHeap(),0,xbuf);
879 return E_FAIL;
880 }
881 bits = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(jd.output_height+1)*jd.output_width*jd.output_components);
882 samprow=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,jd.output_width*jd.output_components);
883 while ( jd.output_scanline<jd.output_height ) {
884 x = jpeg_read_scanlines(&jd,&samprow,1);
885 if (x != 1) {
886 FIXME("failed to read current scanline?\n");
887 break;
888 }
889 memcpy( bits+jd.output_scanline*jd.output_width*jd.output_components,
890 samprow,
891 jd.output_width*jd.output_components
892 );
893 }
894 bmi.biSize = sizeof(bmi);
895 bmi.biWidth = jd.output_width;
896 bmi.biHeight = -jd.output_height;
897 bmi.biPlanes = 1;
898 bmi.biBitCount = jd.output_components<<3;
899 bmi.biCompression = BI_RGB;
900 bmi.biSizeImage = jd.output_height*jd.output_width*jd.output_components;
901 bmi.biXPelsPerMeter = 0;
902 bmi.biYPelsPerMeter = 0;
903 bmi.biClrUsed = 0;
904 bmi.biClrImportant = 0;
905
906 HeapFree(GetProcessHeap(),0,samprow);
907 jpeg_finish_decompress(&jd);
908 jpeg_destroy_decompress(&jd);
909 hdcref = GetDC(0);
910 This->desc.u.bmp.hbitmap=CreateDIBitmap(
911 hdcref,
912 &bmi,
913 CBM_INIT,
914 bits,
915 (BITMAPINFO*)&bmi,
916 DIB_RGB_COLORS
917 );
918 DeleteDC(hdcref);
919 This->desc.picType = PICTYPE_BITMAP;
920 OLEPictureImpl_SetBitmap(This);
921 hr = S_OK;
922 HeapFree(GetProcessHeap(),0,bits);
923#else
924 ERR("Trying to load JPEG picture, but JPEG supported not compiled in.\n");
925 hr = E_FAIL;
926#endif
927 break;
928 }
929 case 0x4d42: { /* Bitmap */
930 BITMAPFILEHEADER *bfh = (BITMAPFILEHEADER*)xbuf;
931 BITMAPINFO *bi = (BITMAPINFO*)(bfh+1);
932 HDC hdcref;
933
934 /* Does not matter whether this is a coreheader or not, we only use
935 * components which are in both
936 */
937 hdcref = GetDC(0);
938 This->desc.u.bmp.hbitmap = CreateDIBitmap(
939 hdcref,
940 &(bi->bmiHeader),
941 CBM_INIT,
942 xbuf+bfh->bfOffBits,
943 bi,
944 (bi->bmiHeader.biBitCount<=8)?DIB_PAL_COLORS:DIB_RGB_COLORS
945 );
946 DeleteDC(hdcref);
947 This->desc.picType = PICTYPE_BITMAP;
948 OLEPictureImpl_SetBitmap(This);
949 hr = S_OK;
950 break;
951 }
952 case 0x0000: { /* ICON , first word is dwReserved */
953 HICON hicon;
954 CURSORICONFILEDIR *cifd = (CURSORICONFILEDIR*)xbuf;
955 int i;
956
957 /*
958 FIXME("icon.idReserved=%d\n",cifd->idReserved);
959 FIXME("icon.idType=%d\n",cifd->idType);
960 FIXME("icon.idCount=%d\n",cifd->idCount);
961
962 for (i=0;i<cifd->idCount;i++) {
963 FIXME("[%d] width %d\n",i,cifd->idEntries[i].bWidth);
964 FIXME("[%d] height %d\n",i,cifd->idEntries[i].bHeight);
965 FIXME("[%d] bColorCount %d\n",i,cifd->idEntries[i].bColorCount);
966 FIXME("[%d] bReserved %d\n",i,cifd->idEntries[i].bReserved);
967 FIXME("[%d] xHotspot %d\n",i,cifd->idEntries[i].xHotspot);
968 FIXME("[%d] yHotspot %d\n",i,cifd->idEntries[i].yHotspot);
969 FIXME("[%d] dwDIBSize %d\n",i,cifd->idEntries[i].dwDIBSize);
970 FIXME("[%d] dwDIBOffset %d\n",i,cifd->idEntries[i].dwDIBOffset);
971 }
972 */
973 i=0;
974 /* If we have more than one icon, try to find the best.
975 * this currently means '32 pixel wide'.
976 */
977 if (cifd->idCount!=1) {
978 for (i=0;i<cifd->idCount;i++) {
979 if (cifd->idEntries[i].bWidth == 32)
980 break;
981 }
982 if (i==cifd->idCount) i=0;
983 }
984
985 hicon = CreateIconFromResourceEx(
986 xbuf+cifd->idEntries[i].dwDIBOffset,
987 cifd->idEntries[i].dwDIBSize,
988 TRUE, /* is icon */
989 0x00030000,
990 cifd->idEntries[i].bWidth,
991 cifd->idEntries[i].bHeight,
992 0
993 );
994 if (!hicon) {
995 FIXME("CreateIcon failed.\n");
996 hr = E_FAIL;
997 } else {
998 This->desc.picType = PICTYPE_ICON;
999 This->desc.u.icon.hicon = hicon;
1000 hr = S_OK;
1001 }
1002 break;
1003 }
1004 default:
1005 FIXME("Unknown magic %04x\n",magic);
1006 hr=E_FAIL;
1007 break;
1008 }
1009
1010 /* FIXME: this notify is not really documented */
1011 if (hr==S_OK)
1012 OLEPicture_SendNotify(This,DISPID_PICT_TYPE);
1013 return hr;
1014}
1015
1016static HRESULT WINAPI OLEPictureImpl_Save(
1017 IPersistStream* iface,IStream*pStm,BOOL fClearDirty)
1018{
1019 ICOM_THIS_From_IPersistStream(IPicture, iface);
1020 FIXME("(%p,%p,%d),stub!\n",This,pStm,fClearDirty);
1021 return E_NOTIMPL;
1022}
1023
1024static HRESULT WINAPI OLEPictureImpl_GetSizeMax(
1025 IPersistStream* iface,ULARGE_INTEGER*pcbSize)
1026{
1027 ICOM_THIS_From_IPersistStream(IPicture, iface);
1028 FIXME("(%p,%p),stub!\n",This,pcbSize);
1029 return E_NOTIMPL;
1030}
1031
1032/************************************************************************
1033 * IDispatch
1034 */
1035/************************************************************************
1036 * OLEPictureImpl_IDispatch_QueryInterface (IUnknown)
1037 *
1038 * See Windows documentation for more details on IUnknown methods.
1039 */
1040static HRESULT WINAPI OLEPictureImpl_IDispatch_QueryInterface(
1041 IDispatch* iface,
1042 REFIID riid,
1043 VOID** ppvoid)
1044{
1045 ICOM_THIS_From_IDispatch(IPicture, iface);
1046
1047 return IPicture_QueryInterface(This, riid, ppvoid);
1048}
1049
1050/************************************************************************
1051 * OLEPictureImpl_IDispatch_AddRef (IUnknown)
1052 *
1053 * See Windows documentation for more details on IUnknown methods.
1054 */
1055static ULONG WINAPI OLEPictureImpl_IDispatch_AddRef(
1056 IDispatch* iface)
1057{
1058 ICOM_THIS_From_IDispatch(IPicture, iface);
1059
1060 return IPicture_AddRef(This);
1061}
1062
1063/************************************************************************
1064 * OLEPictureImpl_IDispatch_Release (IUnknown)
1065 *
1066 * See Windows documentation for more details on IUnknown methods.
1067 */
1068static ULONG WINAPI OLEPictureImpl_IDispatch_Release(
1069 IDispatch* iface)
1070{
1071 ICOM_THIS_From_IDispatch(IPicture, iface);
1072
1073 return IPicture_Release(This);
1074}
1075
1076/************************************************************************
1077 * OLEPictureImpl_GetTypeInfoCount (IDispatch)
1078 *
1079 * See Windows documentation for more details on IDispatch methods.
1080 */
1081static HRESULT WINAPI OLEPictureImpl_GetTypeInfoCount(
1082 IDispatch* iface,
1083 unsigned int* pctinfo)
1084{
1085 FIXME("():Stub\n");
1086
1087 return E_NOTIMPL;
1088}
1089
1090/************************************************************************
1091 * OLEPictureImpl_GetTypeInfo (IDispatch)
1092 *
1093 * See Windows documentation for more details on IDispatch methods.
1094 */
1095static HRESULT WINAPI OLEPictureImpl_GetTypeInfo(
1096 IDispatch* iface,
1097 UINT iTInfo,
1098 LCID lcid,
1099 ITypeInfo** ppTInfo)
1100{
1101 FIXME("():Stub\n");
1102
1103 return E_NOTIMPL;
1104}
1105
1106/************************************************************************
1107 * OLEPictureImpl_GetIDsOfNames (IDispatch)
1108 *
1109 * See Windows documentation for more details on IDispatch methods.
1110 */
1111static HRESULT WINAPI OLEPictureImpl_GetIDsOfNames(
1112 IDispatch* iface,
1113 REFIID riid,
1114 LPOLESTR* rgszNames,
1115 UINT cNames,
1116 LCID lcid,
1117 DISPID* rgDispId)
1118{
1119 FIXME("():Stub\n");
1120
1121 return E_NOTIMPL;
1122}
1123
1124/************************************************************************
1125 * OLEPictureImpl_Invoke (IDispatch)
1126 *
1127 * See Windows documentation for more details on IDispatch methods.
1128 */
1129static HRESULT WINAPI OLEPictureImpl_Invoke(
1130 IDispatch* iface,
1131 DISPID dispIdMember,
1132 REFIID riid,
1133 LCID lcid,
1134 WORD wFlags,
1135 DISPPARAMS* pDispParams,
1136 VARIANT* pVarResult,
1137 EXCEPINFO* pExepInfo,
1138 UINT* puArgErr)
1139{
1140 FIXME("(dispid: %ld):Stub\n",dispIdMember);
1141
1142 VariantInit(pVarResult);
1143 V_VT(pVarResult) = VT_BOOL;
1144 V_UNION(pVarResult,boolVal) = FALSE;
1145 return S_OK;
1146}
1147
1148
1149static ICOM_VTABLE(IPicture) OLEPictureImpl_VTable =
1150{
1151 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1152 OLEPictureImpl_QueryInterface,
1153 OLEPictureImpl_AddRef,
1154 OLEPictureImpl_Release,
1155 OLEPictureImpl_get_Handle,
1156 OLEPictureImpl_get_hPal,
1157 OLEPictureImpl_get_Type,
1158 OLEPictureImpl_get_Width,
1159 OLEPictureImpl_get_Height,
1160 OLEPictureImpl_Render,
1161 OLEPictureImpl_set_hPal,
1162 OLEPictureImpl_get_CurDC,
1163 OLEPictureImpl_SelectPicture,
1164 OLEPictureImpl_get_KeepOriginalFormat,
1165 OLEPictureImpl_put_KeepOriginalFormat,
1166 OLEPictureImpl_PictureChanged,
1167 OLEPictureImpl_SaveAsFile,
1168 OLEPictureImpl_get_Attributes
1169};
1170
1171static ICOM_VTABLE(IDispatch) OLEPictureImpl_IDispatch_VTable =
1172{
1173 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1174 OLEPictureImpl_IDispatch_QueryInterface,
1175 OLEPictureImpl_IDispatch_AddRef,
1176 OLEPictureImpl_IDispatch_Release,
1177 OLEPictureImpl_GetTypeInfoCount,
1178 OLEPictureImpl_GetTypeInfo,
1179 OLEPictureImpl_GetIDsOfNames,
1180 OLEPictureImpl_Invoke
1181};
1182
1183static ICOM_VTABLE(IPersistStream) OLEPictureImpl_IPersistStream_VTable =
1184{
1185 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1186 OLEPictureImpl_IPersistStream_QueryInterface,
1187 OLEPictureImpl_IPersistStream_AddRef,
1188 OLEPictureImpl_IPersistStream_Release,
1189 OLEPictureImpl_GetClassID,
1190 OLEPictureImpl_IsDirty,
1191 OLEPictureImpl_Load,
1192 OLEPictureImpl_Save,
1193 OLEPictureImpl_GetSizeMax
1194};
1195
1196static ICOM_VTABLE(IConnectionPointContainer) OLEPictureImpl_IConnectionPointContainer_VTable =
1197{
1198 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1199 OLEPictureImpl_IConnectionPointContainer_QueryInterface,
1200 OLEPictureImpl_IConnectionPointContainer_AddRef,
1201 OLEPictureImpl_IConnectionPointContainer_Release,
1202 OLEPictureImpl_EnumConnectionPoints,
1203 OLEPictureImpl_FindConnectionPoint
1204};
1205
1206/***********************************************************************
1207 * OleCreatePictureIndirect (OLEAUT32.419)
1208 */
1209HRESULT WINAPI OleCreatePictureIndirect(LPPICTDESC lpPictDesc, REFIID riid,
1210 BOOL fOwn, LPVOID *ppvObj )
1211{
1212 OLEPictureImpl* newPict = NULL;
1213 HRESULT hr = S_OK;
1214
1215 TRACE("(%p,%p,%d,%p)\n", lpPictDesc, riid, fOwn, ppvObj);
1216
1217 /*
1218 * Sanity check
1219 */
1220 if (ppvObj==0)
1221 return E_POINTER;
1222
1223 *ppvObj = NULL;
1224
1225 /*
1226 * Try to construct a new instance of the class.
1227 */
1228 newPict = OLEPictureImpl_Construct(lpPictDesc, fOwn);
1229
1230 if (newPict == NULL)
1231 return E_OUTOFMEMORY;
1232
1233 /*
1234 * Make sure it supports the interface required by the caller.
1235 */
1236 hr = IPicture_QueryInterface((IPicture*)newPict, riid, ppvObj);
1237
1238 /*
1239 * Release the reference obtained in the constructor. If
1240 * the QueryInterface was unsuccessful, it will free the class.
1241 */
1242 IPicture_Release((IPicture*)newPict);
1243
1244 return hr;
1245}
1246
1247
1248/***********************************************************************
1249 * OleLoadPicture (OLEAUT32.418)
1250 */
1251HRESULT WINAPI OleLoadPicture( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
1252 REFIID riid, LPVOID *ppvObj )
1253{
1254 LPPERSISTSTREAM ps;
1255 IPicture *newpic;
1256 HRESULT hr;
1257
1258 TRACE("(%p,%ld,%d,%s,%p), partially implemented.\n",
1259 lpstream, lSize, fRunmode, debugstr_guid(riid), ppvObj);
1260
1261 hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
1262 if (hr)
1263 return hr;
1264 hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
1265 if (hr) {
1266 FIXME("Could not get IPersistStream iface from Ole Picture?\n");
1267 IPicture_Release(newpic);
1268 *ppvObj = NULL;
1269 return hr;
1270 }
1271 IPersistStream_Load(ps,lpstream);
1272 IPersistStream_Release(ps);
1273 hr = IPicture_QueryInterface(newpic,riid,ppvObj);
1274 if (hr)
1275 FIXME("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
1276 IPicture_Release(newpic);
1277 return hr;
1278}
1279
1280/***********************************************************************
1281 * OleLoadPictureEx (OLEAUT32.401)
1282 */
1283HRESULT WINAPI OleLoadPictureEx( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
1284 REFIID riid, DWORD xsiz, DWORD ysiz, DWORD flags, LPVOID *ppvObj )
1285{
1286 LPPERSISTSTREAM ps;
1287 IPicture *newpic;
1288 HRESULT hr;
1289
1290 FIXME("(%p,%ld,%d,%s,x=%ld,y=%ld,f=%lx,%p), partially implemented.\n",
1291 lpstream, lSize, fRunmode, debugstr_guid(riid), xsiz, ysiz, flags, ppvObj);
1292
1293 hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
1294 if (hr)
1295 return hr;
1296 hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
1297 if (hr) {
1298 FIXME("Could not get IPersistStream iface from Ole Picture?\n");
1299 IPicture_Release(newpic);
1300 *ppvObj = NULL;
1301 return hr;
1302 }
1303 IPersistStream_Load(ps,lpstream);
1304 IPersistStream_Release(ps);
1305 hr = IPicture_QueryInterface(newpic,riid,ppvObj);
1306 if (hr)
1307 FIXME("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
1308 IPicture_Release(newpic);
1309 return hr;
1310}
Note: See TracBrowser for help on using the repository browser.