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