git.oblomov.eu Git - wine/blob - dlls/oleaut32/olepicture.c

   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 #define COBJMACROS
  50 #define NONAMELESSUNION
  51 #define NONAMELESSSTRUCT
  52
  53 #include "winerror.h"
  54 #include "windef.h"
  55 #include "winbase.h"
  56 #include "wingdi.h"
  57 #include "winuser.h"
  58 #include "ole2.h"
  59 #include "olectl.h"
  60 #include "oleauto.h"
  61 #include "connpt.h"
  62 #include "urlmon.h"
  63 #include "initguid.h"
  64 #include "wincodec.h"
  65 #include "wine/debug.h"
  66 #include "wine/unicode.h"
  67 #include "wine/library.h"
  68
  69 WINE_DEFAULT_DEBUG_CHANNEL(olepicture);
  70
  71 #define BITMAP_FORMAT_BMP   0x4d42 /* "BM" */
  72 #define BITMAP_FORMAT_JPEG  0xd8ff
  73 #define BITMAP_FORMAT_GIF   0x4947
  74 #define BITMAP_FORMAT_PNG   0x5089
  75 #define BITMAP_FORMAT_APM   0xcdd7
  76
  77 #include "pshpack1.h"
  78
  79 /* Header for Aldus Placable Metafiles - a standard metafile follows */
  80 typedef struct _APM_HEADER
  81 {
  82     DWORD key;
  83     WORD handle;
  84     SHORT left;
  85     SHORT top;
  86     SHORT right;
  87     SHORT bottom;
  88     WORD inch;
  89     DWORD reserved;
  90     WORD checksum;
  91 } APM_HEADER;
  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     IPicture                  IPicture_iface;
 125     IDispatch                 IDispatch_iface;
 126     IPersistStream            IPersistStream_iface;
 127     IConnectionPointContainer IConnectionPointContainer_iface;
 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     HBITMAP stock_bitmap;
 151
 152   /* Bitmap transparency mask */
 153     HBITMAP hbmMask;
 154     HBITMAP hbmXor;
 155     COLORREF rgbTrans;
 156
 157   /* data */
 158     void* data;
 159     int datalen;
 160     BOOL bIsDirty;                  /* Set to TRUE if picture has changed */
 161     unsigned int loadtime_magic;    /* If a length header was found, saves value */
 162     unsigned int loadtime_format;   /* for PICTYPE_BITMAP only, keeps track of image format (GIF/BMP/JPEG) */
 163 } OLEPictureImpl;
 164
 165 static inline OLEPictureImpl *impl_from_IPicture(IPicture *iface)
 166 {
 167     return CONTAINING_RECORD(iface, OLEPictureImpl, IPicture_iface);
 168 }
 169
 170 static inline OLEPictureImpl *impl_from_IDispatch( IDispatch *iface )
 171 {
 172     return CONTAINING_RECORD(iface, OLEPictureImpl, IDispatch_iface);
 173 }
 174
 175 static inline OLEPictureImpl *impl_from_IPersistStream( IPersistStream *iface )
 176 {
 177     return CONTAINING_RECORD(iface, OLEPictureImpl, IPersistStream_iface);
 178 }
 179
 180 static inline OLEPictureImpl *impl_from_IConnectionPointContainer( IConnectionPointContainer *iface )
 181 {
 182     return CONTAINING_RECORD(iface, OLEPictureImpl, IConnectionPointContainer_iface);
 183 }
 184
 185 /*
 186  * Predeclare VTables.  They get initialized at the end.
 187  */
 188 static const IPictureVtbl OLEPictureImpl_VTable;
 189 static const IDispatchVtbl OLEPictureImpl_IDispatch_VTable;
 190 static const IPersistStreamVtbl OLEPictureImpl_IPersistStream_VTable;
 191 static const IConnectionPointContainerVtbl OLEPictureImpl_IConnectionPointContainer_VTable;
 192
 193 /* pixels to HIMETRIC units conversion */
 194 static inline OLE_XSIZE_HIMETRIC xpixels_to_himetric(INT pixels, HDC hdc)
 195 {
 196     return MulDiv(pixels, 2540, GetDeviceCaps(hdc, LOGPIXELSX));
 197 }
 198
 199 static inline OLE_YSIZE_HIMETRIC ypixels_to_himetric(INT pixels, HDC hdc)
 200 {
 201     return MulDiv(pixels, 2540, GetDeviceCaps(hdc, LOGPIXELSY));
 202 }
 203
 204 /***********************************************************************
 205  * Implementation of the OLEPictureImpl class.
 206  */
 207
 208 static void OLEPictureImpl_SetBitmap(OLEPictureImpl *This)
 209 {
 210   BITMAP bm;
 211   HDC hdcRef;
 212
 213   TRACE("bitmap handle %p\n", This->desc.u.bmp.hbitmap);
 214   if(GetObjectW(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
 221   TRACE("width %d, height %d, bpp %d\n", bm.bmWidth, bm.bmHeight, bm.bmBitsPixel);
 222
 223   /* The width and height are stored in HIMETRIC units (0.01 mm),
 224      so we take our pixel width divide by pixels per inch and
 225      multiply by 25.4 * 100 */
 226   /* Should we use GetBitmapDimension if available? */
 227   hdcRef = CreateCompatibleDC(0);
 228
 229   This->himetricWidth  = xpixels_to_himetric(bm.bmWidth, hdcRef);
 230   This->himetricHeight = ypixels_to_himetric(bm.bmHeight, hdcRef);
 231   This->stock_bitmap = GetCurrentObject( hdcRef, OBJ_BITMAP );
 232
 233   This->loadtime_format = BITMAP_FORMAT_BMP;
 234
 235   DeleteDC(hdcRef);
 236 }
 237
 238 static void OLEPictureImpl_SetIcon(OLEPictureImpl * This)
 239 {
 240     ICONINFO infoIcon;
 241
 242     TRACE("icon handle %p\n", This->desc.u.icon.hicon);
 243     if (GetIconInfo(This->desc.u.icon.hicon, &infoIcon)) {
 244         HDC hdcRef;
 245         BITMAP bm;
 246
 247         TRACE("bitmap handle for icon is %p\n", infoIcon.hbmColor);
 248         if(GetObjectW(infoIcon.hbmColor ? infoIcon.hbmColor : infoIcon.hbmMask, sizeof(bm), &bm) != sizeof(bm)) {
 249             ERR("GetObject fails on icon bitmap\n");
 250             return;
 251         }
 252
 253         This->origWidth = bm.bmWidth;
 254         This->origHeight = infoIcon.hbmColor ? bm.bmHeight : bm.bmHeight / 2;
 255         /* see comment on HIMETRIC on OLEPictureImpl_SetBitmap() */
 256         hdcRef = GetDC(0);
 257
 258         This->himetricWidth  = xpixels_to_himetric(This->origWidth, hdcRef);
 259         This->himetricHeight = ypixels_to_himetric(This->origHeight, hdcRef);
 260
 261         ReleaseDC(0, hdcRef);
 262
 263         DeleteObject(infoIcon.hbmMask);
 264         if (infoIcon.hbmColor) DeleteObject(infoIcon.hbmColor);
 265     } else {
 266         ERR("GetIconInfo() fails on icon %p\n", This->desc.u.icon.hicon);
 267     }
 268 }
 269
 270 /************************************************************************
 271  * OLEPictureImpl_Construct
 272  *
 273  * This method will construct a new instance of the OLEPictureImpl
 274  * class.
 275  *
 276  * The caller of this method must release the object when it's
 277  * done with it.
 278  */
 279 static OLEPictureImpl* OLEPictureImpl_Construct(LPPICTDESC pictDesc, BOOL fOwn)
 280 {
 281   OLEPictureImpl* newObject = 0;
 282
 283   if (pictDesc)
 284       TRACE("(%p) type = %d\n", pictDesc, pictDesc->picType);
 285
 286   /*
 287    * Allocate space for the object.
 288    */
 289   newObject = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(OLEPictureImpl));
 290
 291   if (newObject==0)
 292     return newObject;
 293
 294   /*
 295    * Initialize the virtual function table.
 296    */
 297   newObject->IPicture_iface.lpVtbl = &OLEPictureImpl_VTable;
 298   newObject->IDispatch_iface.lpVtbl = &OLEPictureImpl_IDispatch_VTable;
 299   newObject->IPersistStream_iface.lpVtbl = &OLEPictureImpl_IPersistStream_VTable;
 300   newObject->IConnectionPointContainer_iface.lpVtbl = &OLEPictureImpl_IConnectionPointContainer_VTable;
 301
 302   newObject->pCP = NULL;
 303   CreateConnectionPoint((IUnknown*)newObject,&IID_IPropertyNotifySink,&newObject->pCP);
 304   if (!newObject->pCP)
 305   {
 306     HeapFree(GetProcessHeap(), 0, newObject);
 307     return NULL;
 308   }
 309
 310   /*
 311    * Start with one reference count. The caller of this function
 312    * must release the interface pointer when it is done.
 313    */
 314   newObject->ref        = 1;
 315   newObject->hDCCur     = 0;
 316
 317   newObject->fOwn       = fOwn;
 318
 319   /* dunno about original value */
 320   newObject->keepOrigFormat = TRUE;
 321
 322   newObject->hbmMask = NULL;
 323   newObject->hbmXor = NULL;
 324   newObject->loadtime_magic = 0xdeadbeef;
 325   newObject->loadtime_format = 0;
 326   newObject->bIsDirty = FALSE;
 327
 328   if (pictDesc) {
 329       newObject->desc = *pictDesc;
 330
 331       switch(pictDesc->picType) {
 332       case PICTYPE_BITMAP:
 333         OLEPictureImpl_SetBitmap(newObject);
 334         break;
 335
 336       case PICTYPE_METAFILE:
 337         TRACE("metafile handle %p\n", pictDesc->u.wmf.hmeta);
 338         newObject->himetricWidth = pictDesc->u.wmf.xExt;
 339         newObject->himetricHeight = pictDesc->u.wmf.yExt;
 340         break;
 341
 342       case PICTYPE_NONE:
 343         /* not sure what to do here */
 344         newObject->himetricWidth = newObject->himetricHeight = 0;
 345         break;
 346
 347       case PICTYPE_ICON:
 348         OLEPictureImpl_SetIcon(newObject);
 349         break;
 350       case PICTYPE_ENHMETAFILE:
 351       default:
 352         FIXME("Unsupported type %d\n", pictDesc->picType);
 353         newObject->himetricWidth = newObject->himetricHeight = 0;
 354         break;
 355       }
 356   } else {
 357       newObject->desc.picType = PICTYPE_UNINITIALIZED;
 358   }
 359
 360   TRACE("returning %p\n", newObject);
 361   return newObject;
 362 }
 363
 364 /************************************************************************
 365  * OLEPictureImpl_Destroy
 366  *
 367  * This method is called by the Release method when the reference
 368  * count goes down to 0. It will free all resources used by
 369  * this object.  */
 370 static void OLEPictureImpl_Destroy(OLEPictureImpl* Obj)
 371 {
 372   TRACE("(%p)\n", Obj);
 373
 374   if (Obj->pCP)
 375     IConnectionPoint_Release(Obj->pCP);
 376
 377   if(Obj->fOwn) { /* We need to destroy the picture */
 378     switch(Obj->desc.picType) {
 379     case PICTYPE_BITMAP:
 380       DeleteObject(Obj->desc.u.bmp.hbitmap);
 381       if (Obj->hbmMask != NULL) DeleteObject(Obj->hbmMask);
 382       if (Obj->hbmXor != NULL) DeleteObject(Obj->hbmXor);
 383       break;
 384     case PICTYPE_METAFILE:
 385       DeleteMetaFile(Obj->desc.u.wmf.hmeta);
 386       break;
 387     case PICTYPE_ICON:
 388       DestroyIcon(Obj->desc.u.icon.hicon);
 389       break;
 390     case PICTYPE_ENHMETAFILE:
 391       DeleteEnhMetaFile(Obj->desc.u.emf.hemf);
 392       break;
 393     case PICTYPE_NONE:
 394     case PICTYPE_UNINITIALIZED:
 395       /* Nothing to do */
 396       break;
 397     default:
 398       FIXME("Unsupported type %d - unable to delete\n", Obj->desc.picType);
 399       break;
 400     }
 401   }
 402   HeapFree(GetProcessHeap(), 0, Obj->data);
 403   HeapFree(GetProcessHeap(), 0, Obj);
 404 }
 405
 406
 407 /************************************************************************
 408  * OLEPictureImpl_AddRef (IUnknown)
 409  *
 410  * See Windows documentation for more details on IUnknown methods.
 411  */
 412 static ULONG WINAPI OLEPictureImpl_AddRef(
 413   IPicture* iface)
 414 {
 415   OLEPictureImpl *This = impl_from_IPicture(iface);
 416   ULONG refCount = InterlockedIncrement(&This->ref);
 417
 418   TRACE("(%p)->(ref before=%d)\n", This, refCount - 1);
 419
 420   return refCount;
 421 }
 422
 423 /************************************************************************
 424  * OLEPictureImpl_Release (IUnknown)
 425  *
 426  * See Windows documentation for more details on IUnknown methods.
 427  */
 428 static ULONG WINAPI OLEPictureImpl_Release(
 429       IPicture* iface)
 430 {
 431   OLEPictureImpl *This = impl_from_IPicture(iface);
 432   ULONG refCount = InterlockedDecrement(&This->ref);
 433
 434   TRACE("(%p)->(ref before=%d)\n", This, refCount + 1);
 435
 436   /*
 437    * If the reference count goes down to 0, perform suicide.
 438    */
 439   if (!refCount) OLEPictureImpl_Destroy(This);
 440
 441   return refCount;
 442 }
 443
 444 /************************************************************************
 445  * OLEPictureImpl_QueryInterface (IUnknown)
 446  *
 447  * See Windows documentation for more details on IUnknown methods.
 448  */
 449 static HRESULT WINAPI OLEPictureImpl_QueryInterface(
 450   IPicture*  iface,
 451   REFIID  riid,
 452   void**  ppvObject)
 453 {
 454   OLEPictureImpl *This = impl_from_IPicture(iface);
 455
 456   TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 457
 458   if (!ppvObject)
 459     return E_INVALIDARG;
 460
 461   *ppvObject = 0;
 462
 463   if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IPicture, riid))
 464     *ppvObject = This;
 465   else if (IsEqualIID(&IID_IDispatch, riid))
 466     *ppvObject = &This->IDispatch_iface;
 467   else if (IsEqualIID(&IID_IPictureDisp, riid))
 468     *ppvObject = &This->IDispatch_iface;
 469   else if (IsEqualIID(&IID_IPersist, riid) || IsEqualIID(&IID_IPersistStream, riid))
 470     *ppvObject = &This->IPersistStream_iface;
 471   else if (IsEqualIID(&IID_IConnectionPointContainer, riid))
 472     *ppvObject = &This->IConnectionPointContainer_iface;
 473
 474   if (!*ppvObject)
 475   {
 476     FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid));
 477     return E_NOINTERFACE;
 478   }
 479
 480   IPicture_AddRef(iface);
 481
 482   return S_OK;
 483 }
 484
 485 /***********************************************************************
 486  *    OLEPicture_SendNotify (internal)
 487  *
 488  * Sends notification messages of changed properties to any interested
 489  * connections.
 490  */
 491 static void OLEPicture_SendNotify(OLEPictureImpl* this, DISPID dispID)
 492 {
 493   IEnumConnections *pEnum;
 494   CONNECTDATA CD;
 495
 496   if (IConnectionPoint_EnumConnections(this->pCP, &pEnum) != S_OK)
 497       return;
 498   while(IEnumConnections_Next(pEnum, 1, &CD, NULL) == S_OK) {
 499     IPropertyNotifySink *sink;
 500
 501     IUnknown_QueryInterface(CD.pUnk, &IID_IPropertyNotifySink, (LPVOID)&sink);
 502     IPropertyNotifySink_OnChanged(sink, dispID);
 503     IPropertyNotifySink_Release(sink);
 504     IUnknown_Release(CD.pUnk);
 505   }
 506   IEnumConnections_Release(pEnum);
 507 }
 508
 509 /************************************************************************
 510  * OLEPictureImpl_get_Handle
 511  */
 512 static HRESULT WINAPI OLEPictureImpl_get_Handle(IPicture *iface,
 513                                                 OLE_HANDLE *phandle)
 514 {
 515   OLEPictureImpl *This = impl_from_IPicture(iface);
 516   TRACE("(%p)->(%p)\n", This, phandle);
 517
 518   if(!phandle)
 519     return E_POINTER;
 520
 521   switch(This->desc.picType) {
 522   case PICTYPE_NONE:
 523   case PICTYPE_UNINITIALIZED:
 524     *phandle = 0;
 525     break;
 526   case PICTYPE_BITMAP:
 527     *phandle = HandleToUlong(This->desc.u.bmp.hbitmap);
 528     break;
 529   case PICTYPE_METAFILE:
 530     *phandle = HandleToUlong(This->desc.u.wmf.hmeta);
 531     break;
 532   case PICTYPE_ICON:
 533     *phandle = HandleToUlong(This->desc.u.icon.hicon);
 534     break;
 535   case PICTYPE_ENHMETAFILE:
 536     *phandle = HandleToUlong(This->desc.u.emf.hemf);
 537     break;
 538   default:
 539     FIXME("Unimplemented type %d\n", This->desc.picType);
 540     return E_NOTIMPL;
 541   }
 542   TRACE("returning handle %08x\n", *phandle);
 543   return S_OK;
 544 }
 545
 546 /************************************************************************
 547  * OLEPictureImpl_get_hPal
 548  */
 549 static HRESULT WINAPI OLEPictureImpl_get_hPal(IPicture *iface,
 550                                               OLE_HANDLE *phandle)
 551 {
 552   OLEPictureImpl *This = impl_from_IPicture(iface);
 553   HRESULT hres;
 554   TRACE("(%p)->(%p)\n", This, phandle);
 555
 556   if (!phandle)
 557     return E_POINTER;
 558
 559   switch (This->desc.picType) {
 560     case (UINT)PICTYPE_UNINITIALIZED:
 561     case PICTYPE_NONE:
 562       *phandle = 0;
 563       hres = S_FALSE;
 564       break;
 565     case PICTYPE_BITMAP:
 566       *phandle = HandleToUlong(This->desc.u.bmp.hpal);
 567       hres = S_OK;
 568       break;
 569     case PICTYPE_METAFILE:
 570       hres = E_FAIL;
 571       break;
 572     case PICTYPE_ICON:
 573     case PICTYPE_ENHMETAFILE:
 574     default:
 575       FIXME("unimplemented for type %d. Returning 0 palette.\n",
 576            This->desc.picType);
 577       *phandle = 0;
 578       hres = S_OK;
 579   }
 580
 581   TRACE("returning 0x%08x, palette handle %08x\n", hres, *phandle);
 582   return hres;
 583 }
 584
 585 /************************************************************************
 586  * OLEPictureImpl_get_Type
 587  */
 588 static HRESULT WINAPI OLEPictureImpl_get_Type(IPicture *iface,
 589                                               short *ptype)
 590 {
 591   OLEPictureImpl *This = impl_from_IPicture(iface);
 592   TRACE("(%p)->(%p): type is %d\n", This, ptype, This->desc.picType);
 593
 594   if(!ptype)
 595     return E_POINTER;
 596
 597   *ptype = This->desc.picType;
 598   return S_OK;
 599 }
 600
 601 /************************************************************************
 602  * OLEPictureImpl_get_Width
 603  */
 604 static HRESULT WINAPI OLEPictureImpl_get_Width(IPicture *iface,
 605                                                OLE_XSIZE_HIMETRIC *pwidth)
 606 {
 607   OLEPictureImpl *This = impl_from_IPicture(iface);
 608   TRACE("(%p)->(%p): width is %d\n", This, pwidth, This->himetricWidth);
 609   *pwidth = This->himetricWidth;
 610   return S_OK;
 611 }
 612
 613 /************************************************************************
 614  * OLEPictureImpl_get_Height
 615  */
 616 static HRESULT WINAPI OLEPictureImpl_get_Height(IPicture *iface,
 617                                                 OLE_YSIZE_HIMETRIC *pheight)
 618 {
 619   OLEPictureImpl *This = impl_from_IPicture(iface);
 620   TRACE("(%p)->(%p): height is %d\n", This, pheight, This->himetricHeight);
 621   *pheight = This->himetricHeight;
 622   return S_OK;
 623 }
 624
 625 /************************************************************************
 626  * OLEPictureImpl_Render
 627  */
 628 static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
 629                                             LONG x, LONG y, LONG cx, LONG cy,
 630                                             OLE_XPOS_HIMETRIC xSrc,
 631                                             OLE_YPOS_HIMETRIC ySrc,
 632                                             OLE_XSIZE_HIMETRIC cxSrc,
 633                                             OLE_YSIZE_HIMETRIC cySrc,
 634                                             LPCRECT prcWBounds)
 635 {
 636   OLEPictureImpl *This = impl_from_IPicture(iface);
 637   TRACE("(%p)->(%p, (%d,%d), (%d,%d) <- (%d,%d), (%d,%d), %p)\n",
 638         This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, prcWBounds);
 639   if(prcWBounds)
 640     TRACE("prcWBounds (%d,%d) - (%d,%d)\n", prcWBounds->left, prcWBounds->top,
 641           prcWBounds->right, prcWBounds->bottom);
 642
 643   if(cx == 0 || cy == 0 || cxSrc == 0 || cySrc == 0){
 644     return CTL_E_INVALIDPROPERTYVALUE;
 645   }
 646
 647   /*
 648    * While the documentation suggests this to be here (or after rendering?)
 649    * it does cause an endless recursion in my sample app. -MM 20010804
 650   OLEPicture_SendNotify(This,DISPID_PICT_RENDER);
 651    */
 652
 653   switch(This->desc.picType) {
 654   case PICTYPE_UNINITIALIZED:
 655   case PICTYPE_NONE:
 656     /* nothing to do */
 657     return S_OK;
 658   case PICTYPE_BITMAP:
 659     {
 660       HBITMAP hbmpOld;
 661       HDC hdcBmp;
 662
 663       /* Set a mapping mode that maps bitmap pixels into HIMETRIC units.
 664          NB y-axis gets flipped */
 665
 666       hdcBmp = CreateCompatibleDC(0);
 667       SetMapMode(hdcBmp, MM_ANISOTROPIC);
 668       SetWindowOrgEx(hdcBmp, 0, 0, NULL);
 669       SetWindowExtEx(hdcBmp, This->himetricWidth, This->himetricHeight, NULL);
 670       SetViewportOrgEx(hdcBmp, 0, This->origHeight, NULL);
 671       SetViewportExtEx(hdcBmp, This->origWidth, -This->origHeight, NULL);
 672
 673       if (This->hbmMask) {
 674           HDC hdcMask = CreateCompatibleDC(0);
 675           HBITMAP hOldbm = SelectObject(hdcMask, This->hbmMask);
 676
 677           hbmpOld = SelectObject(hdcBmp, This->hbmXor);
 678
 679           SetMapMode(hdcMask, MM_ANISOTROPIC);
 680           SetWindowOrgEx(hdcMask, 0, 0, NULL);
 681           SetWindowExtEx(hdcMask, This->himetricWidth, This->himetricHeight, NULL);
 682           SetViewportOrgEx(hdcMask, 0, This->origHeight, NULL);
 683           SetViewportExtEx(hdcMask, This->origWidth, -This->origHeight, NULL);
 684
 685           SetBkColor(hdc, RGB(255, 255, 255));
 686           SetTextColor(hdc, RGB(0, 0, 0));
 687           StretchBlt(hdc, x, y, cx, cy, hdcMask, xSrc, ySrc, cxSrc, cySrc, SRCAND);
 688           StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc, cxSrc, cySrc, SRCPAINT);
 689
 690           SelectObject(hdcMask, hOldbm);
 691           DeleteDC(hdcMask);
 692       } else {
 693           hbmpOld = SelectObject(hdcBmp, This->desc.u.bmp.hbitmap);
 694           StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc, cxSrc, cySrc, SRCCOPY);
 695       }
 696
 697       SelectObject(hdcBmp, hbmpOld);
 698       DeleteDC(hdcBmp);
 699     }
 700     break;
 701   case PICTYPE_ICON:
 702     FIXME("Not quite correct implementation of rendering icons...\n");
 703     DrawIconEx(hdc, x, y, This->desc.u.icon.hicon, cx, cy, 0, NULL, DI_NORMAL);
 704     break;
 705
 706   case PICTYPE_METAFILE:
 707   {
 708     POINT prevOrg, prevWndOrg;
 709     SIZE prevExt, prevWndExt;
 710     int oldmode;
 711
 712     /* Render the WMF to the appropriate location by setting the
 713        appropriate ratio between "device units" and "logical units" */
 714     oldmode = SetMapMode(hdc, MM_ANISOTROPIC);
 715     /* For the "source rectangle" the y-axis must be inverted */
 716     SetWindowOrgEx(hdc, xSrc, This->himetricHeight-ySrc, &prevWndOrg);
 717     SetWindowExtEx(hdc, cxSrc, -cySrc, &prevWndExt);
 718     /* For the "destination rectangle" no inversion is necessary */
 719     SetViewportOrgEx(hdc, x, y, &prevOrg);
 720     SetViewportExtEx(hdc, cx, cy, &prevExt);
 721
 722     if (!PlayMetaFile(hdc, This->desc.u.wmf.hmeta))
 723         ERR("PlayMetaFile failed!\n");
 724
 725     /* We're done, restore the DC to the previous settings for converting
 726        logical units to device units */
 727     SetWindowExtEx(hdc, prevWndExt.cx, prevWndExt.cy, NULL);
 728     SetWindowOrgEx(hdc, prevWndOrg.x, prevWndOrg.y, NULL);
 729     SetViewportExtEx(hdc, prevExt.cx, prevExt.cy, NULL);
 730     SetViewportOrgEx(hdc, prevOrg.x, prevOrg.y, NULL);
 731     SetMapMode(hdc, oldmode);
 732     break;
 733   }
 734
 735   case PICTYPE_ENHMETAFILE:
 736   {
 737     RECT rc = { x, y, x + cx, y + cy };
 738     PlayEnhMetaFile(hdc, This->desc.u.emf.hemf, &rc);
 739     break;
 740   }
 741
 742   default:
 743     FIXME("type %d not implemented\n", This->desc.picType);
 744     return E_NOTIMPL;
 745   }
 746   return S_OK;
 747 }
 748
 749 /************************************************************************
 750  * OLEPictureImpl_set_hPal
 751  */
 752 static HRESULT WINAPI OLEPictureImpl_set_hPal(IPicture *iface,
 753                                               OLE_HANDLE hpal)
 754 {
 755   OLEPictureImpl *This = impl_from_IPicture(iface);
 756   FIXME("(%p)->(%08x): stub\n", This, hpal);
 757   OLEPicture_SendNotify(This,DISPID_PICT_HPAL);
 758   return E_NOTIMPL;
 759 }
 760
 761 /************************************************************************
 762  * OLEPictureImpl_get_CurDC
 763  */
 764 static HRESULT WINAPI OLEPictureImpl_get_CurDC(IPicture *iface,
 765                                                HDC *phdc)
 766 {
 767   OLEPictureImpl *This = impl_from_IPicture(iface);
 768   TRACE("(%p), returning %p\n", This, This->hDCCur);
 769   if (phdc) *phdc = This->hDCCur;
 770   return S_OK;
 771 }
 772
 773 /************************************************************************
 774  * OLEPictureImpl_SelectPicture
 775  */
 776 static HRESULT WINAPI OLEPictureImpl_SelectPicture(IPicture *iface,
 777                                                    HDC hdcIn,
 778                                                    HDC *phdcOut,
 779                                                    OLE_HANDLE *phbmpOut)
 780 {
 781   OLEPictureImpl *This = impl_from_IPicture(iface);
 782   TRACE("(%p)->(%p, %p, %p)\n", This, hdcIn, phdcOut, phbmpOut);
 783   if (This->desc.picType == PICTYPE_BITMAP) {
 784       if (phdcOut)
 785           *phdcOut = This->hDCCur;
 786       if (This->hDCCur) SelectObject(This->hDCCur,This->stock_bitmap);
 787       if (hdcIn) SelectObject(hdcIn,This->desc.u.bmp.hbitmap);
 788       This->hDCCur = hdcIn;
 789       if (phbmpOut)
 790           *phbmpOut = HandleToUlong(This->desc.u.bmp.hbitmap);
 791       return S_OK;
 792   } else {
 793       FIXME("Don't know how to select picture type %d\n",This->desc.picType);
 794       return E_FAIL;
 795   }
 796 }
 797
 798 /************************************************************************
 799  * OLEPictureImpl_get_KeepOriginalFormat
 800  */
 801 static HRESULT WINAPI OLEPictureImpl_get_KeepOriginalFormat(IPicture *iface,
 802                                                             BOOL *pfKeep)
 803 {
 804   OLEPictureImpl *This = impl_from_IPicture(iface);
 805   TRACE("(%p)->(%p)\n", This, pfKeep);
 806   if (!pfKeep)
 807       return E_POINTER;
 808   *pfKeep = This->keepOrigFormat;
 809   return S_OK;
 810 }
 811
 812 /************************************************************************
 813  * OLEPictureImpl_put_KeepOriginalFormat
 814  */
 815 static HRESULT WINAPI OLEPictureImpl_put_KeepOriginalFormat(IPicture *iface,
 816                                                             BOOL keep)
 817 {
 818   OLEPictureImpl *This = impl_from_IPicture(iface);
 819   TRACE("(%p)->(%d)\n", This, keep);
 820   This->keepOrigFormat = keep;
 821   /* FIXME: what DISPID notification here? */
 822   return S_OK;
 823 }
 824
 825 /************************************************************************
 826  * OLEPictureImpl_PictureChanged
 827  */
 828 static HRESULT WINAPI OLEPictureImpl_PictureChanged(IPicture *iface)
 829 {
 830   OLEPictureImpl *This = impl_from_IPicture(iface);
 831   TRACE("(%p)->()\n", This);
 832   OLEPicture_SendNotify(This,DISPID_PICT_HANDLE);
 833   This->bIsDirty = TRUE;
 834   return S_OK;
 835 }
 836
 837 /************************************************************************
 838  * OLEPictureImpl_SaveAsFile
 839  */
 840 static HRESULT WINAPI OLEPictureImpl_SaveAsFile(IPicture *iface,
 841                                                 IStream *pstream,
 842                                                 BOOL SaveMemCopy,
 843                                                 LONG *pcbSize)
 844 {
 845   OLEPictureImpl *This = impl_from_IPicture(iface);
 846   FIXME("(%p)->(%p, %d, %p), hacked stub.\n", This, pstream, SaveMemCopy, pcbSize);
 847   return IStream_Write(pstream,This->data,This->datalen,(ULONG*)pcbSize);
 848 }
 849
 850 /************************************************************************
 851  * OLEPictureImpl_get_Attributes
 852  */
 853 static HRESULT WINAPI OLEPictureImpl_get_Attributes(IPicture *iface,
 854                                                     DWORD *pdwAttr)
 855 {
 856   OLEPictureImpl *This = impl_from_IPicture(iface);
 857   TRACE("(%p)->(%p).\n", This, pdwAttr);
 858
 859   if(!pdwAttr)
 860     return E_POINTER;
 861
 862   *pdwAttr = 0;
 863   switch (This->desc.picType) {
 864   case PICTYPE_UNINITIALIZED:
 865   case PICTYPE_NONE: break;
 866   case PICTYPE_BITMAP:  if (This->hbmMask) *pdwAttr = PICTURE_TRANSPARENT; break;       /* not 'truly' scalable, see MSDN. */
 867   case PICTYPE_ICON: *pdwAttr     = PICTURE_TRANSPARENT;break;
 868   case PICTYPE_ENHMETAFILE: /* fall through */
 869   case PICTYPE_METAFILE: *pdwAttr = PICTURE_TRANSPARENT|PICTURE_SCALABLE;break;
 870   default:FIXME("Unknown pictype %d\n",This->desc.picType);break;
 871   }
 872   return S_OK;
 873 }
 874
 875
 876 /************************************************************************
 877  *    IConnectionPointContainer
 878  */
 879 static HRESULT WINAPI OLEPictureImpl_IConnectionPointContainer_QueryInterface(
 880   IConnectionPointContainer* iface,
 881   REFIID riid,
 882   VOID** ppvoid)
 883 {
 884   OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 885
 886   return IPicture_QueryInterface(&This->IPicture_iface,riid,ppvoid);
 887 }
 888
 889 static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_AddRef(
 890   IConnectionPointContainer* iface)
 891 {
 892   OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 893
 894   return IPicture_AddRef(&This->IPicture_iface);
 895 }
 896
 897 static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_Release(
 898   IConnectionPointContainer* iface)
 899 {
 900   OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 901
 902   return IPicture_Release(&This->IPicture_iface);
 903 }
 904
 905 static HRESULT WINAPI OLEPictureImpl_EnumConnectionPoints(
 906   IConnectionPointContainer* iface,
 907   IEnumConnectionPoints** ppEnum)
 908 {
 909   OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 910
 911   FIXME("(%p,%p), stub!\n",This,ppEnum);
 912   return E_NOTIMPL;
 913 }
 914
 915 static HRESULT WINAPI OLEPictureImpl_FindConnectionPoint(
 916   IConnectionPointContainer* iface,
 917   REFIID riid,
 918   IConnectionPoint **ppCP)
 919 {
 920   OLEPictureImpl *This = impl_from_IConnectionPointContainer(iface);
 921   TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppCP);
 922   if (!ppCP)
 923       return E_POINTER;
 924   *ppCP = NULL;
 925   if (IsEqualGUID(riid,&IID_IPropertyNotifySink))
 926       return IConnectionPoint_QueryInterface(This->pCP,&IID_IConnectionPoint,(LPVOID)ppCP);
 927   FIXME("no connection point for %s\n",debugstr_guid(riid));
 928   return CONNECT_E_NOCONNECTION;
 929 }
 930
 931
 932 /************************************************************************
 933  *    IPersistStream
 934  */
 935
 936 /************************************************************************
 937  * OLEPictureImpl_IPersistStream_QueryInterface (IUnknown)
 938  *
 939  * See Windows documentation for more details on IUnknown methods.
 940  */
 941 static HRESULT WINAPI OLEPictureImpl_IPersistStream_QueryInterface(
 942   IPersistStream* iface,
 943   REFIID     riid,
 944   VOID**     ppvoid)
 945 {
 946   OLEPictureImpl *This = impl_from_IPersistStream(iface);
 947
 948   return IPicture_QueryInterface(&This->IPicture_iface, riid, ppvoid);
 949 }
 950
 951 /************************************************************************
 952  * OLEPictureImpl_IPersistStream_AddRef (IUnknown)
 953  *
 954  * See Windows documentation for more details on IUnknown methods.
 955  */
 956 static ULONG WINAPI OLEPictureImpl_IPersistStream_AddRef(
 957   IPersistStream* iface)
 958 {
 959   OLEPictureImpl *This = impl_from_IPersistStream(iface);
 960
 961   return IPicture_AddRef(&This->IPicture_iface);
 962 }
 963
 964 /************************************************************************
 965  * OLEPictureImpl_IPersistStream_Release (IUnknown)
 966  *
 967  * See Windows documentation for more details on IUnknown methods.
 968  */
 969 static ULONG WINAPI OLEPictureImpl_IPersistStream_Release(
 970   IPersistStream* iface)
 971 {
 972   OLEPictureImpl *This = impl_from_IPersistStream(iface);
 973
 974   return IPicture_Release(&This->IPicture_iface);
 975 }
 976
 977 /************************************************************************
 978  * OLEPictureImpl_IPersistStream_GetClassID
 979  */
 980 static HRESULT WINAPI OLEPictureImpl_GetClassID(
 981   IPersistStream* iface,CLSID* pClassID)
 982 {
 983   TRACE("(%p)\n", pClassID);
 984   *pClassID = CLSID_StdPicture;
 985   return S_OK;
 986 }
 987
 988 /************************************************************************
 989  * OLEPictureImpl_IPersistStream_IsDirty
 990  */
 991 static HRESULT WINAPI OLEPictureImpl_IsDirty(
 992   IPersistStream* iface)
 993 {
 994   OLEPictureImpl *This = impl_from_IPersistStream(iface);
 995   FIXME("(%p),stub!\n",This);
 996   return E_NOTIMPL;
 997 }
 998
 999 static HRESULT OLEPictureImpl_LoadDIB(OLEPictureImpl *This, BYTE *xbuf, ULONG xread)
