ole/datacache.c

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