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