?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d10core: Implement ID3D10Texture2D::GetType().
[wine/multimedia.git] / dlls / oleaut32 / olepicture.c
blobf05501d5cf4e30bf28927565deec0a093efea918
1 /*
2 * OLE Picture object
3 *
4 * Implementation of OLE IPicture and related interfaces
5 *
6 * Copyright 2000 Huw D M Davies for CodeWeavers.
7 * Copyright 2001 Marcus Meissner
8 * Copyright 2008 Kirill K. Smirnov
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 *
24 * BUGS
25 *
26 * Support PICTYPE_BITMAP and PICTYPE_ICON, although only bitmaps very well..
27 * Lots of methods are just stubs.
28 *
29 *
30 * NOTES (or things that msdn doesn't tell you)
31 *
32 * The width and height properties are returned in HIMETRIC units (0.01mm)
33 * IPicture::Render also uses these to select a region of the src picture.
34 * A bitmap's size is converted into these units by using the screen resolution
35 * thus an 8x8 bitmap on a 96dpi screen has a size of 212x212 (8/96 * 2540).
36 *
37 */
38
39 #include "config.h"
40 #include "wine/port.h"
41
42 #ifdef HAVE_UNISTD_H
43 # include <unistd.h>
44 #endif
45 #include <stdarg.h>
46 #include <stdio.h>
47 #include <string.h>
48
49 #ifdef SONAME_LIBJPEG
50 /* This is a hack, so jpeglib.h does not redefine INT32 and the like*/
51 #define XMD_H
52 #define UINT8 JPEG_UINT8
53 #define UINT16 JPEG_UINT16
54 #define boolean jpeg_boolean
55 # include <jpeglib.h>
56 #undef UINT8
57 #undef UINT16
58 #undef boolean
59 #endif
60
61 #ifdef HAVE_PNG_H
62 #include <png.h>
63 #endif
64
65 /* Must be before wine includes, the header has things conflicting with
66 * WINE headers.
67 */
68 #define COBJMACROS
69 #define NONAMELESSUNION
70 #define NONAMELESSSTRUCT
71
72 #include "winerror.h"
73 #include "windef.h"
74 #include "winbase.h"
75 #include "wingdi.h"
76 #include "winuser.h"
77 #include "ole2.h"
78 #include "olectl.h"
79 #include "oleauto.h"
80 #include "connpt.h"
81 #include "urlmon.h"
82 #include "wine/debug.h"
83 #include "wine/unicode.h"
84
85 #include "wine/wingdi16.h"
86
87 #include "ungif.h"
88
89 WINE_DEFAULT_DEBUG_CHANNEL(ole);
90
91 #include "pshpack1.h"
92
93 /* Header for Aldus Placable Metafiles - a standard metafile follows */
94 typedef struct _APM_HEADER
95 {
96 DWORD key;
97 WORD handle;
98 SHORT left;
99 SHORT top;
100 SHORT right;
101 SHORT bottom;
102 WORD inch;
103 DWORD reserved;
104 WORD checksum;
105 } APM_HEADER;
106
107 typedef struct {
108 BYTE bWidth;
109 BYTE bHeight;
110 BYTE bColorCount;
111 BYTE bReserved;
112 WORD xHotspot;
113 WORD yHotspot;
114 DWORD dwDIBSize;
115 DWORD dwDIBOffset;
116 } CURSORICONFILEDIRENTRY;
117
118 typedef struct
119 {
120 WORD idReserved;
121 WORD idType;
122 WORD idCount;
123 CURSORICONFILEDIRENTRY idEntries[1];
124 } CURSORICONFILEDIR;
125
126 #include "poppack.h"
127
128 /*************************************************************************
129 * Declaration of implementation class
130 */
131
132 typedef struct OLEPictureImpl {
133
134 /*
135 * IPicture handles IUnknown
136 */
137
138 const IPictureVtbl *lpVtbl;
139 const IDispatchVtbl *lpvtblIDispatch;
140 const IPersistStreamVtbl *lpvtblIPersistStream;
141 const IConnectionPointContainerVtbl *lpvtblIConnectionPointContainer;
142
143 /* Object reference count */
144 LONG ref;
145
146 /* We own the object and must destroy it ourselves */
147 BOOL fOwn;
148
149 /* Picture description */
150 PICTDESC desc;
151
152 /* These are the pixel size of a bitmap */
153 DWORD origWidth;
154 DWORD origHeight;
155
156 /* And these are the size of the picture converted into HIMETRIC units */
157 OLE_XSIZE_HIMETRIC himetricWidth;
158 OLE_YSIZE_HIMETRIC himetricHeight;
159
160 IConnectionPoint *pCP;
161
162 BOOL keepOrigFormat;
163 HDC hDCCur;
164
165 /* Bitmap transparency mask */
166 HBITMAP hbmMask;
167 HBITMAP hbmXor;
168 COLORREF rgbTrans;
169
170 /* data */
171 void* data;
172 int datalen;
173 BOOL bIsDirty; /* Set to TRUE if picture has changed */
174 unsigned int loadtime_magic; /* If a length header was found, saves value */
175 unsigned int loadtime_format; /* for PICTYPE_BITMAP only, keeps track of image format (GIF/BMP/JPEG) */
176 } OLEPictureImpl;
177
178 /*
179 * Macros to retrieve pointer to IUnknown (IPicture) from the other VTables.
180 */
181
182 static inline OLEPictureImpl *impl_from_IDispatch( IDispatch *iface )
183 {
184 return (OLEPictureImpl *)((char*)iface - FIELD_OFFSET(OLEPictureImpl, lpvtblIDispatch));
185 }
186
187 static inline OLEPictureImpl *impl_from_IPersistStream( IPersistStream *iface )
188 {
189 return (OLEPictureImpl *)((char*)iface - FIELD_OFFSET(OLEPictureImpl, lpvtblIPersistStream));
190 }
191
192 static inline OLEPictureImpl *impl_from_IConnectionPointContainer( IConnectionPointContainer *iface )
193 {
194 return (OLEPictureImpl *)((char*)iface - FIELD_OFFSET(OLEPictureImpl, lpvtblIConnectionPointContainer));
195 }
196
197 /*
198 * Predeclare VTables. They get initialized at the end.
199 */
200 static const IPictureVtbl OLEPictureImpl_VTable;
201 static const IDispatchVtbl OLEPictureImpl_IDispatch_VTable;
202 static const IPersistStreamVtbl OLEPictureImpl_IPersistStream_VTable;
203 static const IConnectionPointContainerVtbl OLEPictureImpl_IConnectionPointContainer_VTable;
204
205 /***********************************************************************
206 * Implementation of the OLEPictureImpl class.
207 */
208
209 static void OLEPictureImpl_SetBitmap(OLEPictureImpl*This) {
210 BITMAP bm;
211 HDC hdcRef;
212
213 TRACE("bitmap handle %p\n", This->desc.u.bmp.hbitmap);
214 if(GetObjectA(This->desc.u.bmp.hbitmap, sizeof(bm), &bm) != sizeof(bm)) {
215 ERR("GetObject fails\n");
216 return;
217 }
218 This->origWidth = bm.bmWidth;
219 This->origHeight = bm.bmHeight;
220 /* The width and height are stored in HIMETRIC units (0.01 mm),
221 so we take our pixel width divide by pixels per inch and
222 multiply by 25.4 * 100 */
223 /* Should we use GetBitmapDimension if available? */
224 hdcRef = CreateCompatibleDC(0);
225 This->himetricWidth =(bm.bmWidth *2540)/GetDeviceCaps(hdcRef, LOGPIXELSX);
226 This->himetricHeight=(bm.bmHeight*2540)/GetDeviceCaps(hdcRef, LOGPIXELSY);
227 DeleteDC(hdcRef);
228 }
229
230 static void OLEPictureImpl_SetIcon(OLEPictureImpl * This)
231 {
232 ICONINFO infoIcon;
233
234 TRACE("icon handle %p\n", This->desc.u.icon.hicon);
235 if (GetIconInfo(This->desc.u.icon.hicon, &infoIcon)) {
236 HDC hdcRef;
237 BITMAP bm;
238
239 TRACE("bitmap handle for icon is %p\n", infoIcon.hbmColor);
240 if(GetObjectA(infoIcon.hbmColor ? infoIcon.hbmColor : infoIcon.hbmMask, sizeof(bm), &bm) != sizeof(bm)) {
241 ERR("GetObject fails on icon bitmap\n");
242 return;
243 }
244
245 This->origWidth = bm.bmWidth;
246 This->origHeight = infoIcon.hbmColor ? bm.bmHeight : bm.bmHeight / 2;
247 /* see comment on HIMETRIC on OLEPictureImpl_SetBitmap() */
248 hdcRef = GetDC(0);
249 This->himetricWidth = (This->origWidth *2540)/GetDeviceCaps(hdcRef, LOGPIXELSX);
250 This->himetricHeight= (This->origHeight *2540)/GetDeviceCaps(hdcRef, LOGPIXELSY);
251 ReleaseDC(0, hdcRef);
252
253 DeleteObject(infoIcon.hbmMask);
254 if (infoIcon.hbmColor) DeleteObject(infoIcon.hbmColor);
255 } else {
256 ERR("GetIconInfo() fails on icon %p\n", This->desc.u.icon.hicon);
257 }
258 }
259
260 /************************************************************************
261 * OLEPictureImpl_Construct
262 *
263 * This method will construct a new instance of the OLEPictureImpl
264 * class.
265 *
266 * The caller of this method must release the object when it's
267 * done with it.
268 */
269 static OLEPictureImpl* OLEPictureImpl_Construct(LPPICTDESC pictDesc, BOOL fOwn)
270 {
271 OLEPictureImpl* newObject = 0;
272
273 if (pictDesc)
274 TRACE("(%p) type = %d\n", pictDesc, pictDesc->picType);
275
276 /*
277 * Allocate space for the object.
278 */
279 newObject = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(OLEPictureImpl));
280
281 if (newObject==0)
282 return newObject;
283
284 /*
285 * Initialize the virtual function table.
286 */
287 newObject->lpVtbl = &OLEPictureImpl_VTable;
288 newObject->lpvtblIDispatch = &OLEPictureImpl_IDispatch_VTable;
289 newObject->lpvtblIPersistStream = &OLEPictureImpl_IPersistStream_VTable;
290 newObject->lpvtblIConnectionPointContainer = &OLEPictureImpl_IConnectionPointContainer_VTable;
291
292 newObject->pCP = NULL;
293 CreateConnectionPoint((IUnknown*)newObject,&IID_IPropertyNotifySink,&newObject->pCP);
294 if (!newObject->pCP)
295 {
296 HeapFree(GetProcessHeap(), 0, newObject);
297 return NULL;
298 }
299
300 /*
301 * Start with one reference count. The caller of this function
302 * must release the interface pointer when it is done.
303 */
304 newObject->ref = 1;
305 newObject->hDCCur = 0;
306
307 newObject->fOwn = fOwn;
308
309 /* dunno about original value */
310 newObject->keepOrigFormat = TRUE;
311
312 newObject->hbmMask = NULL;
313 newObject->hbmXor = NULL;
314 newObject->loadtime_magic = 0xdeadbeef;
315 newObject->loadtime_format = 0;
316 newObject->bIsDirty = FALSE;
317
318 if (pictDesc) {
319 newObject->desc = *pictDesc;
320
321 switch(pictDesc->picType) {
322 case PICTYPE_BITMAP:
323 OLEPictureImpl_SetBitmap(newObject);
324 break;
325
326 case PICTYPE_METAFILE:
327 TRACE("metafile handle %p\n", pictDesc->u.wmf.hmeta);
328 newObject->himetricWidth = pictDesc->u.wmf.xExt;
329 newObject->himetricHeight = pictDesc->u.wmf.yExt;
330 break;
331
332 case PICTYPE_NONE:
333 /* not sure what to do here */
334 newObject->himetricWidth = newObject->himetricHeight = 0;
335 break;
336
337 case PICTYPE_ICON:
338 OLEPictureImpl_SetIcon(newObject);
339 break;
340 case PICTYPE_ENHMETAFILE:
341 default:
342 FIXME("Unsupported type %d\n", pictDesc->picType);
343 newObject->himetricWidth = newObject->himetricHeight = 0;
344 break;
345 }
346 } else {
347 newObject->desc.picType = PICTYPE_UNINITIALIZED;
348 }
349
350 TRACE("returning %p\n", newObject);
351 return newObject;
352 }
353
354 /************************************************************************
355 * OLEPictureImpl_Destroy
356 *
357 * This method is called by the Release method when the reference
358 * count goes down to 0. It will free all resources used by
359 * this object. */
360 static void OLEPictureImpl_Destroy(OLEPictureImpl* Obj)
361 {
362 TRACE("(%p)\n", Obj);
363
364 if (Obj->pCP)
365 IConnectionPoint_Release(Obj->pCP);
366
367 if(Obj->fOwn) { /* We need to destroy the picture */
368 switch(Obj->desc.picType) {
369 case PICTYPE_BITMAP:
370 DeleteObject(Obj->desc.u.bmp.hbitmap);
371 if (Obj->hbmMask != NULL) DeleteObject(Obj->hbmMask);
372 if (Obj->hbmXor != NULL) DeleteObject(Obj->hbmXor);
373 break;
374 case PICTYPE_METAFILE:
375 DeleteMetaFile(Obj->desc.u.wmf.hmeta);
376 break;
377 case PICTYPE_ICON:
378 DestroyIcon(Obj->desc.u.icon.hicon);
379 break;
380 case PICTYPE_ENHMETAFILE:
381 DeleteEnhMetaFile(Obj->desc.u.emf.hemf);
382 break;
383 case PICTYPE_NONE:
384 case PICTYPE_UNINITIALIZED:
385 /* Nothing to do */
386 break;
387 default:
388 FIXME("Unsupported type %d - unable to delete\n", Obj->desc.picType);
389 break;
390 }
391 }
392 HeapFree(GetProcessHeap(), 0, Obj->data);
393 HeapFree(GetProcessHeap(), 0, Obj);
394 }
395
396
397 /************************************************************************
398 * OLEPictureImpl_AddRef (IUnknown)
399 *
400 * See Windows documentation for more details on IUnknown methods.
401 */
402 static ULONG WINAPI OLEPictureImpl_AddRef(
403 IPicture* iface)
404 {
405 OLEPictureImpl *This = (OLEPictureImpl *)iface;
406 ULONG refCount = InterlockedIncrement(&This->ref);
407
408 TRACE("(%p)->(ref before=%d)\n", This, refCount - 1);
409
410 return refCount;
411 }
412
413 /************************************************************************
414 * OLEPictureImpl_Release (IUnknown)
415 *
416 * See Windows documentation for more details on IUnknown methods.
417 */
418 static ULONG WINAPI OLEPictureImpl_Release(
419 IPicture* iface)
420 {
421 OLEPictureImpl *This = (OLEPictureImpl *)iface;
422 ULONG refCount = InterlockedDecrement(&This->ref);
423
424 TRACE("(%p)->(ref before=%d)\n", This, refCount + 1);
425
426 /*
427 * If the reference count goes down to 0, perform suicide.
428 */
429 if (!refCount) OLEPictureImpl_Destroy(This);
430
431 return refCount;
432 }
433
434 /************************************************************************
435 * OLEPictureImpl_QueryInterface (IUnknown)
436 *
437 * See Windows documentation for more details on IUnknown methods.
438 */
439 static HRESULT WINAPI OLEPictureImpl_QueryInterface(
440 IPicture* iface,
441 REFIID riid,
442 void** ppvObject)
443 {
444 OLEPictureImpl *This = (OLEPictureImpl *)iface;
445 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
446
447 /*
448 * Perform a sanity check on the parameters.
449 */
450 if ( (This==0) || (ppvObject==0) )
451 return E_INVALIDARG;
452
453 /*
454 * Initialize the return parameter.
455 */
456 *ppvObject = 0;
457
458 /*
459 * Compare the riid with the interface IDs implemented by this object.
460 */
461 if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IPicture, riid))
462 *ppvObject = (IPicture*)This;
463 else if (IsEqualIID(&IID_IDispatch, riid))
464 *ppvObject = (IDispatch*)&(This->lpvtblIDispatch);
465 else if (IsEqualIID(&IID_IPictureDisp, riid))
466 *ppvObject = (IDispatch*)&(This->lpvtblIDispatch);
467 else if (IsEqualIID(&IID_IPersist, riid) || IsEqualIID(&IID_IPersistStream, riid))
468 *ppvObject = (IPersistStream*)&(This->lpvtblIPersistStream);
469 else if (IsEqualIID(&IID_IConnectionPointContainer, riid))
470 *ppvObject = (IConnectionPointContainer*)&(This->lpvtblIConnectionPointContainer);
471
472 /*
473 * Check that we obtained an interface.
474 */
475 if ((*ppvObject)==0)
476 {
477 FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid));
478 return E_NOINTERFACE;
479 }
480
481 /*
482 * Query Interface always increases the reference count by one when it is
483 * successful
484 */
485 OLEPictureImpl_AddRef((IPicture*)This);
486
487 return S_OK;
488 }
489
490 /***********************************************************************
491 * OLEPicture_SendNotify (internal)
492 *
493 * Sends notification messages of changed properties to any interested
494 * connections.
495 */
496 static void OLEPicture_SendNotify(OLEPictureImpl* this, DISPID dispID)
497 {
498 IEnumConnections *pEnum;
499 CONNECTDATA CD;
500
501 if (IConnectionPoint_EnumConnections(this->pCP, &pEnum))
502 return;
503 while(IEnumConnections_Next(pEnum, 1, &CD, NULL) == S_OK) {
504 IPropertyNotifySink *sink;
505
506 IUnknown_QueryInterface(CD.pUnk, &IID_IPropertyNotifySink, (LPVOID)&sink);
507 IPropertyNotifySink_OnChanged(sink, dispID);
508 IPropertyNotifySink_Release(sink);
509 IUnknown_Release(CD.pUnk);
510 }
511 IEnumConnections_Release(pEnum);
512 }
513
514 /************************************************************************
515 * OLEPictureImpl_get_Handle
516 */
517 static HRESULT WINAPI OLEPictureImpl_get_Handle(IPicture *iface,
518 OLE_HANDLE *phandle)
519 {
520 OLEPictureImpl *This = (OLEPictureImpl *)iface;
521 TRACE("(%p)->(%p)\n", This, phandle);
522
523 if(!phandle)
524 return E_POINTER;
525
526 switch(This->desc.picType) {
527 case PICTYPE_NONE:
528 case PICTYPE_UNINITIALIZED:
529 *phandle = 0;
530 break;
531 case PICTYPE_BITMAP:
532 *phandle = HandleToUlong(This->desc.u.bmp.hbitmap);
533 break;
534 case PICTYPE_METAFILE:
535 *phandle = HandleToUlong(This->desc.u.wmf.hmeta);
536 break;
537 case PICTYPE_ICON:
538 *phandle = HandleToUlong(This->desc.u.icon.hicon);
539 break;
540 case PICTYPE_ENHMETAFILE:
541 *phandle = HandleToUlong(This->desc.u.emf.hemf);
542 break;
543 default:
544 FIXME("Unimplemented type %d\n", This->desc.picType);
545 return E_NOTIMPL;
546 }
547 TRACE("returning handle %08x\n", *phandle);
548 return S_OK;
549 }
550
551 /************************************************************************
552 * OLEPictureImpl_get_hPal
553 */
554 static HRESULT WINAPI OLEPictureImpl_get_hPal(IPicture *iface,
555 OLE_HANDLE *phandle)
556 {
557 OLEPictureImpl *This = (OLEPictureImpl *)iface;
558 HRESULT hres;
559 TRACE("(%p)->(%p)\n", This, phandle);
560
561 if (!phandle)
562 return E_POINTER;
563
564 switch (This->desc.picType) {
565 case (UINT)PICTYPE_UNINITIALIZED:
566 case PICTYPE_NONE:
567 *phandle = 0;
568 hres = S_FALSE;
569 break;
570 case PICTYPE_BITMAP:
571 *phandle = HandleToUlong(This->desc.u.bmp.hpal);
572 hres = S_OK;
573 break;
574 case PICTYPE_METAFILE:
575 hres = E_FAIL;
576 break;
577 case PICTYPE_ICON:
578 case PICTYPE_ENHMETAFILE:
579 default:
580 FIXME("unimplemented for type %d. Returning 0 palette.\n",
581 This->desc.picType);
582 *phandle = 0;
583 hres = S_OK;
584 }
585
586 TRACE("returning 0x%08x, palette handle %08x\n", hres, *phandle);
587 return hres;
588 }
589
590 /************************************************************************
591 * OLEPictureImpl_get_Type
592 */
593 static HRESULT WINAPI OLEPictureImpl_get_Type(IPicture *iface,
594 short *ptype)
595 {
596 OLEPictureImpl *This = (OLEPictureImpl *)iface;
597 TRACE("(%p)->(%p): type is %d\n", This, ptype, This->desc.picType);
598
599 if(!ptype)
600 return E_POINTER;
601
602 *ptype = This->desc.picType;
603 return S_OK;
604 }
605
606 /************************************************************************
607 * OLEPictureImpl_get_Width
608 */
609 static HRESULT WINAPI OLEPictureImpl_get_Width(IPicture *iface,
610 OLE_XSIZE_HIMETRIC *pwidth)
611 {
612 OLEPictureImpl *This = (OLEPictureImpl *)iface;
613 TRACE("(%p)->(%p): width is %d\n", This, pwidth, This->himetricWidth);
614 *pwidth = This->himetricWidth;
615 return S_OK;
616 }
617
618 /************************************************************************
619 * OLEPictureImpl_get_Height
620 */
621 static HRESULT WINAPI OLEPictureImpl_get_Height(IPicture *iface,
622 OLE_YSIZE_HIMETRIC *pheight)
623 {
624 OLEPictureImpl *This = (OLEPictureImpl *)iface;
625 TRACE("(%p)->(%p): height is %d\n", This, pheight, This->himetricHeight);
626 *pheight = This->himetricHeight;
627 return S_OK;
628 }
629
630 /************************************************************************
631 * OLEPictureImpl_Render
632 */
633 static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
634 LONG x, LONG y, LONG cx, LONG cy,
635 OLE_XPOS_HIMETRIC xSrc,
636 OLE_YPOS_HIMETRIC ySrc,
637 OLE_XSIZE_HIMETRIC cxSrc,
638 OLE_YSIZE_HIMETRIC cySrc,
639 LPCRECT prcWBounds)
640 {
641 OLEPictureImpl *This = (OLEPictureImpl *)iface;
642 TRACE("(%p)->(%p, (%d,%d), (%d,%d) <- (%d,%d), (%d,%d), %p)\n",
643 This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, prcWBounds);
644 if(prcWBounds)
645 TRACE("prcWBounds (%d,%d) - (%d,%d)\n", prcWBounds->left, prcWBounds->top,
646 prcWBounds->right, prcWBounds->bottom);
647
648 if(cx == 0 || cy == 0 || cxSrc == 0 || cySrc == 0){
649 return CTL_E_INVALIDPROPERTYVALUE;
650 }
651
652 /*
653 * While the documentation suggests this to be here (or after rendering?)
654 * it does cause an endless recursion in my sample app. -MM 20010804
655 OLEPicture_SendNotify(This,DISPID_PICT_RENDER);
656 */
657
658 switch(This->desc.picType) {
659 case PICTYPE_UNINITIALIZED:
660 case PICTYPE_NONE:
661 /* nothing to do */
662 return S_OK;
663 case PICTYPE_BITMAP:
664 {
665 HBITMAP hbmpOld;
666 HDC hdcBmp;
667
668 /* Set a mapping mode that maps bitmap pixels into HIMETRIC units.
669 NB y-axis gets flipped */
670
671 hdcBmp = CreateCompatibleDC(0);
672 SetMapMode(hdcBmp, MM_ANISOTROPIC);
673 SetWindowOrgEx(hdcBmp, 0, 0, NULL);
674 SetWindowExtEx(hdcBmp, This->himetricWidth, This->himetricHeight, NULL);
675 SetViewportOrgEx(hdcBmp, 0, This->origHeight, NULL);
676 SetViewportExtEx(hdcBmp, This->origWidth, -This->origHeight, NULL);
677
678 if (This->hbmMask) {
679 HDC hdcMask = CreateCompatibleDC(0);
680 HBITMAP hOldbm = SelectObject(hdcMask, This->hbmMask);
681
682 hbmpOld = SelectObject(hdcBmp, This->hbmXor);
683
684 SetMapMode(hdcMask, MM_ANISOTROPIC);
685 SetWindowOrgEx(hdcMask, 0, 0, NULL);
686 SetWindowExtEx(hdcMask, This->himetricWidth, This->himetricHeight, NULL);
687 SetViewportOrgEx(hdcMask, 0, This->origHeight, NULL);
688 SetViewportExtEx(hdcMask, This->origWidth, -This->origHeight, NULL);
689
690 SetBkColor(hdc, RGB(255, 255, 255));
691 SetTextColor(hdc, RGB(0, 0, 0));
692 StretchBlt(hdc, x, y, cx, cy, hdcMask, xSrc, ySrc, cxSrc, cySrc, SRCAND);
693 StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc, cxSrc, cySrc, SRCPAINT);
694
695 SelectObject(hdcMask, hOldbm);
696 DeleteDC(hdcMask);
697 } else {
698 hbmpOld = SelectObject(hdcBmp, This->desc.u.bmp.hbitmap);
699 StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc, cxSrc, cySrc, SRCCOPY);
700 }
701
702 SelectObject(hdcBmp, hbmpOld);
703 DeleteDC(hdcBmp);
704 }
705 break;
706 case PICTYPE_ICON:
707 FIXME("Not quite correct implementation of rendering icons...\n");
708 DrawIcon(hdc,x,y,This->desc.u.icon.hicon);
709 break;
710
711 case PICTYPE_METAFILE:
712 {
713 POINT prevOrg, prevWndOrg;
714 SIZE prevExt, prevWndExt;
715 int oldmode;
716
717 /* Render the WMF to the appropriate location by setting the
718 appropriate ratio between "device units" and "logical units" */
719 oldmode = SetMapMode(hdc, MM_ANISOTROPIC);
720 /* For the "source rectangle" the y-axis must be inverted */
721 SetWindowOrgEx(hdc, xSrc, This->himetricHeight-ySrc, &prevWndOrg);
722 SetWindowExtEx(hdc, cxSrc, -cySrc, &prevWndExt);
723 /* For the "destination rectangle" no inversion is necessary */
724 SetViewportOrgEx(hdc, x, y, &prevOrg);
725 SetViewportExtEx(hdc, cx, cy, &prevExt);
726
727 if (!PlayMetaFile(hdc, This->desc.u.wmf.hmeta))
728 ERR("PlayMetaFile failed!\n");
729
730 /* We're done, restore the DC to the previous settings for converting
731 logical units to device units */
732 SetWindowExtEx(hdc, prevWndExt.cx, prevWndExt.cy, NULL);
733 SetWindowOrgEx(hdc, prevWndOrg.x, prevWndOrg.y, NULL);
734 SetViewportExtEx(hdc, prevExt.cx, prevExt.cy, NULL);
735 SetViewportOrgEx(hdc, prevOrg.x, prevOrg.y, NULL);
736 SetMapMode(hdc, oldmode);
737 break;
738 }
739
740 case PICTYPE_ENHMETAFILE:
741 {
742 RECT rc = { x, y, x + cx, y + cy };
743 PlayEnhMetaFile(hdc, This->desc.u.emf.hemf, &rc);
744 break;
745 }
746
747 default:
748 FIXME("type %d not implemented\n", This->desc.picType);
749 return E_NOTIMPL;
750 }
751 return S_OK;
752 }
753
754 /************************************************************************
755 * OLEPictureImpl_set_hPal
756 */
757 static HRESULT WINAPI OLEPictureImpl_set_hPal(IPicture *iface,
758 OLE_HANDLE hpal)
759 {
760 OLEPictureImpl *This = (OLEPictureImpl *)iface;
761 FIXME("(%p)->(%08x): stub\n", This, hpal);
762 OLEPicture_SendNotify(This,DISPID_PICT_HPAL);
763 return E_NOTIMPL;
764 }
765
766 /************************************************************************
767 * OLEPictureImpl_get_CurDC
768 */
769 static HRESULT WINAPI OLEPictureImpl_get_CurDC(IPicture *iface,
770 HDC *phdc)
771 {
772 OLEPictureImpl *This = (OLEPictureImpl *)iface;
773 TRACE("(%p), returning %p\n", This, This->hDCCur);
774 if (phdc) *phdc = This->hDCCur;
775 return S_OK;
776 }
777
778 /************************************************************************
779 * OLEPictureImpl_SelectPicture
780 */
781 static HRESULT WINAPI OLEPictureImpl_SelectPicture(IPicture *iface,
782 HDC hdcIn,
783 HDC *phdcOut,
784 OLE_HANDLE *phbmpOut)
785 {
786 OLEPictureImpl *This = (OLEPictureImpl *)iface;
787 TRACE("(%p)->(%p, %p, %p)\n", This, hdcIn, phdcOut, phbmpOut);
788 if (This->desc.picType == PICTYPE_BITMAP) {
789 SelectObject(hdcIn,This->desc.u.bmp.hbitmap);
790
791 if (phdcOut)
792 *phdcOut = This->hDCCur;
793 This->hDCCur = hdcIn;
794 if (phbmpOut)
795 *phbmpOut = HandleToUlong(This->desc.u.bmp.hbitmap);
796 return S_OK;
797 } else {
798 FIXME("Don't know how to select picture type %d\n",This->desc.picType);
799 return E_FAIL;
800 }
801 }
802
803 /************************************************************************
804 * OLEPictureImpl_get_KeepOriginalFormat
805 */
806 static HRESULT WINAPI OLEPictureImpl_get_KeepOriginalFormat(IPicture *iface,
807 BOOL *pfKeep)
808 {
809 OLEPictureImpl *This = (OLEPictureImpl *)iface;
810 TRACE("(%p)->(%p)\n", This, pfKeep);
811 if (!pfKeep)
812 return E_POINTER;
813 *pfKeep = This->keepOrigFormat;
814 return S_OK;
815 }
816
817 /************************************************************************
818 * OLEPictureImpl_put_KeepOriginalFormat
819 */
820 static HRESULT WINAPI OLEPictureImpl_put_KeepOriginalFormat(IPicture *iface,
821 BOOL keep)
822 {
823 OLEPictureImpl *This = (OLEPictureImpl *)iface;
824 TRACE("(%p)->(%d)\n", This, keep);
825 This->keepOrigFormat = keep;
826 /* FIXME: what DISPID notification here? */
827 return S_OK;
828 }
829
830 /************************************************************************
831 * OLEPictureImpl_PictureChanged
832 */
833 static HRESULT WINAPI OLEPictureImpl_PictureChanged(IPicture *iface)
834 {
835 OLEPictureImpl *This = (OLEPictureImpl *)iface;
836 TRACE("(%p)->()\n", This);
837 OLEPicture_SendNotify(This,DISPID_PICT_HANDLE);
838 This->bIsDirty = TRUE;
839 return S_OK;
840 }
841
842 /************************************************************************
843 * OLEPictureImpl_SaveAsFile
844 */
845 static HRESULT WINAPI OLEPictureImpl_SaveAsFile(IPicture *iface,
846 IStream *pstream,
847 BOOL SaveMemCopy,
848 LONG *pcbSize)
849 {
850 OLEPictureImpl *This = (OLEPictureImpl *)iface;
851 FIXME("(%p)->(%p, %d, %p), hacked stub.\n", This, pstream, SaveMemCopy, pcbSize);
852 return IStream_Write(pstream,This->data,This->datalen,(ULONG*)pcbSize);
853 }
854
855 /************************************************************************
856 * OLEPictureImpl_get_Attributes
857 */
858 static HRESULT WINAPI OLEPictureImpl_get_Attributes(IPicture *iface,
859 DWORD *pdwAttr)
860 {
861 OLEPictureImpl *This = (OLEPictureImpl *)iface;
862 TRACE("(%p)->(%p).\n", This, pdwAttr);
863
864 if(!pdwAttr)
865 return E_POINTER;
866
867 *pdwAttr = 0;
868 switch (This->desc.picType) {
869 case PICTYPE_UNINITIALIZED:
870 case PICTYPE_NONE: break;
871 case PICTYPE_BITMAP: if (This->hbmMask) *pdwAttr = PICTURE_TRANSPARENT; break; /* not 'truly' scalable, see MSDN. */
872 case PICTYPE_ICON: *pdwAttr = PICTURE_TRANSPARENT;break;
873 case PICTYPE_ENHMETAFILE: /* fall through */
874 case PICTYPE_METAFILE: *pdwAttr = PICTURE_TRANSPARENT|PICTURE_SCALABLE;break;
875 default:FIXME("Unknown pictype %d\n",This->desc.picType);break;
876 }
877 return S_OK;
878 }
879
880
881 /************************************************************************
882 * IConnectionPointContainer
883 */
884 static HRESULT WINAPI OLEPictureImpl_IConnectionPointContainer_QueryInterface(
885 IConnectionPointContainer* iface,
886 REFIID riid,
887 VOID** ppvoid)
888 {
889 OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
890
891 return IPicture_QueryInterface((IPicture *)This,riid,ppvoid);
892 }
893
894 static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_AddRef(
895 IConnectionPointContainer* iface)
896 {
897 OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
898
899 return IPicture_AddRef((IPicture *)This);
900 }
901
902 static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_Release(
903 IConnectionPointContainer* iface)
904 {
905 OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
906
907 return IPicture_Release((IPicture *)This);
908 }
909
910 static HRESULT WINAPI OLEPictureImpl_EnumConnectionPoints(
911 IConnectionPointContainer* iface,
912 IEnumConnectionPoints** ppEnum)
913 {
914 OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
915
916 FIXME("(%p,%p), stub!\n",This,ppEnum);
917 return E_NOTIMPL;
918 }
919
920 static HRESULT WINAPI OLEPictureImpl_FindConnectionPoint(
921 IConnectionPointContainer* iface,
922 REFIID riid,
923 IConnectionPoint **ppCP)
924 {
925 OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
926 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppCP);
927 if (!ppCP)
928 return E_POINTER;
929 *ppCP = NULL;
930 if (IsEqualGUID(riid,&IID_IPropertyNotifySink))
931 return IConnectionPoint_QueryInterface(This->pCP,&IID_IConnectionPoint,(LPVOID)ppCP);
932 FIXME("no connection point for %s\n",debugstr_guid(riid));
933 return CONNECT_E_NOCONNECTION;
934 }
935
936
937 /************************************************************************
938 * IPersistStream
939 */
940
941 /************************************************************************
942 * OLEPictureImpl_IPersistStream_QueryInterface (IUnknown)
943 *
944 * See Windows documentation for more details on IUnknown methods.
945 */
946 static HRESULT WINAPI OLEPictureImpl_IPersistStream_QueryInterface(
947 IPersistStream* iface,
948 REFIID riid,
949 VOID** ppvoid)
950 {
951 OLEPictureImpl *This = impl_from_IPersistStream(iface);
952
953 return IPicture_QueryInterface((IPicture *)This, riid, ppvoid);
954 }
955
956 /************************************************************************
957 * OLEPictureImpl_IPersistStream_AddRef (IUnknown)
958 *
959 * See Windows documentation for more details on IUnknown methods.
960 */
961 static ULONG WINAPI OLEPictureImpl_IPersistStream_AddRef(
962 IPersistStream* iface)
963 {
964 OLEPictureImpl *This = impl_from_IPersistStream(iface);
965
966 return IPicture_AddRef((IPicture *)This);
967 }
968
969 /************************************************************************
970 * OLEPictureImpl_IPersistStream_Release (IUnknown)
971 *
972 * See Windows documentation for more details on IUnknown methods.
973 */
974 static ULONG WINAPI OLEPictureImpl_IPersistStream_Release(
975 IPersistStream* iface)
976 {
977 OLEPictureImpl *This = impl_from_IPersistStream(iface);
978
979 return IPicture_Release((IPicture *)This);
980 }
981
982 /************************************************************************
983 * OLEPictureImpl_IPersistStream_GetClassID
984 */
985 static HRESULT WINAPI OLEPictureImpl_GetClassID(
986 IPersistStream* iface,CLSID* pClassID)
987 {
988 TRACE("(%p)\n", pClassID);
989 *pClassID = CLSID_StdPicture;
990 return S_OK;
991 }
992
993 /************************************************************************
994 * OLEPictureImpl_IPersistStream_IsDirty
995 */
996 static HRESULT WINAPI OLEPictureImpl_IsDirty(
997 IPersistStream* iface)
998 {
999 OLEPictureImpl *This = impl_from_IPersistStream(iface);
1000 FIXME("(%p),stub!\n",This);
1001 return E_NOTIMPL;
1002 }
1003
1004 #ifdef SONAME_LIBJPEG
1005
1006 static void *libjpeg_handle;
1007 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
1008 MAKE_FUNCPTR(jpeg_std_error);
1009 MAKE_FUNCPTR(jpeg_CreateDecompress);
1010 MAKE_FUNCPTR(jpeg_read_header);
1011 MAKE_FUNCPTR(jpeg_start_decompress);
1012 MAKE_FUNCPTR(jpeg_read_scanlines);
1013 MAKE_FUNCPTR(jpeg_finish_decompress);
1014 MAKE_FUNCPTR(jpeg_destroy_decompress);
1015 #undef MAKE_FUNCPTR
1016
1017 static void *load_libjpeg(void)
1018 {
1019 if((libjpeg_handle = wine_dlopen(SONAME_LIBJPEG, RTLD_NOW, NULL, 0)) != NULL) {
1020
1021 #define LOAD_FUNCPTR(f) \
1022 if((p##f = wine_dlsym(libjpeg_handle, #f, NULL, 0)) == NULL) { \
1023 libjpeg_handle = NULL; \
1024 return NULL; \
1025 }
1026
1027 LOAD_FUNCPTR(jpeg_std_error);
1028 LOAD_FUNCPTR(jpeg_CreateDecompress);
1029 LOAD_FUNCPTR(jpeg_read_header);
1030 LOAD_FUNCPTR(jpeg_start_decompress);
1031 LOAD_FUNCPTR(jpeg_read_scanlines);
1032 LOAD_FUNCPTR(jpeg_finish_decompress);
1033 LOAD_FUNCPTR(jpeg_destroy_decompress);
1034 #undef LOAD_FUNCPTR
1035 }
1036 return libjpeg_handle;
1037 }
1038
1039 /* for the jpeg decompressor source manager. */
1040 static void _jpeg_init_source(j_decompress_ptr cinfo) { }
1041
1042 static jpeg_boolean _jpeg_fill_input_buffer(j_decompress_ptr cinfo) {
1043 ERR("(), should not get here.\n");
1044 return FALSE;
1045 }
1046
1047 static void _jpeg_skip_input_data(j_decompress_ptr cinfo,long num_bytes) {
1048 TRACE("Skipping %ld bytes...\n", num_bytes);
1049 cinfo->src->next_input_byte += num_bytes;
1050 cinfo->src->bytes_in_buffer -= num_bytes;
1051 }
1052
1053 static jpeg_boolean _jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired) {
1054 ERR("(desired=%d), should not get here.\n",desired);
1055 return FALSE;
1056 }
1057 static void _jpeg_term_source(j_decompress_ptr cinfo) { }
1058 #endif /* SONAME_LIBJPEG */
1059
1060 struct gifdata {
1061 unsigned char *data;
1062 unsigned int curoff;
1063 unsigned int len;
1064 };
1065
1066 static int _gif_inputfunc(GifFileType *gif, GifByteType *data, int len) {
1067 struct gifdata *gd = (struct gifdata*)gif->UserData;
1068
1069 if (len+gd->curoff > gd->len) {
1070 ERR("Trying to read %d bytes, but only %d available.\n",len, gd->len-gd->curoff);
1071 len = gd->len - gd->curoff;
1072 }
1073 memcpy(data, gd->data+gd->curoff, len);
1074 gd->curoff += len;
1075 return len;
1076 }
1077
1078
1079 static HRESULT OLEPictureImpl_LoadGif(OLEPictureImpl *This, BYTE *xbuf, ULONG xread)
1080 {
1081 struct gifdata gd;
1082 GifFileType *gif;
1083 BITMAPINFO *bmi;
1084 HDC hdcref;
1085 LPBYTE bytes;
1086 int i,j,ret;
1087 GifImageDesc *gid;
1088 SavedImage *si;
1089 ColorMapObject *cm;
1090 int transparent = -1;
1091 ExtensionBlock *eb;
1092 int padding;
1093
1094 gd.data = xbuf;
1095 gd.curoff = 0;
1096 gd.len = xread;
1097 gif = DGifOpen((void*)&gd, _gif_inputfunc);
1098 ret = DGifSlurp(gif);
1099 if (ret == GIF_ERROR) {
1100 ERR("Failed reading GIF using libgif.\n");
1101 return E_FAIL;
1102 }
1103 TRACE("screen height %d, width %d\n", gif->SWidth, gif->SHeight);
1104 TRACE("color res %d, backgcolor %d\n", gif->SColorResolution, gif->SBackGroundColor);
1105 TRACE("imgcnt %d\n", gif->ImageCount);
1106 if (gif->ImageCount<1) {
1107 ERR("GIF stream does not have images inside?\n");
1108 return E_FAIL;
1109 }
1110 TRACE("curimage: %d x %d, on %dx%d, interlace %d\n",
1111 gif->Image.Width, gif->Image.Height,
1112 gif->Image.Left, gif->Image.Top,
1113 gif->Image.Interlace
1114 );
1115 /* */
1116 padding = (gif->SWidth+3) & ~3;
1117 si = gif->SavedImages+0;
1118 gid = &(si->ImageDesc);
1119 cm = gid->ColorMap;
1120 if (!cm) cm = gif->SColorMap;
1121 bmi = HeapAlloc(GetProcessHeap(),0,sizeof(BITMAPINFOHEADER)+(cm->ColorCount)*sizeof(RGBQUAD));
1122 bytes= HeapAlloc(GetProcessHeap(),0,padding*gif->SHeight);
1123
1124 /* look for the transparent color extension */
1125 for (i = 0; i < si->ExtensionBlockCount; ++i) {
1126 eb = si->ExtensionBlocks + i;
1127 if (eb->Function == 0xF9 && eb->ByteCount == 4) {
1128 if ((eb->Bytes[0] & 1) == 1) {
1129 transparent = (unsigned char)eb->Bytes[3];
1130 }
1131 }
1132 }
1133
1134 for (i = 0; i < cm->ColorCount; i++) {
1135 bmi->bmiColors[i].rgbRed = cm->Colors[i].Red;
1136 bmi->bmiColors[i].rgbGreen = cm->Colors[i].Green;
1137 bmi->bmiColors[i].rgbBlue = cm->Colors[i].Blue;
1138 if (i == transparent) {
1139 This->rgbTrans = RGB(bmi->bmiColors[i].rgbRed,
1140 bmi->bmiColors[i].rgbGreen,
1141 bmi->bmiColors[i].rgbBlue);
1142 }
1143 }
1144
1145 /* Map to in picture coordinates */
1146 for (i = 0, j = 0; i < gid->Height; i++) {
1147 if (gif->Image.Interlace) {
1148 memcpy(
1149 bytes + (gid->Top + j) * padding + gid->Left,
1150 si->RasterBits + i * gid->Width,
1151 gid->Width);
1152
1153 /* Lower bits of interlaced counter encode current interlace */
1154 if (j & 1) j += 2; /* Currently filling odd rows */
1155 else if (j & 2) j += 4; /* Currently filling even rows not multiples of 4 */
1156 else j += 8; /* Currently filling every 8th row or 4th row in-between */
1157
1158 if (j >= gid->Height && i < gid->Height && (j & 1) == 0) {
1159 /* End of current interlace, go to next interlace */
1160 if (j & 2) j = 1; /* Next iteration fills odd rows */
1161 else if (j & 4) j = 2; /* Next iteration fills even rows not mod 4 and not mod 8 */
1162 else j = 4; /* Next iteration fills rows in-between rows mod 6 */
1163 }
1164 } else {
1165 memcpy(
1166 bytes + (gid->Top + i) * padding + gid->Left,
1167 si->RasterBits + i * gid->Width,
1168 gid->Width);
1169 }
1170 }
1171
1172 bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1173 bmi->bmiHeader.biWidth = gif->SWidth;
1174 bmi->bmiHeader.biHeight = -gif->SHeight;
1175 bmi->bmiHeader.biPlanes = 1;
1176 bmi->bmiHeader.biBitCount = 8;
1177 bmi->bmiHeader.biCompression = BI_RGB;
1178 bmi->bmiHeader.biSizeImage = padding*gif->SHeight;
1179 bmi->bmiHeader.biXPelsPerMeter = 0;
1180 bmi->bmiHeader.biYPelsPerMeter = 0;
1181 bmi->bmiHeader.biClrUsed = cm->ColorCount;
1182 bmi->bmiHeader.biClrImportant = 0;
1183
1184 hdcref = GetDC(0);
1185 This->desc.u.bmp.hbitmap=CreateDIBitmap(
1186 hdcref,
1187 &bmi->bmiHeader,
1188 CBM_INIT,
1189 bytes,
1190 bmi,
1191 DIB_RGB_COLORS
1192 );
1193
1194 if (transparent > -1) {
1195 /* Create the Mask */
1196 HDC hdc = CreateCompatibleDC(0);
1197 HDC hdcMask = CreateCompatibleDC(0);
1198 HBITMAP hOldbitmap;
1199 HBITMAP hOldbitmapmask;
1200
1201 unsigned int monopadding = (((unsigned)(gif->SWidth + 31)) >> 5) << 2;
1202 HBITMAP hTempMask;
1203
1204 This->hbmXor = CreateDIBitmap(
1205 hdcref,
1206 &bmi->bmiHeader,
1207 CBM_INIT,
1208 bytes,
1209 bmi,
1210 DIB_RGB_COLORS
1211 );
1212
1213 bmi->bmiColors[0].rgbRed = 0;
1214 bmi->bmiColors[0].rgbGreen = 0;
1215 bmi->bmiColors[0].rgbBlue = 0;
1216 bmi->bmiColors[1].rgbRed = 255;
1217 bmi->bmiColors[1].rgbGreen = 255;
1218 bmi->bmiColors[1].rgbBlue = 255;
1219
1220 bmi->bmiHeader.biBitCount = 1;
1221 bmi->bmiHeader.biSizeImage = monopadding*gif->SHeight;
1222 bmi->bmiHeader.biClrUsed = 2;
1223
1224 for (i = 0; i < gif->SHeight; i++) {
1225 unsigned char * colorPointer = bytes + padding * i;
1226 unsigned char * monoPointer = bytes + monopadding * i;
1227 for (j = 0; j < gif->SWidth; j++) {
1228 unsigned char pixel = colorPointer[j];
1229 if ((j & 7) == 0) monoPointer[j >> 3] = 0;
1230 if (pixel == (transparent & 0x000000FFU)) monoPointer[j >> 3] |= 1 << (7 - (j & 7));
1231 }
1232 }
1233 hdcref = GetDC(0);
1234 hTempMask = CreateDIBitmap(
1235 hdcref,
1236 &bmi->bmiHeader,
1237 CBM_INIT,
1238 bytes,
1239 bmi,
1240 DIB_RGB_COLORS
1241 );
1242 DeleteDC(hdcref);
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 DeleteDC(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 DeleteDC(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 DeleteDC(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 = (BITMAPFILEHEADER *)(*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 = (LPVOID)&STDPIC_CF; }
Maarten's multimedia branch