dlls/ole32/datacache.c

   1 /*
   2  *      OLE 2 Data cache
   3  *
   4  *      Copyright 1999  Francis Beaudet
   5  *      Copyright 2000  Abey George
   6  *
   7  * NOTES:
   8  *    The OLE2 data cache supports a whole whack of
   9  *    interfaces including:
  10  *       IDataObject, IPersistStorage, IViewObject2,
  11  *       IOleCache2 and IOleCacheControl.
  12  *
  13  *    Most of the implementation details are taken from: Inside OLE
  14  *    second edition by Kraig Brockschmidt,
  15  *
  16  * NOTES
  17  *  -  This implementation of the datacache will let your application
  18  *     load documents that have embedded OLE objects in them and it will
  19  *     also retrieve the metafile representation of those objects.
  20  *  -  This implementation of the datacache will also allow your
  21  *     application to save new documents with OLE objects in them.
  22  *  -  The main thing that it doesn't do is allow you to activate
  23  *     or modify the OLE objects in any way.
  24  *  -  I haven't found any good documentation on the real usage of
  25  *     the streams created by the data cache. In particular, How to
  26  *     determine what the XXX stands for in the stream name
  27  *     "\002OlePresXXX". It appears to just be a counter.
  28  *  -  Also, I don't know the real content of the presentation stream
  29  *     header. I was able to figure-out where the extent of the object
  30  *     was stored and the aspect, but that's about it.
  31  */
  32 #include <assert.h>
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "wingdi.h"
  36 #include "winuser.h"
  37 #include "winerror.h"
  38 #include "crtdll.h"
  39 #include "wine/obj_oleview.h"
  40 #include "wine/obj_cache.h"
  41 #include "wine/unicode.h"
  42 #include "ole2.h"
  43 #include "debugtools.h"
  44
  45 DEFAULT_DEBUG_CHANNEL(ole);
  46
  47 /****************************************************************************
  48  * PresentationDataHeader
  49  *
  50  * This structure represents the header of the \002OlePresXXX stream in
  51  * the OLE object strorage.
  52  *
  53  * Most fields are still unknown.
  54  */
  55 typedef struct PresentationDataHeader
  56 {
  57   DWORD unknown1;       /* -1 */
  58   DWORD unknown2;       /* 3, possibly CF_METAFILEPICT */
  59   DWORD unknown3;       /* 4, possibly TYMED_ISTREAM */
  60   DVASPECT dvAspect;
  61   DWORD unknown5;       /* -1 */
  62
  63   DWORD unknown6;
  64   DWORD unknown7;       /* 0 */
  65   DWORD dwObjectExtentX;
  66   DWORD dwObjectExtentY;
  67   DWORD dwSize;
  68 } PresentationDataHeader;
  69
  70 /****************************************************************************
  71  * DataCache
  72  */
  73 struct DataCache
  74 {
  75   /*
  76    * List all interface VTables here
  77    */
  78   ICOM_VTABLE(IDataObject)*      lpvtbl1;
  79   ICOM_VTABLE(IUnknown)*         lpvtbl2;
  80   ICOM_VTABLE(IPersistStorage)*  lpvtbl3;
  81   ICOM_VTABLE(IViewObject2)*     lpvtbl4;
  82   ICOM_VTABLE(IOleCache2)*       lpvtbl5;
  83   ICOM_VTABLE(IOleCacheControl)* lpvtbl6;
  84
  85   /*
  86    * Reference count of this object
  87    */
  88   ULONG ref;
  89
  90   /*
  91    * IUnknown implementation of the outer object.
  92    */
  93   IUnknown* outerUnknown;
  94
  95   /*
  96    * This storage pointer is set through a call to
  97    * IPersistStorage_Load. This is where the visual
  98    * representation of the object is stored.
  99    */
 100   IStorage* presentationStorage;
 101
 102   /*
 103    * The user of this object can setup ONE advise sink
 104    * connection with the object. These parameters describe
 105    * that connection.
 106    */
 107   DWORD        sinkAspects;
 108   DWORD        sinkAdviseFlag;
 109   IAdviseSink* sinkInterface;
 110
 111 };
 112
 113 typedef struct DataCache DataCache;
 114
 115 /*
 116  * Here, I define utility macros to help with the casting of the
 117  * "this" parameter.
 118  * There is a version to accomodate all of the VTables implemented
 119  * by this object.
 120  */
 121 #define _ICOM_THIS_From_IDataObject(class,name)       class* this = (class*)name;
 122 #define _ICOM_THIS_From_NDIUnknown(class, name)       class* this = (class*)(((char*)name)-sizeof(void*));
 123 #define _ICOM_THIS_From_IPersistStorage(class, name)  class* this = (class*)(((char*)name)-2*sizeof(void*));
 124 #define _ICOM_THIS_From_IViewObject2(class, name)     class* this = (class*)(((char*)name)-3*sizeof(void*));
 125 #define _ICOM_THIS_From_IOleCache2(class, name)       class* this = (class*)(((char*)name)-4*sizeof(void*));
 126 #define _ICOM_THIS_From_IOleCacheControl(class, name) class* this = (class*)(((char*)name)-5*sizeof(void*));
 127
 128 /*
 129  * Prototypes for the methods of the DataCache class.
 130  */
 131 static DataCache* DataCache_Construct(REFCLSID  clsid,
 132                                       LPUNKNOWN pUnkOuter);
 133 static void       DataCache_Destroy(DataCache* ptrToDestroy);
 134 static HRESULT    DataCache_ReadPresentationData(DataCache*              this,
 135                                                  DWORD                   drawAspect,
 136                                                  PresentationDataHeader* header);
 137 static HRESULT    DataCache_OpenPresStream(DataCache *this,
 138                                            DWORD      drawAspect,
 139                                            IStream  **pStm);
 140 static HMETAFILE  DataCache_ReadPresMetafile(DataCache* this,
 141                                              DWORD      drawAspect);
 142 static void       DataCache_FireOnViewChange(DataCache* this,
 143                                              DWORD      aspect,
 144                                              LONG       lindex);
 145
 146 /*
 147  * Prototypes for the methods of the DataCache class
 148  * that implement non delegating IUnknown methods.
 149  */
 150 static HRESULT WINAPI DataCache_NDIUnknown_QueryInterface(
 151             IUnknown*      iface,
 152             REFIID         riid,
 153             void**         ppvObject);
 154 static ULONG WINAPI DataCache_NDIUnknown_AddRef(
 155             IUnknown*      iface);
 156 static ULONG WINAPI DataCache_NDIUnknown_Release(
 157             IUnknown*      iface);
 158
 159 /*
 160  * Prototypes for the methods of the DataCache class
 161  * that implement IDataObject methods.
 162  */
 163 static HRESULT WINAPI DataCache_IDataObject_QueryInterface(
 164             IDataObject*     iface,
 165             REFIID           riid,
 166             void**           ppvObject);
 167 static ULONG WINAPI DataCache_IDataObject_AddRef(
 168             IDataObject*     iface);
 169 static ULONG WINAPI DataCache_IDataObject_Release(
 170             IDataObject*     iface);
 171 static HRESULT WINAPI DataCache_GetData(
 172             IDataObject*     iface,
 173             LPFORMATETC      pformatetcIn,
 174             STGMEDIUM*       pmedium);
 175 static HRESULT WINAPI DataCache_GetDataHere(
 176             IDataObject*     iface,
 177             LPFORMATETC      pformatetc,
 178             STGMEDIUM*       pmedium);
 179 static HRESULT WINAPI DataCache_QueryGetData(
 180             IDataObject*     iface,
 181             LPFORMATETC      pformatetc);
 182 static HRESULT WINAPI DataCache_GetCanonicalFormatEtc(
 183             IDataObject*     iface,
 184             LPFORMATETC      pformatectIn,
 185             LPFORMATETC      pformatetcOut);
 186 static HRESULT WINAPI DataCache_IDataObject_SetData(
 187             IDataObject*     iface,
 188             LPFORMATETC      pformatetc,
 189             STGMEDIUM*       pmedium,
 190             BOOL             fRelease);
 191 static HRESULT WINAPI DataCache_EnumFormatEtc(
 192             IDataObject*     iface,
 193             DWORD            dwDirection,
 194             IEnumFORMATETC** ppenumFormatEtc);
 195 static HRESULT WINAPI DataCache_DAdvise(
 196             IDataObject*     iface,
 197             FORMATETC*       pformatetc,
 198             DWORD            advf,
 199             IAdviseSink*     pAdvSink,
 200             DWORD*           pdwConnection);
 201 static HRESULT WINAPI DataCache_DUnadvise(
 202             IDataObject*     iface,
 203             DWORD            dwConnection);
 204 static HRESULT WINAPI DataCache_EnumDAdvise(
 205             IDataObject*     iface,
 206             IEnumSTATDATA**  ppenumAdvise);
 207
 208 /*
 209  * Prototypes for the methods of the DataCache class
 210  * that implement IPersistStorage methods.
 211  */
 212 static HRESULT WINAPI DataCache_IPersistStorage_QueryInterface(
 213             IPersistStorage* iface,
 214             REFIID           riid,
 215             void**           ppvObject);
 216 static ULONG WINAPI DataCache_IPersistStorage_AddRef(
 217             IPersistStorage* iface);
 218 static ULONG WINAPI DataCache_IPersistStorage_Release(
 219             IPersistStorage* iface);
 220 static HRESULT WINAPI DataCache_GetClassID(
 221             IPersistStorage* iface,
 222             CLSID*           pClassID);
 223 static HRESULT WINAPI DataCache_IsDirty(
 224             IPersistStorage* iface);
 225 static HRESULT WINAPI DataCache_InitNew(
 226             IPersistStorage* iface,
 227             IStorage*        pStg);
 228 static HRESULT WINAPI DataCache_Load(
 229             IPersistStorage* iface,
 230             IStorage*        pStg);
 231 static HRESULT WINAPI DataCache_Save(
 232             IPersistStorage* iface,
 233             IStorage*        pStg,
 234             BOOL             fSameAsLoad);
 235 static HRESULT WINAPI DataCache_SaveCompleted(
 236             IPersistStorage* iface,
 237             IStorage*        pStgNew);
 238 static HRESULT WINAPI DataCache_HandsOffStorage(
 239             IPersistStorage* iface);
 240
 241 /*
 242  * Prototypes for the methods of the DataCache class
 243  * that implement IViewObject2 methods.
 244  */
 245 static HRESULT WINAPI DataCache_IViewObject2_QueryInterface(
 246             IViewObject2* iface,
 247             REFIID           riid,
 248             void**           ppvObject);
 249 static ULONG WINAPI DataCache_IViewObject2_AddRef(
 250             IViewObject2* iface);
 251 static ULONG WINAPI DataCache_IViewObject2_Release(
 252             IViewObject2* iface);
 253 static HRESULT WINAPI DataCache_Draw(
 254             IViewObject2*    iface,
 255             DWORD            dwDrawAspect,
 256             LONG             lindex,
 257             void*            pvAspect,
 258             DVTARGETDEVICE*  ptd,
 259             HDC              hdcTargetDev,
 260             HDC              hdcDraw,
 261             LPCRECTL         lprcBounds,
 262             LPCRECTL         lprcWBounds,
 263             IVO_ContCallback pfnContinue,
 264             DWORD            dwContinue);
 265 static HRESULT WINAPI DataCache_GetColorSet(
 266             IViewObject2*   iface,
 267             DWORD           dwDrawAspect,
 268             LONG            lindex,
 269             void*           pvAspect,
 270             DVTARGETDEVICE* ptd,
 271             HDC             hicTargetDevice,
 272             LOGPALETTE**    ppColorSet);
 273 static HRESULT WINAPI DataCache_Freeze(
 274             IViewObject2*   iface,
 275             DWORD           dwDrawAspect,
 276             LONG            lindex,
 277             void*           pvAspect,
 278             DWORD*          pdwFreeze);
 279 static HRESULT WINAPI DataCache_Unfreeze(
 280             IViewObject2*   iface,
 281             DWORD           dwFreeze);
 282 static HRESULT WINAPI DataCache_SetAdvise(
 283             IViewObject2*   iface,
 284             DWORD           aspects,
 285             DWORD           advf,
 286             IAdviseSink*    pAdvSink);
 287 static HRESULT WINAPI DataCache_GetAdvise(
 288             IViewObject2*   iface,
 289             DWORD*          pAspects,
 290             DWORD*          pAdvf,
 291             IAdviseSink**   ppAdvSink);
 292 static HRESULT WINAPI DataCache_GetExtent(
 293             IViewObject2*   iface,
 294             DWORD           dwDrawAspect,
 295             LONG            lindex,
 296             DVTARGETDEVICE* ptd,
 297             LPSIZEL         lpsizel);
 298
 299 /*
 300  * Prototypes for the methods of the DataCache class
 301  * that implement IOleCache2 methods.
 302  */
 303 static HRESULT WINAPI DataCache_IOleCache2_QueryInterface(
 304             IOleCache2*     iface,
 305             REFIID          riid,
 306             void**          ppvObject);
 307 static ULONG WINAPI DataCache_IOleCache2_AddRef(
 308             IOleCache2*     iface);
 309 static ULONG WINAPI DataCache_IOleCache2_Release(
 310             IOleCache2*     iface);
 311 static HRESULT WINAPI DataCache_Cache(
 312             IOleCache2*     iface,
 313             FORMATETC*      pformatetc,
 314             DWORD           advf,
 315             DWORD*          pdwConnection);
 316 static HRESULT WINAPI DataCache_Uncache(
 317             IOleCache2*     iface,
 318             DWORD           dwConnection);
 319 static HRESULT WINAPI DataCache_EnumCache(
 320             IOleCache2*     iface,
 321             IEnumSTATDATA** ppenumSTATDATA);
 322 static HRESULT WINAPI DataCache_InitCache(
 323             IOleCache2*     iface,
 324             IDataObject*    pDataObject);
 325 static HRESULT WINAPI DataCache_IOleCache2_SetData(
 326             IOleCache2*     iface,
 327             FORMATETC*      pformatetc,
 328             STGMEDIUM*      pmedium,
 329             BOOL            fRelease);
 330 static HRESULT WINAPI DataCache_UpdateCache(
 331             IOleCache2*     iface,
 332             LPDATAOBJECT    pDataObject,
 333             DWORD           grfUpdf,
 334             LPVOID          pReserved);
 335 static HRESULT WINAPI DataCache_DiscardCache(
 336             IOleCache2*     iface,
 337             DWORD           dwDiscardOptions);
 338
 339 /*
 340  * Prototypes for the methods of the DataCache class
 341  * that implement IOleCacheControl methods.
 342  */
 343 static HRESULT WINAPI DataCache_IOleCacheControl_QueryInterface(
 344             IOleCacheControl* iface,
 345             REFIID            riid,
 346             void**            ppvObject);
 347 static ULONG WINAPI DataCache_IOleCacheControl_AddRef(
 348             IOleCacheControl* iface);
 349 static ULONG WINAPI DataCache_IOleCacheControl_Release(
 350             IOleCacheControl* iface);
 351 static HRESULT WINAPI DataCache_OnRun(
 352             IOleCacheControl* iface,
 353             LPDATAOBJECT      pDataObject);
 354 static HRESULT WINAPI DataCache_OnStop(
 355             IOleCacheControl* iface);
 356
 357 /*
 358  * Virtual function tables for the DataCache class.
 359  */
 360 static ICOM_VTABLE(IUnknown) DataCache_NDIUnknown_VTable =
 361 {
 362   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 363   DataCache_NDIUnknown_QueryInterface,
 364   DataCache_NDIUnknown_AddRef,
 365   DataCache_NDIUnknown_Release
 366 };
 367
 368 static ICOM_VTABLE(IDataObject) DataCache_IDataObject_VTable =
 369 {
 370   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 371   DataCache_IDataObject_QueryInterface,
 372   DataCache_IDataObject_AddRef,
 373   DataCache_IDataObject_Release,
 374   DataCache_GetData,
 375   DataCache_GetDataHere,
 376   DataCache_QueryGetData,
 377   DataCache_GetCanonicalFormatEtc,
 378   DataCache_IDataObject_SetData,
 379   DataCache_EnumFormatEtc,
 380   DataCache_DAdvise,
 381   DataCache_DUnadvise,
 382   DataCache_EnumDAdvise
 383 };
 384
 385 static ICOM_VTABLE(IPersistStorage) DataCache_IPersistStorage_VTable =
 386 {
 387   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 388   DataCache_IPersistStorage_QueryInterface,
 389   DataCache_IPersistStorage_AddRef,
 390   DataCache_IPersistStorage_Release,
 391   DataCache_GetClassID,
 392   DataCache_IsDirty,
 393   DataCache_InitNew,
 394   DataCache_Load,
 395   DataCache_Save,
 396   DataCache_SaveCompleted,
 397   DataCache_HandsOffStorage
 398 };
 399
 400 static ICOM_VTABLE(IViewObject2) DataCache_IViewObject2_VTable =
 401 {
 402   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 403   DataCache_IViewObject2_QueryInterface,
 404   DataCache_IViewObject2_AddRef,
 405   DataCache_IViewObject2_Release,
 406   DataCache_Draw,
 407   DataCache_GetColorSet,
 408   DataCache_Freeze,
 409   DataCache_Unfreeze,
 410   DataCache_SetAdvise,
 411   DataCache_GetAdvise,
 412   DataCache_GetExtent
 413 };
 414
 415 static ICOM_VTABLE(IOleCache2) DataCache_IOleCache2_VTable =
 416 {
 417   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 418   DataCache_IOleCache2_QueryInterface,
 419   DataCache_IOleCache2_AddRef,
 420   DataCache_IOleCache2_Release,
 421   DataCache_Cache,
 422   DataCache_Uncache,
 423   DataCache_EnumCache,
 424   DataCache_InitCache,
 425   DataCache_IOleCache2_SetData,
 426   DataCache_UpdateCache,
 427   DataCache_DiscardCache
 428 };
 429
 430 static ICOM_VTABLE(IOleCacheControl) DataCache_IOleCacheControl_VTable =
 431 {
 432   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 433   DataCache_IOleCacheControl_QueryInterface,
 434   DataCache_IOleCacheControl_AddRef,
 435   DataCache_IOleCacheControl_Release,
 436   DataCache_OnRun,
 437   DataCache_OnStop
 438 };
 439
 440 /******************************************************************************
 441  *              CreateDataCache        [OLE32.54]
 442  */
 443 HRESULT WINAPI CreateDataCache(
 444   LPUNKNOWN pUnkOuter,
 445   REFCLSID  rclsid,
 446   REFIID    riid,
 447   LPVOID*   ppvObj)
 448 {
 449   DataCache* newCache = NULL;
 450   HRESULT    hr       = S_OK;
 451
 452   TRACE("(%s, %p, %s, %p)\n", debugstr_guid(rclsid), pUnkOuter, debugstr_guid(riid), ppvObj);
 453
 454   /*
 455    * Sanity check
 456    */
 457   if (ppvObj==0)
 458     return E_POINTER;
 459
 460   *ppvObj = 0;
 461
 462   /*
 463    * If this cache is constructed for aggregation, make sure
 464    * the caller is requesting the IUnknown interface.
 465    * This is necessary because it's the only time the non-delegating
 466    * IUnknown pointer can be returned to the outside.
 467    */
 468   if ( (pUnkOuter!=NULL) &&
 469        (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) != 0) )
 470     return CLASS_E_NOAGGREGATION;
 471
 472   /*
 473    * Try to construct a new instance of the class.
 474    */
 475   newCache = DataCache_Construct(rclsid,
 476                                  pUnkOuter);
 477
 478   if (newCache == 0)
 479     return E_OUTOFMEMORY;
 480
 481   /*
 482    * Make sure it supports the interface required by the caller.
 483    */
 484   hr = IUnknown_QueryInterface((IUnknown*)&(newCache->lpvtbl2), riid, ppvObj);
 485
 486   /*
 487    * Release the reference obtained in the constructor. If
 488    * the QueryInterface was unsuccessful, it will free the class.
 489    */
 490   IUnknown_Release((IUnknown*)&(newCache->lpvtbl2));
 491
 492   return hr;
 493 }
 494
 495 /*********************************************************
 496  * Method implementation for DataCache class.
 497  */
 498 static DataCache* DataCache_Construct(
 499   REFCLSID  clsid,
 500   LPUNKNOWN pUnkOuter)
 501 {
 502   DataCache* newObject = 0;
 503
 504   /*
 505    * Allocate space for the object.
 506    */
 507   newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(DataCache));
 508
 509   if (newObject==0)
 510     return newObject;
 511
 512   /*
 513    * Initialize the virtual function table.
 514    */
 515   newObject->lpvtbl1 = &DataCache_IDataObject_VTable;
 516   newObject->lpvtbl2 = &DataCache_NDIUnknown_VTable;
 517   newObject->lpvtbl3 = &DataCache_IPersistStorage_VTable;
 518   newObject->lpvtbl4 = &DataCache_IViewObject2_VTable;
 519   newObject->lpvtbl5 = &DataCache_IOleCache2_VTable;
 520   newObject->lpvtbl6 = &DataCache_IOleCacheControl_VTable;
 521
 522   /*
 523    * Start with one reference count. The caller of this function
 524    * must release the interface pointer when it is done.
 525    */
 526   newObject->ref = 1;
 527
 528   /*
 529    * Initialize the outer unknown
 530    * We don't keep a reference on the outer unknown since, the way
 531    * aggregation works, our lifetime is at least as large as it's
 532    * lifetime.
 533    */
 534   if (pUnkOuter==NULL)
 535     pUnkOuter = (IUnknown*)&(newObject->lpvtbl2);
 536
 537   newObject->outerUnknown = pUnkOuter;
 538
 539   /*
 540    * Initialize the other members of the structure.
 541    */
 542   newObject->presentationStorage = NULL;
 543   newObject->sinkAspects = 0;
 544   newObject->sinkAdviseFlag = 0;
 545   newObject->sinkInterface = 0;
 546
 547   return newObject;
 548 }
 549
 550 static void DataCache_Destroy(
 551   DataCache* ptrToDestroy)
 552 {
 553   TRACE("()\n");
 554
 555   if (ptrToDestroy->sinkInterface != NULL)
 556   {
 557     IAdviseSink_Release(ptrToDestroy->sinkInterface);
 558     ptrToDestroy->sinkInterface = NULL;
 559   }
 560
 561   if (ptrToDestroy->presentationStorage != NULL)
 562   {
 563     IStorage_Release(ptrToDestroy->presentationStorage);
 564     ptrToDestroy->presentationStorage = NULL;
 565   }
 566
 567   /*
 568    * Free the datacache pointer.
 569    */
 570   HeapFree(GetProcessHeap(), 0, ptrToDestroy);
 571 }
 572
 573 /************************************************************************
 574  * DataCache_ReadPresentationData
 575  *
 576  * This method will read information for the requested presentation
 577  * into the given structure.
 578  *
 579  * Param:
 580  *   this       - Pointer to the DataCache object
 581  *   drawAspect - The aspect of the object that we wish to draw.
 582  *   header     - The structure containing information about this
 583  *                aspect of the object.
 584  */
 585 static HRESULT DataCache_ReadPresentationData(
 586   DataCache*              this,
 587   DWORD                   drawAspect,
 588   PresentationDataHeader* header)
 589 {
 590   IStream* presStream = NULL;
 591   HRESULT  hres;
 592
 593   /*
 594    * Open the presentation stream.
 595    */
 596   hres = DataCache_OpenPresStream(
 597            this,
 598            drawAspect,
 599            &presStream);
 600
 601   if (FAILED(hres))
 602     return hres;
 603
 604   /*
 605    * Read the header.
 606    */
 607
 608   hres = IStream_Read(
 609            presStream,
 610            header,
 611            sizeof(PresentationDataHeader),
 612            NULL);
 613
 614   /*
 615    * Cleanup.
 616    */
 617   IStream_Release(presStream);
 618
 619   /*
 620    * We don't want to propagate any other error
 621    * code than a failure.
 622    */
 623   if (hres!=S_OK)
 624     hres = E_FAIL;
 625
 626   return hres;
 627 }
 628
 629 /************************************************************************
 630  * DataCache_FireOnViewChange
 631  *
 632  * This method will fire an OnViewChange notification to the advise
 633  * sink registered with the datacache.
 634  *
 635  * See IAdviseSink::OnViewChange for more details.
 636  */
 637 static void DataCache_FireOnViewChange(
 638   DataCache* this,
 639   DWORD      aspect,
 640   LONG       lindex)
 641 {
 642   TRACE("(%p, %lx, %ld)\n", this, aspect, lindex);
 643
 644   /*
 645    * The sink supplies a filter when it registers
 646    * we make sure we only send the notifications when that
 647    * filter matches.
 648    */
 649   if ((this->sinkAspects & aspect) != 0)
 650   {
 651     if (this->sinkInterface != NULL)
 652     {
 653       IAdviseSink_OnViewChange(this->sinkInterface,
 654                                aspect,
 655                                lindex);
 656
 657       /*
 658        * Some sinks want to be unregistered automatically when
 659        * the first notification goes out.
 660        */
 661       if ( (this->sinkAdviseFlag & ADVF_ONLYONCE) != 0)
 662       {
 663         IAdviseSink_Release(this->sinkInterface);
 664
 665         this->sinkInterface  = NULL;
 666         this->sinkAspects    = 0;
 667         this->sinkAdviseFlag = 0;
 668       }
 669     }
 670   }
 671 }
 672
 673 /* Helper for DataCache_OpenPresStream */
 674 static BOOL DataCache_IsPresentationStream(const STATSTG *elem)
 675 {
 676     /* The presentation streams have names of the form "\002OlePresXXX",
 677      * where XXX goes from 000 to 999. */
 678     static const WCHAR OlePres[] = { 2,'O','l','e','P','r','e','s' };
 679
 680     LPCWSTR name = elem->pwcsName;
 681
 682     return (elem->type == STGTY_STREAM)
 683         && (elem->cbSize.s.LowPart >= sizeof(PresentationDataHeader))
 684         && (strlenW(name) == 11)
 685         && (strncmpW(name, OlePres, 8) == 0)
 686         && CRTDLL_iswdigit(name[8])
 687         && CRTDLL_iswdigit(name[9])
 688         && CRTDLL_iswdigit(name[10]);
 689 }
 690
 691 /************************************************************************
 692  * DataCache_OpenPresStream
 693  *
 694  * This method will find the stream for the given presentation. It makes
 695  * no attempt at fallback.
 696  *
 697  * Param:
 698  *   this       - Pointer to the DataCache object
 699  *   drawAspect - The aspect of the object that we wish to draw.
 700  *   pStm       - A returned stream. It points to the beginning of the
 701  *              - presentation data, including the header.
 702  *
 703  * Errors:
 704  *   S_OK               The requested stream has been opened.
 705  *   OLE_E_BLANK        The requested stream could not be found.
 706  *   Quite a few others I'm too lazy to map correctly.
 707  *
 708  * Notes:
 709  *   Algorithm: Scan the elements of the presentation storage, looking
 710  *              for presentation streams. For each presentation stream,
 711  *              load the header and check to see if the aspect maches.
 712  *
 713  *   If a fallback is desired, just opening the first presentation stream
 714  *   is a possibility.
 715  */
 716 static HRESULT DataCache_OpenPresStream(
 717   DataCache *this,
 718   DWORD      drawAspect,
 719   IStream  **ppStm)
 720 {
 721     STATSTG elem;
 722     IEnumSTATSTG *pEnum;
 723     HRESULT hr;
 724
 725     if (!ppStm) return E_POINTER;
 726
 727     hr = IStorage_EnumElements(this->presentationStorage, 0, NULL, 0, &pEnum);
 728     if (FAILED(hr)) return hr;
 729
 730     while ((hr = IEnumSTATSTG_Next(pEnum, 1, &elem, NULL)) == S_OK)
 731     {
 732         if (DataCache_IsPresentationStream(&elem))
 733         {
 734             IStream *pStm;
 735
 736             hr = IStorage_OpenStream(this->presentationStorage, elem.pwcsName,
 737                                      NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0,
 738                                      &pStm);
 739             if (SUCCEEDED(hr))
 740             {
 741                 PresentationDataHeader header;
 742                 ULONG actual_read;
 743
 744                 hr = IStream_Read(pStm, &header, sizeof(header), &actual_read);
 745
 746                 /* can't use SUCCEEDED(hr): S_FALSE counts as an error */
 747                 if (hr == S_OK && actual_read == sizeof(header)
 748                     && header.dvAspect == drawAspect)
 749                 {
 750                     /* Rewind the stream before returning it. */
 751                     LARGE_INTEGER offset;
 752                     offset.s.LowPart = 0;
 753                     offset.s.HighPart = 0;
 754                     IStream_Seek(pStm, offset, STREAM_SEEK_SET, NULL);
 755
 756                     *ppStm = pStm;
 757
 758                     CoTaskMemFree(elem.pwcsName);
 759                     IEnumSTATSTG_Release(pEnum);
 760
 761                     return S_OK;
 762                 }
 763
 764                 IStream_Release(pStm);
 765             }
 766         }
 767
 768         CoTaskMemFree(elem.pwcsName);
 769     }
 770
 771     IEnumSTATSTG_Release(pEnum);
 772
 773     return (hr == S_FALSE ? OLE_E_BLANK : hr);
 774 }
 775
 776 /************************************************************************
 777  * DataCache_ReadPresentationData
 778  *
 779  * This method will read information for the requested presentation
 780  * into the given structure.
 781  *
 782  * Param:
 783  *   this       - Pointer to the DataCache object
 784  *   drawAspect - The aspect of the object that we wish to draw.
 785  *
 786  * Returns:
 787  *   This method returns a metafile handle if it is successful.
 788  *   it will return 0 if not.
 789  */
 790 static HMETAFILE DataCache_ReadPresMetafile(
 791   DataCache* this,
 792   DWORD      drawAspect)
 793 {
 794   LARGE_INTEGER offset;
 795   IStream*      presStream = NULL;
 796   HRESULT       hres;
 797   void*         metafileBits;
 798   STATSTG       streamInfo;
 799   HMETAFILE     newMetafile = 0;
 800
 801   /*
 802    * Open the presentation stream.
 803    */
 804   hres = DataCache_OpenPresStream(
 805            this,
 806            drawAspect,
 807            &presStream);
 808
 809   if (FAILED(hres))
 810     return hres;
 811
 812   /*
 813    * Get the size of the stream.
 814    */
 815   hres = IStream_Stat(presStream,
 816                       &streamInfo,
 817                       STATFLAG_NONAME);
 818
 819   /*
 820    * Skip the header
 821    */
 822   offset.s.HighPart = 0;
 823   offset.s.LowPart  = sizeof(PresentationDataHeader);
 824
 825   hres = IStream_Seek(
 826            presStream,
 827            offset,
 828            STREAM_SEEK_SET,
 829            NULL);
 830
 831   streamInfo.cbSize.s.LowPart -= offset.s.LowPart;
 832
 833   /*
 834    * Allocate a buffer for the metafile bits.
 835    */
 836   metafileBits = HeapAlloc(GetProcessHeap(),
 837                            0,
 838                            streamInfo.cbSize.s.LowPart);
 839
 840   /*
 841    * Read the metafile bits.
 842    */
 843   hres = IStream_Read(
 844            presStream,
 845            metafileBits,
 846            streamInfo.cbSize.s.LowPart,
 847            NULL);
 848
 849   /*
 850    * Create a metafile with those bits.
 851    */
 852   if (SUCCEEDED(hres))
 853   {
 854     newMetafile = SetMetaFileBitsEx(streamInfo.cbSize.s.LowPart, metafileBits);
 855   }
 856
 857   /*
 858    * Cleanup.
 859    */
 860   HeapFree(GetProcessHeap(), 0, metafileBits);
 861   IStream_Release(presStream);
 862
 863   if (newMetafile==0)
 864     hres = E_FAIL;
 865
 866   return newMetafile;
 867 }
 868
 869 /*********************************************************
 870  * Method implementation for the  non delegating IUnknown
 871  * part of the DataCache class.
 872  */
 873
 874 /************************************************************************
 875  * DataCache_NDIUnknown_QueryInterface (IUnknown)
 876  *
 877  * See Windows documentation for more details on IUnknown methods.
 878  *
 879  * This version of QueryInterface will not delegate it's implementation
 880  * to the outer unknown.
 881  */
 882 static HRESULT WINAPI DataCache_NDIUnknown_QueryInterface(
 883             IUnknown*      iface,
 884             REFIID         riid,
 885             void**         ppvObject)
 886 {
 887   _ICOM_THIS_From_NDIUnknown(DataCache, iface);
 888
 889   /*
 890    * Perform a sanity check on the parameters.
 891    */
 892   if ( (this==0) || (ppvObject==0) )
 893     return E_INVALIDARG;
 894
 895   /*
 896    * Initialize the return parameter.
 897    */
 898   *ppvObject = 0;
 899
 900   /*
 901    * Compare the riid with the interface IDs implemented by this object.
 902    */
 903   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
 904   {
 905     *ppvObject = iface;
 906   }
 907   else if (memcmp(&IID_IDataObject, riid, sizeof(IID_IDataObject)) == 0)
 908   {
 909     *ppvObject = (IDataObject*)&(this->lpvtbl1);
 910   }
 911   else if ( (memcmp(&IID_IPersistStorage, riid, sizeof(IID_IPersistStorage)) == 0)  ||
 912             (memcmp(&IID_IPersist, riid, sizeof(IID_IPersist)) == 0) )
 913   {
 914     *ppvObject = (IPersistStorage*)&(this->lpvtbl3);
 915   }
 916   else if ( (memcmp(&IID_IViewObject, riid, sizeof(IID_IViewObject)) == 0) ||
 917             (memcmp(&IID_IViewObject2, riid, sizeof(IID_IViewObject2)) == 0) )
 918   {
 919     *ppvObject = (IViewObject2*)&(this->lpvtbl4);
 920   }
 921   else if ( (memcmp(&IID_IOleCache, riid, sizeof(IID_IOleCache)) == 0) ||
 922             (memcmp(&IID_IOleCache2, riid, sizeof(IID_IOleCache2)) == 0) )
 923   {
 924     *ppvObject = (IOleCache2*)&(this->lpvtbl5);
 925   }
 926   else if (memcmp(&IID_IOleCacheControl, riid, sizeof(IID_IOleCacheControl)) == 0)
 927   {
 928     *ppvObject = (IOleCacheControl*)&(this->lpvtbl6);
 929   }
 930
 931   /*
 932    * Check that we obtained an interface.
 933    */
 934   if ((*ppvObject)==0)
 935   {
 936     WARN( "() : asking for un supported interface %s\n", debugstr_guid(riid));
 937     return E_NOINTERFACE;
 938   }
 939
 940   /*
 941    * Query Interface always increases the reference count by one when it is
 942    * successful.
 943    */
 944   IUnknown_AddRef((IUnknown*)*ppvObject);
 945
 946   return S_OK;;
 947 }
 948
 949 /************************************************************************
 950  * DataCache_NDIUnknown_AddRef (IUnknown)
 951  *
 952  * See Windows documentation for more details on IUnknown methods.
 953  *
 954  * This version of QueryInterface will not delegate it's implementation
 955  * to the outer unknown.
 956  */
 957 static ULONG WINAPI DataCache_NDIUnknown_AddRef(
 958             IUnknown*      iface)
 959 {
 960   _ICOM_THIS_From_NDIUnknown(DataCache, iface);
 961
 962   this->ref++;
 963
 964   return this->ref;
 965 }
 966
 967 /************************************************************************
 968  * DataCache_NDIUnknown_Release (IUnknown)
 969  *
 970  * See Windows documentation for more details on IUnknown methods.
 971  *
 972  * This version of QueryInterface will not delegate it's implementation
 973  * to the outer unknown.
 974  */
 975 static ULONG WINAPI DataCache_NDIUnknown_Release(
 976             IUnknown*      iface)
 977 {
 978   _ICOM_THIS_From_NDIUnknown(DataCache, iface);
 979
 980   /*
 981    * Decrease the reference count on this object.
 982    */
 983   this->ref--;
 984
 985   /*
 986    * If the reference count goes down to 0, perform suicide.
 987    */
 988   if (this->ref==0)
 989   {
 990     DataCache_Destroy(this);
 991
 992     return 0;
 993   }
 994
 995   return this->ref;
 996 }
 997
 998 /*********************************************************
 999  * Method implementation for the IDataObject
1000  * part of the DataCache class.
1001  */
1002
1003 /************************************************************************
1004  * DataCache_IDataObject_QueryInterface (IUnknown)
1005  *
1006  * See Windows documentation for more details on IUnknown methods.
1007  */
1008 static HRESULT WINAPI DataCache_IDataObject_QueryInterface(
1009             IDataObject*     iface,
1010             REFIID           riid,
1011             void**           ppvObject)
1012 {
1013   _ICOM_THIS_From_IDataObject(DataCache, iface);
1014
1015   return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
1016 }
1017
1018 /************************************************************************
1019  * DataCache_IDataObject_AddRef (IUnknown)
1020  *
1021  * See Windows documentation for more details on IUnknown methods.
1022  */
1023 static ULONG WINAPI DataCache_IDataObject_AddRef(
1024             IDataObject*     iface)
1025 {
1026   _ICOM_THIS_From_IDataObject(DataCache, iface);
1027
1028   return IUnknown_AddRef(this->outerUnknown);
1029 }
1030
1031 /************************************************************************
1032  * DataCache_IDataObject_Release (IUnknown)
1033  *
1034  * See Windows documentation for more details on IUnknown methods.
1035  */
1036 static ULONG WINAPI DataCache_IDataObject_Release(
1037             IDataObject*     iface)
1038 {
1039   _ICOM_THIS_From_IDataObject(DataCache, iface);
1040
1041   return IUnknown_Release(this->outerUnknown);
1042 }
1043
1044 /************************************************************************
1045  * DataCache_GetData
1046  *
1047  * Get Data from a source dataobject using format pformatetcIn->cfFormat
1048  * See Windows documentation for more details on GetData.
1049  * TODO: Currently only CF_METAFILEPICT is implemented
1050  */
1051 static HRESULT WINAPI DataCache_GetData(
1052             IDataObject*     iface,
1053             LPFORMATETC      pformatetcIn,
1054             STGMEDIUM*       pmedium)
1055 {
1056   HRESULT hr = 0;
1057   HRESULT hrRet = E_UNEXPECTED;
1058   IPersistStorage *pPersistStorage = 0;
1059   IStorage *pStorage = 0;
1060   IStream *pStream = 0;
1061   OLECHAR name[]={ 2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '0', '0', '0', 0};
1062   HGLOBAL hGlobalMF = 0;
1063   void *mfBits = 0;
1064   PresentationDataHeader pdh;
1065   METAFILEPICT *mfPict;
1066   HMETAFILE hMetaFile = 0;
1067
1068   if (pformatetcIn->cfFormat == CF_METAFILEPICT)
1069   {
1070     /* Get the Persist Storage */
1071
1072     hr = IDataObject_QueryInterface(iface, &IID_IPersistStorage, (void**)&pPersistStorage);
1073
1074     if (hr != S_OK)
1075       goto cleanup;
1076
1077     /* Create a doc file to copy the doc to a storage */
1078
1079     hr = StgCreateDocfile(NULL, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &pStorage);
1080
1081     if (hr != S_OK)
1082       goto cleanup;
1083
1084     /* Save it to storage */
1085
1086     hr = OleSave(pPersistStorage, pStorage, FALSE);
1087
1088     if (hr != S_OK)
1089       goto cleanup;
1090
1091     /* Open the Presentation data srteam */
1092
1093     hr = IStorage_OpenStream(pStorage, name, 0, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &pStream);
1094
1095     if (hr != S_OK)
1096       goto cleanup;
1097
1098     /* Read the presentation header */
1099
1100     hr = IStream_Read(pStream, &pdh, sizeof(PresentationDataHeader), NULL);
1101
1102     if (hr != S_OK)
1103       goto cleanup;
1104
1105     mfBits = HeapAlloc(GetProcessHeap(), 0, pdh.dwSize);
1106
1107     /* Read the Metafile bits */
1108
1109     hr = IStream_Read(pStream, mfBits, pdh.dwSize, NULL);
1110
1111     if (hr != S_OK)
1112       goto cleanup;
1113
1114     /* Create the metafile and place it in the STGMEDIUM structure */
1115
1116     hMetaFile = SetMetaFileBitsEx(pdh.dwSize, mfBits);
1117
1118     hGlobalMF = GlobalAlloc(GMEM_SHARE|GMEM_MOVEABLE, sizeof(METAFILEPICT));
1119     mfPict = (METAFILEPICT *)GlobalLock(hGlobalMF);
1120     mfPict->hMF = hMetaFile;
1121
1122     GlobalUnlock(hGlobalMF);
1123
1124     pmedium->u.hGlobal = hGlobalMF;
1125     pmedium->tymed = TYMED_MFPICT;
1126     hrRet = S_OK;
1127
1128 cleanup:
1129
1130     if (mfBits)
1131       HeapFree(GetProcessHeap(), 0, mfBits);
1132
1133     if (pStream)
1134       IStream_Release(pStream);
1135
1136     if (pStorage)
1137       IStorage_Release(pStorage);
1138
1139     if (pPersistStorage)
1140       IPersistStorage_Release(pPersistStorage);
1141
1142     return hrRet;
1143   }
1144
1145   /* TODO: Other formats are not implemented */
1146
1147   return E_NOTIMPL;
1148 }
1149
1150 static HRESULT WINAPI DataCache_GetDataHere(
1151             IDataObject*     iface,
1152             LPFORMATETC      pformatetc,
1153             STGMEDIUM*       pmedium)
1154 {
1155   FIXME("stub\n");
1156   return E_NOTIMPL;
1157 }
1158
1159 static HRESULT WINAPI DataCache_QueryGetData(
1160             IDataObject*     iface,
1161             LPFORMATETC      pformatetc)
1162 {
1163   FIXME("stub\n");
1164   return E_NOTIMPL;
1165 }
1166
1167 /************************************************************************
1168  * DataCache_EnumFormatEtc (IDataObject)
1169  *
1170  * The data cache doesn't implement this method.
1171  *
1172  * See Windows documentation for more details on IDataObject methods.
1173  */
1174 static HRESULT WINAPI DataCache_GetCanonicalFormatEtc(
1175             IDataObject*     iface,
1176             LPFORMATETC      pformatectIn,
1177             LPFORMATETC      pformatetcOut)
1178 {
1179   TRACE("()\n");
1180   return E_NOTIMPL;
1181 }
1182
1183 /************************************************************************
1184  * DataCache_IDataObject_SetData (IDataObject)
1185  *
1186  * This method is delegated to the IOleCache2 implementation.
1187  *
1188  * See Windows documentation for more details on IDataObject methods.
1189  */
1190 static HRESULT WINAPI DataCache_IDataObject_SetData(
1191             IDataObject*     iface,
1192             LPFORMATETC      pformatetc,
1193             STGMEDIUM*       pmedium,
1194             BOOL             fRelease)
1195 {
1196   IOleCache2* oleCache = NULL;
1197   HRESULT     hres;
1198
1199   TRACE("(%p, %p, %p, %d)\n", iface, pformatetc, pmedium, fRelease);
1200
1201   hres = IDataObject_QueryInterface(iface, &IID_IOleCache2, (void**)&oleCache);
1202
1203   if (FAILED(hres))
1204     return E_UNEXPECTED;
1205
1206   hres = IOleCache2_SetData(oleCache, pformatetc, pmedium, fRelease);
1207
1208   IOleCache2_Release(oleCache);
1209
1210   return hres;;
1211 }
1212
1213 /************************************************************************
1214  * DataCache_EnumFormatEtc (IDataObject)
1215  *
1216  * The data cache doesn't implement this method.
1217  *
1218  * See Windows documentation for more details on IDataObject methods.
1219  */
1220 static HRESULT WINAPI DataCache_EnumFormatEtc(
1221             IDataObject*     iface,
1222             DWORD            dwDirection,
1223             IEnumFORMATETC** ppenumFormatEtc)
1224 {
1225   TRACE("()\n");
1226   return E_NOTIMPL;
1227 }
1228
1229 /************************************************************************
1230  * DataCache_DAdvise (IDataObject)
1231  *
1232  * The data cache doesn't support connections.
1233  *
1234  * See Windows documentation for more details on IDataObject methods.
1235  */
1236 static HRESULT WINAPI DataCache_DAdvise(
1237             IDataObject*     iface,
1238             FORMATETC*       pformatetc,
1239             DWORD            advf,
1240             IAdviseSink*     pAdvSink,
1241             DWORD*           pdwConnection)
1242 {
1243   TRACE("()\n");
1244   return OLE_E_ADVISENOTSUPPORTED;
1245 }
1246
1247 /************************************************************************
1248  * DataCache_DUnadvise (IDataObject)
1249  *
1250  * The data cache doesn't support connections.
1251  *
1252  * See Windows documentation for more details on IDataObject methods.
1253  */
1254 static HRESULT WINAPI DataCache_DUnadvise(
1255             IDataObject*     iface,
1256             DWORD            dwConnection)
1257 {
1258   TRACE("()\n");
1259   return OLE_E_NOCONNECTION;
1260 }
1261
1262 /************************************************************************
1263  * DataCache_EnumDAdvise (IDataObject)
1264  *
1265  * The data cache doesn't support connections.
1266  *
1267  * See Windows documentation for more details on IDataObject methods.
1268  */
1269 static HRESULT WINAPI DataCache_EnumDAdvise(
1270             IDataObject*     iface,
1271             IEnumSTATDATA**  ppenumAdvise)
1272 {
1273   TRACE("()\n");
1274   return OLE_E_ADVISENOTSUPPORTED;
1275 }
1276
1277 /*********************************************************
1278  * Method implementation for the IDataObject
1279  * part of the DataCache class.
1280  */
1281
1282 /************************************************************************
1283  * DataCache_IPersistStorage_QueryInterface (IUnknown)
1284  *
1285  * See Windows documentation for more details on IUnknown methods.
1286  */
1287 static HRESULT WINAPI DataCache_IPersistStorage_QueryInterface(
1288             IPersistStorage* iface,
1289             REFIID           riid,
1290             void**           ppvObject)
1291 {
1292   _ICOM_THIS_From_IPersistStorage(DataCache, iface);
1293
1294   return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
1295 }
1296
1297 /************************************************************************
1298  * DataCache_IPersistStorage_AddRef (IUnknown)
1299  *
1300  * See Windows documentation for more details on IUnknown methods.
1301  */
1302 static ULONG WINAPI DataCache_IPersistStorage_AddRef(
1303             IPersistStorage* iface)
1304 {
1305   _ICOM_THIS_From_IPersistStorage(DataCache, iface);
1306
1307   return IUnknown_AddRef(this->outerUnknown);
1308 }
1309
1310 /************************************************************************
1311  * DataCache_IPersistStorage_Release (IUnknown)
1312  *
1313  * See Windows documentation for more details on IUnknown methods.
1314  */
1315 static ULONG WINAPI DataCache_IPersistStorage_Release(
1316             IPersistStorage* iface)
1317 {
1318   _ICOM_THIS_From_IPersistStorage(DataCache, iface);
1319
1320   return IUnknown_Release(this->outerUnknown);
1321 }
1322
1323 /************************************************************************
1324  * DataCache_GetClassID (IPersistStorage)
1325  *
1326  * The data cache doesn't implement this method.
1327  *
1328  * See Windows documentation for more details on IPersistStorage methods.
1329  */
1330 static HRESULT WINAPI DataCache_GetClassID(
1331             IPersistStorage* iface,
1332             CLSID*           pClassID)
1333 {
1334   TRACE("(%p, %p)\n", iface, pClassID);
1335   return E_NOTIMPL;
1336 }
1337
1338 /************************************************************************
1339  * DataCache_IsDirty (IPersistStorage)
1340  *
1341  * Until we actully connect to a running object and retrieve new
1342  * information to it, we never get dirty.
1343  *
1344  * See Windows documentation for more details on IPersistStorage methods.
1345  */
1346 static HRESULT WINAPI DataCache_IsDirty(
1347             IPersistStorage* iface)
1348 {
1349   TRACE("(%p)\n", iface);
1350
1351   return S_FALSE;
1352 }
1353
1354 /************************************************************************
1355  * DataCache_InitNew (IPersistStorage)
1356  *
1357  * The data cache implementation of IPersistStorage_InitNew simply stores
1358  * the storage pointer.
1359  *
1360  * See Windows documentation for more details on IPersistStorage methods.
1361  */
1362 static HRESULT WINAPI DataCache_InitNew(
1363             IPersistStorage* iface,
1364             IStorage*        pStg)
1365 {
1366   TRACE("(%p, %p)\n", iface, pStg);
1367
1368   return DataCache_Load(iface, pStg);
1369 }
1370
1371 /************************************************************************
1372  * DataCache_Load (IPersistStorage)
1373  *
1374  * The data cache implementation of IPersistStorage_Load doesn't
1375  * actually load anything. Instead, it holds on to the storage pointer
1376  * and it will load the presentation information when the
1377  * IDataObject_GetData or IViewObject2_Draw methods are called.
1378  *
1379  * See Windows documentation for more details on IPersistStorage methods.
1380  */
1381 static HRESULT WINAPI DataCache_Load(
1382             IPersistStorage* iface,
1383             IStorage*        pStg)
1384 {
1385   _ICOM_THIS_From_IPersistStorage(DataCache, iface);
1386
1387   TRACE("(%p, %p)\n", iface, pStg);
1388
1389   if (this->presentationStorage != NULL)
1390   {
1391     IStorage_Release(this->presentationStorage);
1392   }
1393
1394   this->presentationStorage = pStg;
1395
1396   if (this->presentationStorage != NULL)
1397   {
1398     IStorage_AddRef(this->presentationStorage);
1399   }
1400   return S_OK;
1401 }
1402
1403 /************************************************************************
1404  * DataCache_Save (IPersistStorage)
1405  *
1406  * Until we actully connect to a running object and retrieve new
1407  * information to it, we never have to save anything. However, it is
1408  * our responsability to copy the information when saving to a new
1409  * storage.
1410  *
1411  * See Windows documentation for more details on IPersistStorage methods.
1412  */
1413 static HRESULT WINAPI DataCache_Save(
1414             IPersistStorage* iface,
1415             IStorage*        pStg,
1416             BOOL             fSameAsLoad)
1417 {
1418   _ICOM_THIS_From_IPersistStorage(DataCache, iface);
1419
1420   TRACE("(%p, %p, %d)\n", iface, pStg, fSameAsLoad);
1421
1422   if ( (!fSameAsLoad) &&
1423        (this->presentationStorage!=NULL) )
1424   {
1425     return IStorage_CopyTo(this->presentationStorage,
1426                            0,
1427                            NULL,
1428                            NULL,
1429                            pStg);
1430   }
1431
1432   return S_OK;
1433 }
1434
1435 /************************************************************************
1436  * DataCache_SaveCompleted (IPersistStorage)
1437  *
1438  * This method is called to tell the cache to release the storage
1439  * pointer it's currentlu holding.
1440  *
1441  * See Windows documentation for more details on IPersistStorage methods.
1442  */
1443 static HRESULT WINAPI DataCache_SaveCompleted(
1444             IPersistStorage* iface,
1445             IStorage*        pStgNew)
1446 {
1447   TRACE("(%p, %p)\n", iface, pStgNew);
1448
1449   if (pStgNew)
1450   {
1451   /*
1452    * First, make sure we get our hands off any storage we have.
1453    */
1454
1455   DataCache_HandsOffStorage(iface);
1456
1457   /*
1458    * Then, attach to the new storage.
1459    */
1460
1461   DataCache_Load(iface, pStgNew);
1462   }
1463
1464   return S_OK;
1465 }
1466
1467 /************************************************************************
1468  * DataCache_HandsOffStorage (IPersistStorage)
1469  *
1470  * This method is called to tell the cache to release the storage
1471  * pointer it's currentlu holding.
1472  *
1473  * See Windows documentation for more details on IPersistStorage methods.
1474  */
1475 static HRESULT WINAPI DataCache_HandsOffStorage(
1476             IPersistStorage* iface)
1477 {
1478   _ICOM_THIS_From_IPersistStorage(DataCache, iface);
1479
1480   TRACE("(%p)\n", iface);
1481
1482   if (this->presentationStorage != NULL)
1483   {
1484     IStorage_Release(this->presentationStorage);
1485     this->presentationStorage = NULL;
1486   }
1487
1488   return S_OK;
1489 }
1490
1491 /*********************************************************
1492  * Method implementation for the IViewObject2
1493  * part of the DataCache class.
1494  */
1495
1496 /************************************************************************
1497  * DataCache_IViewObject2_QueryInterface (IUnknown)
1498  *
1499  * See Windows documentation for more details on IUnknown methods.
1500  */
1501 static HRESULT WINAPI DataCache_IViewObject2_QueryInterface(
1502             IViewObject2* iface,
1503             REFIID           riid,
1504             void**           ppvObject)
1505 {
1506   _ICOM_THIS_From_IViewObject2(DataCache, iface);
1507
1508   return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
1509 }
1510
1511 /************************************************************************
1512  * DataCache_IViewObject2_AddRef (IUnknown)
1513  *
1514  * See Windows documentation for more details on IUnknown methods.
1515  */
1516 static ULONG WINAPI DataCache_IViewObject2_AddRef(
1517             IViewObject2* iface)
1518 {
1519   _ICOM_THIS_From_IViewObject2(DataCache, iface);
1520
1521   return IUnknown_AddRef(this->outerUnknown);
1522 }
1523
1524 /************************************************************************
1525  * DataCache_IViewObject2_Release (IUnknown)
1526  *
1527  * See Windows documentation for more details on IUnknown methods.
1528  */
1529 static ULONG WINAPI DataCache_IViewObject2_Release(
1530             IViewObject2* iface)
1531 {
1532   _ICOM_THIS_From_IViewObject2(DataCache, iface);
1533
1534   return IUnknown_Release(this->outerUnknown);
1535 }
1536
1537 /************************************************************************
1538  * DataCache_Draw (IViewObject2)
1539  *
1540  * This method will draw the cached representation of the object
1541  * to the given device context.
1542  *
1543  * See Windows documentation for more details on IViewObject2 methods.
1544  */
1545 static HRESULT WINAPI DataCache_Draw(
1546             IViewObject2*    iface,
1547             DWORD            dwDrawAspect,
1548             LONG             lindex,
1549             void*            pvAspect,
1550             DVTARGETDEVICE*  ptd,
1551             HDC              hdcTargetDev,
1552             HDC              hdcDraw,
1553             LPCRECTL         lprcBounds,
1554             LPCRECTL         lprcWBounds,
1555             IVO_ContCallback pfnContinue,
1556             DWORD            dwContinue)
1557 {
1558   PresentationDataHeader presData;
1559   HMETAFILE              presMetafile = 0;
1560   HRESULT                hres;
1561
1562   _ICOM_THIS_From_IViewObject2(DataCache, iface);
1563
1564   TRACE("(%p, %lx, %ld, %p, %x, %x, %p, %p, %p, %lx)\n",
1565         iface,
1566         dwDrawAspect,
1567         lindex,
1568         pvAspect,
1569         hdcTargetDev,
1570         hdcDraw,
1571         lprcBounds,
1572         lprcWBounds,
1573         pfnContinue,
1574         dwContinue);
1575
1576   /*
1577    * Sanity check
1578    */
1579   if (lprcBounds==NULL)
1580     return E_INVALIDARG;
1581
1582   /*
1583    * First, we need to retrieve the dimensions of the
1584    * image in the metafile.
1585    */
1586   hres = DataCache_ReadPresentationData(this,
1587                                         dwDrawAspect,
1588                                         &presData);
1589
1590   if (FAILED(hres))
1591     return hres;
1592
1593   /*
1594    * Then, we can extract the metafile itself from the cached
1595    * data.
1596    *
1597    * FIXME Unless it isn't a metafile. I think it could be any CF_XXX type,
1598    * particularly CF_DIB.
1599    */
1600   presMetafile = DataCache_ReadPresMetafile(this,
1601                                             dwDrawAspect);
1602
1603   /*
1604    * If we have a metafile, just draw baby...
1605    * We have to be careful not to modify the state of the
1606    * DC.
1607    */
1608   if (presMetafile!=0)
1609   {
1610     INT   prevMapMode = SetMapMode(hdcDraw, MM_ANISOTROPIC);
1611     SIZE  oldWindowExt;
1612     SIZE  oldViewportExt;
1613     POINT oldViewportOrg;
1614
1615     SetWindowExtEx(hdcDraw,
1616                    presData.dwObjectExtentX,
1617                    presData.dwObjectExtentY,
1618                    &oldWindowExt);
1619
1620     SetViewportExtEx(hdcDraw,
1621                      lprcBounds->right - lprcBounds->left,
1622                      lprcBounds->bottom - lprcBounds->top,
1623                      &oldViewportExt);
1624
1625     SetViewportOrgEx(hdcDraw,
1626                      lprcBounds->left,
1627                      lprcBounds->top,
1628                      &oldViewportOrg);
1629
1630     PlayMetaFile(hdcDraw, presMetafile);
1631
1632     SetWindowExtEx(hdcDraw,
1633                    oldWindowExt.cx,
1634                    oldWindowExt.cy,
1635                    NULL);
1636
1637     SetViewportExtEx(hdcDraw,
1638                      oldViewportExt.cx,
1639                      oldViewportExt.cy,
1640                      NULL);
1641
1642     SetViewportOrgEx(hdcDraw,
1643                      oldViewportOrg.x,
1644                      oldViewportOrg.y,
1645                      NULL);
1646
1647     SetMapMode(hdcDraw, prevMapMode);
1648
1649     DeleteMetaFile(presMetafile);
1650   }
1651
1652   return S_OK;
1653 }
1654
1655 static HRESULT WINAPI DataCache_GetColorSet(
1656             IViewObject2*   iface,
1657             DWORD           dwDrawAspect,
1658             LONG            lindex,
1659             void*           pvAspect,
1660             DVTARGETDEVICE* ptd,
1661             HDC             hicTargetDevice,
1662             LOGPALETTE**    ppColorSet)
1663 {
1664   FIXME("stub\n");
1665   return E_NOTIMPL;
1666 }
1667
1668 static HRESULT WINAPI DataCache_Freeze(
1669             IViewObject2*   iface,
1670             DWORD           dwDrawAspect,
1671             LONG            lindex,
1672             void*           pvAspect,
1673             DWORD*          pdwFreeze)
1674 {
1675   FIXME("stub\n");
1676   return E_NOTIMPL;
1677 }
1678
1679 static HRESULT WINAPI DataCache_Unfreeze(
1680             IViewObject2*   iface,
1681             DWORD           dwFreeze)
1682 {
1683   FIXME("stub\n");
1684   return E_NOTIMPL;
1685 }
1686
1687 /************************************************************************
1688  * DataCache_SetAdvise (IViewObject2)
1689  *
1690  * This sets-up an advisory sink with the data cache. When the object's
1691  * view changes, this sink is called.
1692  *
1693  * See Windows documentation for more details on IViewObject2 methods.
1694  */
1695 static HRESULT WINAPI DataCache_SetAdvise(
1696             IViewObject2*   iface,
1697             DWORD           aspects,
1698             DWORD           advf,
1699             IAdviseSink*    pAdvSink)
1700 {
1701   _ICOM_THIS_From_IViewObject2(DataCache, iface);
1702
1703   TRACE("(%p, %lx, %lx, %p)\n", iface, aspects, advf, pAdvSink);
1704
1705   /*
1706    * A call to this function removes the previous sink
1707    */
1708   if (this->sinkInterface != NULL)
1709   {
1710     IAdviseSink_Release(this->sinkInterface);
1711     this->sinkInterface  = NULL;
1712     this->sinkAspects    = 0;
1713     this->sinkAdviseFlag = 0;
1714   }
1715
1716   /*
1717    * Now, setup the new one.
1718    */
1719   if (pAdvSink!=NULL)
1720   {
1721     this->sinkInterface  = pAdvSink;
1722     this->sinkAspects    = aspects;
1723     this->sinkAdviseFlag = advf;
1724
1725     IAdviseSink_AddRef(this->sinkInterface);
1726   }
1727
1728   /*
1729    * When the ADVF_PRIMEFIRST flag is set, we have to advise the
1730    * sink immediately.
1731    */
1732   if (advf & ADVF_PRIMEFIRST)
1733   {
1734     DataCache_FireOnViewChange(this,
1735                                DVASPECT_CONTENT,
1736                                -1);
1737   }
1738
1739   return S_OK;
1740 }
1741
1742 /************************************************************************
1743  * DataCache_GetAdvise (IViewObject2)
1744  *
1745  * This method queries the current state of the advise sink
1746  * installed on the data cache.
1747  *
1748  * See Windows documentation for more details on IViewObject2 methods.
1749  */
1750 static HRESULT WINAPI DataCache_GetAdvise(
1751             IViewObject2*   iface,
1752             DWORD*          pAspects,
1753             DWORD*          pAdvf,
1754             IAdviseSink**   ppAdvSink)
1755 {
1756   _ICOM_THIS_From_IViewObject2(DataCache, iface);
1757
1758   TRACE("(%p, %p, %p, %p)\n", iface, pAspects, pAdvf, ppAdvSink);
1759
1760   /*
1761    * Just copy all the requested values.
1762    */
1763   if (pAspects!=NULL)
1764     *pAspects = this->sinkAspects;
1765
1766   if (pAdvf!=NULL)
1767     *pAdvf = this->sinkAdviseFlag;
1768
1769   if (ppAdvSink!=NULL)
1770   {
1771     IAdviseSink_QueryInterface(this->sinkInterface,
1772                                &IID_IAdviseSink,
1773                                (void**)ppAdvSink);
1774   }
1775
1776   return S_OK;
1777 }
1778
1779 /************************************************************************
1780  * DataCache_GetExtent (IViewObject2)
1781  *
1782  * This method retrieves the "natural" size of this cached object.
1783  *
1784  * See Windows documentation for more details on IViewObject2 methods.
1785  */
1786 static HRESULT WINAPI DataCache_GetExtent(
1787             IViewObject2*   iface,
1788             DWORD           dwDrawAspect,
1789             LONG            lindex,
1790             DVTARGETDEVICE* ptd,
1791             LPSIZEL         lpsizel)
1792 {
1793   PresentationDataHeader presData;
1794   HRESULT                hres = E_FAIL;
1795
1796   _ICOM_THIS_From_IViewObject2(DataCache, iface);
1797
1798   TRACE("(%p, %lx, %ld, %p, %p)\n",
1799         iface, dwDrawAspect, lindex, ptd, lpsizel);
1800
1801   /*
1802    * Sanity check
1803    */
1804   if (lpsizel==NULL)
1805     return E_POINTER;
1806
1807   /*
1808    * Initialize the out parameter.
1809    */
1810   lpsizel->cx = 0;
1811   lpsizel->cy = 0;
1812
1813   /*
1814    * This flag should be set to -1.
1815    */
1816   if (lindex!=-1)
1817     FIXME("Unimplemented flag lindex = %ld\n", lindex);
1818
1819   /*
1820    * Right now, we suport only the callback from
1821    * the default handler.
1822    */
1823   if (ptd!=NULL)
1824     FIXME("Unimplemented ptd = %p\n", ptd);
1825
1826   /*
1827    * Get the presentation information from the
1828    * cache.
1829    */
1830   hres = DataCache_ReadPresentationData(this,
1831                                         dwDrawAspect,
1832                                         &presData);
1833
1834   if (SUCCEEDED(hres))
1835   {
1836     lpsizel->cx = presData.dwObjectExtentX;
1837     lpsizel->cy = presData.dwObjectExtentY;
1838   }
1839
1840   /*
1841    * This method returns OLE_E_BLANK when it fails.
1842    */
1843   if (FAILED(hres))
1844     hres = OLE_E_BLANK;
1845
1846   return hres;
1847 }
1848
1849
1850 /*********************************************************
1851  * Method implementation for the IOleCache2
1852  * part of the DataCache class.
1853  */
1854
1855 /************************************************************************
1856  * DataCache_IOleCache2_QueryInterface (IUnknown)
1857  *
1858  * See Windows documentation for more details on IUnknown methods.
1859  */
1860 static HRESULT WINAPI DataCache_IOleCache2_QueryInterface(
1861             IOleCache2*     iface,
1862             REFIID          riid,
1863             void**          ppvObject)
1864 {
1865   _ICOM_THIS_From_IOleCache2(DataCache, iface);
1866
1867   return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
1868 }
1869
1870 /************************************************************************
1871  * DataCache_IOleCache2_AddRef (IUnknown)
1872  *
1873  * See Windows documentation for more details on IUnknown methods.
1874  */
1875 static ULONG WINAPI DataCache_IOleCache2_AddRef(
1876             IOleCache2*     iface)
1877 {
1878   _ICOM_THIS_From_IOleCache2(DataCache, iface);
1879
1880   return IUnknown_AddRef(this->outerUnknown);
1881 }
1882
1883 /************************************************************************
1884  * DataCache_IOleCache2_Release (IUnknown)
1885  *
1886  * See Windows documentation for more details on IUnknown methods.
1887  */
1888 static ULONG WINAPI DataCache_IOleCache2_Release(
1889             IOleCache2*     iface)
1890 {
1891   _ICOM_THIS_From_IOleCache2(DataCache, iface);
1892
1893   return IUnknown_Release(this->outerUnknown);
1894 }
1895
1896 static HRESULT WINAPI DataCache_Cache(
1897             IOleCache2*     iface,
1898             FORMATETC*      pformatetc,
1899             DWORD           advf,
1900             DWORD*          pdwConnection)
1901 {
1902   FIXME("stub\n");
1903   return E_NOTIMPL;
1904 }
1905
1906 static HRESULT WINAPI DataCache_Uncache(
1907             IOleCache2*     iface,
1908             DWORD           dwConnection)
1909 {
1910   FIXME("stub\n");
1911   return E_NOTIMPL;
1912 }
1913
1914 static HRESULT WINAPI DataCache_EnumCache(
1915             IOleCache2*     iface,
1916             IEnumSTATDATA** ppenumSTATDATA)
1917 {
1918   FIXME("stub\n");
1919   return E_NOTIMPL;
1920 }
1921
1922 static HRESULT WINAPI DataCache_InitCache(
1923             IOleCache2*     iface,
1924             IDataObject*    pDataObject)
1925 {
1926   FIXME("stub\n");
1927   return E_NOTIMPL;
1928 }
1929
1930 static HRESULT WINAPI DataCache_IOleCache2_SetData(
1931             IOleCache2*     iface,
1932             FORMATETC*      pformatetc,
1933             STGMEDIUM*      pmedium,
1934             BOOL            fRelease)
1935 {
1936   FIXME("stub\n");
1937   return E_NOTIMPL;
1938 }
1939
1940 static HRESULT WINAPI DataCache_UpdateCache(
1941             IOleCache2*     iface,
1942             LPDATAOBJECT    pDataObject,
1943             DWORD           grfUpdf,
1944             LPVOID          pReserved)
1945 {
1946   FIXME("stub\n");
1947   return E_NOTIMPL;
1948 }
1949
1950 static HRESULT WINAPI DataCache_DiscardCache(
1951             IOleCache2*     iface,
1952             DWORD           dwDiscardOptions)
1953 {
1954   FIXME("stub\n");
1955   return E_NOTIMPL;
1956 }
1957
1958
1959 /*********************************************************
1960  * Method implementation for the IOleCacheControl
1961  * part of the DataCache class.
1962  */
1963
1964 /************************************************************************
1965  * DataCache_IOleCacheControl_QueryInterface (IUnknown)
1966  *
1967  * See Windows documentation for more details on IUnknown methods.
1968  */
1969 static HRESULT WINAPI DataCache_IOleCacheControl_QueryInterface(
1970             IOleCacheControl* iface,
1971             REFIID            riid,
1972             void**            ppvObject)
1973 {
1974   _ICOM_THIS_From_IOleCacheControl(DataCache, iface);
1975
1976   return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
1977 }
1978
1979 /************************************************************************
1980  * DataCache_IOleCacheControl_AddRef (IUnknown)
1981  *
1982  * See Windows documentation for more details on IUnknown methods.
1983  */
1984 static ULONG WINAPI DataCache_IOleCacheControl_AddRef(
1985             IOleCacheControl* iface)
1986 {
1987   _ICOM_THIS_From_IOleCacheControl(DataCache, iface);
1988
1989   return IUnknown_AddRef(this->outerUnknown);
1990 }
1991
1992 /************************************************************************
1993  * DataCache_IOleCacheControl_Release (IUnknown)
1994  *
1995  * See Windows documentation for more details on IUnknown methods.
1996  */
1997 static ULONG WINAPI DataCache_IOleCacheControl_Release(
1998             IOleCacheControl* iface)
1999 {
2000   _ICOM_THIS_From_IOleCacheControl(DataCache, iface);
2001
2002   return IUnknown_Release(this->outerUnknown);
2003 }
2004
2005 static HRESULT WINAPI DataCache_OnRun(
2006             IOleCacheControl* iface,
2007             LPDATAOBJECT      pDataObject)
2008 {
2009   FIXME("stub\n");
2010   return E_NOTIMPL;
2011 }
2012
2013 static HRESULT WINAPI DataCache_OnStop(
2014             IOleCacheControl* iface)
2015 {
2016   FIXME("stub\n");
2017   return E_NOTIMPL;
2018 }
2019
2020