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