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