1000 {
1001     BITMAPFILEHEADER    *bfh = (BITMAPFILEHEADER*)xbuf;
1002     BITMAPINFO          *bi = (BITMAPINFO*)(bfh+1);
1003     HDC                 hdcref;
1004
1005     /* Does not matter whether this is a coreheader or not, we only use
1006      * components which are in both
1007      */
1008     hdcref = GetDC(0);
1009     This->desc.u.bmp.hbitmap = CreateDIBitmap(
1010         hdcref,
1011         &(bi->bmiHeader),
1012         CBM_INIT,
1013         xbuf+bfh->bfOffBits,
1014         bi,
1015        DIB_RGB_COLORS
1016     );
1017     ReleaseDC(0, hdcref);
1018     if (This->desc.u.bmp.hbitmap == 0)
1019         return E_FAIL;
1020     This->desc.picType = PICTYPE_BITMAP;
1021     OLEPictureImpl_SetBitmap(This);
1022     return S_OK;
1023 }
1024
1025 static HRESULT OLEPictureImpl_LoadWICSource(OLEPictureImpl *This, IWICBitmapSource *src)
1026 {
1027     HRESULT hr;
1028     BITMAPINFOHEADER bih;
1029     HDC hdcref;
1030     UINT width, height;
1031     UINT stride, buffersize;
1032     LPBYTE bits=NULL;
1033     WICRect rc;
1034     IWICBitmapSource *real_source;
1035     UINT x, y;
1036     COLORREF white = RGB(255, 255, 255), black = RGB(0, 0, 0);
1037     BOOL has_alpha=FALSE;
1038
1039     hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, src, &real_source);
1040     if (FAILED(hr)) return hr;
1041
1042     hr = IWICBitmapSource_GetSize(real_source, &width, &height);
1043     if (FAILED(hr)) goto end;
1044
1045     bih.biSize = sizeof(bih);
1046     bih.biWidth = width;
1047     bih.biHeight = -height;
1048     bih.biPlanes = 1;
1049     bih.biBitCount = 32;
1050     bih.biCompression = BI_RGB;
1051     bih.biSizeImage = 0;
1052     bih.biXPelsPerMeter = 4085; /* olepicture ignores the stored resolution */
1053     bih.biYPelsPerMeter = 4085;
1054     bih.biClrUsed = 0;
1055     bih.biClrImportant = 0;
1056
1057     stride = 4 * width;
1058     buffersize = stride * height;
1059
1060     bits = HeapAlloc(GetProcessHeap(), 0, buffersize);
1061     if (!bits)
1062     {
1063         hr = E_OUTOFMEMORY;
1064         goto end;
1065     }
1066
1067     rc.X = 0;
1068     rc.Y = 0;
1069     rc.Width = width;
1070     rc.Height = height;
1071     hr = IWICBitmapSource_CopyPixels(real_source, &rc, stride, buffersize, bits);
1072     if (FAILED(hr))
1073         goto end;
1074
1075     hdcref = GetDC(0);
1076     This->desc.u.bmp.hbitmap = CreateDIBitmap(
1077         hdcref,
1078         &bih,
1079         CBM_INIT,
1080         bits,
1081         (BITMAPINFO*)&bih,
1082         DIB_RGB_COLORS);
1083
1084     if (This->desc.u.bmp.hbitmap == 0)
1085     {
1086         hr = E_FAIL;
1087         ReleaseDC(0, hdcref);
1088         goto end;
1089     }
1090
1091     This->desc.picType = PICTYPE_BITMAP;
1092     OLEPictureImpl_SetBitmap(This);
1093
1094     /* set transparent pixels to black, all others to white */
1095     for(y = 0; y < height; y++){
1096         for(x = 0; x < width; x++){
1097             DWORD *pixel = (DWORD*)(bits + stride*y + 4*x);
1098             if((*pixel & 0x80000000) == 0)
1099             {
1100                 has_alpha = TRUE;
1101                 *pixel = black;
1102             }
1103             else
1104                 *pixel = white;
1105         }
1106     }
1107
1108     if (has_alpha)
1109     {
1110         HDC hdcBmp, hdcXor, hdcMask;
1111         HBITMAP hbmoldBmp, hbmoldXor, hbmoldMask;
1112
1113         This->hbmXor = CreateDIBitmap(
1114             hdcref,
1115             &bih,
1116             CBM_INIT,
1117             bits,
1118             (BITMAPINFO*)&bih,
1119             DIB_RGB_COLORS
1120         );
1121
1122         This->hbmMask = CreateBitmap(width,-height,1,1,NULL);
1123         hdcBmp = CreateCompatibleDC(NULL);
1124         hdcXor = CreateCompatibleDC(NULL);
1125         hdcMask = CreateCompatibleDC(NULL);
1126
1127         hbmoldBmp = SelectObject(hdcBmp,This->desc.u.bmp.hbitmap);
1128         hbmoldXor = SelectObject(hdcXor,This->hbmXor);
1129         hbmoldMask = SelectObject(hdcMask,This->hbmMask);
1130
1131         SetBkColor(hdcXor,black);
1132         BitBlt(hdcMask,0,0,width,height,hdcXor,0,0,SRCCOPY);
1133         BitBlt(hdcXor,0,0,width,height,hdcBmp,0,0,SRCAND);
1134
1135         SelectObject(hdcBmp,hbmoldBmp);
1136         SelectObject(hdcXor,hbmoldXor);
1137         SelectObject(hdcMask,hbmoldMask);
1138
1139         DeleteDC(hdcBmp);
1140         DeleteDC(hdcXor);
1141         DeleteDC(hdcMask);
1142     }
1143
1144     ReleaseDC(0, hdcref);
1145
1146 end:
1147     HeapFree(GetProcessHeap(), 0, bits);
1148     IWICBitmapSource_Release(real_source);
1149     return hr;
1150 }
1151
1152 static HRESULT OLEPictureImpl_LoadWICDecoder(OLEPictureImpl *This, REFCLSID decoder_clsid, BYTE *xbuf, ULONG xread)
1153 {
1154     HRESULT hr;
1155     IWICImagingFactory *factory;
1156     IWICBitmapDecoder *decoder;
1157     IWICBitmapFrameDecode *framedecode;
1158     HRESULT initresult;
1159     IWICStream *stream;
1160
1161     initresult = CoInitialize(NULL);
1162
1163     hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1164         &IID_IWICImagingFactory, (void**)&factory);
1165     if (SUCCEEDED(hr)) /* created factory */
1166     {
1167         hr = IWICImagingFactory_CreateStream(factory, &stream);
1168         IWICImagingFactory_Release(factory);
1169     }
1170
1171     if (SUCCEEDED(hr)) /* created stream */
1172     {
1173         hr = IWICStream_InitializeFromMemory(stream, xbuf, xread);
1174
1175         if (SUCCEEDED(hr)) /* initialized stream */
1176         {
1177             hr = CoCreateInstance(decoder_clsid, NULL, CLSCTX_INPROC_SERVER,
1178                 &IID_IWICBitmapDecoder, (void**)&decoder);
1179             if (SUCCEEDED(hr)) /* created decoder */
1180             {
1181                 hr = IWICBitmapDecoder_Initialize(decoder, (IStream*)stream, WICDecodeMetadataCacheOnLoad);
1182
1183                 if (SUCCEEDED(hr)) /* initialized decoder */
1184                     hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
1185
1186                 IWICBitmapDecoder_Release(decoder);
1187             }
1188         }
1189
1190         IWICStream_Release(stream);
1191     }
1192
1193     if (SUCCEEDED(hr)) /* got framedecode */
1194     {
1195         hr = OLEPictureImpl_LoadWICSource(This, (IWICBitmapSource*)framedecode);
1196         IWICBitmapFrameDecode_Release(framedecode);
1197     }
1198
1199     if (SUCCEEDED(initresult)) CoUninitialize();
1200     return hr;
1201 }
1202
1203 /*****************************************************
1204 *   start of Icon-specific code
1205 */
1206
1207 static HRESULT OLEPictureImpl_LoadIcon(OLEPictureImpl *This, BYTE *xbuf, ULONG xread)
1208 {
1209     HICON hicon;
1210     CURSORICONFILEDIR   *cifd = (CURSORICONFILEDIR*)xbuf;
1211     HDC hdcRef;
1212     int i;
1213
1214     /*
1215     FIXME("icon.idReserved=%d\n",cifd->idReserved);
1216     FIXME("icon.idType=%d\n",cifd->idType);
1217     FIXME("icon.idCount=%d\n",cifd->idCount);
1218
1219     for (i=0;i<cifd->idCount;i++) {
1220         FIXME("[%d] width %d\n",i,cifd->idEntries[i].bWidth);
1221         FIXME("[%d] height %d\n",i,cifd->idEntries[i].bHeight);
1222         FIXME("[%d] bColorCount %d\n",i,cifd->idEntries[i].bColorCount);
1223         FIXME("[%d] bReserved %d\n",i,cifd->idEntries[i].bReserved);
1224         FIXME("[%d] xHotspot %d\n",i,cifd->idEntries[i].xHotspot);
1225         FIXME("[%d] yHotspot %d\n",i,cifd->idEntries[i].yHotspot);
1226         FIXME("[%d] dwDIBSize %d\n",i,cifd->idEntries[i].dwDIBSize);
1227         FIXME("[%d] dwDIBOffset %d\n",i,cifd->idEntries[i].dwDIBOffset);
1228     }
1229     */
1230     i=0;
1231     /* If we have more than one icon, try to find the best.
1232      * this currently means '32 pixel wide'.
1233      */
1234     if (cifd->idCount!=1) {
1235         for (i=0;i<cifd->idCount;i++) {
1236             if (cifd->idEntries[i].bWidth == 32)
1237                 break;
1238         }
1239         if (i==cifd->idCount) i=0;
1240     }
1241     if (cifd->idType == 2)
1242     {
1243         LPBYTE buf = HeapAlloc(GetProcessHeap(), 0, cifd->idEntries[i].dwDIBSize + 4);
1244         memcpy(buf, &cifd->idEntries[i].xHotspot, 4);
1245         memcpy(buf + 4, xbuf+cifd->idEntries[i].dwDIBOffset, cifd->idEntries[i].dwDIBSize);
1246         hicon = CreateIconFromResourceEx(
1247                     buf,
1248                     cifd->idEntries[i].dwDIBSize + 4,
1249                     FALSE, /* is cursor */
1250                     0x00030000,
1251                     cifd->idEntries[i].bWidth,
1252                     cifd->idEntries[i].bHeight,
1253                     0
1254         );
1255         HeapFree(GetProcessHeap(), 0, buf);
1256     }
1257     else
1258     {
1259         hicon = CreateIconFromResourceEx(
1260                     xbuf+cifd->idEntries[i].dwDIBOffset,
1261                     cifd->idEntries[i].dwDIBSize,
1262                     TRUE, /* is icon */
1263                     0x00030000,
1264                     cifd->idEntries[i].bWidth,
1265                     cifd->idEntries[i].bHeight,
1266                     0
1267         );
1268     }
1269     if (!hicon) {
1270         ERR("CreateIcon failed.\n");
1271         return E_FAIL;
1272     } else {
1273         This->desc.picType = PICTYPE_ICON;
1274         This->desc.u.icon.hicon = hicon;
1275         This->origWidth = cifd->idEntries[i].bWidth;
1276         This->origHeight = cifd->idEntries[i].bHeight;
1277         hdcRef = CreateCompatibleDC(0);
1278         This->himetricWidth = xpixels_to_himetric(cifd->idEntries[i].bWidth, hdcRef);
1279         This->himetricHeight= ypixels_to_himetric(cifd->idEntries[i].bHeight, hdcRef);
1280         DeleteDC(hdcRef);
1281         return S_OK;
1282     }
1283 }
1284
1285 static HRESULT OLEPictureImpl_LoadEnhMetafile(OLEPictureImpl *This,
1286                                               const BYTE *data, ULONG size)
1287 {
1288     HENHMETAFILE hemf;
1289     ENHMETAHEADER hdr;
1290
1291     hemf = SetEnhMetaFileBits(size, data);
1292     if (!hemf) return E_FAIL;
1293
1294     GetEnhMetaFileHeader(hemf, sizeof(hdr), &hdr);
1295
1296     This->desc.picType = PICTYPE_ENHMETAFILE;
1297     This->desc.u.emf.hemf = hemf;
1298
1299     This->origWidth = 0;
1300     This->origHeight = 0;
1301     This->himetricWidth = hdr.rclFrame.right - hdr.rclFrame.left;
1302     This->himetricHeight = hdr.rclFrame.bottom - hdr.rclFrame.top;
1303
1304     return S_OK;
1305 }
1306
1307 static HRESULT OLEPictureImpl_LoadAPM(OLEPictureImpl *This,
1308                                       const BYTE *data, ULONG size)
1309 {
1310     const APM_HEADER *header = (const APM_HEADER *)data;
1311     HMETAFILE hmf;
1312
1313     if (size < sizeof(APM_HEADER))
1314         return E_FAIL;
1315     if (header->key != 0x9ac6cdd7)
1316         return E_FAIL;
1317
1318     /* SetMetaFileBitsEx performs data check on its own */
1319     hmf = SetMetaFileBitsEx(size - sizeof(*header), data + sizeof(*header));
1320     if (!hmf) return E_FAIL;
1321
1322     This->desc.picType = PICTYPE_METAFILE;
1323     This->desc.u.wmf.hmeta = hmf;
1324     This->desc.u.wmf.xExt = 0;
1325     This->desc.u.wmf.yExt = 0;
1326
1327     This->origWidth = 0;
1328     This->origHeight = 0;
1329     This->himetricWidth = MulDiv((INT)header->right - header->left, 2540, header->inch);
1330     This->himetricHeight = MulDiv((INT)header->bottom - header->top, 2540, header->inch);
1331     return S_OK;
1332 }
1333
1334 /************************************************************************
1335  * OLEPictureImpl_IPersistStream_Load (IUnknown)
1336  *
1337  * Loads the binary data from the IStream. Starts at current position.
1338  * There appears to be an 2 DWORD header:
1339  *      DWORD magic;
1340  *      DWORD len;
1341  *
1342  * Currently implemented: BITMAP, ICON, CURSOR, JPEG, GIF, WMF, EMF
1343  */
1344 static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface, IStream *pStm) {
1345   HRESULT       hr;
1346   BOOL          headerisdata;
1347   BOOL          statfailed = FALSE;
1348   ULONG         xread, toread;
1349   ULONG         headerread;
1350   BYTE          *xbuf;
1351   DWORD         header[2];
1352   WORD          magic;
1353   STATSTG       statstg;
1354   OLEPictureImpl *This = impl_from_IPersistStream(iface);
1355
1356   TRACE("(%p,%p)\n",This,pStm);
1357
1358   /****************************************************************************************
1359    * Part 1: Load the data
1360    */
1361   /* Sometimes we have a header, sometimes we don't. Apply some guesses to find
1362    * out whether we do.
1363    *
1364    * UPDATE: the IStream can be mapped to a plain file instead of a stream in a
1365    * compound file. This may explain most, if not all, of the cases of "no
1366    * header", and the header validation should take this into account.
1367    * At least in Visual Basic 6, resource streams, valid headers are
1368    *    header[0] == "lt\0\0",
1369    *    header[1] == length_of_stream.
1370    *
1371    * Also handle streams where we do not have a working "Stat" method by
1372    * reading all data until the end of the stream.
1373    */
1374   hr = IStream_Stat(pStm,&statstg,STATFLAG_NONAME);
1375   if (hr != S_OK) {
1376       TRACE("stat failed with hres %x, proceeding to read all data.\n",hr);
1377       statfailed = TRUE;
1378       /* we will read at least 8 byte ... just right below */
1379       statstg.cbSize.QuadPart = 8;
1380   }
1381
1382   toread = 0;
1383   headerread = 0;
1384   headerisdata = FALSE;
1385   do {
1386       hr = IStream_Read(pStm, header, 8, &xread);
1387       if (hr != S_OK || xread!=8) {
1388           ERR("Failure while reading picture header (hr is %x, nread is %d).\n",hr,xread);
1389           return (hr?hr:E_FAIL);
1390       }
1391       headerread += xread;
1392       xread = 0;
1393
1394       if (!memcmp(&(header[0]),"lt\0\0", 4) && (statfailed || (header[1] + headerread <= statstg.cbSize.QuadPart))) {
1395           if (toread != 0 && toread != header[1])
1396               FIXME("varying lengths of image data (prev=%u curr=%u), only last one will be used\n",
1397                   toread, header[1]);
1398           toread = header[1];
1399           if (toread == 0) break;
1400       } else {
1401           if (!memcmp(&(header[0]), "GIF8",     4) ||   /* GIF header */
1402               !memcmp(&(header[0]), "BM",       2) ||   /* BMP header */
1403               !memcmp(&(header[0]), "\xff\xd8", 2) ||   /* JPEG header */
1404               (header[0] == EMR_HEADER)            ||   /* EMF header */
1405               (header[0] == 0x10000)               ||   /* icon: idReserved 0, idType 1 */
1406               (header[0] == 0x20000)               ||   /* cursor: idReserved 0, idType 2 */
1407               (header[1] > statstg.cbSize.QuadPart)||   /* invalid size */
1408               (header[1]==0)
1409           ) {/* Found start of bitmap data */
1410               headerisdata = TRUE;
1411               if (toread == 0)
1412                   toread = statstg.cbSize.QuadPart-8;
1413               else toread -= 8;
1414               xread = 8;
1415           } else {
1416               FIXME("Unknown stream header magic: %08x\n", header[0]);
1417               toread = header[1];
1418           }
1419       }
1420   } while (!headerisdata);
1421
1422   if (statfailed) { /* we don't know the size ... read all we get */
1423       int sizeinc = 4096;
1424       int origsize = sizeinc;
1425       ULONG nread = 42;
1426
1427       TRACE("Reading all data from stream.\n");
1428       xbuf = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, origsize);
1429       if (headerisdata)
1430           memcpy (xbuf, header, 8);
1431       while (1) {
1432           while (xread < origsize) {
1433               hr = IStream_Read(pStm,xbuf+xread,origsize-xread,&nread);
1434               xread += nread;
1435               if (hr != S_OK || !nread)
1436                   break;
1437           }
1438           if (!nread || hr != S_OK) /* done, or error */
1439               break;
1440           if (xread == origsize) {
1441               origsize += sizeinc;
1442               sizeinc = 2*sizeinc; /* exponential increase */
1443               xbuf = HeapReAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, xbuf, origsize);
1444           }
1445       }
1446       if (hr != S_OK)
1447           TRACE("hr in no-stat loader case is %08x\n", hr);
1448       TRACE("loaded %d bytes.\n", xread);
1449       This->datalen = xread;
1450       This->data    = xbuf;
1451   } else {
1452       This->datalen = toread+(headerisdata?8:0);
1453       xbuf = This->data = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, This->datalen);
1454       if (!xbuf)
1455           return E_OUTOFMEMORY;
1456
1457       if (headerisdata)
1458           memcpy (xbuf, header, 8);
1459
1460       while (xread < This->datalen) {
1461           ULONG nread;
1462           hr = IStream_Read(pStm,xbuf+xread,This->datalen-xread,&nread);
1463           xread += nread;
1464           if (hr != S_OK || !nread)
1465               break;
1466       }
1467       if (xread != This->datalen)
1468           ERR("Could only read %d of %d bytes out of stream?\n",xread,This->datalen);
1469   }
1470   if (This->datalen == 0) { /* Marks the "NONE" picture */
1471       This->desc.picType = PICTYPE_NONE;
1472       return S_OK;
1473   }
1474
1475
1476   /****************************************************************************************
1477    * Part 2: Process the loaded data
1478    */
1479
1480   magic = xbuf[0] + (xbuf[1]<<8);
1481   This->loadtime_format = magic;
1482
1483   switch (magic) {
1484   case BITMAP_FORMAT_GIF: /* GIF */
1485     hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICGifDecoder, xbuf, xread);
1486     break;
1487   case BITMAP_FORMAT_JPEG: /* JPEG */
1488     hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICJpegDecoder, xbuf, xread);
1489     break;
1490   case BITMAP_FORMAT_BMP: /* Bitmap */
1491     hr = OLEPictureImpl_LoadDIB(This, xbuf, xread);
1492     break;
1493   case BITMAP_FORMAT_PNG: /* PNG */
1494     hr = OLEPictureImpl_LoadWICDecoder(This, &CLSID_WICPngDecoder, xbuf, xread);
1495     break;
1496   case BITMAP_FORMAT_APM: /* APM */
1497     hr = OLEPictureImpl_LoadAPM(This, xbuf, xread);
1498     break;
1499   case 0x0000: { /* ICON or CURSOR, first word is dwReserved */
1500     hr = OLEPictureImpl_LoadIcon(This, xbuf, xread);
1501     break;
1502   }
1503   default:
1504   {
1505     unsigned int i;
1506
1507     /* let's see if it's a EMF */
1508     hr = OLEPictureImpl_LoadEnhMetafile(This, xbuf, xread);
1509     if (hr == S_OK) break;
1510
1511     FIXME("Unknown magic %04x, %d read bytes:\n",magic,xread);
1512     hr=E_FAIL;
1513     for (i=0;i<xread+8;i++) {
1514         if (i<8) MESSAGE("%02x ",((unsigned char*)header)[i]);
1515         else MESSAGE("%02x ",xbuf[i-8]);
1516         if (i % 10 == 9) MESSAGE("\n");
1517     }
1518     MESSAGE("\n");
1519     break;
1520   }
1521   }
1522   This->bIsDirty = FALSE;
1523
1524   /* FIXME: this notify is not really documented */
1525   if (hr==S_OK)
1526       OLEPicture_SendNotify(This,DISPID_PICT_TYPE);
1527   return hr;
1528 }
1529
1530 static int serializeBMP(HBITMAP hBitmap, void ** ppBuffer, unsigned int * pLength)
1531 {
1532     int iSuccess = 0;
1533     HDC hDC;
1534     BITMAPINFO * pInfoBitmap;
1535     int iNumPaletteEntries;
1536     unsigned char * pPixelData;
1537     BITMAPFILEHEADER * pFileHeader;
1538     BITMAPINFO * pInfoHeader;
1539
1540     pInfoBitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1541         sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1542
1543     /* Find out bitmap size and padded length */
1544     hDC = GetDC(0);
1545     pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
1546     GetDIBits(hDC, hBitmap, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
1547
1548     /* Fetch bitmap palette & pixel data */
1549
1550     pPixelData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pInfoBitmap->bmiHeader.biSizeImage);
1551     GetDIBits(hDC, hBitmap, 0, pInfoBitmap->bmiHeader.biHeight, pPixelData, pInfoBitmap, DIB_RGB_COLORS);
1552
1553     /* Calculate the total length required for the BMP data */
1554     if (pInfoBitmap->bmiHeader.biClrUsed != 0) {
1555         iNumPaletteEntries = pInfoBitmap->bmiHeader.biClrUsed;
1556         if (iNumPaletteEntries > 256) iNumPaletteEntries = 256;
1557     } else {
1558         if (pInfoBitmap->bmiHeader.biBitCount <= 8)
1559             iNumPaletteEntries = 1 << pInfoBitmap->bmiHeader.biBitCount;
1560         else
1561             iNumPaletteEntries = 0;
1562     }
1563     *pLength =
1564         sizeof(BITMAPFILEHEADER) +
1565         sizeof(BITMAPINFOHEADER) +
1566         iNumPaletteEntries * sizeof(RGBQUAD) +
1567         pInfoBitmap->bmiHeader.biSizeImage;
1568     *ppBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *pLength);
1569
1570     /* Fill the BITMAPFILEHEADER */
1571     pFileHeader = *ppBuffer;
1572     pFileHeader->bfType = BITMAP_FORMAT_BMP;
1573     pFileHeader->bfSize = *pLength;
1574     pFileHeader->bfOffBits =
1575         sizeof(BITMAPFILEHEADER) +
1576         sizeof(BITMAPINFOHEADER) +
1577         iNumPaletteEntries * sizeof(RGBQUAD);
1578
1579     /* Fill the BITMAPINFOHEADER and the palette data */
1580     pInfoHeader = (BITMAPINFO *)((unsigned char *)(*ppBuffer) + sizeof(BITMAPFILEHEADER));
1581     memcpy(pInfoHeader, pInfoBitmap, sizeof(BITMAPINFOHEADER) + iNumPaletteEntries * sizeof(RGBQUAD));
1582     memcpy(
1583         (unsigned char *)(*ppBuffer) +
1584             sizeof(BITMAPFILEHEADER) +
1585             sizeof(BITMAPINFOHEADER) +
1586             iNumPaletteEntries * sizeof(RGBQUAD),
1587         pPixelData, pInfoBitmap->bmiHeader.biSizeImage);
1588     iSuccess = 1;
1589
1590     HeapFree(GetProcessHeap(), 0, pPixelData);
1591     HeapFree(GetProcessHeap(), 0, pInfoBitmap);
1592     return iSuccess;
1593 }
1594
1595 static int serializeIcon(HICON hIcon, void ** ppBuffer, unsigned int * pLength)
1596 {
1597         ICONINFO infoIcon;
1598         int iSuccess = 0;
1599
1600         *ppBuffer = NULL; *pLength = 0;
1601         if (GetIconInfo(hIcon, &infoIcon)) {
1602                 HDC hDC;
1603                 BITMAPINFO * pInfoBitmap;
1604                 unsigned char * pIconData = NULL;
1605                 unsigned int iDataSize = 0;
1606
1607         pInfoBitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1608
1609                 /* Find out icon size */
1610                 hDC = GetDC(0);
1611                 pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
1612                 GetDIBits(hDC, infoIcon.hbmColor, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
1613                 if (1) {
1614                         /* Auxiliary pointers */
1615                         CURSORICONFILEDIR * pIconDir;
1616                         CURSORICONFILEDIRENTRY * pIconEntry;
1617                         BITMAPINFOHEADER * pIconBitmapHeader;
1618                         unsigned int iOffsetPalette;
1619                         unsigned int iOffsetColorData;
1620                         unsigned int iOffsetMaskData;
1621
1622                         unsigned int iLengthScanLineMask;
1623                         unsigned int iNumEntriesPalette;
1624
1625                         iLengthScanLineMask = ((pInfoBitmap->bmiHeader.biWidth + 31) >> 5) << 2;
1626 /*
1627                         FIXME("DEBUG: bitmap size is %d x %d\n",
1628                                 pInfoBitmap->bmiHeader.biWidth,
1629                                 pInfoBitmap->bmiHeader.biHeight);
1630                         FIXME("DEBUG: bitmap bpp is %d\n",
1631                                 pInfoBitmap->bmiHeader.biBitCount);
1632                         FIXME("DEBUG: bitmap nplanes is %d\n",
1633                                 pInfoBitmap->bmiHeader.biPlanes);
1634                         FIXME("DEBUG: bitmap biSizeImage is %u\n",
1635                                 pInfoBitmap->bmiHeader.biSizeImage);
1636 */
1637                         /* Let's start with one CURSORICONFILEDIR and one CURSORICONFILEDIRENTRY */
1638                         iDataSize += 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY) + sizeof(BITMAPINFOHEADER);
1639                         pIconData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, iDataSize);
1640
1641                         /* Fill out the CURSORICONFILEDIR */
1642                         pIconDir = (CURSORICONFILEDIR *)pIconData;
1643                         pIconDir->idType = 1;
1644                         pIconDir->idCount = 1;
1645                         pIconDir->idReserved = 0;
1646
1647                         /* Fill out the CURSORICONFILEDIRENTRY */
1648                         pIconEntry = (CURSORICONFILEDIRENTRY *)(pIconData + 3 * sizeof(WORD));
1649                         pIconEntry->bWidth = (unsigned char)pInfoBitmap->bmiHeader.biWidth;
1650                         pIconEntry->bHeight = (unsigned char)pInfoBitmap->bmiHeader.biHeight;
1651                         pIconEntry->bColorCount =
1652                                 (pInfoBitmap->bmiHeader.biBitCount < 8)
1653                                 ? 1 << pInfoBitmap->bmiHeader.biBitCount
1654                                 : 0;
1655                         pIconEntry->xHotspot = pInfoBitmap->bmiHeader.biPlanes;
1656                         pIconEntry->yHotspot = pInfoBitmap->bmiHeader.biBitCount;
1657                         pIconEntry->dwDIBSize = 0;
1658                         pIconEntry->dwDIBOffset = 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY);
1659
1660                         /* Fill out the BITMAPINFOHEADER */
1661                         pIconBitmapHeader = (BITMAPINFOHEADER *)(pIconData + 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
1662                         *pIconBitmapHeader = pInfoBitmap->bmiHeader;
1663
1664                         /*      Find out whether a palette exists for the bitmap */
1665                         if (    (pInfoBitmap->bmiHeader.biBitCount == 16 && pInfoBitmap->bmiHeader.biCompression == BI_RGB)
1666                                 ||      (pInfoBitmap->bmiHeader.biBitCount == 24)
1667                                 ||      (pInfoBitmap->bmiHeader.biBitCount == 32 && pInfoBitmap->bmiHeader.biCompression == BI_RGB)) {
1668                                 iNumEntriesPalette = pInfoBitmap->bmiHeader.biClrUsed;
1669                                 if (iNumEntriesPalette > 256) iNumEntriesPalette = 256;
1670                         } else if ((pInfoBitmap->bmiHeader.biBitCount == 16 || pInfoBitmap->bmiHeader.biBitCount == 32)
1671                                 && pInfoBitmap->bmiHeader.biCompression == BI_BITFIELDS) {
1672                                 iNumEntriesPalette = 3;
1673                         } else if (pInfoBitmap->bmiHeader.biBitCount <= 8) {
1674                                 iNumEntriesPalette = 1 << pInfoBitmap->bmiHeader.biBitCount;
1675                         } else {
1676                                 iNumEntriesPalette = 0;
1677                         }
1678
1679                         /*  Add bitmap size and header size to icon data size. */
1680                         iOffsetPalette = iDataSize;
1681                         iDataSize += iNumEntriesPalette * sizeof(DWORD);
1682                         iOffsetColorData = iDataSize;
1683                         iDataSize += pIconBitmapHeader->biSizeImage;
1684                         iOffsetMaskData = iDataSize;
1685                         iDataSize += pIconBitmapHeader->biHeight * iLengthScanLineMask;
1686                         pIconBitmapHeader->biSizeImage += pIconBitmapHeader->biHeight * iLengthScanLineMask;
1687                         pIconBitmapHeader->biHeight *= 2;
1688                         pIconData = HeapReAlloc(GetProcessHeap(), 0, pIconData, iDataSize);
1689                         pIconEntry = (CURSORICONFILEDIRENTRY *)(pIconData + 3 * sizeof(WORD));
1690                         pIconBitmapHeader = (BITMAPINFOHEADER *)(pIconData + 3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
1691                         pIconEntry->dwDIBSize = iDataSize - (3 * sizeof(WORD) + sizeof(CURSORICONFILEDIRENTRY));
1692
1693                         /* Get the actual bitmap data from the icon bitmap */
1694                         GetDIBits(hDC, infoIcon.hbmColor, 0, pInfoBitmap->bmiHeader.biHeight,
1695                                 pIconData + iOffsetColorData, pInfoBitmap, DIB_RGB_COLORS);
1696                         if (iNumEntriesPalette > 0) {
1697                                 memcpy(pIconData + iOffsetPalette, pInfoBitmap->bmiColors,
1698                                         iNumEntriesPalette * sizeof(RGBQUAD));
1699                         }
1700
1701                         /* Reset all values so that GetDIBits call succeeds */
1702                         memset(pIconData + iOffsetMaskData, 0, iDataSize - iOffsetMaskData);
1703                         memset(pInfoBitmap, 0, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1704                         pInfoBitmap->bmiHeader.biSize = sizeof(pInfoBitmap->bmiHeader);
1705 /*
1706             if (!(GetDIBits(hDC, infoIcon.hbmMask, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS)
1707                                 && GetDIBits(hDC, infoIcon.hbmMask, 0, pIconEntry->bHeight,
1708                                         pIconData + iOffsetMaskData, pInfoBitmap, DIB_RGB_COLORS))) {
1709
1710                 printf("ERROR: unable to get bitmap mask (error %u)\n",
1711                                         GetLastError());
1712
1713                         }
1714 */
1715             GetDIBits(hDC, infoIcon.hbmMask, 0, 0, NULL, pInfoBitmap, DIB_RGB_COLORS);
1716             GetDIBits(hDC, infoIcon.hbmMask, 0, pIconEntry->bHeight, pIconData + iOffsetMaskData, pInfoBitmap, DIB_RGB_COLORS);
1717
1718                         /* Write out everything produced so far to the stream */
1719                         *ppBuffer = pIconData; *pLength = iDataSize;
1720                         iSuccess = 1;
1721                 } else {
1722 /*
1723                         printf("ERROR: unable to get bitmap information via GetDIBits() (error %u)\n",
1724                                 GetLastError());
1725 */
1726                 }
1727                 /*
1728                         Remarks (from MSDN entry on GetIconInfo):
1729
1730                         GetIconInfo creates bitmaps for the hbmMask and hbmColor
1731                         members of ICONINFO. The calling application must manage
1732                         these bitmaps and delete them when they are no longer
1733                         necessary.
1734                  */
1735                 if (hDC) ReleaseDC(0, hDC);
1736                 DeleteObject(infoIcon.hbmMask);
1737                 if (infoIcon.hbmColor) DeleteObject(infoIcon.hbmColor);
1738                 HeapFree(GetProcessHeap(), 0, pInfoBitmap);
1739         } else {
1740                 printf("ERROR: Unable to get icon information (error %u)\n",
1741                         GetLastError());
1742         }
1743         return iSuccess;
1744 }
1745
1746 static HRESULT WINAPI OLEPictureImpl_Save(
1747   IPersistStream* iface,IStream*pStm,BOOL fClearDirty)
1748 {
1749     HRESULT hResult = E_NOTIMPL;
1750     void * pIconData;
1751     unsigned int iDataSize;
1752     DWORD header[2];
1753     ULONG dummy;
1754     int iSerializeResult = 0;
1755     OLEPictureImpl *This = impl_from_IPersistStream(iface);
1756
1757     TRACE("%p %p %d\n", This, pStm, fClearDirty);
1758
1759     switch (This->desc.picType) {
1760     case PICTYPE_ICON:
1761         if (This->bIsDirty || !This->data) {
1762             if (!serializeIcon(This->desc.u.icon.hicon, &pIconData, &iDataSize)) {
1763                 ERR("(%p,%p,%d), serializeIcon() failed\n", This, pStm, fClearDirty);
1764                 hResult = E_FAIL;
1765                 break;
1766             }
1767             HeapFree(GetProcessHeap(), 0, This->data);
1768             This->data = pIconData;
1769             This->datalen = iDataSize;
1770         }
1771
1772         header[0] = (This->loadtime_magic != 0xdeadbeef) ? This->loadtime_magic : 0x0000746c;
1773         header[1] = This->datalen;
1774         IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
1775         IStream_Write(pStm, This->data, This->datalen, &dummy);
1776         hResult = S_OK;
1777         break;
1778     case PICTYPE_BITMAP:
1779         if (This->bIsDirty || !This->data) {
1780             switch (This->keepOrigFormat ? This->loadtime_format : BITMAP_FORMAT_BMP) {
1781             case BITMAP_FORMAT_BMP:
1782                 iSerializeResult = serializeBMP(This->desc.u.bmp.hbitmap, &pIconData, &iDataSize);
1783                 break;
1784             case BITMAP_FORMAT_JPEG:
1785                 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format JPEG) not implemented!\n",This,pStm,fClearDirty);
1786                 break;
1787             case BITMAP_FORMAT_GIF:
1788                 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format GIF) not implemented!\n",This,pStm,fClearDirty);
1789                 break;
1790             case BITMAP_FORMAT_PNG:
1791                 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format PNG) not implemented!\n",This,pStm,fClearDirty);
1792                 break;
1793             default:
1794                 FIXME("(%p,%p,%d), PICTYPE_BITMAP (format UNKNOWN, using BMP?) not implemented!\n",This,pStm,fClearDirty);
1795                 break;
1796             }
1797
1798             if (!iSerializeResult)
1799             {
1800                 hResult = E_FAIL;
1801                 break;
1802             }
1803
1804             HeapFree(GetProcessHeap(), 0, This->data);
1805             This->data = pIconData;
1806             This->datalen = iDataSize;
1807         }
1808
1809         header[0] = (This->loadtime_magic != 0xdeadbeef) ? This->loadtime_magic : 0x0000746c;
1810         header[1] = This->datalen;
1811         IStream_Write(pStm, header, 2 * sizeof(DWORD), &dummy);
1812         IStream_Write(pStm, This->data, This->datalen, &dummy);
1813         hResult = S_OK;
1814         break;
1815     case PICTYPE_METAFILE:
1816         FIXME("(%p,%p,%d), PICTYPE_METAFILE not implemented!\n",This,pStm,fClearDirty);
1817         break;
1818     case PICTYPE_ENHMETAFILE:
1819         FIXME("(%p,%p,%d),PICTYPE_ENHMETAFILE not implemented!\n",This,pStm,fClearDirty);
1820         break;
1821     default:
1822         FIXME("(%p,%p,%d), [unknown type] not implemented!\n",This,pStm,fClearDirty);
1823         break;
1824     }
1825     if (hResult == S_OK && fClearDirty) This->bIsDirty = FALSE;
1826     return hResult;
1827 }
1828
1829 static HRESULT WINAPI OLEPictureImpl_GetSizeMax(
1830   IPersistStream* iface,ULARGE_INTEGER*pcbSize)
1831 {
1832   OLEPictureImpl *This = impl_from_IPersistStream(iface);
1833   FIXME("(%p,%p),stub!\n",This,pcbSize);
1834   return E_NOTIMPL;
1835 }
1836
1837
1838 /************************************************************************
1839  *    IDispatch
1840  */
1841
1842 /************************************************************************
1843  * OLEPictureImpl_IDispatch_QueryInterface (IUnknown)
1844  *
1845  * See Windows documentation for more details on IUnknown methods.
1846  */
1847 static HRESULT WINAPI OLEPictureImpl_IDispatch_QueryInterface(
1848   IDispatch* iface,
1849   REFIID     riid,
1850   VOID**     ppvoid)
1851 {
1852   OLEPictureImpl *This = impl_from_IDispatch(iface);
1853
1854   return IPicture_QueryInterface(&This->IPicture_iface, riid, ppvoid);
1855 }
1856
1857 /************************************************************************
1858  * OLEPictureImpl_IDispatch_AddRef (IUnknown)
1859  *
1860  * See Windows documentation for more details on IUnknown methods.
1861  */
1862 static ULONG WINAPI OLEPictureImpl_IDispatch_AddRef(
1863   IDispatch* iface)
1864 {
1865   OLEPictureImpl *This = impl_from_IDispatch(iface);
1866
1867   return IPicture_AddRef(&This->IPicture_iface);
1868 }
1869
1870 /************************************************************************
1871  * OLEPictureImpl_IDispatch_Release (IUnknown)
1872  *
1873  * See Windows documentation for more details on IUnknown methods.
1874  */
1875 static ULONG WINAPI OLEPictureImpl_IDispatch_Release(
1876   IDispatch* iface)
1877 {
1878   OLEPictureImpl *This = impl_from_IDispatch(iface);
1879
1880   return IPicture_Release(&This->IPicture_iface);
1881 }
1882
1883 /************************************************************************
1884  * OLEPictureImpl_GetTypeInfoCount (IDispatch)
1885  *
1886  * See Windows documentation for more details on IDispatch methods.
1887  */
1888 static HRESULT WINAPI OLEPictureImpl_GetTypeInfoCount(
1889   IDispatch*    iface,
1890   unsigned int* pctinfo)
1891 {
1892   TRACE("(%p)\n", pctinfo);
1893
1894   *pctinfo = 1;
1895
1896   return S_OK;
1897 }
1898
1899 /************************************************************************
1900  * OLEPictureImpl_GetTypeInfo (IDispatch)
1901  *
1902  * See Windows documentation for more details on IDispatch methods.
1903  */
1904 static HRESULT WINAPI OLEPictureImpl_GetTypeInfo(
1905   IDispatch*  iface,
1906   UINT      iTInfo,
1907   LCID        lcid,
1908   ITypeInfo** ppTInfo)
1909 {
1910   static const WCHAR stdole2tlb[] = {'s','t','d','o','l','e','2','.','t','l','b',0};
1911   ITypeLib *tl;
1912   HRESULT hres;
1913
1914   TRACE("(iTInfo=%d, lcid=%04x, %p)\n", iTInfo, (int)lcid, ppTInfo);
1915
1916   if (iTInfo != 0)
1917     return E_FAIL;
1918
1919   hres = LoadTypeLib(stdole2tlb, &tl);
1920   if (FAILED(hres))
1921   {
1922     ERR("Could not load stdole2.tlb\n");
1923     return hres;
1924   }
1925
1926   hres = ITypeLib_GetTypeInfoOfGuid(tl, &IID_IPictureDisp, ppTInfo);
1927   if (FAILED(hres))
1928     ERR("Did not get IPictureDisp typeinfo from typelib, hres %x\n", hres);
1929
1930   return hres;
1931 }
1932
1933 /************************************************************************
1934  * OLEPictureImpl_GetIDsOfNames (IDispatch)
1935  *
1936  * See Windows documentation for more details on IDispatch methods.
1937  */
1938 static HRESULT WINAPI OLEPictureImpl_GetIDsOfNames(
1939   IDispatch*  iface,
1940   REFIID      riid,
1941   LPOLESTR* rgszNames,
1942   UINT      cNames,
1943   LCID        lcid,
1944   DISPID*     rgDispId)
1945 {
1946   ITypeInfo * pTInfo;
1947   HRESULT hres;
1948
1949   TRACE("(%p,%s,%p,cNames=%d,lcid=%04x,%p)\n", iface, debugstr_guid(riid),
1950         rgszNames, cNames, (int)lcid, rgDispId);
1951
1952   if (cNames == 0)
1953   {
1954     return E_INVALIDARG;
1955   }
1956   else
1957   {
1958     /* retrieve type information */
1959     hres = OLEPictureImpl_GetTypeInfo(iface, 0, lcid, &pTInfo);
1960
1961     if (FAILED(hres))
1962     {
1963       ERR("GetTypeInfo failed.\n");
1964       return hres;
1965     }
1966
1967     /* convert names to DISPIDs */
1968     hres = DispGetIDsOfNames (pTInfo, rgszNames, cNames, rgDispId);
1969     ITypeInfo_Release(pTInfo);
1970
1971     return hres;
1972   }
1973 }
1974
1975 /************************************************************************
1976  * OLEPictureImpl_Invoke (IDispatch)
1977  *
1978  * See Windows documentation for more details on IDispatch methods.
1979  */
1980 static HRESULT WINAPI OLEPictureImpl_Invoke(
1981   IDispatch*  iface,
1982   DISPID      dispIdMember,
1983   REFIID      riid,
1984   LCID        lcid,
1985   WORD        wFlags,
1986   DISPPARAMS* pDispParams,
1987   VARIANT*    pVarResult,
1988   EXCEPINFO*  pExepInfo,
1989   UINT*     puArgErr)
1990 {
1991   OLEPictureImpl *This = impl_from_IDispatch(iface);
1992
1993   /* validate parameters */
1994
1995   if (!IsEqualIID(riid, &IID_NULL))
1996   {
1997     ERR("riid was %s instead of IID_NULL\n", debugstr_guid(riid));
1998     return DISP_E_UNKNOWNNAME;
1999   }
2000
2001   if (!pDispParams)
2002   {
2003     ERR("null pDispParams not allowed\n");
2004     return DISP_E_PARAMNOTOPTIONAL;
2005   }
2006
2007   if (wFlags & DISPATCH_PROPERTYGET)
2008   {
2009     if (pDispParams->cArgs != 0)
2010     {
2011       ERR("param count for DISPATCH_PROPERTYGET was %d instead of 0\n", pDispParams->cArgs);
2012       return DISP_E_BADPARAMCOUNT;
2013     }
2014     if (!pVarResult)
2015     {
2016       ERR("null pVarResult not allowed when DISPATCH_PROPERTYGET specified\n");
2017       return DISP_E_PARAMNOTOPTIONAL;
2018     }
2019   }
2020   else if (wFlags & DISPATCH_PROPERTYPUT)
2021   {
2022     if (pDispParams->cArgs != 1)
2023     {
2024       ERR("param count for DISPATCH_PROPERTYPUT was %d instead of 1\n", pDispParams->cArgs);
2025       return DISP_E_BADPARAMCOUNT;
2026     }
2027   }
2028
2029   switch (dispIdMember)
2030   {
2031   case DISPID_PICT_HANDLE:
2032     if (wFlags & DISPATCH_PROPERTYGET)
2033     {
2034       TRACE("DISPID_PICT_HANDLE\n");
2035       V_VT(pVarResult) = VT_I4;
2036       return IPicture_get_Handle(&This->IPicture_iface, &V_UINT(pVarResult));
2037     }
2038     break;
2039   case DISPID_PICT_HPAL:
2040     if (wFlags & DISPATCH_PROPERTYGET)
2041     {
2042       TRACE("DISPID_PICT_HPAL\n");
2043       V_VT(pVarResult) = VT_I4;
2044       return IPicture_get_hPal(&This->IPicture_iface, &V_UINT(pVarResult));
2045     }
2046     else if (wFlags & DISPATCH_PROPERTYPUT)
2047     {
2048       VARIANTARG vararg;
2049       HRESULT hr;
2050       TRACE("DISPID_PICT_HPAL\n");
2051
2052       VariantInit(&vararg);
2053       hr = VariantChangeTypeEx(&vararg, &pDispParams->rgvarg[0], lcid, 0, VT_I4);
2054       if (FAILED(hr))
2055         return hr;
2056
2057       hr = IPicture_set_hPal(&This->IPicture_iface, V_I4(&vararg));
2058
2059       VariantClear(&vararg);
2060       return hr;
2061     }
2062     break;
2063   case DISPID_PICT_TYPE:
2064     if (wFlags & DISPATCH_PROPERTYGET)
2065     {
2066       TRACE("DISPID_PICT_TYPE\n");
2067       V_VT(pVarResult) = VT_I2;
2068       return OLEPictureImpl_get_Type(&This->IPicture_iface, &V_I2(pVarResult));
2069     }
2070     break;
2071   case DISPID_PICT_WIDTH:
2072     if (wFlags & DISPATCH_PROPERTYGET)
2073     {
2074       TRACE("DISPID_PICT_WIDTH\n");
2075       V_VT(pVarResult) = VT_I4;
2076       return IPicture_get_Width(&This->IPicture_iface, &V_I4(pVarResult));
2077     }
2078     break;
2079   case DISPID_PICT_HEIGHT:
2080     if (wFlags & DISPATCH_PROPERTYGET)
2081     {
2082       TRACE("DISPID_PICT_HEIGHT\n");
2083       V_VT(pVarResult) = VT_I4;
2084       return IPicture_get_Height(&This->IPicture_iface, &V_I4(pVarResult));
2085     }
2086     break;
2087   }
2088
2089   ERR("invalid dispid 0x%x or wFlags 0x%x\n", dispIdMember, wFlags);
2090   return DISP_E_MEMBERNOTFOUND;
2091 }
2092
2093
2094 static const IPictureVtbl OLEPictureImpl_VTable =
2095 {
2096   OLEPictureImpl_QueryInterface,
2097   OLEPictureImpl_AddRef,
2098   OLEPictureImpl_Release,
2099   OLEPictureImpl_get_Handle,
2100   OLEPictureImpl_get_hPal,
2101   OLEPictureImpl_get_Type,
2102   OLEPictureImpl_get_Width,
2103   OLEPictureImpl_get_Height,
2104   OLEPictureImpl_Render,
2105   OLEPictureImpl_set_hPal,
2106   OLEPictureImpl_get_CurDC,
2107   OLEPictureImpl_SelectPicture,
2108   OLEPictureImpl_get_KeepOriginalFormat,
2109   OLEPictureImpl_put_KeepOriginalFormat,
2110   OLEPictureImpl_PictureChanged,
2111   OLEPictureImpl_SaveAsFile,
2112   OLEPictureImpl_get_Attributes
2113 };
2114
2115 static const IDispatchVtbl OLEPictureImpl_IDispatch_VTable =
2116 {
2117   OLEPictureImpl_IDispatch_QueryInterface,
2118   OLEPictureImpl_IDispatch_AddRef,
2119   OLEPictureImpl_IDispatch_Release,
2120   OLEPictureImpl_GetTypeInfoCount,
2121   OLEPictureImpl_GetTypeInfo,
2122   OLEPictureImpl_GetIDsOfNames,
2123   OLEPictureImpl_Invoke
2124 };
2125
2126 static const IPersistStreamVtbl OLEPictureImpl_IPersistStream_VTable =
2127 {
2128   OLEPictureImpl_IPersistStream_QueryInterface,
2129   OLEPictureImpl_IPersistStream_AddRef,
2130   OLEPictureImpl_IPersistStream_Release,
2131   OLEPictureImpl_GetClassID,
2132   OLEPictureImpl_IsDirty,
2133   OLEPictureImpl_Load,
2134   OLEPictureImpl_Save,
2135   OLEPictureImpl_GetSizeMax
2136 };
2137
2138 static const IConnectionPointContainerVtbl OLEPictureImpl_IConnectionPointContainer_VTable =
2139 {
2140   OLEPictureImpl_IConnectionPointContainer_QueryInterface,
2141   OLEPictureImpl_IConnectionPointContainer_AddRef,
2142   OLEPictureImpl_IConnectionPointContainer_Release,
2143   OLEPictureImpl_EnumConnectionPoints,
2144   OLEPictureImpl_FindConnectionPoint
2145 };
2146
2147 /***********************************************************************
2148  * OleCreatePictureIndirect (OLEAUT32.419)
2149  */
2150 HRESULT WINAPI OleCreatePictureIndirect(LPPICTDESC lpPictDesc, REFIID riid,
2151                             BOOL Own, void **ppvObj )
2152 {
2153   OLEPictureImpl* newPict;
2154   HRESULT hr;
2155
2156   TRACE("(%p,%s,%d,%p)\n", lpPictDesc, debugstr_guid(riid), Own, ppvObj);
2157
2158   *ppvObj = NULL;
2159
2160   newPict = OLEPictureImpl_Construct(lpPictDesc, Own);
2161
2162   if (newPict == NULL)
2163     return E_OUTOFMEMORY;
2164
2165   /*
2166    * Make sure it supports the interface required by the caller.
2167    */
2168   hr = IPicture_QueryInterface(&newPict->IPicture_iface, riid, ppvObj);
2169
2170   /*
2171    * Release the reference obtained in the constructor. If
2172    * the QueryInterface was unsuccessful, it will free the class.
2173    */
2174   IPicture_Release(&newPict->IPicture_iface);
2175
2176   return hr;
2177 }
2178
2179
2180 /***********************************************************************
2181  * OleLoadPicture (OLEAUT32.418)
2182  */
2183 HRESULT WINAPI OleLoadPicture( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
2184                             REFIID riid, LPVOID *ppvObj )
2185 {
2186   LPPERSISTSTREAM ps;
2187   IPicture      *newpic;
2188   HRESULT hr;
2189
2190   TRACE("(%p,%d,%d,%s,%p), partially implemented.\n",
2191         lpstream, lSize, fRunmode, debugstr_guid(riid), ppvObj);
2192
2193   hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
2194   if (hr != S_OK)
2195     return hr;
2196   hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
2197   if (hr != S_OK) {
2198       ERR("Could not get IPersistStream iface from Ole Picture?\n");
2199       IPicture_Release(newpic);
2200       *ppvObj = NULL;
2201       return hr;
2202   }
2203   hr = IPersistStream_Load(ps,lpstream);
2204   IPersistStream_Release(ps);
2205   if (FAILED(hr))
2206   {
2207       ERR("IPersistStream_Load failed\n");
2208       IPicture_Release(newpic);
2209       *ppvObj = NULL;
2210       return hr;
2211   }
2212   hr = IPicture_QueryInterface(newpic,riid,ppvObj);
2213   if (hr != S_OK)
2214       ERR("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
2215   IPicture_Release(newpic);
2216   return hr;
2217 }
2218
2219 /***********************************************************************
2220  * OleLoadPictureEx (OLEAUT32.401)
2221  */
2222 HRESULT WINAPI OleLoadPictureEx( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
2223                             REFIID riid, DWORD xsiz, DWORD ysiz, DWORD flags, LPVOID *ppvObj )
2224 {
2225   LPPERSISTSTREAM ps;
2226   IPicture      *newpic;
2227   HRESULT hr;
2228
2229   FIXME("(%p,%d,%d,%s,x=%d,y=%d,f=%x,%p), partially implemented.\n",
2230         lpstream, lSize, fRunmode, debugstr_guid(riid), xsiz, ysiz, flags, ppvObj);
2231
2232   hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
2233   if (hr != S_OK)
2234     return hr;
2235   hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
2236   if (hr != S_OK) {
2237       ERR("Could not get IPersistStream iface from Ole Picture?\n");
2238       IPicture_Release(newpic);
2239       *ppvObj = NULL;
2240       return hr;
2241   }
2242   hr = IPersistStream_Load(ps,lpstream);
2243   IPersistStream_Release(ps);
2244   if (FAILED(hr))
2245   {
2246       ERR("IPersistStream_Load failed\n");
2247       IPicture_Release(newpic);
2248       *ppvObj = NULL;
2249       return hr;
2250   }
2251   hr = IPicture_QueryInterface(newpic,riid,ppvObj);
2252   if (hr != S_OK)
2253       ERR("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
2254   IPicture_Release(newpic);
2255   return hr;
2256 }
2257
2258 /***********************************************************************
2259  * OleLoadPicturePath (OLEAUT32.424)
2260  */
2261 HRESULT WINAPI OleLoadPicturePath( LPOLESTR szURLorPath, LPUNKNOWN punkCaller,
2262                 DWORD dwReserved, OLE_COLOR clrReserved, REFIID riid,
2263                 LPVOID *ppvRet )
2264 {
2265   static const WCHAR file[] = { 'f','i','l','e',':',0 };
2266   IPicture *ipicture;
2267   HANDLE hFile;
2268   DWORD dwFileSize;
2269   HGLOBAL hGlobal = NULL;
2270   DWORD dwBytesRead = 0;
2271   IStream *stream;
2272   BOOL bRead;
2273   IPersistStream *pStream;
2274   HRESULT hRes;
2275   HRESULT init_res;
2276   WCHAR *file_candidate;
2277   WCHAR path_buf[MAX_PATH];
2278
2279   TRACE("(%s,%p,%d,%08x,%s,%p): stub\n",
2280         debugstr_w(szURLorPath), punkCaller, dwReserved, clrReserved,
2281         debugstr_guid(riid), ppvRet);
2282
2283   if (!szURLorPath || !ppvRet)
2284       return E_INVALIDARG;
2285
2286   *ppvRet = NULL;
2287
2288   /* Convert file URLs to DOS paths. */
2289   if (strncmpW(szURLorPath, file, 5) == 0) {
2290       DWORD size;
2291       hRes = CoInternetParseUrl(szURLorPath, PARSE_PATH_FROM_URL, 0, path_buf,
2292                                 sizeof(path_buf)/sizeof(WCHAR), &size, 0);
2293       if (FAILED(hRes))
2294           return hRes;
2295
2296       file_candidate = path_buf;
2297   }
2298   else
2299       file_candidate = szURLorPath;
2300
2301   /* Handle candidate DOS paths separately. */
2302   if (file_candidate[1] == ':') {
2303       hFile = CreateFileW(file_candidate, GENERIC_READ, 0, NULL, OPEN_EXISTING,
2304                           0, NULL);
2305       if (hFile == INVALID_HANDLE_VALUE)
2306           return INET_E_RESOURCE_NOT_FOUND;
2307
2308       dwFileSize = GetFileSize(hFile, NULL);
2309       if (dwFileSize != INVALID_FILE_SIZE )
2310       {
2311           hGlobal = GlobalAlloc(GMEM_FIXED,dwFileSize);
2312           if ( hGlobal)
2313           {
2314               bRead = ReadFile(hFile, hGlobal, dwFileSize, &dwBytesRead, NULL);
2315               if (!bRead)
2316               {
2317                   GlobalFree(hGlobal);
2318                   hGlobal = 0;
2319               }
2320           }
2321       }
2322       CloseHandle(hFile);
2323
2324       if (!hGlobal)
2325           return INET_E_RESOURCE_NOT_FOUND;
2326
2327       hRes = CreateStreamOnHGlobal(hGlobal, TRUE, &stream);
2328       if (FAILED(hRes))
2329       {
2330           GlobalFree(hGlobal);
2331           return hRes;
2332       }
2333   } else {
2334       IMoniker *pmnk;
2335       IBindCtx *pbc;
2336
2337       hRes = CreateBindCtx(0, &pbc);
2338       if (SUCCEEDED(hRes))
2339       {
2340           hRes = CreateURLMoniker(NULL, szURLorPath, &pmnk);
2341           if (SUCCEEDED(hRes))
2342           {
2343               hRes = IMoniker_BindToStorage(pmnk, pbc, NULL, &IID_IStream, (LPVOID*)&stream);
2344               IMoniker_Release(pmnk);
2345           }
2346           IBindCtx_Release(pbc);
2347       }
2348       if (FAILED(hRes))
2349           return hRes;
2350   }
2351
2352   init_res = CoInitialize(NULL);
2353
2354   hRes = CoCreateInstance(&CLSID_StdPicture, punkCaller, CLSCTX_INPROC_SERVER,
2355                           &IID_IPicture, (LPVOID*)&ipicture);
2356   if (SUCCEEDED(hRes)) {
2357       hRes = IPicture_QueryInterface(ipicture, &IID_IPersistStream, (LPVOID*)&pStream);
2358
2359       if (SUCCEEDED(hRes)) {
2360           hRes = IPersistStream_Load(pStream, stream);
2361
2362           if (SUCCEEDED(hRes)) {
2363               hRes = IPicture_QueryInterface(ipicture, riid, ppvRet);
2364
2365               if (FAILED(hRes))
2366                   ERR("Failed to get interface %s from IPicture.\n", debugstr_guid(riid));
2367           }
2368           IPersistStream_Release(pStream);
2369       }
2370       IPicture_Release(ipicture);
2371   }
2372
2373   IStream_Release(stream);
2374
2375   if (SUCCEEDED(init_res))
2376       CoUninitialize();
2377
2378   return hRes;
2379 }
2380
2381 /*******************************************************************************
2382  * StdPic ClassFactory
2383  */
2384 typedef struct
2385 {
2386     /* IUnknown fields */
2387     IClassFactory IClassFactory_iface;
2388     LONG          ref;
2389 } IClassFactoryImpl;
2390
2391 static inline IClassFactoryImpl *impl_from_IClassFactory(IClassFactory *iface)
2392 {
2393        return CONTAINING_RECORD(iface, IClassFactoryImpl, IClassFactory_iface);
2394 }
2395
2396 static HRESULT WINAPI
2397 SPCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
2398         IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2399
2400         FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
2401         return E_NOINTERFACE;
2402 }
2403
2404 static ULONG WINAPI
2405 SPCF_AddRef(LPCLASSFACTORY iface) {
2406         IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2407         return InterlockedIncrement(&This->ref);
2408 }
2409
2410 static ULONG WINAPI SPCF_Release(LPCLASSFACTORY iface) {
2411         IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2412         /* static class, won't be  freed */
2413         return InterlockedDecrement(&This->ref);
2414 }
2415
2416 static HRESULT WINAPI SPCF_CreateInstance(
2417         LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
2418 ) {
2419     /* Creates an uninitialized picture */
2420     return OleCreatePictureIndirect(NULL,riid,TRUE,ppobj);
2421
2422 }
2423
2424 static HRESULT WINAPI SPCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
2425         IClassFactoryImpl *This = impl_from_IClassFactory(iface);
2426         FIXME("(%p)->(%d),stub!\n",This,dolock);
2427         return S_OK;
2428 }
2429
2430 static const IClassFactoryVtbl SPCF_Vtbl = {
2431         SPCF_QueryInterface,
2432         SPCF_AddRef,
2433         SPCF_Release,
2434         SPCF_CreateInstance,
2435         SPCF_LockServer
2436 };
2437 static IClassFactoryImpl STDPIC_CF = {{&SPCF_Vtbl}, 1 };
2438
2439 void _get_STDPIC_CF(LPVOID *ppv) { *ppv = &STDPIC_CF; }