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