?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
server: Clone file_get_sd() and file_set_fd() for directories.
[wine/multimedia.git] / dlls / oleaut32 / olepicture.c
blob498ee53f89240cd58fbe224107d17243351372bc
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, info_ptr ? &info_ptr : NULL, NULL);
1614 HeapFree(GetProcessHeap(), 0, row_pointers);
1615 HeapFree(GetProcessHeap(), 0, pngdata);
1616 return ret;
1617 #else /* SONAME_LIBPNG */
1618 ERR("Trying to load PNG picture, but PNG supported not compiled in.\n");
1619 return E_FAIL;
1620 #endif
1621 }
1622
1623 /*****************************************************
1624 * start of Icon-specific code
1625 */
1626
1627 static HRESULT OLEPictureImpl_LoadIcon(OLEPictureImpl *This, BYTE *xbuf, ULONG xread)
1628 {
1629 HICON hicon;
1630 CURSORICONFILEDIR *cifd = (CURSORICONFILEDIR*)xbuf;
1631 HDC hdcRef;
1632 int i;
1633
1634 /*
1635 FIXME("icon.idReserved=%d\n",cifd->idReserved);
1636 FIXME("icon.idType=%d\n",cifd->idType);
1637 FIXME("icon.idCount=%d\n",cifd->idCount);
1638
1639 for (i=0;i<cifd->idCount;i++) {
1640 FIXME("[%d] width %d\n",i,cifd->idEntries[i].bWidth);
1641 FIXME("[%d] height %d\n",i,cifd->idEntries[i].bHeight);
1642 FIXME("[%d] bColorCount %d\n",i,cifd->idEntries[i].bColorCount);
1643 FIXME("[%d] bReserved %d\n",i,cifd->idEntries[i].bReserved);
1644 FIXME("[%d] xHotspot %d\n",i,cifd->idEntries[i].xHotspot);
1645 FIXME("[%d] yHotspot %d\n",i,cifd->idEntries[i].yHotspot);
1646 FIXME("[%d] dwDIBSize %d\n",i,cifd->idEntries[i].dwDIBSize);
1647 FIXME("[%d] dwDIBOffset %d\n",i,cifd->idEntries[i].dwDIBOffset);
1648 }
1649 */
1650 i=0;
1651 /* If we have more than one icon, try to find the best.
1652 * this currently means '32 pixel wide'.
1653 */
1654 if (cifd->idCount!=1) {
1655 for (i=0;i<cifd->idCount;i++) {
1656 if (cifd->idEntries[i].bWidth == 32)
1657 break;
1658 }
1659 if (i==cifd->idCount) i=0;
1660 }
1661
1662 hicon = CreateIconFromResourceEx(
1663 xbuf+cifd->idEntries[i].dwDIBOffset,
1664 cifd->idEntries[i].dwDIBSize,
1665 TRUE, /* is icon */
1666 0x00030000,
1667 cifd->idEntries[i].bWidth,
1668 cifd->idEntries[i].bHeight,
1669 0
1670 );
1671 if (!hicon) {
1672 ERR("CreateIcon failed.\n");
1673 return E_FAIL;
1674 } else {
1675 This->desc.picType = PICTYPE_ICON;
1676 This->desc.u.icon.hicon = hicon;
1677 This->origWidth = cifd->idEntries[i].bWidth;
1678 This->origHeight = cifd->idEntries[i].bHeight;
1679 hdcRef = CreateCompatibleDC(0);
1680 This->himetricWidth =(cifd->idEntries[i].bWidth *2540)/GetDeviceCaps(hdcRef, LOGPIXELSX);
1681 This->himetricHeight=(cifd->idEntries[i].bHeight*2540)/GetDeviceCaps(hdcRef, LOGPIXELSY);
1682 DeleteDC(hdcRef);
1683 return S_OK;
1684 }
1685 }
1686
1687 static HRESULT OLEPictureImpl_LoadEnhMetafile(OLEPictureImpl *This,
1688 const BYTE *data, ULONG size)
1689 {
1690 HENHMETAFILE hemf;
1691 ENHMETAHEADER hdr;
1692
1693 hemf = SetEnhMetaFileBits(size, data);
1694 if (!hemf) return E_FAIL;
1695
1696 GetEnhMetaFileHeader(hemf, sizeof(hdr), &hdr);
1697
1698 This->desc.picType = PICTYPE_ENHMETAFILE;
1699 This->desc.u.emf.hemf = hemf;
1700
1701 This->origWidth = 0;
1702 This->origHeight = 0;
1703 This->himetricWidth = hdr.rclFrame.right - hdr.rclFrame.left;
1704 This->himetricHeight = hdr.rclFrame.bottom - hdr.rclFrame.top;
1705
1706 return S_OK;
1707 }
1708
1709 static HRESULT OLEPictureImpl_LoadAPM(OLEPictureImpl *This,
1710 const BYTE *data, ULONG size)
1711 {
1712 APM_HEADER *header = (APM_HEADER *)data;
1713 HMETAFILE hmf;
1714
1715 if (size < sizeof(APM_HEADER))
1716 return E_FAIL;
1717 if (header->key != 0x9ac6cdd7)
1718 return E_FAIL;
1719
1720 /* SetMetaFileBitsEx performs data check on its own */
1721 hmf = SetMetaFileBitsEx(size - sizeof(*header), data + sizeof(*header));
1722 if (!hmf) return E_FAIL;
1723
1724 This->desc.picType = PICTYPE_METAFILE;
1725 This->desc.u.wmf.hmeta = hmf;
1726 This->desc.u.wmf.xExt = 0;
1727 This->desc.u.wmf.yExt = 0;
1728
1729 This->origWidth = 0;
1730 This->origHeight = 0;
1731 This->himetricWidth = MulDiv((INT)header->right - header->left, 2540, header->inch);
1732 This->himetricHeight = MulDiv((INT)header->bottom - header->top, 2540, header->inch);
1733 return S_OK;
1734 }
1735
1736 /************************************************************************
1737 * BITMAP FORMAT FLAGS -
1738 * Flags that differentiate between different types of bitmaps.
1739 */
1740
1741 #define BITMAP_FORMAT_BMP 0x4d42 /* "BM" */
1742 #define BITMAP_FORMAT_JPEG 0xd8ff
1743 #define BITMAP_FORMAT_GIF 0x4947
1744 #define BITMAP_FORMAT_PNG 0x5089
1745 #define BITMAP_FORMAT_APM 0xcdd7
1746
1747 /************************************************************************
1748 * OLEPictureImpl_IPersistStream_Load (IUnknown)
1749 *
1750 * Loads the binary data from the IStream. Starts at current position.
1751 * There appears to be an 2 DWORD header:
1752 * DWORD magic;
1753 * DWORD len;
1754 *
1755 * Currently implemented: BITMAP, ICON, JPEG, GIF, WMF, EMF
1756 */
1757 static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface,IStream*pStm) {
1758 HRESULT hr = E_FAIL;
1759 BOOL headerisdata = FALSE;
1760 BOOL statfailed = FALSE;
1761 ULONG xread, toread;
1762 ULONG headerread;
1763 BYTE *xbuf;
1764 DWORD header[2];
1765 WORD magic;
1766 STATSTG statstg;
1767 OLEPictureImpl *This = impl_from_IPersistStream(iface);
1768
1769 TRACE("(%p,%p)\n",This,pStm);
1770
1771 /****************************************************************************************
1772 * Part 1: Load the data
1773 */
1774 /* Sometimes we have a header, sometimes we don't. Apply some guesses to find
1775 * out whether we do.
1776 *
1777 * UPDATE: the IStream can be mapped to a plain file instead of a stream in a
1778 * compound file. This may explain most, if not all, of the cases of "no
1779 * header", and the header validation should take this into account.
1780 * At least in Visual Basic 6, resource streams, valid headers are
1781 * header[0] == "lt\0\0",
1782 * header[1] == length_of_stream.
1783 *
1784 * Also handle streams where we do not have a working "Stat" method by
1785 * reading all data until the end of the stream.
1786 */
1787 hr=IStream_Stat(pStm,&statstg,STATFLAG_NONAME);
1788 if (hr) {
1789 TRACE("stat failed with hres %x, proceeding to read all data.\n",hr);
1790 statfailed = TRUE;
1791 /* we will read at least 8 byte ... just right below */
1792 statstg.cbSize.QuadPart = 8;
1793 }
1794
1795 toread = 0;
1796 headerread = 0;
1797 headerisdata = FALSE;
1798 do {
1799 hr=IStream_Read(pStm,header,8,&xread);
1800 if (hr || xread!=8) {
1801 ERR("Failure while reading picture header (hr is %x, nread is %d).\n",hr,xread);
1802 return (hr?hr:E_FAIL);
1803 }
1804 headerread += xread;
1805 xread = 0;
1806
1807 if (!memcmp(&(header[0]),"lt\0\0", 4) && (statfailed || (header[1] + headerread <= statstg.cbSize.QuadPart))) {
1808 if (toread != 0 && toread != header[1])
1809 FIXME("varying lengths of image data (prev=%u curr=%u), only last one will be used\n",
1810 toread, header[1]);
1811 toread = header[1];
1812 if (toread == 0) break;
1813 } else {
1814 if (!memcmp(&(header[0]), "GIF8", 4) || /* GIF header */
1815 !memcmp(&(header[0]), "BM", 2) || /* BMP header */
1816 !memcmp(&(header[0]), "\xff\xd8", 2) || /* JPEG header */
1817 (header[0] == EMR_HEADER) || /* EMF header */
1818 (header[1] > statstg.cbSize.QuadPart)|| /* invalid size */
1819 (header[1]==0)
1820 ) {/* Found start of bitmap data */
1821 headerisdata = TRUE;
1822 if (toread == 0)
1823 toread = statstg.cbSize.QuadPart-8;
1824 else toread -= 8;
1825 xread = 8;
1826 } else {
1827 FIXME("Unknown stream header magic: %08x\n", header[0]);
1828 toread = header[1];
1829 }
1830 }
1831 } while (!headerisdata);
1832
1833 if (statfailed) { /* we don't know the size ... read all we get */
1834 int sizeinc = 4096;
1835 int origsize = sizeinc;
1836 ULONG nread = 42;
1837
1838 TRACE("Reading all data from stream.\n");
1839 xbuf = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, origsize);
1840 if (headerisdata)
1841 memcpy (xbuf, header, 8);
1842 while (1) {
1843 while (xread < origsize) {
1844 hr = IStream_Read(pStm,xbuf+xread,origsize-xread,&nread);
1845 xread+=nread;
1846 if (hr || !nread)
1847 break;
1848 }
1849 if (!nread || hr) /* done, or error */
1850 break;
1851 if (xread == origsize) {
1852 origsize += sizeinc;
1853 sizeinc = 2*sizeinc; /* exponential increase */
1854 xbuf = HeapReAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, xbuf, origsize);
1855 }
1856 }
1857 if (hr)
1858 TRACE("hr in no-stat loader case is %08x\n", hr);
1859 TRACE("loaded %d bytes.\n", xread);
1860 This->datalen = xread;
1861 This->data = xbuf;
1862 } else {
1863 This->datalen = toread+(headerisdata?8:0);
1864 xbuf = This->data = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, This->datalen);
1865 if (!xbuf)
1866 return E_OUTOFMEMORY;
1867
1868 if (headerisdata)
1869 memcpy (xbuf, header, 8);
1870
1871 while (xread < This->datalen) {
1872 ULONG nread;
1873 hr = IStream_Read(pStm,xbuf+xread,This->datalen-xread,&nread);
1874 xread+=nread;
1875 if (hr || !nread)
1876 break;
1877 }
1878 if (xread != This->datalen)
1879 ERR("Could only read %d of %d bytes out of stream?\n",xread,This->datalen);
1880 }
1881 if (This->datalen == 0) { /* Marks the "NONE" picture */
1882 This->desc.picType = PICTYPE_NONE;
1883 return S_OK;
1884 }
1885
1886
1887 /****************************************************************************************
1888 * Part 2: Process the loaded data
1889 */
1890
1891 magic = xbuf[0] + (xbuf[1]<<8);
1892 This->loadtime_format = magic;
1893
1894 switch (magic) {
1895 case BITMAP_FORMAT_GIF: /* GIF */
1896 hr = OLEPictureImpl_LoadGif(This, xbuf, xread);
1897 break;
1898 case BITMAP_FORMAT_JPEG: /* JPEG */
1899 hr = OLEPictureImpl_LoadJpeg(This, xbuf, xread);
1900 break;
1901 case BITMAP_FORMAT_BMP: /* Bitmap */
1902 hr = OLEPictureImpl_LoadDIB(This, xbuf, xread);
1903 break;
1904 case BITMAP_FORMAT_PNG: /* PNG */
1905 hr = OLEPictureImpl_LoadPNG(This, xbuf, xread);
1906 break;
1907 case BITMAP_FORMAT_APM: /* APM */
1908 hr = OLEPictureImpl_LoadAPM(This, xbuf, xread);
1909 break;
1910 case 0x0000: { /* ICON , first word is dwReserved */
1911 hr = OLEPictureImpl_LoadIcon(This, xbuf, xread);
1912 break;
1913 }
1914 default:
1915 {
1916 unsigned int i;
1917
1918 /* let's see if it's a EMF */
1919 hr = OLEPictureImpl_LoadEnhMetafile(This, xbuf, xread);
1920 if (hr == S_OK) break;
1921
1922 FIXME("Unknown magic %04x, %d read bytes:\n",magic,xread);
1923 hr=E_FAIL;
1924 for (i=0;i<xread+8;i++) {
1925 if (i<8) MESSAGE("%02x ",((unsigned char*)header)[i]);
1926 else MESSAGE("%02x ",xbuf[i-8]);
1927 if (i % 10 == 9) MESSAGE("\n");
1928 }
1929 MESSAGE("\n");
1930 break;
1931 }
1932 }
1933 This->bIsDirty = FALSE;
1934
1935 /* FIXME: this notify is not really documented */
1936 if (hr==S_OK)
1937 OLEPicture_SendNotify(This,DISPID_PICT_TYPE);
1938 return hr;
1939 }
1940
1941 static int serializeBMP(HBITMAP hBitmap, void ** ppBuffer, unsigned int * pLength)
1942 {
1943 int iSuccess = 0;
1944 HDC hDC;
1945 BITMAPINFO * pInfoBitmap;
1946 int iNumPaletteEntries;
1947 unsigned char * pPixelData;
1948 BITMAPFILEHEADER * pFileHeader;
1949 BITMAPINFO * pInfoHeader;
1950
1951 pInfoBitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1952 sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1953
1954 /* Find out bitmap size and padded length */
1955 hDC = GetDC(0);
1956 pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
1957 GetDIBits(hDC, hBitmap, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
1958
1959 /* Fetch bitmap palette & pixel data */
1960
1961 pPixelData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pInfoBitmap->bmiHeader.biSizeImage);
1962 GetDIBits(hDC, hBitmap, 0, pInfoBitmap->bmiHeader.biHeight, pPixelData, pInfoBitmap, DIB_RGB_COLORS);
1963
1964 /* Calculate the total length required for the BMP data */
1965 if (pInfoBitmap->bmiHeader.biClrUsed != 0) {
1966 iNumPaletteEntries = pInfoBitmap->bmiHeader.biClrUsed;
1967 if (iNumPaletteEntries > 256) iNumPaletteEntries = 256;
1968 } else {
1969 if (pInfoBitmap->bmiHeader.biBitCount <= 8)
1970 iNumPaletteEntries = 1 << pInfoBitmap->bmiHeader.biBitCount;
1971 else
1972 iNumPaletteEntries = 0;
1973 }
1974 *pLength =
1975 sizeof(BITMAPFILEHEADER) +
1976 sizeof(BITMAPINFOHEADER) +
1977 iNumPaletteEntries * sizeof(RGBQUAD) +
1978 pInfoBitmap->bmiHeader.biSizeImage;
1979 *ppBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *pLength);
1980
1981 /* Fill the BITMAPFILEHEADER */
1982 pFileHeader = (BITMAPFILEHEADER *)(*ppBuffer);
1983 pFileHeader->bfType = BITMAP_FORMAT_BMP;
1984 pFileHeader->bfSize = *pLength;
1985 pFileHeader->bfOffBits =
1986 sizeof(BITMAPFILEHEADER) +
1987 sizeof(BITMAPINFOHEADER) +
1988 iNumPaletteEntries * sizeof(RGBQUAD);
1989
1990 /* Fill the BITMAPINFOHEADER and the palette data */
1991 pInfoHeader = (BITMAPINFO *)((unsigned char *)(*ppBuffer) + sizeof(BITMAPFILEHEADER));
1992 memcpy(pInfoHeader, pInfoBitmap, sizeof(BITMAPINFOHEADER) + iNumPaletteEntries * sizeof(RGBQUAD));
1993 memcpy(
1994 (unsigned char *)(*ppBuffer) +
1995 sizeof(BITMAPFILEHEADER) +
1996 sizeof(BITMAPINFOHEADER) +
1997 iNumPaletteEntries * sizeof(RGBQUAD),
1998 pPixelData, pInfoBitmap->bmiHeader.biSizeImage);
1999 iSuccess = 1;
2000
2001 HeapFree(GetProcessHeap(), 0, pPixelData);
2002 HeapFree(GetProcessHeap(), 0, pInfoBitmap);
2003 return iSuccess;
2004 }
2005
2006 static int serializeIcon(HICON hIcon, void ** ppBuffer, unsigned int * pLength)
2007 {
2008 ICONINFO infoIcon;
2009 int iSuccess = 0;
2010
2011 *ppBuffer = NULL; *pLength = 0;
2012 if (GetIconInfo(hIcon, &infoIcon)) {
2013 HDC hDC;
2014 BITMAPINFO * pInfoBitmap;
2015 unsigned char * pIconData = NULL;
2016 unsigned int iDataSize = 0;
2017
2018 pInfoBitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
2019
2020 /* Find out icon size */
2021 hDC = GetDC(0);
2022 pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
2023 GetDIBits(hDC, infoIcon.hbmColor, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
2024 if (1) {
2025 /* Auxiliary pointers */
2026 CURSORICONFILEDIR * pIconDir;
2027 CURSORICONFILEDIRENTRY * pIconEntry;
2028 BITMAPINFOHEADER * pIconBitmapHeader;
2029 unsigned int iOffsetPalette;
2030 unsigned int iOffsetColorData;
2031 unsigned int iOffsetMaskData;
2032
2033 unsigned int iLengthScanLineColor;
2034 unsigned int iLengthScanLineMask;
2035 unsigned int iNumEntriesPalette;
2036
2037 iLengthScanLineMask = ((pInfoBitmap->bmiHeader.biWidth + 31) >> 5) << 2;
2038 iLengthScanLineColor = ((pInfoBitmap->bmiHeader.biWidth * pInfoBitmap->bmiHeader.biBitCount + 31) >> 5) << 2;
2039 /*
2040 FIXME("DEBUG: bitmap size is %d x %d\n",
2041 pInfoBitmap->bmiHeader.biWidth,
2042 pInfoBitmap->bmiHeader.biHeight);
2043 FIXME("DEBUG: bitmap bpp is %d\n",
2044 pInfoBitmap->bmiHeader.biBitCount);
2045 FIXME("DEBUG: bitmap nplanes is %d\n",
2046 pInfoBitmap->bmiHeader.biPlanes);
2047 FIXME("DEBUG: bitmap biSizeImage is %u\n",
2048 pInfoBitmap->bmiHeader.biSizeImage);
2049 */
2050 /* Let's start with one CURSORICONFILEDIR and one CURSORICONFILEDIRENTRY */
2051 iDataSize += 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY) + sizeof(BITMAPINFOHEADER);
2052 pIconData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, iDataSize);
2053
2054 /* Fill out the CURSORICONFILEDIR */
2055 pIconDir = (CURSORICONFILEDIR *)pIconData;
2056 pIconDir->idType = 1;
2057 pIconDir->idCount = 1;
2058
2059 /* Fill out the CURSORICONFILEDIRENTRY */
2060 pIconEntry = (CURSORICONFILEDIRENTRY *)(pIconData + 3 * sizeof(WORD));
2061 pIconEntry->bWidth = (unsigned char)pInfoBitmap->bmiHeader.biWidth;
2062 pIconEntry->bHeight = (unsigned char)pInfoBitmap->bmiHeader.biHeight;
2063 pIconEntry->bColorCount =
2064 (pInfoBitmap->bmiHeader.biBitCount < 8)
2065 ? 1 << pInfoBitmap->bmiHeader.biBitCount
2066 : 0;
2067 pIconEntry->xHotspot = pInfoBitmap->bmiHeader.biPlanes;
2068 pIconEntry->yHotspot = pInfoBitmap->bmiHeader.biBitCount;
2069 pIconEntry->dwDIBSize = 0;
2070 pIconEntry->dwDIBOffset = 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY);
2071
2072 /* Fill out the BITMAPINFOHEADER */
2073 pIconBitmapHeader = (BITMAPINFOHEADER *)(pIconData + 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
2074 *pIconBitmapHeader = pInfoBitmap->bmiHeader;
2075
2076 /* Find out whether a palette exists for the bitmap */
2077 if ( (pInfoBitmap->bmiHeader.biBitCount == 16 && pInfoBitmap->bmiHeader.biCompression == BI_RGB)
2078 || (pInfoBitmap->bmiHeader.biBitCount == 24)
2079 || (pInfoBitmap->bmiHeader.biBitCount == 32 && pInfoBitmap->bmiHeader.biCompression == BI_RGB)) {
2080 iNumEntriesPalette = pInfoBitmap->bmiHeader.biClrUsed;
2081 if (iNumEntriesPalette > 256) iNumEntriesPalette = 256;
2082 } else if ((pInfoBitmap->bmiHeader.biBitCount == 16 || pInfoBitmap->bmiHeader.biBitCount == 32)
2083 && pInfoBitmap->bmiHeader.biCompression == BI_BITFIELDS) {
2084 iNumEntriesPalette = 3;
2085 } else if (pInfoBitmap->bmiHeader.biBitCount <= 8) {
2086 iNumEntriesPalette = 1 << pInfoBitmap->bmiHeader.biBitCount;
2087 } else {
2088 iNumEntriesPalette = 0;
2089 }
2090
2091 /* Add bitmap size and header size to icon data size. */
2092 iOffsetPalette = iDataSize;
2093 iDataSize += iNumEntriesPalette * sizeof(DWORD);
2094 iOffsetColorData = iDataSize;
2095 iDataSize += pIconBitmapHeader->biSizeImage;
2096 iOffsetMaskData = iDataSize;
2097 iDataSize += pIconBitmapHeader->biHeight * iLengthScanLineMask;
2098 pIconBitmapHeader->biSizeImage += pIconBitmapHeader->biHeight * iLengthScanLineMask;
2099 pIconBitmapHeader->biHeight *= 2;
2100 pIconData = HeapReAlloc(GetProcessHeap(), 0, pIconData, iDataSize);
2101 pIconEntry = (CURSORICONFILEDIRENTRY *)(pIconData + 3 * sizeof(WORD));
2102 pIconBitmapHeader = (BITMAPINFOHEADER *)(pIconData + 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
2103 pIconEntry->dwDIBSize = iDataSize - (3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
2104
2105 /* Get the actual bitmap data from the icon bitmap */
2106 GetDIBits(hDC, infoIcon.hbmColor, 0, pInfoBitmap->bmiHeader.biHeight,
2107 pIconData + iOffsetColorData, pInfoBitmap, DIB_RGB_COLORS);
2108 if (iNumEntriesPalette > 0) {
2109 memcpy(pIconData + iOffsetPalette, pInfoBitmap->bmiColors,
2110 iNumEntriesPalette * sizeof(RGBQUAD));
2111 }
2112
2113 /* Reset all values so that GetDIBits call succeeds */
2114 memset(pIconData + iOffsetMaskData, 0, iDataSize - iOffsetMaskData);
2115 memset(pInfoBitmap, 0, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
2116 pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
2117 /*
2118 if (!(GetDIBits(hDC, infoIcon.hbmMask, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS)
2119 && GetDIBits(hDC, infoIcon.hbmMask, 0, pIconEntry->bHeight,
2120 pIconData + iOffsetMaskData, pInfoBitmap, DIB_RGB_COLORS))) {
2121
2122 printf("ERROR: unable to get bitmap mask (error %u)\n",
2123 GetLastError());
2124
2125 }
2126 */
2127 GetDIBits(hDC, infoIcon.hbmMask, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
2128 GetDIBits(hDC, infoIcon.hbmMask, 0, pIconEntry->bHeight, pIconData + iOffsetMaskData, pInfoBitmap, DIB_RGB_COLORS);
2129
2130 /* Write out everything produced so far to the stream */
2131 *ppBuffer = pIconData; *pLength = iDataSize;
2132 iSuccess = 1;
2133 } else {
2134 /*
2135 printf("ERROR: unable to get bitmap information via GetDIBits() (error %u)\n",
2136 GetLastError());
2137 */
2138 }
2139 /*
2140 Remarks (from MSDN entry on GetIconInfo):
2141
2142 GetIconInfo creates bitmaps for the hbmMask and hbmColor
2143 members of ICONINFO. The calling application must manage
2144 these bitmaps and delete them when they are no longer
2145 necessary.
2146 */
2147 if (hDC) ReleaseDC(0, hDC);
2148 DeleteObject(infoIcon.hbmMask);
2149 if (infoIcon.hbmColor) DeleteObject(infoIcon.hbmColor);
2150 HeapFree(GetProcessHeap(), 0, pInfoBitmap);
2151 } else {
2152 printf("ERROR: Unable to get icon information (error %u)\n",
2153 GetLastError());
2154 }
2155 return iSuccess;
2156 }
2157
2158 static HRESULT WINAPI OLEPictureImpl_Save(
2159 IPersistStream* iface,IStream*pStm,BOOL fClearDirty)
2160 {
2161 HRESULT hResult = E_NOTIMPL;
2162 void * pIconData;
2163 unsigned int iDataSize;
2164 ULONG dummy;
2165 int iSerializeResult = 0;
2166 OLEPictureImpl *This = impl_from_IPersistStream(iface);
2167
2168 TRACE("%p %p %d\n", This, pStm, fClearDirty);
2169
2170 switch (This->desc.picType) {
2171 case PICTYPE_ICON:
2172 if (This->bIsDirty || !This->data) {
2173 if (!serializeIcon(This->desc.u.icon.hicon, &pIconData, &iDataSize)) {
2174 ERR("(%p,%p,%d), serializeIcon() failed\n", This, pStm, fClearDirty);
2175 hResult = E_FAIL;
2176 break;
2177 }
2178 HeapFree(GetProcessHeap(), 0, This->data);
2179 This->data = pIconData;
2180 This->datalen = iDataSize;
2181 }
2182 if (This->loadtime_magic != 0xdeadbeef) {
2183 DWORD header[2];
2184
2185 header[0] = This->loadtime_magic;
2186 header[1] = This->datalen;
2187 IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
2188 }
2189 IStream_Write(pStm, This->data, This->datalen, &dummy);
2190
2191 hResult = S_OK;
2192 break;
2193 case PICTYPE_BITMAP:
2194 if (This->bIsDirty) {
2195 switch (This->keepOrigFormat ? This->loadtime_format : BITMAP_FORMAT_BMP) {
2196 case BITMAP_FORMAT_BMP:
2197 iSerializeResult = serializeBMP(This->desc.u.bmp.hbitmap, &pIconData, &iDataSize);
2198 break;
2199 case BITMAP_FORMAT_JPEG:
2200 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format JPEG) not implemented!\n",This,pStm,fClearDirty);
2201 break;
2202 case BITMAP_FORMAT_GIF:
2203 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format GIF) not implemented!\n",This,pStm,fClearDirty);
2204 break;
2205 case BITMAP_FORMAT_PNG:
2206 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format PNG) not implemented!\n",This,pStm,fClearDirty);
2207 break;
2208 default:
2209 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format UNKNOWN, using BMP?) not implemented!\n",This,pStm,fClearDirty);
2210 break;
2211 }
2212 if (iSerializeResult) {
2213 /*
2214 if (This->loadtime_magic != 0xdeadbeef) {
2215 */
2216 if (1) {
2217 DWORD header[2];
2218
2219 header[0] = (This->loadtime_magic != 0xdeadbeef) ? This->loadtime_magic : 0x0000746c;
2220 header[1] = iDataSize;
2221 IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
2222 }
2223 IStream_Write(pStm, pIconData, iDataSize, &dummy);
2224
2225 HeapFree(GetProcessHeap(), 0, This->data);
2226 This->data = pIconData;
2227 This->datalen = iDataSize;
2228 hResult = S_OK;
2229 }
2230 } else {
2231 /*
2232 if (This->loadtime_magic != 0xdeadbeef) {
2233 */
2234 if (1) {
2235 DWORD header[2];
2236
2237 header[0] = (This->loadtime_magic != 0xdeadbeef) ? This->loadtime_magic : 0x0000746c;
2238 header[1] = This->datalen;
2239 IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
2240 }
2241 IStream_Write(pStm, This->data, This->datalen, &dummy);
2242 hResult = S_OK;
2243 }
2244 break;
2245 case PICTYPE_METAFILE:
2246 FIXME("(%p,%p,%d), PICTYPE_METAFILE not implemented!\n",This,pStm,fClearDirty);
2247 break;
2248 case PICTYPE_ENHMETAFILE:
2249 FIXME("(%p,%p,%d),PICTYPE_ENHMETAFILE not implemented!\n",This,pStm,fClearDirty);
2250 break;
2251 default:
2252 FIXME("(%p,%p,%d), [unknown type] not implemented!\n",This,pStm,fClearDirty);
2253 break;
2254 }
2255 if (hResult == S_OK && fClearDirty) This->bIsDirty = FALSE;
2256 return hResult;
2257 }
2258
2259 static HRESULT WINAPI OLEPictureImpl_GetSizeMax(
2260 IPersistStream* iface,ULARGE_INTEGER*pcbSize)
2261 {
2262 OLEPictureImpl *This = impl_from_IPersistStream(iface);
2263 FIXME("(%p,%p),stub!\n",This,pcbSize);
2264 return E_NOTIMPL;
2265 }
2266
2267
2268 /************************************************************************
2269 * IDispatch
2270 */
2271
2272 /************************************************************************
2273 * OLEPictureImpl_IDispatch_QueryInterface (IUnknown)
2274 *
2275 * See Windows documentation for more details on IUnknown methods.
2276 */
2277 static HRESULT WINAPI OLEPictureImpl_IDispatch_QueryInterface(
2278 IDispatch* iface,
2279 REFIID riid,
2280 VOID** ppvoid)
2281 {
2282 OLEPictureImpl *This = impl_from_IDispatch(iface);
2283
2284 return IPicture_QueryInterface((IPicture *)This, riid, ppvoid);
2285 }
2286
2287 /************************************************************************
2288 * OLEPictureImpl_IDispatch_AddRef (IUnknown)
2289 *
2290 * See Windows documentation for more details on IUnknown methods.
2291 */
2292 static ULONG WINAPI OLEPictureImpl_IDispatch_AddRef(
2293 IDispatch* iface)
2294 {
2295 OLEPictureImpl *This = impl_from_IDispatch(iface);
2296
2297 return IPicture_AddRef((IPicture *)This);
2298 }
2299
2300 /************************************************************************
2301 * OLEPictureImpl_IDispatch_Release (IUnknown)
2302 *
2303 * See Windows documentation for more details on IUnknown methods.
2304 */
2305 static ULONG WINAPI OLEPictureImpl_IDispatch_Release(
2306 IDispatch* iface)
2307 {
2308 OLEPictureImpl *This = impl_from_IDispatch(iface);
2309
2310 return IPicture_Release((IPicture *)This);
2311 }
2312
2313 /************************************************************************
2314 * OLEPictureImpl_GetTypeInfoCount (IDispatch)
2315 *
2316 * See Windows documentation for more details on IDispatch methods.
2317 */
2318 static HRESULT WINAPI OLEPictureImpl_GetTypeInfoCount(
2319 IDispatch* iface,
2320 unsigned int* pctinfo)
2321 {
2322 TRACE("(%p)\n", pctinfo);
2323
2324 *pctinfo = 1;
2325
2326 return S_OK;
2327 }
2328
2329 /************************************************************************
2330 * OLEPictureImpl_GetTypeInfo (IDispatch)
2331 *
2332 * See Windows documentation for more details on IDispatch methods.
2333 */
2334 static HRESULT WINAPI OLEPictureImpl_GetTypeInfo(
2335 IDispatch* iface,
2336 UINT iTInfo,
2337 LCID lcid,
2338 ITypeInfo** ppTInfo)
2339 {
2340 static const WCHAR stdole2tlb[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
2341 ITypeLib *tl;
2342 HRESULT hres;
2343
2344 TRACE("(iTInfo=%d, lcid=%04x, %p)\n", iTInfo, (int)lcid, ppTInfo);
2345
2346 if (iTInfo != 0)
2347 return E_FAIL;
2348
2349 hres = LoadTypeLib(stdole2tlb, &tl);
2350 if (FAILED(hres))
2351 {
2352 ERR("Could not load stdole2.tlb\n");
2353 return hres;
2354 }
2355
2356 hres = ITypeLib_GetTypeInfoOfGuid(tl, &IID_IPictureDisp, ppTInfo);
2357 if (FAILED(hres))
2358 ERR("Did not get IPictureDisp typeinfo from typelib, hres %x\n", hres);
2359
2360 return hres;
2361 }
2362
2363 /************************************************************************
2364 * OLEPictureImpl_GetIDsOfNames (IDispatch)
2365 *
2366 * See Windows documentation for more details on IDispatch methods.
2367 */
2368 static HRESULT WINAPI OLEPictureImpl_GetIDsOfNames(
2369 IDispatch* iface,
2370 REFIID riid,
2371 LPOLESTR* rgszNames,
2372 UINT cNames,
2373 LCID lcid,
2374 DISPID* rgDispId)
2375 {
2376 ITypeInfo * pTInfo;
2377 HRESULT hres;
2378
2379 TRACE("(%p,%s,%p,cNames=%d,lcid=%04x,%p)\n", iface, debugstr_guid(riid),
2380 rgszNames, cNames, (int)lcid, rgDispId);
2381
2382 if (cNames == 0)
2383 {
2384 return E_INVALIDARG;
2385 }
2386 else
2387 {
2388 /* retrieve type information */
2389 hres = OLEPictureImpl_GetTypeInfo(iface, 0, lcid, &pTInfo);
2390
2391 if (FAILED(hres))
2392 {
2393 ERR("GetTypeInfo failed.\n");
2394 return hres;
2395 }
2396
2397 /* convert names to DISPIDs */
2398 hres = DispGetIDsOfNames (pTInfo, rgszNames, cNames, rgDispId);
2399 ITypeInfo_Release(pTInfo);
2400
2401 return hres;
2402 }
2403 }
2404
2405 /************************************************************************
2406 * OLEPictureImpl_Invoke (IDispatch)
2407 *
2408 * See Windows documentation for more details on IDispatch methods.
2409 */
2410 static HRESULT WINAPI OLEPictureImpl_Invoke(
2411 IDispatch* iface,
2412 DISPID dispIdMember,
2413 REFIID riid,
2414 LCID lcid,
2415 WORD wFlags,
2416 DISPPARAMS* pDispParams,
2417 VARIANT* pVarResult,
2418 EXCEPINFO* pExepInfo,
2419 UINT* puArgErr)
2420 {
2421 OLEPictureImpl *This = impl_from_IDispatch(iface);
2422
2423 /* validate parameters */
2424
2425 if (!IsEqualIID(riid, &IID_NULL))
2426 {
2427 ERR("riid was %s instead of IID_NULL\n", debugstr_guid(riid));
2428 return DISP_E_UNKNOWNNAME;
2429 }
2430
2431 if (!pDispParams)
2432 {
2433 ERR("null pDispParams not allowed\n");
2434 return DISP_E_PARAMNOTOPTIONAL;
2435 }
2436
2437 if (wFlags & DISPATCH_PROPERTYGET)
2438 {
2439 if (pDispParams->cArgs != 0)
2440 {
2441 ERR("param count for DISPATCH_PROPERTYGET was %d instead of 0\n", pDispParams->cArgs);
2442 return DISP_E_BADPARAMCOUNT;
2443 }
2444 if (!pVarResult)
2445 {
2446 ERR("null pVarResult not allowed when DISPATCH_PROPERTYGET specified\n");
2447 return DISP_E_PARAMNOTOPTIONAL;
2448 }
2449 }
2450 else if (wFlags & DISPATCH_PROPERTYPUT)
2451 {
2452 if (pDispParams->cArgs != 1)
2453 {
2454 ERR("param count for DISPATCH_PROPERTYPUT was %d instead of 1\n", pDispParams->cArgs);
2455 return DISP_E_BADPARAMCOUNT;
2456 }
2457 }
2458
2459 switch (dispIdMember)
2460 {
2461 case DISPID_PICT_HANDLE:
2462 if (wFlags & DISPATCH_PROPERTYGET)
2463 {
2464 TRACE("DISPID_PICT_HANDLE\n");
2465 V_VT(pVarResult) = VT_I4;
2466 return IPicture_get_Handle((IPicture *)&This->lpVtbl, &V_UINT(pVarResult));
2467 }
2468 break;
2469 case DISPID_PICT_HPAL:
2470 if (wFlags & DISPATCH_PROPERTYGET)
2471 {
2472 TRACE("DISPID_PICT_HPAL\n");
2473 V_VT(pVarResult) = VT_I4;
2474 return IPicture_get_hPal((IPicture *)&This->lpVtbl, &V_UINT(pVarResult));
2475 }
2476 else if (wFlags & DISPATCH_PROPERTYPUT)
2477 {
2478 VARIANTARG vararg;
2479 HRESULT hr;
2480 TRACE("DISPID_PICT_HPAL\n");
2481
2482 VariantInit(&vararg);
2483 hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_I4);
2484 if (FAILED(hr))
2485 return hr;
2486
2487 hr = IPicture_set_hPal((IPicture *)&This->lpVtbl, V_I4(&vararg));
2488
2489 VariantClear(&vararg);
2490 return hr;
2491 }
2492 break;
2493 case DISPID_PICT_TYPE:
2494 if (wFlags & DISPATCH_PROPERTYGET)
2495 {
2496 TRACE("DISPID_PICT_TYPE\n");
2497 V_VT(pVarResult) = VT_I2;
2498 return OLEPictureImpl_get_Type((IPicture *)&This->lpVtbl, &V_I2(pVarResult));
2499 }
2500 break;
2501 case DISPID_PICT_WIDTH:
2502 if (wFlags & DISPATCH_PROPERTYGET)
2503 {
2504 TRACE("DISPID_PICT_WIDTH\n");
2505 V_VT(pVarResult) = VT_I4;
2506 return IPicture_get_Width((IPicture *)&This->lpVtbl, &V_I4(pVarResult));
2507 }
2508 break;
2509 case DISPID_PICT_HEIGHT:
2510 if (wFlags & DISPATCH_PROPERTYGET)
2511 {
2512 TRACE("DISPID_PICT_HEIGHT\n");
2513 V_VT(pVarResult) = VT_I4;
2514 return IPicture_get_Height((IPicture *)&This->lpVtbl, &V_I4(pVarResult));
2515 }
2516 break;
2517 }
2518
2519 ERR("invalid dispid 0x%x or wFlags 0x%x\n", dispIdMember, wFlags);
2520 return DISP_E_MEMBERNOTFOUND;
2521 }
2522
2523
2524 static const IPictureVtbl OLEPictureImpl_VTable =
2525 {
2526 OLEPictureImpl_QueryInterface,
2527 OLEPictureImpl_AddRef,
2528 OLEPictureImpl_Release,
2529 OLEPictureImpl_get_Handle,
2530 OLEPictureImpl_get_hPal,
2531 OLEPictureImpl_get_Type,
2532 OLEPictureImpl_get_Width,
2533 OLEPictureImpl_get_Height,
2534 OLEPictureImpl_Render,
2535 OLEPictureImpl_set_hPal,
2536 OLEPictureImpl_get_CurDC,
2537 OLEPictureImpl_SelectPicture,
2538 OLEPictureImpl_get_KeepOriginalFormat,
2539 OLEPictureImpl_put_KeepOriginalFormat,
2540 OLEPictureImpl_PictureChanged,
2541 OLEPictureImpl_SaveAsFile,
2542 OLEPictureImpl_get_Attributes
2543 };
2544
2545 static const IDispatchVtbl OLEPictureImpl_IDispatch_VTable =
2546 {
2547 OLEPictureImpl_IDispatch_QueryInterface,
2548 OLEPictureImpl_IDispatch_AddRef,
2549 OLEPictureImpl_IDispatch_Release,
2550 OLEPictureImpl_GetTypeInfoCount,
2551 OLEPictureImpl_GetTypeInfo,
2552 OLEPictureImpl_GetIDsOfNames,
2553 OLEPictureImpl_Invoke
2554 };
2555
2556 static const IPersistStreamVtbl OLEPictureImpl_IPersistStream_VTable =
2557 {
2558 OLEPictureImpl_IPersistStream_QueryInterface,
2559 OLEPictureImpl_IPersistStream_AddRef,
2560 OLEPictureImpl_IPersistStream_Release,
2561 OLEPictureImpl_GetClassID,
2562 OLEPictureImpl_IsDirty,
2563 OLEPictureImpl_Load,
2564 OLEPictureImpl_Save,
2565 OLEPictureImpl_GetSizeMax
2566 };
2567
2568 static const IConnectionPointContainerVtbl OLEPictureImpl_IConnectionPointContainer_VTable =
2569 {
2570 OLEPictureImpl_IConnectionPointContainer_QueryInterface,
2571 OLEPictureImpl_IConnectionPointContainer_AddRef,
2572 OLEPictureImpl_IConnectionPointContainer_Release,
2573 OLEPictureImpl_EnumConnectionPoints,
2574 OLEPictureImpl_FindConnectionPoint
2575 };
2576
2577 /***********************************************************************
2578 * OleCreatePictureIndirect (OLEAUT32.419)
2579 */
2580 HRESULT WINAPI OleCreatePictureIndirect(LPPICTDESC lpPictDesc, REFIID riid,
2581 BOOL fOwn, LPVOID *ppvObj )
2582 {
2583 OLEPictureImpl* newPict = NULL;
2584 HRESULT hr = S_OK;
2585
2586 TRACE("(%p,%s,%d,%p)\n", lpPictDesc, debugstr_guid(riid), fOwn, ppvObj);
2587
2588 /*
2589 * Sanity check
2590 */
2591 if (ppvObj==0)
2592 return E_POINTER;
2593
2594 *ppvObj = NULL;
2595
2596 /*
2597 * Try to construct a new instance of the class.
2598 */
2599 newPict = OLEPictureImpl_Construct(lpPictDesc, fOwn);
2600
2601 if (newPict == NULL)
2602 return E_OUTOFMEMORY;
2603
2604 /*
2605 * Make sure it supports the interface required by the caller.
2606 */
2607 hr = IPicture_QueryInterface((IPicture*)newPict, riid, ppvObj);
2608
2609 /*
2610 * Release the reference obtained in the constructor. If
2611 * the QueryInterface was unsuccessful, it will free the class.
2612 */
2613 IPicture_Release((IPicture*)newPict);
2614
2615 return hr;
2616 }
2617
2618
2619 /***********************************************************************
2620 * OleLoadPicture (OLEAUT32.418)
2621 */
2622 HRESULT WINAPI OleLoadPicture( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
2623 REFIID riid, LPVOID *ppvObj )
2624 {
2625 LPPERSISTSTREAM ps;
2626 IPicture *newpic;
2627 HRESULT hr;
2628
2629 TRACE("(%p,%d,%d,%s,%p), partially implemented.\n",
2630 lpstream, lSize, fRunmode, debugstr_guid(riid), ppvObj);
2631
2632 hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
2633 if (hr)
2634 return hr;
2635 hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
2636 if (hr) {
2637 ERR("Could not get IPersistStream iface from Ole Picture?\n");
2638 IPicture_Release(newpic);
2639 *ppvObj = NULL;
2640 return hr;
2641 }
2642 hr = IPersistStream_Load(ps,lpstream);
2643 IPersistStream_Release(ps);
2644 if (FAILED(hr))
2645 {
2646 ERR("IPersistStream_Load failed\n");
2647 IPicture_Release(newpic);
2648 *ppvObj = NULL;
2649 return hr;
2650 }
2651 hr = IPicture_QueryInterface(newpic,riid,ppvObj);
2652 if (hr)
2653 ERR("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
2654 IPicture_Release(newpic);
2655 return hr;
2656 }
2657
2658 /***********************************************************************
2659 * OleLoadPictureEx (OLEAUT32.401)
2660 */
2661 HRESULT WINAPI OleLoadPictureEx( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
2662 REFIID riid, DWORD xsiz, DWORD ysiz, DWORD flags, LPVOID *ppvObj )
2663 {
2664 LPPERSISTSTREAM ps;
2665 IPicture *newpic;
2666 HRESULT hr;
2667
2668 FIXME("(%p,%d,%d,%s,x=%d,y=%d,f=%x,%p), partially implemented.\n",
2669 lpstream, lSize, fRunmode, debugstr_guid(riid), xsiz, ysiz, flags, ppvObj);
2670
2671 hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
2672 if (hr)
2673 return hr;
2674 hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
2675 if (hr) {
2676 ERR("Could not get IPersistStream iface from Ole Picture?\n");
2677 IPicture_Release(newpic);
2678 *ppvObj = NULL;
2679 return hr;
2680 }
2681 hr = IPersistStream_Load(ps,lpstream);
2682 IPersistStream_Release(ps);
2683 if (FAILED(hr))
2684 {
2685 ERR("IPersistStream_Load failed\n");
2686 IPicture_Release(newpic);
2687 *ppvObj = NULL;
2688 return hr;
2689 }
2690 hr = IPicture_QueryInterface(newpic,riid,ppvObj);
2691 if (hr)
2692 ERR("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
2693 IPicture_Release(newpic);
2694 return hr;
2695 }
2696
2697 /***********************************************************************
2698 * OleLoadPicturePath (OLEAUT32.424)
2699 */
2700 HRESULT WINAPI OleLoadPicturePath( LPOLESTR szURLorPath, LPUNKNOWN punkCaller,
2701 DWORD dwReserved, OLE_COLOR clrReserved, REFIID riid,
2702 LPVOID *ppvRet )
2703 {
2704 static const WCHAR file[] = { 'f','i','l','e',':','/','/',0 };
2705 IPicture *ipicture;
2706 HANDLE hFile;
2707 DWORD dwFileSize;
2708 HGLOBAL hGlobal = NULL;
2709 DWORD dwBytesRead = 0;
2710 IStream *stream;
2711 BOOL bRead;
2712 IPersistStream *pStream;
2713 HRESULT hRes;
2714
2715 TRACE("(%s,%p,%d,%08x,%s,%p): stub\n",
2716 debugstr_w(szURLorPath), punkCaller, dwReserved, clrReserved,
2717 debugstr_guid(riid), ppvRet);
2718
2719 if (!ppvRet) return E_POINTER;
2720
2721 if (strncmpW(szURLorPath, file, 7) == 0) {
2722 szURLorPath += 7;
2723
2724 hFile = CreateFileW(szURLorPath, GENERIC_READ, 0, NULL, OPEN_EXISTING,
2725 0, NULL);
2726 if (hFile == INVALID_HANDLE_VALUE)
2727 return E_UNEXPECTED;
2728
2729 dwFileSize = GetFileSize(hFile, NULL);
2730 if (dwFileSize != INVALID_FILE_SIZE )
2731 {
2732 hGlobal = GlobalAlloc(GMEM_FIXED,dwFileSize);
2733 if ( hGlobal)
2734 {
2735 bRead = ReadFile(hFile, hGlobal, dwFileSize, &dwBytesRead, NULL);
2736 if (!bRead)
2737 {
2738 GlobalFree(hGlobal);
2739 hGlobal = 0;
2740 }
2741 }
2742 }
2743 CloseHandle(hFile);
2744
2745 if (!hGlobal)
2746 return E_UNEXPECTED;
2747
2748 hRes = CreateStreamOnHGlobal(hGlobal, TRUE, &stream);
2749 if (FAILED(hRes))
2750 {
2751 GlobalFree(hGlobal);
2752 return hRes;
2753 }
2754 } else {
2755 IMoniker *pmnk;
2756 IBindCtx *pbc;
2757
2758 hRes = CreateBindCtx(0, &pbc);
2759 if (SUCCEEDED(hRes))
2760 {
2761 hRes = CreateURLMoniker(NULL, szURLorPath, &pmnk);
2762 if (SUCCEEDED(hRes))
2763 {
2764 hRes = IMoniker_BindToStorage(pmnk, pbc, NULL, &IID_IStream, (LPVOID*)&stream);
2765 IMoniker_Release(pmnk);
2766 }
2767 IBindCtx_Release(pbc);
2768 }
2769 if (FAILED(hRes))
2770 return hRes;
2771 }
2772
2773 hRes = CoCreateInstance(&CLSID_StdPicture, punkCaller, CLSCTX_INPROC_SERVER,
2774 &IID_IPicture, (LPVOID*)&ipicture);
2775 if (hRes != S_OK) {
2776 IStream_Release(stream);
2777 return hRes;
2778 }
2779
2780 hRes = IPicture_QueryInterface(ipicture, &IID_IPersistStream, (LPVOID*)&pStream);
2781 if (hRes) {
2782 IStream_Release(stream);
2783 IPicture_Release(ipicture);
2784 return hRes;
2785 }
2786
2787 hRes = IPersistStream_Load(pStream, stream);
2788 IPersistStream_Release(pStream);
2789 IStream_Release(stream);
2790
2791 if (hRes) {
2792 IPicture_Release(ipicture);
2793 return hRes;
2794 }
2795
2796 hRes = IPicture_QueryInterface(ipicture,riid,ppvRet);
2797 if (hRes)
2798 ERR("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
2799
2800 IPicture_Release(ipicture);
2801 return hRes;
2802 }
2803
2804 /*******************************************************************************
2805 * StdPic ClassFactory
2806 */
2807 typedef struct
2808 {
2809 /* IUnknown fields */
2810 const IClassFactoryVtbl *lpVtbl;
2811 LONG ref;
2812 } IClassFactoryImpl;
2813
2814 static HRESULT WINAPI
2815 SPCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
2816 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
2817
2818 FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
2819 return E_NOINTERFACE;
2820 }
2821
2822 static ULONG WINAPI
2823 SPCF_AddRef(LPCLASSFACTORY iface) {
2824 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
2825 return InterlockedIncrement(&This->ref);
2826 }
2827
2828 static ULONG WINAPI SPCF_Release(LPCLASSFACTORY iface) {
2829 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
2830 /* static class, won't be freed */
2831 return InterlockedDecrement(&This->ref);
2832 }
2833
2834 static HRESULT WINAPI SPCF_CreateInstance(
2835 LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
2836 ) {
2837 /* Creates an uninitialized picture */
2838 return OleCreatePictureIndirect(NULL,riid,TRUE,ppobj);
2839
2840 }
2841
2842 static HRESULT WINAPI SPCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
2843 IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
2844 FIXME("(%p)->(%d),stub!\n",This,dolock);
2845 return S_OK;
2846 }
2847
2848 static const IClassFactoryVtbl SPCF_Vtbl = {
2849 SPCF_QueryInterface,
2850 SPCF_AddRef,
2851 SPCF_Release,
2852 SPCF_CreateInstance,
2853 SPCF_LockServer
2854 };
2855 static IClassFactoryImpl STDPIC_CF = {&SPCF_Vtbl, 1 };
2856
2857 void _get_STDPIC_CF(LPVOID *ppv) { *ppv = (LPVOID)&STDPIC_CF; }
Maarten's multimedia branch