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