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