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