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  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  * BUGS
  24  *
  25  * Support PICTYPE_BITMAP and PICTYPE_ICON, altough only bitmaps very well..
  26  * Lots of methods are just stubs.
  27  *
  28  *
  29  * NOTES (or things that msdn doesn't tell you)
  30  *
  31  * The width and height properties are returned in HIMETRIC units (0.01mm)
  32  * IPicture::Render also uses these to select a region of the src picture.
  33  * A bitmap's size is converted into these units by using the screen resolution
  34  * thus an 8x8 bitmap on a 96dpi screen has a size of 212x212 (8/96 * 2540).
  35  *
  36  */
  37
  38 #include "config.h"
  39
  40 #ifdef HAVE_UNISTD_H
  41 # include <unistd.h>
  42 #endif
  43 #include <stdio.h>
  44 #include <string.h>
  45
  46 /* Must be before wine includes, the header has things conflicting with
  47  * WINE headers.
  48  */
  49 #ifdef HAVE_LIBGIF
  50 # include <gif_lib.h>
  51 #endif
  52
  53 #define NONAMELESSUNION
  54 #define NONAMELESSSTRUCT
  55 #include "winerror.h"
  56 #include "winbase.h"
  57 #include "wingdi.h"
  58 #include "winuser.h"
  59 #include "ole2.h"
  60 #include "olectl.h"
  61 #include "oleauto.h"
  62 #include "wine/obj_picture.h"
  63 #include "wine/obj_connection.h"
  64 #include "connpt.h"
  65 #include "wine/debug.h"
  66
  67 #include "wine/wingdi16.h"
  68 #include "cursoricon.h"
  69
  70 #ifdef HAVE_LIBJPEG
  71 /* This is a hack, so jpeglib.h does not redefine INT32 and the like*/
  72 #define XMD_H
  73 #define UINT8 JPEG_UINT8
  74 #define UINT16 JPEG_UINT16
  75 #ifdef HAVE_JPEGLIB_H
  76 # include <jpeglib.h>
  77 #endif
  78 #undef UINT16
  79 #endif
  80
  81 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  82
  83 /*************************************************************************
  84  *  Declaration of implementation class
  85  */
  86
  87 typedef struct OLEPictureImpl {
  88
  89   /*
  90    * IPicture handles IUnknown
  91    */
  92
  93     ICOM_VTABLE(IPicture)       *lpvtbl1;
  94     ICOM_VTABLE(IDispatch)      *lpvtbl2;
  95     ICOM_VTABLE(IPersistStream) *lpvtbl3;
  96     ICOM_VTABLE(IConnectionPointContainer) *lpvtbl4;
  97
  98   /* Object referenece count */
  99     DWORD ref;
 100
 101   /* We own the object and must destroy it ourselves */
 102     BOOL fOwn;
 103
 104   /* Picture description */
 105     PICTDESC desc;
 106
 107   /* These are the pixel size of a bitmap */
 108     DWORD origWidth;
 109     DWORD origHeight;
 110
 111   /* And these are the size of the picture converted into HIMETRIC units */
 112     OLE_XSIZE_HIMETRIC himetricWidth;
 113     OLE_YSIZE_HIMETRIC himetricHeight;
 114
 115     IConnectionPoint *pCP;
 116
 117     BOOL keepOrigFormat;
 118     HDC hDCCur;
 119
 120   /* data */
 121     void* data;
 122     int datalen;
 123 } OLEPictureImpl;
 124
 125 /*
 126  * Macros to retrieve pointer to IUnknown (IPicture) from the other VTables.
 127  */
 128 #define ICOM_THIS_From_IDispatch(impl, name) \
 129     impl *This = (impl*)(((char*)name)-sizeof(void*));
 130 #define ICOM_THIS_From_IPersistStream(impl, name) \
 131     impl *This = (impl*)(((char*)name)-2*sizeof(void*));
 132 #define ICOM_THIS_From_IConnectionPointContainer(impl, name) \
 133     impl *This = (impl*)(((char*)name)-3*sizeof(void*));
 134
 135 /*
 136  * Predeclare VTables.  They get initialized at the end.
 137  */
 138 static ICOM_VTABLE(IPicture) OLEPictureImpl_VTable;
 139 static ICOM_VTABLE(IDispatch) OLEPictureImpl_IDispatch_VTable;
 140 static ICOM_VTABLE(IPersistStream) OLEPictureImpl_IPersistStream_VTable;
 141 static ICOM_VTABLE(IConnectionPointContainer) OLEPictureImpl_IConnectionPointContainer_VTable;
 142
 143 /***********************************************************************
 144  * Implementation of the OLEPictureImpl class.
 145  */
 146
 147 static void OLEPictureImpl_SetBitmap(OLEPictureImpl*This) {
 148   BITMAP bm;
 149   HDC hdcRef;
 150
 151   TRACE("bitmap handle %p\n", This->desc.u.bmp.hbitmap);
 152   if(GetObjectA(This->desc.u.bmp.hbitmap, sizeof(bm), &bm) != sizeof(bm)) {
 153     ERR("GetObject fails\n");
 154     return;
 155   }
 156   This->origWidth = bm.bmWidth;
 157   This->origHeight = bm.bmHeight;
 158   /* The width and height are stored in HIMETRIC units (0.01 mm),
 159      so we take our pixel width divide by pixels per inch and
 160      multiply by 25.4 * 100 */
 161   /* Should we use GetBitmapDimension if available? */
 162   hdcRef = CreateCompatibleDC(0);
 163   This->himetricWidth =(bm.bmWidth *2540)/GetDeviceCaps(hdcRef, LOGPIXELSX);
 164   This->himetricHeight=(bm.bmHeight*2540)/GetDeviceCaps(hdcRef, LOGPIXELSY);
 165   DeleteDC(hdcRef);
 166 }
 167
 168 /************************************************************************
 169  * OLEPictureImpl_Construct
 170  *
 171  * This method will construct a new instance of the OLEPictureImpl
 172  * class.
 173  *
 174  * The caller of this method must release the object when it's
 175  * done with it.
 176  */
 177 static OLEPictureImpl* OLEPictureImpl_Construct(LPPICTDESC pictDesc, BOOL fOwn)
 178 {
 179   OLEPictureImpl* newObject = 0;
 180
 181   if (pictDesc)
 182       TRACE("(%p) type = %d\n", pictDesc, pictDesc->picType);
 183
 184   /*
 185    * Allocate space for the object.
 186    */
 187   newObject = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(OLEPictureImpl));
 188
 189   if (newObject==0)
 190     return newObject;
 191
 192   /*
 193    * Initialize the virtual function table.
 194    */
 195   newObject->lpvtbl1 = &OLEPictureImpl_VTable;
 196   newObject->lpvtbl2 = &OLEPictureImpl_IDispatch_VTable;
 197   newObject->lpvtbl3 = &OLEPictureImpl_IPersistStream_VTable;
 198   newObject->lpvtbl4 = &OLEPictureImpl_IConnectionPointContainer_VTable;
 199
 200   CreateConnectionPoint((IUnknown*)newObject,&IID_IPropertyNotifySink,&newObject->pCP);
 201
 202   /*
 203    * Start with one reference count. The caller of this function
 204    * must release the interface pointer when it is done.
 205    */
 206   newObject->ref        = 1;
 207   newObject->hDCCur     = 0;
 208
 209   newObject->fOwn       = fOwn;
 210
 211   /* dunno about original value */
 212   newObject->keepOrigFormat = TRUE;
 213
 214   if (pictDesc) {
 215       if(pictDesc->cbSizeofstruct != sizeof(PICTDESC)) {
 216           FIXME("struct size = %d\n", pictDesc->cbSizeofstruct);
 217       }
 218       memcpy(&newObject->desc, pictDesc, sizeof(PICTDESC));
 219
 220
 221       switch(pictDesc->picType) {
 222       case PICTYPE_BITMAP:
 223         OLEPictureImpl_SetBitmap(newObject);
 224         break;
 225
 226       case PICTYPE_METAFILE:
 227         TRACE("metafile handle %p\n", pictDesc->u.wmf.hmeta);
 228         newObject->himetricWidth = pictDesc->u.wmf.xExt;
 229         newObject->himetricHeight = pictDesc->u.wmf.yExt;
 230         break;
 231
 232       case PICTYPE_NONE:
 233         /* not sure what to do here */
 234         newObject->himetricWidth = newObject->himetricHeight = 0;
 235         break;
 236
 237       case PICTYPE_ICON:
 238       case PICTYPE_ENHMETAFILE:
 239       default:
 240         FIXME("Unsupported type %d\n", pictDesc->picType);
 241         newObject->himetricWidth = newObject->himetricHeight = 0;
 242         break;
 243       }
 244   } else {
 245       newObject->desc.picType = PICTYPE_UNINITIALIZED;
 246   }
 247
 248   TRACE("returning %p\n", newObject);
 249   return newObject;
 250 }
 251
 252 /************************************************************************
 253  * OLEPictureImpl_Destroy
 254  *
 255  * This method is called by the Release method when the reference
 256  * count goes down to 0. It will free all resources used by
 257  * this object.  */
 258 static void OLEPictureImpl_Destroy(OLEPictureImpl* Obj)
 259 {
 260   TRACE("(%p)\n", Obj);
 261
 262   if(Obj->fOwn) { /* We need to destroy the picture */
 263     switch(Obj->desc.picType) {
 264     case PICTYPE_BITMAP:
 265       DeleteObject(Obj->desc.u.bmp.hbitmap);
 266       break;
 267     case PICTYPE_METAFILE:
 268       DeleteMetaFile(Obj->desc.u.wmf.hmeta);
 269       break;
 270     case PICTYPE_ICON:
 271       DestroyIcon(Obj->desc.u.icon.hicon);
 272       break;
 273     case PICTYPE_ENHMETAFILE:
 274       DeleteEnhMetaFile(Obj->desc.u.emf.hemf);
 275       break;
 276     default:
 277       FIXME("Unsupported type %d - unable to delete\n", Obj->desc.picType);
 278       break;
 279     }
 280   }
 281   if (Obj->data) HeapFree(GetProcessHeap(), 0, Obj->data);
 282   HeapFree(GetProcessHeap(), 0, Obj);
 283 }
 284
 285 static ULONG WINAPI OLEPictureImpl_AddRef(IPicture* iface);
 286
 287 /************************************************************************
 288  * OLEPictureImpl_QueryInterface (IUnknown)
 289  *
 290  * See Windows documentation for more details on IUnknown methods.
 291  */
 292 static HRESULT WINAPI OLEPictureImpl_QueryInterface(
 293   IPicture*  iface,
 294   REFIID  riid,
 295   void**  ppvObject)
 296 {
 297   ICOM_THIS(OLEPictureImpl, iface);
 298   TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 299
 300   /*
 301    * Perform a sanity check on the parameters.
 302    */
 303   if ( (This==0) || (ppvObject==0) )
 304     return E_INVALIDARG;
 305
 306   /*
 307    * Initialize the return parameter.
 308    */
 309   *ppvObject = 0;
 310
 311   /*
 312    * Compare the riid with the interface IDs implemented by this object.
 313    */
 314   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
 315   {
 316     *ppvObject = (IPicture*)This;
 317   }
 318   else if (memcmp(&IID_IPicture, riid, sizeof(IID_IPicture)) == 0)
 319   {
 320     *ppvObject = (IPicture*)This;
 321   }
 322   else if (memcmp(&IID_IDispatch, riid, sizeof(IID_IDispatch)) == 0)
 323   {
 324     *ppvObject = (IDispatch*)&(This->lpvtbl2);
 325   }
 326   else if (memcmp(&IID_IPictureDisp, riid, sizeof(IID_IPictureDisp)) == 0)
 327   {
 328     *ppvObject = (IDispatch*)&(This->lpvtbl2);
 329   }
 330   else if (memcmp(&IID_IPersistStream, riid, sizeof(IID_IPersistStream)) == 0)
 331   {
 332   *ppvObject = (IPersistStream*)&(This->lpvtbl3);
 333   }
 334   else if (memcmp(&IID_IConnectionPointContainer, riid, sizeof(IID_IConnectionPointContainer)) == 0)
 335   {
 336   *ppvObject = (IConnectionPointContainer*)&(This->lpvtbl4);
 337   }
 338   /*
 339    * Check that we obtained an interface.
 340    */
 341   if ((*ppvObject)==0)
 342   {
 343     FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid));
 344     return E_NOINTERFACE;
 345   }
 346
 347   /*
 348    * Query Interface always increases the reference count by one when it is
 349    * successful
 350    */
 351   OLEPictureImpl_AddRef((IPicture*)This);
 352
 353   return S_OK;
 354 }
 355 /***********************************************************************
 356  *    OLEPicture_SendNotify (internal)
 357  *
 358  * Sends notification messages of changed properties to any interested
 359  * connections.
 360  */
 361 static void OLEPicture_SendNotify(OLEPictureImpl* this, DISPID dispID)
 362 {
 363   IEnumConnections *pEnum;
 364   CONNECTDATA CD;
 365
 366   if (IConnectionPoint_EnumConnections(this->pCP, &pEnum))
 367       return;
 368   while(IEnumConnections_Next(pEnum, 1, &CD, NULL) == S_OK) {
 369     IPropertyNotifySink *sink;
 370
 371     IUnknown_QueryInterface(CD.pUnk, &IID_IPropertyNotifySink, (LPVOID)&sink);
 372     IPropertyNotifySink_OnChanged(sink, dispID);
 373     IPropertyNotifySink_Release(sink);
 374     IUnknown_Release(CD.pUnk);
 375   }
 376   IEnumConnections_Release(pEnum);
 377   return;
 378 }
 379
 380 /************************************************************************
 381  * OLEPictureImpl_AddRef (IUnknown)
 382  *
 383  * See Windows documentation for more details on IUnknown methods.
 384  */
 385 static ULONG WINAPI OLEPictureImpl_AddRef(
 386   IPicture* iface)
 387 {
 388   ICOM_THIS(OLEPictureImpl, iface);
 389   TRACE("(%p)->(ref=%ld)\n", This, This->ref);
 390   This->ref++;
 391
 392   return This->ref;
 393 }
 394
 395 /************************************************************************
 396  * OLEPictureImpl_Release (IUnknown)
 397  *
 398  * See Windows documentation for more details on IUnknown methods.
 399  */
 400 static ULONG WINAPI OLEPictureImpl_Release(
 401       IPicture* iface)
 402 {
 403   ICOM_THIS(OLEPictureImpl, iface);
 404   TRACE("(%p)->(ref=%ld)\n", This, This->ref);
 405
 406   /*
 407    * Decrease the reference count on this object.
 408    */
 409   This->ref--;
 410
 411   /*
 412    * If the reference count goes down to 0, perform suicide.
 413    */
 414   if (This->ref==0)
 415   {
 416     OLEPictureImpl_Destroy(This);
 417
 418     return 0;
 419   }
 420
 421   return This->ref;
 422 }
 423
 424
 425 /************************************************************************
 426  * OLEPictureImpl_get_Handle
 427  */
 428 static HRESULT WINAPI OLEPictureImpl_get_Handle(IPicture *iface,
 429                                                 OLE_HANDLE *phandle)
 430 {
 431   ICOM_THIS(OLEPictureImpl, iface);
 432   TRACE("(%p)->(%p)\n", This, phandle);
 433   switch(This->desc.picType) {
 434   case PICTYPE_BITMAP:
 435     *phandle = (OLE_HANDLE)This->desc.u.bmp.hbitmap;
 436     break;
 437   case PICTYPE_METAFILE:
 438     *phandle = (OLE_HANDLE)This->desc.u.wmf.hmeta;
 439     break;
 440   case PICTYPE_ICON:
 441     *phandle = (OLE_HANDLE)This->desc.u.icon.hicon;
 442     break;
 443   case PICTYPE_ENHMETAFILE:
 444     *phandle = (OLE_HANDLE)This->desc.u.emf.hemf;
 445     break;
 446   default:
 447     FIXME("Unimplemented type %d\n", This->desc.picType);
 448     return E_NOTIMPL;
 449   }
 450   TRACE("returning handle %08x\n", *phandle);
 451   return S_OK;
 452 }
 453
 454 /************************************************************************
 455  * OLEPictureImpl_get_hPal
 456  */
 457 static HRESULT WINAPI OLEPictureImpl_get_hPal(IPicture *iface,
 458                                               OLE_HANDLE *phandle)
 459 {
 460   ICOM_THIS(OLEPictureImpl, iface);
 461   FIXME("(%p)->(%p): stub\n", This, phandle);
 462   return E_NOTIMPL;
 463 }
 464
 465 /************************************************************************
 466  * OLEPictureImpl_get_Type
 467  */
 468 static HRESULT WINAPI OLEPictureImpl_get_Type(IPicture *iface,
 469                                               short *ptype)
 470 {
 471   ICOM_THIS(OLEPictureImpl, iface);
 472   TRACE("(%p)->(%p): type is %d\n", This, ptype, This->desc.picType);
 473   *ptype = This->desc.picType;
 474   return S_OK;
 475 }
 476
 477 /************************************************************************
 478  * OLEPictureImpl_get_Width
 479  */
 480 static HRESULT WINAPI OLEPictureImpl_get_Width(IPicture *iface,
 481                                                OLE_XSIZE_HIMETRIC *pwidth)
 482 {
 483   ICOM_THIS(OLEPictureImpl, iface);
 484   TRACE("(%p)->(%p): width is %ld\n", This, pwidth, This->himetricWidth);
 485   *pwidth = This->himetricWidth;
 486   return S_OK;
 487 }
 488
 489 /************************************************************************
 490  * OLEPictureImpl_get_Height
 491  */
 492 static HRESULT WINAPI OLEPictureImpl_get_Height(IPicture *iface,
 493                                                 OLE_YSIZE_HIMETRIC *pheight)
 494 {
 495   ICOM_THIS(OLEPictureImpl, iface);
 496   TRACE("(%p)->(%p): height is %ld\n", This, pheight, This->himetricHeight);
 497   *pheight = This->himetricHeight;
 498   return S_OK;
 499 }
 500
 501 /************************************************************************
 502  * OLEPictureImpl_Render
 503  */
 504 static HRESULT WINAPI OLEPictureImpl_Render(IPicture *iface, HDC hdc,
 505                                             long x, long y, long cx, long cy,
 506                                             OLE_XPOS_HIMETRIC xSrc,
 507                                             OLE_YPOS_HIMETRIC ySrc,
 508                                             OLE_XSIZE_HIMETRIC cxSrc,
 509                                             OLE_YSIZE_HIMETRIC cySrc,
 510                                             LPCRECT prcWBounds)
 511 {
 512   ICOM_THIS(OLEPictureImpl, iface);
 513   TRACE("(%p)->(%p, (%ld,%ld), (%ld,%ld) <- (%ld,%ld), (%ld,%ld), %p)\n",
 514         This, hdc, x, y, cx, cy, xSrc, ySrc, cxSrc, cySrc, prcWBounds);
 515   if(prcWBounds)
 516     TRACE("prcWBounds (%ld,%ld) - (%ld,%ld)\n", prcWBounds->left, prcWBounds->top,
 517           prcWBounds->right, prcWBounds->bottom);
 518
 519   /*
 520    * While the documentation suggests this to be here (or after rendering?)
 521    * it does cause an endless recursion in my sample app. -MM 20010804
 522   OLEPicture_SendNotify(This,DISPID_PICT_RENDER);
 523    */
 524
 525   switch(This->desc.picType) {
 526   case PICTYPE_BITMAP:
 527     {
 528       HBITMAP hbmpOld;
 529       HDC hdcBmp;
 530
 531       /* Set a mapping mode that maps bitmap pixels into HIMETRIC units.
 532          NB y-axis gets flipped */
 533
 534       hdcBmp = CreateCompatibleDC(0);
 535       SetMapMode(hdcBmp, MM_ANISOTROPIC);
 536       SetWindowOrgEx(hdcBmp, 0, 0, NULL);
 537       SetWindowExtEx(hdcBmp, This->himetricWidth, This->himetricHeight, NULL);
 538       SetViewportOrgEx(hdcBmp, 0, This->origHeight, NULL);
 539       SetViewportExtEx(hdcBmp, This->origWidth, -This->origHeight, NULL);
 540
 541       hbmpOld = SelectObject(hdcBmp, This->desc.u.bmp.hbitmap);
 542
 543       StretchBlt(hdc, x, y, cx, cy, hdcBmp, xSrc, ySrc, cxSrc, cySrc, SRCCOPY);
 544
 545       SelectObject(hdcBmp, hbmpOld);
 546       DeleteDC(hdcBmp);
 547     }
 548     break;
 549   case PICTYPE_ICON:
 550     FIXME("Not quite correct implementation of rendering icons...\n");
 551     DrawIcon(hdc,x,y,This->desc.u.icon.hicon);
 552     break;
 553
 554   case PICTYPE_METAFILE:
 555   case PICTYPE_ENHMETAFILE:
 556   default:
 557     FIXME("type %d not implemented\n", This->desc.picType);
 558     return E_NOTIMPL;
 559   }
 560   return S_OK;
 561 }
 562
 563 /************************************************************************
 564  * OLEPictureImpl_set_hPal
 565  */
 566 static HRESULT WINAPI OLEPictureImpl_set_hPal(IPicture *iface,
 567                                               OLE_HANDLE hpal)
 568 {
 569   ICOM_THIS(OLEPictureImpl, iface);
 570   FIXME("(%p)->(%08x): stub\n", This, hpal);
 571   OLEPicture_SendNotify(This,DISPID_PICT_HPAL);
 572   return E_NOTIMPL;
 573 }
 574
 575 /************************************************************************
 576  * OLEPictureImpl_get_CurDC
 577  */
 578 static HRESULT WINAPI OLEPictureImpl_get_CurDC(IPicture *iface,
 579                                                HDC *phdc)
 580 {
 581   ICOM_THIS(OLEPictureImpl, iface);
 582   TRACE("(%p), returning %p\n", This, This->hDCCur);
 583   if (phdc) *phdc = This->hDCCur;
 584   return S_OK;
 585 }
 586
 587 /************************************************************************
 588  * OLEPictureImpl_SelectPicture
 589  */
 590 static HRESULT WINAPI OLEPictureImpl_SelectPicture(IPicture *iface,
 591                                                    HDC hdcIn,
 592                                                    HDC *phdcOut,
 593                                                    OLE_HANDLE *phbmpOut)
 594 {
 595   ICOM_THIS(OLEPictureImpl, iface);
 596   TRACE("(%p)->(%p, %p, %p)\n", This, hdcIn, phdcOut, phbmpOut);
 597   if (This->desc.picType == PICTYPE_BITMAP) {
 598       SelectObject(hdcIn,This->desc.u.bmp.hbitmap);
 599
 600       if (phdcOut)
 601           *phdcOut = This->hDCCur;
 602       This->hDCCur = hdcIn;
 603       if (phbmpOut)
 604           *phbmpOut = (OLE_HANDLE)This->desc.u.bmp.hbitmap;
 605       return S_OK;
 606   } else {
 607       FIXME("Don't know how to select picture type %d\n",This->desc.picType);
 608       return E_FAIL;
 609   }
 610 }
 611
 612 /************************************************************************
 613  * OLEPictureImpl_get_KeepOriginalFormat
 614  */
 615 static HRESULT WINAPI OLEPictureImpl_get_KeepOriginalFormat(IPicture *iface,
 616                                                             BOOL *pfKeep)
 617 {
 618   ICOM_THIS(OLEPictureImpl, iface);
 619   TRACE("(%p)->(%p)\n", This, pfKeep);
 620   if (!pfKeep)
 621       return E_POINTER;
 622   *pfKeep = This->keepOrigFormat;
 623   return S_OK;
 624 }
 625
 626 /************************************************************************
 627  * OLEPictureImpl_put_KeepOriginalFormat
 628  */
 629 static HRESULT WINAPI OLEPictureImpl_put_KeepOriginalFormat(IPicture *iface,
 630                                                             BOOL keep)
 631 {
 632   ICOM_THIS(OLEPictureImpl, iface);
 633   TRACE("(%p)->(%d)\n", This, keep);
 634   This->keepOrigFormat = keep;
 635   /* FIXME: what DISPID notification here? */
 636   return S_OK;
 637 }
 638
 639 /************************************************************************
 640  * OLEPictureImpl_PictureChanged
 641  */
 642 static HRESULT WINAPI OLEPictureImpl_PictureChanged(IPicture *iface)
 643 {
 644   ICOM_THIS(OLEPictureImpl, iface);
 645   TRACE("(%p)->()\n", This);
 646   OLEPicture_SendNotify(This,DISPID_PICT_HANDLE);
 647   return S_OK;
 648 }
 649
 650 /************************************************************************
 651  * OLEPictureImpl_SaveAsFile
 652  */
 653 static HRESULT WINAPI OLEPictureImpl_SaveAsFile(IPicture *iface,
 654                                                 IStream *pstream,
 655                                                 BOOL SaveMemCopy,
 656                                                 LONG *pcbSize)
 657 {
 658   ICOM_THIS(OLEPictureImpl, iface);
 659   FIXME("(%p)->(%p, %d, %p), hacked stub.\n", This, pstream, SaveMemCopy, pcbSize);
 660   return IStream_Write(pstream,This->data,This->datalen,(ULONG*)pcbSize);
 661 }
 662
 663 /************************************************************************
 664  * OLEPictureImpl_get_Attributes
 665  */
 666 static HRESULT WINAPI OLEPictureImpl_get_Attributes(IPicture *iface,
 667                                                     DWORD *pdwAttr)
 668 {
 669   ICOM_THIS(OLEPictureImpl, iface);
 670   TRACE("(%p)->(%p).\n", This, pdwAttr);
 671   *pdwAttr = 0;
 672   switch (This->desc.picType) {
 673   case PICTYPE_BITMAP:  break;  /* not 'truely' scalable, see MSDN. */
 674   case PICTYPE_ICON: *pdwAttr     = PICTURE_TRANSPARENT;break;
 675   case PICTYPE_METAFILE: *pdwAttr = PICTURE_TRANSPARENT|PICTURE_SCALABLE;break;
 676   default:FIXME("Unknown pictype %d\n",This->desc.picType);break;
 677   }
 678   return S_OK;
 679 }
 680
 681
 682 /************************************************************************
 683  *    IConnectionPointContainer
 684  */
 685
 686 static HRESULT WINAPI OLEPictureImpl_IConnectionPointContainer_QueryInterface(
 687   IConnectionPointContainer* iface,
 688   REFIID riid,
 689   VOID** ppvoid
 690 ) {
 691   ICOM_THIS_From_IConnectionPointContainer(IPicture,iface);
 692
 693   return IPicture_QueryInterface(This,riid,ppvoid);
 694 }
 695
 696 static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_AddRef(
 697   IConnectionPointContainer* iface)
 698 {
 699   ICOM_THIS_From_IConnectionPointContainer(IPicture, iface);
 700
 701   return IPicture_AddRef(This);
 702 }
 703
 704 static ULONG WINAPI OLEPictureImpl_IConnectionPointContainer_Release(
 705   IConnectionPointContainer* iface)
 706 {
 707   ICOM_THIS_From_IConnectionPointContainer(IPicture, iface);
 708
 709   return IPicture_Release(This);
 710 }
 711
 712 static HRESULT WINAPI OLEPictureImpl_EnumConnectionPoints(
 713   IConnectionPointContainer* iface,
 714   IEnumConnectionPoints** ppEnum
 715 ) {
 716   ICOM_THIS_From_IConnectionPointContainer(IPicture, iface);
 717
 718   FIXME("(%p,%p), stub!\n",This,ppEnum);
 719   return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI OLEPictureImpl_FindConnectionPoint(
 723   IConnectionPointContainer* iface,
 724   REFIID riid,
 725   IConnectionPoint **ppCP
 726 ) {
 727   ICOM_THIS_From_IConnectionPointContainer(OLEPictureImpl, iface);
 728   TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppCP);
 729   if (!ppCP)
 730       return E_POINTER;
 731   *ppCP = NULL;
 732   if (IsEqualGUID(riid,&IID_IPropertyNotifySink))
 733       return IConnectionPoint_QueryInterface(This->pCP,&IID_IConnectionPoint,(LPVOID)ppCP);
 734   FIXME("tried to find connection point on %s?\n",debugstr_guid(riid));
 735   return 0x80040200;
 736 }
 737 /************************************************************************
 738  *    IPersistStream
 739  */
 740 /************************************************************************
 741  * OLEPictureImpl_IPersistStream_QueryInterface (IUnknown)
 742  *
 743  * See Windows documentation for more details on IUnknown methods.
 744  */
 745 static HRESULT WINAPI OLEPictureImpl_IPersistStream_QueryInterface(
 746   IPersistStream* iface,
 747   REFIID     riid,
 748   VOID**     ppvoid)
 749 {
 750   ICOM_THIS_From_IPersistStream(IPicture, iface);
 751
 752   return IPicture_QueryInterface(This, riid, ppvoid);
 753 }
 754
 755 /************************************************************************
 756  * OLEPictureImpl_IPersistStream_AddRef (IUnknown)
 757  *
 758  * See Windows documentation for more details on IUnknown methods.
 759  */
 760 static ULONG WINAPI OLEPictureImpl_IPersistStream_AddRef(
 761   IPersistStream* iface)
 762 {
 763   ICOM_THIS_From_IPersistStream(IPicture, iface);
 764
 765   return IPicture_AddRef(This);
 766 }
 767
 768 /************************************************************************
 769  * OLEPictureImpl_IPersistStream_Release (IUnknown)
 770  *
 771  * See Windows documentation for more details on IUnknown methods.
 772  */
 773 static ULONG WINAPI OLEPictureImpl_IPersistStream_Release(
 774   IPersistStream* iface)
 775 {
 776   ICOM_THIS_From_IPersistStream(IPicture, iface);
 777
 778   return IPicture_Release(This);
 779 }
 780
 781 /************************************************************************
 782  * OLEPictureImpl_IPersistStream_GetClassID
 783  */
 784 static HRESULT WINAPI OLEPictureImpl_GetClassID(
 785   IPersistStream* iface,CLSID* pClassID)
 786 {
 787   ICOM_THIS_From_IPersistStream(IPicture, iface);
 788   FIXME("(%p),stub!\n",This);
 789   return E_NOTIMPL;
 790 }
 791
 792 /************************************************************************
 793  * OLEPictureImpl_IPersistStream_IsDirty
 794  */
 795 static HRESULT WINAPI OLEPictureImpl_IsDirty(
 796   IPersistStream* iface)
 797 {
 798   ICOM_THIS_From_IPersistStream(IPicture, iface);
 799   FIXME("(%p),stub!\n",This);
 800   return E_NOTIMPL;
 801 }
 802
 803 #ifdef HAVE_LIBJPEG
 804 /* for the jpeg decompressor source manager. */
 805 static void _jpeg_init_source(j_decompress_ptr cinfo) { }
 806
 807 static boolean _jpeg_fill_input_buffer(j_decompress_ptr cinfo) {
 808     ERR("(), should not get here.\n");
 809     return FALSE;
 810 }
 811
 812 static void _jpeg_skip_input_data(j_decompress_ptr cinfo,long num_bytes) {
 813     ERR("(%ld), should not get here.\n",num_bytes);
 814 }
 815
 816 static boolean _jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired) {
 817     ERR("(desired=%d), should not get here.\n",desired);
 818     return FALSE;
 819 }
 820 static void _jpeg_term_source(j_decompress_ptr cinfo) { }
 821 #endif /* HAVE_LIBJPEG */
 822
 823 #ifdef HAVE_LIBGIF
 824 struct gifdata {
 825     unsigned char *data;
 826     unsigned int curoff;
 827     unsigned int len;
 828 };
 829
 830 static int _gif_inputfunc(GifFileType *gif, GifByteType *data, int len) {
 831     struct gifdata *gd = (struct gifdata*)gif->UserData;
 832
 833     if (len+gd->curoff > gd->len) {
 834         FIXME("Trying to read %d bytes, but only %d available.\n",len, gd->len-gd->curoff);
 835         len = gd->len - gd->curoff;
 836     }
 837     memcpy(data, gd->data+gd->curoff, len);
 838     gd->curoff += len;
 839     return len;
 840 }
 841 #endif
 842
 843 /************************************************************************
 844  * OLEPictureImpl_IPersistStream_Load (IUnknown)
 845  *
 846  * Loads the binary data from the IStream. Starts at current position.
 847  * There appears to be an 2 DWORD header:
 848  *      DWORD magic;
 849  *      DWORD len;
 850  *
 851  * Currently implemented: BITMAP, ICON, JPEG.
 852  */
 853 static HRESULT WINAPI OLEPictureImpl_Load(IPersistStream* iface,IStream*pStm) {
 854   HRESULT       hr = E_FAIL;
 855   ULONG         xread;
 856   BYTE          *xbuf;
 857   DWORD         header[2];
 858   WORD          magic;
 859   STATSTG       statstg;
 860   ICOM_THIS_From_IPersistStream(OLEPictureImpl, iface);
 861
 862   TRACE("(%p,%p)\n",This,pStm);
 863
 864   /* Sometimes we have a header, sometimes we don't. Apply some guesses to find
 865    * out whether we do.
 866    */
 867   hr=IStream_Stat(pStm,&statstg,STATFLAG_NONAME);
 868   if (hr)
 869     FIXME("Stat failed with hres %lx\n",hr);
 870   hr=IStream_Read(pStm,header,8,&xread);
 871   if (hr || xread!=8) {
 872       FIXME("Failure while reading picture header (hr is %lx, nread is %ld).\n",hr,xread);
 873       return hr;
 874   }
 875   if (header[1] > statstg.cbSize.QuadPart) {/* Incorrect header, assume none. */
 876     xread = 8;
 877     xbuf = This->data = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,statstg.cbSize.QuadPart);
 878     memcpy(xbuf,&header,8);
 879     This->datalen = statstg.cbSize.QuadPart;
 880     while (xread < This->datalen) {
 881       ULONG nread;
 882       hr = IStream_Read(pStm,xbuf+xread,This->datalen-xread,&nread);
 883       xread+=nread;
 884       if (hr || !nread)
 885         break;
 886     }
 887     if (xread != This->datalen)
 888       FIXME("Could only read %ld of %d bytes in no-header case?\n",xread,This->datalen);
 889   } else {
 890     xread = 0;
 891     xbuf = This->data = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,header[1]);
 892     This->datalen = header[1];
 893     while (xread < header[1]) {
 894       ULONG nread;
 895       hr = IStream_Read(pStm,xbuf+xread,header[1]-xread,&nread);
 896       xread+=nread;
 897       if (hr || !nread)
 898         break;
 899     }
 900     if (xread != header[1])
 901       FIXME("Could only read %ld of %ld bytes?\n",xread,header[1]);
 902   }
 903   magic = xbuf[0] + (xbuf[1]<<8);
 904   switch (magic) {
 905   case 0x4947: { /* GIF */
 906 #ifdef HAVE_LIBGIF
 907     struct gifdata      gd;
 908     GifFileType         *gif;
 909     BITMAPINFO          *bmi;
 910     HDC                 hdcref;
 911     LPBYTE              bytes;
 912     int                 i,j,ret;
 913     GifImageDesc        *gid;
 914     SavedImage          *si;
 915     ColorMapObject      *cm;
 916
 917     gd.data   = xbuf;
 918     gd.curoff = 0;
 919     gd.len    = xread;
 920     gif = DGifOpen((void*)&gd, _gif_inputfunc);
 921     ret = DGifSlurp(gif);
 922     if (ret == GIF_ERROR) {
 923       FIXME("Failed reading GIF using libgif.\n");
 924       return E_FAIL;
 925     }
 926     TRACE("screen height %d, width %d\n", gif->SWidth, gif->SHeight);
 927     TRACE("color res %d, backgcolor %d\n", gif->SColorResolution, gif->SBackGroundColor);
 928     TRACE("imgcnt %d\n", gif->ImageCount);
 929     if (gif->ImageCount<1) {
 930       FIXME("GIF stream does not have images inside?\n");
 931       return E_FAIL;
 932     }
 933     TRACE("curimage: %d x %d, on %dx%d, interlace %d\n",
 934       gif->Image.Width, gif->Image.Height,
 935       gif->Image.Left, gif->Image.Top,
 936       gif->Image.Interlace
 937     );
 938     /* */
 939     bmi  = HeapAlloc(GetProcessHeap(),0,sizeof(BITMAPINFOHEADER)+(1<<gif->SColorResolution)*sizeof(RGBQUAD));
 940     bytes= HeapAlloc(GetProcessHeap(),0,gif->SWidth*gif->SHeight);
 941     si   = gif->SavedImages+0;
 942     gid  = &(si->ImageDesc);
 943     cm   = gid->ColorMap;
 944     if (!cm) cm = gif->SColorMap;
 945     for (i=0;i<(1<<gif->SColorResolution);i++) {
 946       bmi->bmiColors[i].rgbRed = cm->Colors[i].Red;
 947       bmi->bmiColors[i].rgbGreen = cm->Colors[i].Green;
 948       bmi->bmiColors[i].rgbBlue = cm->Colors[i].Blue;
 949     }
 950     /* Map to in picture coordinates */
 951     for (i=0;i<gid->Height;i++)
 952       for (j=0;j<gid->Width;j++)
 953         bytes[(gid->Top+i)*gif->SWidth+gid->Left+j]=si->RasterBits[i*gid->Width+j];
 954     bmi->bmiHeader.biSize               = sizeof(BITMAPINFOHEADER);
 955     bmi->bmiHeader.biWidth              = gif->SWidth;
 956     bmi->bmiHeader.biHeight             = gif->SHeight;
 957     bmi->bmiHeader.biPlanes             = 1;
 958     bmi->bmiHeader.biBitCount           = 8;
 959     bmi->bmiHeader.biCompression        = BI_RGB;
 960     bmi->bmiHeader.biSizeImage          = gif->SWidth*gif->SHeight;
 961     bmi->bmiHeader.biXPelsPerMeter      = 0;
 962     bmi->bmiHeader.biYPelsPerMeter      = 0;
 963     bmi->bmiHeader.biClrUsed            = 1 << gif->SColorResolution;
 964     bmi->bmiHeader.biClrImportant       = 0;
 965
 966     hdcref = GetDC(0);
 967     This->desc.u.bmp.hbitmap=CreateDIBitmap(
 968             hdcref,
 969             &bmi->bmiHeader,
 970             CBM_INIT,
 971             bytes,
 972             bmi,
 973             DIB_PAL_COLORS
 974     );
 975     DeleteDC(hdcref);
 976     This->desc.picType = PICTYPE_BITMAP;
 977     OLEPictureImpl_SetBitmap(This);
 978     DGifCloseFile(gif);
 979     HeapFree(GetProcessHeap(),0,bytes);
 980     return S_OK;
 981 #else
 982     FIXME("Trying to load GIF, but no support for libgif/libungif compiled in.\n");
 983     return E_FAIL;
 984 #endif
 985     break;
 986   }
 987   case 0xd8ff: { /* JPEG */
 988 #ifdef HAVE_LIBJPEG
 989     struct jpeg_decompress_struct       jd;
 990     struct jpeg_error_mgr               jerr;
 991     int                                 ret;
 992     JDIMENSION                          x;
 993     JSAMPROW                            samprow;
 994     BITMAPINFOHEADER                    bmi;
 995     LPBYTE                              bits;
 996     HDC                                 hdcref;
 997     struct jpeg_source_mgr              xjsm;
 998
 999     /* This is basically so we can use in-memory data for jpeg decompression.
1000      * We need to have all the functions.
1001      */
1002     xjsm.next_input_byte        = xbuf;
1003     xjsm.bytes_in_buffer        = xread;
1004     xjsm.init_source            = _jpeg_init_source;
1005     xjsm.fill_input_buffer      = _jpeg_fill_input_buffer;
1006     xjsm.skip_input_data        = _jpeg_skip_input_data;
1007     xjsm.resync_to_restart      = _jpeg_resync_to_restart;
1008     xjsm.term_source            = _jpeg_term_source;
1009
1010     jd.err = jpeg_std_error(&jerr);
1011     jpeg_create_decompress(&jd);
1012     jd.src = &xjsm;
1013     ret=jpeg_read_header(&jd,TRUE);
1014     jpeg_start_decompress(&jd);
1015     if (ret != JPEG_HEADER_OK) {
1016         ERR("Jpeg image in stream has bad format, read header returned %d.\n",ret);
1017         HeapFree(GetProcessHeap(),0,xbuf);
1018         return E_FAIL;
1019     }
1020     bits = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(jd.output_height+1)*jd.output_width*jd.output_components);
1021     samprow=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,jd.output_width*jd.output_components);
1022     while ( jd.output_scanline<jd.output_height ) {
1023       x = jpeg_read_scanlines(&jd,&samprow,1);
1024       if (x != 1) {
1025         FIXME("failed to read current scanline?\n");
1026         break;
1027       }
1028       memcpy( bits+jd.output_scanline*jd.output_width*jd.output_components,
1029               samprow,
1030               jd.output_width*jd.output_components
1031       );
1032     }
1033     bmi.biSize          = sizeof(bmi);
1034     bmi.biWidth         =  jd.output_width;
1035     bmi.biHeight        = -jd.output_height;
1036     bmi.biPlanes        = 1;
1037     bmi.biBitCount      = jd.output_components<<3;
1038     bmi.biCompression   = BI_RGB;
1039     bmi.biSizeImage     = jd.output_height*jd.output_width*jd.output_components;
1040     bmi.biXPelsPerMeter = 0;
1041     bmi.biYPelsPerMeter = 0;
1042     bmi.biClrUsed       = 0;
1043     bmi.biClrImportant  = 0;
1044
1045     HeapFree(GetProcessHeap(),0,samprow);
1046     jpeg_finish_decompress(&jd);
1047     jpeg_destroy_decompress(&jd);
1048     hdcref = GetDC(0);
1049     This->desc.u.bmp.hbitmap=CreateDIBitmap(
1050             hdcref,
1051             &bmi,
1052             CBM_INIT,
1053             bits,
1054             (BITMAPINFO*)&bmi,
1055             DIB_RGB_COLORS
1056     );
1057     DeleteDC(hdcref);
1058     This->desc.picType = PICTYPE_BITMAP;
1059     OLEPictureImpl_SetBitmap(This);
1060     hr = S_OK;
1061     HeapFree(GetProcessHeap(),0,bits);
1062 #else
1063     ERR("Trying to load JPEG picture, but JPEG supported not compiled in.\n");
1064     hr = E_FAIL;
1065 #endif
1066     break;
1067   }
1068   case 0x4d42: { /* Bitmap */
1069     BITMAPFILEHEADER    *bfh = (BITMAPFILEHEADER*)xbuf;
1070     BITMAPINFO          *bi = (BITMAPINFO*)(bfh+1);
1071     HDC                 hdcref;
1072
1073     /* Does not matter whether this is a coreheader or not, we only use
1074      * components which are in both
1075      */
1076     hdcref = GetDC(0);
1077     This->desc.u.bmp.hbitmap = CreateDIBitmap(
1078         hdcref,
1079         &(bi->bmiHeader),
1080         CBM_INIT,
1081         xbuf+bfh->bfOffBits,
1082         bi,
1083         (bi->bmiHeader.biBitCount<=8)?DIB_PAL_COLORS:DIB_RGB_COLORS
1084     );
1085     DeleteDC(hdcref);
1086     This->desc.picType = PICTYPE_BITMAP;
1087     OLEPictureImpl_SetBitmap(This);
1088     hr = S_OK;
1089     break;
1090   }
1091   case 0x0000: { /* ICON , first word is dwReserved */
1092     HICON hicon;
1093     CURSORICONFILEDIR   *cifd = (CURSORICONFILEDIR*)xbuf;
1094     int i;
1095
1096     /*
1097     FIXME("icon.idReserved=%d\n",cifd->idReserved);
1098     FIXME("icon.idType=%d\n",cifd->idType);
1099     FIXME("icon.idCount=%d\n",cifd->idCount);
1100
1101     for (i=0;i<cifd->idCount;i++) {
1102         FIXME("[%d] width %d\n",i,cifd->idEntries[i].bWidth);
1103         FIXME("[%d] height %d\n",i,cifd->idEntries[i].bHeight);
1104         FIXME("[%d] bColorCount %d\n",i,cifd->idEntries[i].bColorCount);
1105         FIXME("[%d] bReserved %d\n",i,cifd->idEntries[i].bReserved);
1106         FIXME("[%d] xHotspot %d\n",i,cifd->idEntries[i].xHotspot);
1107         FIXME("[%d] yHotspot %d\n",i,cifd->idEntries[i].yHotspot);
1108         FIXME("[%d] dwDIBSize %d\n",i,cifd->idEntries[i].dwDIBSize);
1109         FIXME("[%d] dwDIBOffset %d\n",i,cifd->idEntries[i].dwDIBOffset);
1110     }
1111     */
1112     i=0;
1113     /* If we have more than one icon, try to find the best.
1114      * this currently means '32 pixel wide'.
1115      */
1116     if (cifd->idCount!=1) {
1117         for (i=0;i<cifd->idCount;i++) {
1118             if (cifd->idEntries[i].bWidth == 32)
1119                 break;
1120         }
1121         if (i==cifd->idCount) i=0;
1122     }
1123
1124     hicon = CreateIconFromResourceEx(
1125                 xbuf+cifd->idEntries[i].dwDIBOffset,
1126                 cifd->idEntries[i].dwDIBSize,
1127                 TRUE, /* is icon */
1128                 0x00030000,
1129                 cifd->idEntries[i].bWidth,
1130                 cifd->idEntries[i].bHeight,
1131                 0
1132     );
1133     if (!hicon) {
1134         FIXME("CreateIcon failed.\n");
1135         hr = E_FAIL;
1136     } else {
1137         This->desc.picType = PICTYPE_ICON;
1138         This->desc.u.icon.hicon = hicon;
1139         This->himetricWidth = cifd->idEntries[i].bWidth;
1140         This->himetricHeight = cifd->idEntries[i].bHeight;
1141         hr = S_OK;
1142     }
1143     break;
1144   }
1145   default:
1146   {
1147     int i;
1148     FIXME("Unknown magic %04x, %ld read bytes:\n",magic,xread);
1149     hr=E_FAIL;
1150     for (i=0;i<xread+8;i++) {
1151         if (i<8) MESSAGE("%02x ",((unsigned char*)&header)[i]);
1152         else MESSAGE("%02x ",xbuf[i-8]);
1153         if (i % 10 == 9) MESSAGE("\n");
1154     }
1155     MESSAGE("\n");
1156     break;
1157   }
1158   }
1159
1160   /* FIXME: this notify is not really documented */
1161   if (hr==S_OK)
1162       OLEPicture_SendNotify(This,DISPID_PICT_TYPE);
1163   return hr;
1164 }
1165
1166 static HRESULT WINAPI OLEPictureImpl_Save(
1167   IPersistStream* iface,IStream*pStm,BOOL fClearDirty)
1168 {
1169   ICOM_THIS_From_IPersistStream(IPicture, iface);
1170   FIXME("(%p,%p,%d),stub!\n",This,pStm,fClearDirty);
1171   return E_NOTIMPL;
1172 }
1173
1174 static HRESULT WINAPI OLEPictureImpl_GetSizeMax(
1175   IPersistStream* iface,ULARGE_INTEGER*pcbSize)
1176 {
1177   ICOM_THIS_From_IPersistStream(IPicture, iface);
1178   FIXME("(%p,%p),stub!\n",This,pcbSize);
1179   return E_NOTIMPL;
1180 }
1181
1182 /************************************************************************
1183  *    IDispatch
1184  */
1185 /************************************************************************
1186  * OLEPictureImpl_IDispatch_QueryInterface (IUnknown)
1187  *
1188  * See Windows documentation for more details on IUnknown methods.
1189  */
1190 static HRESULT WINAPI OLEPictureImpl_IDispatch_QueryInterface(
1191   IDispatch* iface,
1192   REFIID     riid,
1193   VOID**     ppvoid)
1194 {
1195   ICOM_THIS_From_IDispatch(IPicture, iface);
1196
1197   return IPicture_QueryInterface(This, riid, ppvoid);
1198 }
1199
1200 /************************************************************************
1201  * OLEPictureImpl_IDispatch_AddRef (IUnknown)
1202  *
1203  * See Windows documentation for more details on IUnknown methods.
1204  */
1205 static ULONG WINAPI OLEPictureImpl_IDispatch_AddRef(
1206   IDispatch* iface)
1207 {
1208   ICOM_THIS_From_IDispatch(IPicture, iface);
1209
1210   return IPicture_AddRef(This);
1211 }
1212
1213 /************************************************************************
1214  * OLEPictureImpl_IDispatch_Release (IUnknown)
1215  *
1216  * See Windows documentation for more details on IUnknown methods.
1217  */
1218 static ULONG WINAPI OLEPictureImpl_IDispatch_Release(
1219   IDispatch* iface)
1220 {
1221   ICOM_THIS_From_IDispatch(IPicture, iface);
1222
1223   return IPicture_Release(This);
1224 }
1225
1226 /************************************************************************
1227  * OLEPictureImpl_GetTypeInfoCount (IDispatch)
1228  *
1229  * See Windows documentation for more details on IDispatch methods.
1230  */
1231 static HRESULT WINAPI OLEPictureImpl_GetTypeInfoCount(
1232   IDispatch*    iface,
1233   unsigned int* pctinfo)
1234 {
1235   FIXME("():Stub\n");
1236
1237   return E_NOTIMPL;
1238 }
1239
1240 /************************************************************************
1241  * OLEPictureImpl_GetTypeInfo (IDispatch)
1242  *
1243  * See Windows documentation for more details on IDispatch methods.
1244  */
1245 static HRESULT WINAPI OLEPictureImpl_GetTypeInfo(
1246   IDispatch*  iface,
1247   UINT      iTInfo,
1248   LCID        lcid,
1249   ITypeInfo** ppTInfo)
1250 {
1251   FIXME("():Stub\n");
1252
1253   return E_NOTIMPL;
1254 }
1255
1256 /************************************************************************
1257  * OLEPictureImpl_GetIDsOfNames (IDispatch)
1258  *
1259  * See Windows documentation for more details on IDispatch methods.
1260  */
1261 static HRESULT WINAPI OLEPictureImpl_GetIDsOfNames(
1262   IDispatch*  iface,
1263   REFIID      riid,
1264   LPOLESTR* rgszNames,
1265   UINT      cNames,
1266   LCID        lcid,
1267   DISPID*     rgDispId)
1268 {
1269   FIXME("():Stub\n");
1270
1271   return E_NOTIMPL;
1272 }
1273
1274 /************************************************************************
1275  * OLEPictureImpl_Invoke (IDispatch)
1276  *
1277  * See Windows documentation for more details on IDispatch methods.
1278  */
1279 static HRESULT WINAPI OLEPictureImpl_Invoke(
1280   IDispatch*  iface,
1281   DISPID      dispIdMember,
1282   REFIID      riid,
1283   LCID        lcid,
1284   WORD        wFlags,
1285   DISPPARAMS* pDispParams,
1286   VARIANT*    pVarResult,
1287   EXCEPINFO*  pExepInfo,
1288   UINT*     puArgErr)
1289 {
1290   FIXME("(dispid: %ld):Stub\n",dispIdMember);
1291
1292   VariantInit(pVarResult);
1293   V_VT(pVarResult) = VT_BOOL;
1294   V_UNION(pVarResult,boolVal) = FALSE;
1295   return S_OK;
1296 }
1297
1298
1299 static ICOM_VTABLE(IPicture) OLEPictureImpl_VTable =
1300 {
1301   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1302   OLEPictureImpl_QueryInterface,
1303   OLEPictureImpl_AddRef,
1304   OLEPictureImpl_Release,
1305   OLEPictureImpl_get_Handle,
1306   OLEPictureImpl_get_hPal,
1307   OLEPictureImpl_get_Type,
1308   OLEPictureImpl_get_Width,
1309   OLEPictureImpl_get_Height,
1310   OLEPictureImpl_Render,
1311   OLEPictureImpl_set_hPal,
1312   OLEPictureImpl_get_CurDC,
1313   OLEPictureImpl_SelectPicture,
1314   OLEPictureImpl_get_KeepOriginalFormat,
1315   OLEPictureImpl_put_KeepOriginalFormat,
1316   OLEPictureImpl_PictureChanged,
1317   OLEPictureImpl_SaveAsFile,
1318   OLEPictureImpl_get_Attributes
1319 };
1320
1321 static ICOM_VTABLE(IDispatch) OLEPictureImpl_IDispatch_VTable =
1322 {
1323   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1324   OLEPictureImpl_IDispatch_QueryInterface,
1325   OLEPictureImpl_IDispatch_AddRef,
1326   OLEPictureImpl_IDispatch_Release,
1327   OLEPictureImpl_GetTypeInfoCount,
1328   OLEPictureImpl_GetTypeInfo,
1329   OLEPictureImpl_GetIDsOfNames,
1330   OLEPictureImpl_Invoke
1331 };
1332
1333 static ICOM_VTABLE(IPersistStream) OLEPictureImpl_IPersistStream_VTable =
1334 {
1335   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1336   OLEPictureImpl_IPersistStream_QueryInterface,
1337   OLEPictureImpl_IPersistStream_AddRef,
1338   OLEPictureImpl_IPersistStream_Release,
1339   OLEPictureImpl_GetClassID,
1340   OLEPictureImpl_IsDirty,
1341   OLEPictureImpl_Load,
1342   OLEPictureImpl_Save,
1343   OLEPictureImpl_GetSizeMax
1344 };
1345
1346 static ICOM_VTABLE(IConnectionPointContainer) OLEPictureImpl_IConnectionPointContainer_VTable =
1347 {
1348   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1349   OLEPictureImpl_IConnectionPointContainer_QueryInterface,
1350   OLEPictureImpl_IConnectionPointContainer_AddRef,
1351   OLEPictureImpl_IConnectionPointContainer_Release,
1352   OLEPictureImpl_EnumConnectionPoints,
1353   OLEPictureImpl_FindConnectionPoint
1354 };
1355
1356 /***********************************************************************
1357  * OleCreatePictureIndirect (OLEAUT32.419)
1358  */
1359 HRESULT WINAPI OleCreatePictureIndirect(LPPICTDESC lpPictDesc, REFIID riid,
1360                             BOOL fOwn, LPVOID *ppvObj )
1361 {
1362   OLEPictureImpl* newPict = NULL;
1363   HRESULT      hr         = S_OK;
1364
1365   TRACE("(%p,%p,%d,%p)\n", lpPictDesc, riid, fOwn, ppvObj);
1366
1367   /*
1368    * Sanity check
1369    */
1370   if (ppvObj==0)
1371     return E_POINTER;
1372
1373   *ppvObj = NULL;
1374
1375   /*
1376    * Try to construct a new instance of the class.
1377    */
1378   newPict = OLEPictureImpl_Construct(lpPictDesc, fOwn);
1379
1380   if (newPict == NULL)
1381     return E_OUTOFMEMORY;
1382
1383   /*
1384    * Make sure it supports the interface required by the caller.
1385    */
1386   hr = IPicture_QueryInterface((IPicture*)newPict, riid, ppvObj);
1387
1388   /*
1389    * Release the reference obtained in the constructor. If
1390    * the QueryInterface was unsuccessful, it will free the class.
1391    */
1392   IPicture_Release((IPicture*)newPict);
1393
1394   return hr;
1395 }
1396
1397
1398 /***********************************************************************
1399  * OleLoadPicture (OLEAUT32.418)
1400  */
1401 HRESULT WINAPI OleLoadPicture( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
1402                             REFIID riid, LPVOID *ppvObj )
1403 {
1404   LPPERSISTSTREAM ps;
1405   IPicture      *newpic;
1406   HRESULT hr;
1407
1408   TRACE("(%p,%ld,%d,%s,%p), partially implemented.\n",
1409         lpstream, lSize, fRunmode, debugstr_guid(riid), ppvObj);
1410
1411   hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
1412   if (hr)
1413     return hr;
1414   hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
1415   if (hr) {
1416       FIXME("Could not get IPersistStream iface from Ole Picture?\n");
1417       IPicture_Release(newpic);
1418       *ppvObj = NULL;
1419       return hr;
1420   }
1421   IPersistStream_Load(ps,lpstream);
1422   IPersistStream_Release(ps);
1423   hr = IPicture_QueryInterface(newpic,riid,ppvObj);
1424   if (hr)
1425       FIXME("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
1426   IPicture_Release(newpic);
1427   return hr;
1428 }
1429
1430 /***********************************************************************
1431  * OleLoadPictureEx (OLEAUT32.401)
1432  */
1433 HRESULT WINAPI OleLoadPictureEx( LPSTREAM lpstream, LONG lSize, BOOL fRunmode,
1434                             REFIID riid, DWORD xsiz, DWORD ysiz, DWORD flags, LPVOID *ppvObj )
1435 {
1436   LPPERSISTSTREAM ps;
1437   IPicture      *newpic;
1438   HRESULT hr;
1439
1440   FIXME("(%p,%ld,%d,%s,x=%ld,y=%ld,f=%lx,%p), partially implemented.\n",
1441         lpstream, lSize, fRunmode, debugstr_guid(riid), xsiz, ysiz, flags, ppvObj);
1442
1443   hr = OleCreatePictureIndirect(NULL,riid,!fRunmode,(LPVOID*)&newpic);
1444   if (hr)
1445     return hr;
1446   hr = IPicture_QueryInterface(newpic,&IID_IPersistStream, (LPVOID*)&ps);
1447   if (hr) {
1448       FIXME("Could not get IPersistStream iface from Ole Picture?\n");
1449       IPicture_Release(newpic);
1450       *ppvObj = NULL;
1451       return hr;
1452   }
1453   IPersistStream_Load(ps,lpstream);
1454   IPersistStream_Release(ps);
1455   hr = IPicture_QueryInterface(newpic,riid,ppvObj);
1456   if (hr)
1457       FIXME("Failed to get interface %s from IPicture.\n",debugstr_guid(riid));
1458   IPicture_Release(newpic);
1459   return hr;
1460 }
1461
1462 /*******************************************************************************
1463  * StdPic ClassFactory
1464  */
1465 typedef struct
1466 {
1467     /* IUnknown fields */
1468     ICOM_VFIELD(IClassFactory);
1469     DWORD                       ref;
1470 } IClassFactoryImpl;
1471
1472 static HRESULT WINAPI
1473 SPCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
1474         ICOM_THIS(IClassFactoryImpl,iface);
1475
1476         FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
1477         return E_NOINTERFACE;
1478 }
1479
1480 static ULONG WINAPI
1481 SPCF_AddRef(LPCLASSFACTORY iface) {
1482         ICOM_THIS(IClassFactoryImpl,iface);
1483         return ++(This->ref);
1484 }
1485
1486 static ULONG WINAPI SPCF_Release(LPCLASSFACTORY iface) {
1487         ICOM_THIS(IClassFactoryImpl,iface);
1488         /* static class, won't be  freed */
1489         return --(This->ref);
1490 }
1491
1492 static HRESULT WINAPI SPCF_CreateInstance(
1493         LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
1494 ) {
1495         PICTDESC        pd;
1496
1497         FIXME("(%p,%p,%s,%p), creating stdpic with PICTYPE_NONE.\n",iface,pOuter,debugstr_guid(riid),ppobj);
1498         pd.cbSizeofstruct = sizeof(pd);
1499         pd.picType = PICTYPE_NONE;
1500         return OleCreatePictureIndirect(&pd,riid,TRUE,ppobj);
1501
1502 }
1503
1504 static HRESULT WINAPI SPCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
1505         ICOM_THIS(IClassFactoryImpl,iface);
1506         FIXME("(%p)->(%d),stub!\n",This,dolock);
1507         return S_OK;
1508 }
1509
1510 static ICOM_VTABLE(IClassFactory) SPCF_Vtbl = {
1511         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1512         SPCF_QueryInterface,
1513         SPCF_AddRef,
1514         SPCF_Release,
1515         SPCF_CreateInstance,
1516         SPCF_LockServer
1517 };
1518 static IClassFactoryImpl STDPIC_CF = {&SPCF_Vtbl, 1 };
1519
1520 void _get_STDPIC_CF(LPVOID *ppv) { *ppv = (LPVOID)&STDPIC_CF; }