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