embedserv/source/inprocserv/inprocembobj.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <embservconst.h>
  21 #include "inprocembobj.h"
  22
  23 namespace inprocserv
  24 {
  25
  26 //-------------------------------------------------------------------------------
  27 BOOL StringsEqual( LPCOLESTR pszNameFromOutside, wchar_t* pOwnName )
  28 {
  29     BOOL bResult = TRUE;
  30
  31     if ( pszNameFromOutside && pOwnName )
  32     {
  33         for ( int nInd = 0; pszNameFromOutside[nInd] != 0 || pOwnName[nInd] != 0; nInd++ )
  34         {
  35             if ( pszNameFromOutside[nInd] != pOwnName[nInd] )
  36             {
  37                 bResult = FALSE;
  38                 break;
  39             }
  40         }
  41     }
  42     else if ( pszNameFromOutside || pOwnName )
  43         bResult = FALSE;
  44
  45     return bResult;
  46 }
  47
  48 //-------------------------------------------------------------------------------
  49 HRESULT InprocEmbedDocument_Impl::Init()
  50 {
  51     return S_OK;
  52 }
  53
  54 //-------------------------------------------------------------------------------
  55 void InprocEmbedDocument_Impl::SetName( LPCOLESTR pszNameFromOutside, wchar_t*& pOwnName )
  56 {
  57     if ( !pszNameFromOutside )
  58         return;
  59
  60     // copy the string
  61     size_t nLen = 0;
  62     while( pszNameFromOutside[nLen] != 0 )
  63         nLen++;
  64
  65     if ( pOwnName )
  66     {
  67         delete[] pOwnName;
  68         pOwnName = NULL;
  69     }
  70
  71     pOwnName = new wchar_t[nLen+1];
  72     for ( size_t nInd = 0; nInd < nLen; nInd++ )
  73         pOwnName[nInd] = pszNameFromOutside[nInd];
  74     pOwnName[nLen] = 0;
  75 }
  76
  77 //-------------------------------------------------------------------------------
  78 BOOL InprocEmbedDocument_Impl::CheckDefHandler()
  79 {
  80     // set the own listener
  81     if ( m_pOleAdvises[0] == NULL )
  82     {
  83         m_pOleAdvises[0] = new OleWrapperAdviseSink();
  84     }
  85     else
  86     {
  87         if ( m_pOleAdvises[0]->IsClosed() )
  88         {
  89             if ( m_pDefHandler )
  90             {
  91                 // deregister all the listeners
  92
  93                 ComSmart< IOleObject > pOleObject;
  94                 HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
  95                 if ( SUCCEEDED( hr ) && pOleObject )
  96                 {
  97                     for ( DWORD nInd = 0; nInd < DEFAULT_ARRAY_LEN; nInd++ )
  98                         if ( m_pOleAdvises[nInd] )
  99                         {
 100                             DWORD nID = m_pOleAdvises[nInd]->GetRegID();
 101                             pOleObject->Unadvise( nID );
 102                             m_pOleAdvises[nInd]->SetRegID( 0 );
 103                         }
 104
 105                     pOleObject->SetClientSite( NULL );
 106                 }
 107
 108                 ComSmart< IDataObject > pIDataObject;
 109                 hr = m_pDefHandler->QueryInterface( IID_IDataObject, (void**)&pIDataObject );
 110                 if ( SUCCEEDED( hr ) && pIDataObject )
 111                 {
 112                     for ( DWORD nInd = 0; nInd < DEFAULT_ARRAY_LEN; nInd++ )
 113                         if ( m_pDataAdvises[nInd] )
 114                         {
 115                             DWORD nID = m_pDataAdvises[nInd]->GetRegID();
 116                             pIDataObject->DUnadvise( nID );
 117                             m_pDataAdvises[nInd]->SetRegID( 0 );
 118                         }
 119                 }
 120
 121                 ComSmart< IViewObject > pIViewObject;
 122                 hr = m_pDefHandler->QueryInterface( IID_IViewObject, (void**)&pIViewObject );
 123                 if ( SUCCEEDED( hr ) && pIViewObject )
 124                 {
 125                     if ( m_pViewAdvise )
 126                         pIViewObject->SetAdvise( m_pViewAdvise->GetAspect(), m_pViewAdvise->GetViewAdviseFlag(), NULL );
 127                 }
 128
 129                 ComSmart< IPersistStorage > pPersist;
 130                 hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, (void**)&pPersist );
 131                 if ( SUCCEEDED( hr ) && pPersist )
 132                 {
 133                     // disconnect the old wrapper from the storage
 134                     pPersist->HandsOffStorage();
 135                 }
 136
 137                 m_pDefHandler = NULL;
 138             }
 139
 140             m_pOleAdvises[0]->UnsetClosed();
 141         }
 142     }
 143
 144     if ( m_nCallsOnStack )
 145         return FALSE;
 146
 147     if ( !m_pDefHandler )
 148     {
 149         // create a new default inprocess handler
 150         HRESULT hr = OleCreateDefaultHandler( m_guid, NULL, IID_IUnknown, (void**)&m_pDefHandler );
 151         if ( SUCCEEDED( hr ) )
 152         {
 153             {
 154                     if ( m_nInitMode == INIT_FROM_STORAGE )
 155                     {
 156                         ComSmart< IPersistStorage > pPersist;
 157                         hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, (void**)&pPersist );
 158
 159                         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 160                         if ( SUCCEEDED( hr ) && pPersist && m_pStorage )
 161                             hr = pPersist->InitNew( m_pStorage );
 162                     }
 163                     else if ( m_nInitMode == LOAD_FROM_STORAGE )
 164                     {
 165                         ComSmart< IPersistStorage > pPersist;
 166                         hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, (void**)&pPersist );
 167
 168                         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 169                         if ( SUCCEEDED( hr ) && pPersist && m_pStorage )
 170                             hr = pPersist->Load( m_pStorage );
 171                     }
 172                     else if ( m_nInitMode == LOAD_FROM_FILE )
 173                     {
 174                         ComSmart< IPersistFile > pPersistFile;
 175                         hr = m_pDefHandler->QueryInterface( IID_IPersistFile, (void**)&pPersistFile );
 176
 177                         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 178                         if ( SUCCEEDED( hr ) && pPersistFile && m_pFileName )
 179                             hr = pPersistFile->Load( m_pFileName, m_nFileOpenMode );
 180                     }
 181             }
 182         }
 183
 184         if ( !SUCCEEDED( hr ) || !m_pDefHandler )
 185         {
 186             m_pDefHandler = NULL;
 187             return FALSE;
 188         }
 189
 190         // register all the listeners new
 191
 192         ComSmart< IOleObject > pOleObject;
 193         hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 194         if ( SUCCEEDED( hr ) && pOleObject )
 195         {
 196             if ( m_pClientSite )
 197                 pOleObject->SetClientSite( m_pClientSite );
 198
 199             for ( DWORD nInd = 0; nInd < DEFAULT_ARRAY_LEN; nInd++ )
 200                 if ( m_pOleAdvises[nInd] )
 201                 {
 202                     DWORD nRegID = 0;
 203                     if ( SUCCEEDED( pOleObject->Advise( m_pOleAdvises[nInd], &nRegID ) ) && nRegID > 0 )
 204                         m_pOleAdvises[nInd]->SetRegID( nRegID );
 205                 }
 206         }
 207
 208         ComSmart< IDataObject > pIDataObject;
 209         hr = m_pDefHandler->QueryInterface( IID_IDataObject, (void**)&pIDataObject );
 210         if ( SUCCEEDED( hr ) && pIDataObject )
 211         {
 212             for ( DWORD nInd = 0; nInd < DEFAULT_ARRAY_LEN; nInd++ )
 213                 if ( m_pDataAdvises[nInd] )
 214                 {
 215                     DWORD nRegID = 0;
 216                     if ( SUCCEEDED( pIDataObject->DAdvise( m_pDataAdvises[nInd]->GetFormatEtc(), m_pDataAdvises[nInd]->GetDataAdviseFlag(), m_pDataAdvises[nInd], &nRegID ) ) && nRegID > 0 )
 217                         m_pDataAdvises[nInd]->SetRegID( nRegID );
 218                 }
 219         }
 220
 221         ComSmart< IViewObject > pIViewObject;
 222         hr = m_pDefHandler->QueryInterface( IID_IViewObject, (void**)&pIViewObject );
 223         if ( SUCCEEDED( hr ) && pIViewObject )
 224         {
 225             if ( m_pViewAdvise )
 226                 pIViewObject->SetAdvise( m_pViewAdvise->GetAspect(), m_pViewAdvise->GetViewAdviseFlag(), m_pViewAdvise );
 227         }
 228     }
 229
 230
 231     return TRUE;
 232 }
 233
 234 //-------------------------------------------------------------------------------
 235 DWORD InprocEmbedDocument_Impl::InsertAdviseLinkToList( const ComSmart<OleWrapperAdviseSink>& pOwnAdvise, ComSmart< OleWrapperAdviseSink > pAdvises[] )
 236 {
 237     // the result should start from 1 in case of success, the element 0 can be used for own needs
 238     DWORD nResult = 0;
 239
 240     if ( pOwnAdvise )
 241     {
 242         for ( DWORD nInd = 1; nInd < DEFAULT_ARRAY_LEN && nResult == 0; nInd++ )
 243         {
 244             if ( pAdvises[nInd] == pOwnAdvise )
 245             {
 246                 nResult = nInd;
 247             }
 248             else if ( pAdvises[nInd] == NULL )
 249             {
 250                 pAdvises[nInd] = pOwnAdvise;
 251                 nResult = nInd;
 252             }
 253         }
 254     }
 255
 256     return nResult;
 257 }
 258
 259 //-------------------------------------------------------------------------------
 260 void InprocEmbedDocument_Impl::Clean()
 261 {
 262     m_pDefHandler = (IUnknown*)NULL;
 263
 264     // no DisconnectOrigAdvise() call here, since it is no explicit disconnection
 265     for ( DWORD nInd = 0; nInd < DEFAULT_ARRAY_LEN; nInd++ )
 266     {
 267         if ( m_pOleAdvises[nInd] )
 268         {
 269             ComSmart< OleWrapperAdviseSink > pAdvise = m_pOleAdvises[nInd];
 270             m_pOleAdvises[nInd] = NULL;
 271         }
 272
 273         if ( m_pDataAdvises[nInd] )
 274         {
 275             ComSmart< OleWrapperAdviseSink > pAdvise = m_pDataAdvises[nInd];
 276             m_pDataAdvises[nInd] = NULL;
 277         }
 278     }
 279
 280     m_pViewAdvise = NULL;
 281
 282     m_nInitMode = NOINIT;
 283     m_pStorage = NULL;
 284
 285     if ( m_pOleContainer )
 286     {
 287         m_pOleContainer->LockContainer( FALSE );
 288         m_pOleContainer = NULL;
 289     }
 290
 291     m_pClientSite = NULL;
 292
 293     m_nFileOpenMode = 0;
 294     if ( m_pFileName )
 295     {
 296         delete m_pFileName;
 297         m_pFileName = NULL;
 298     }
 299 }
 300
 301 // IUnknown
 302 //-------------------------------------------------------------------------------
 303 STDMETHODIMP InprocEmbedDocument_Impl::QueryInterface( REFIID riid, void FAR* FAR* ppv )
 304 {
 305     if(IsEqualIID(riid, IID_IUnknown))
 306     {
 307         AddRef();
 308         *ppv = (IUnknown*) (IPersistStorage*) this;
 309         return S_OK;
 310     }
 311     else if (IsEqualIID(riid, IID_IPersist))
 312     {
 313         AddRef();
 314         *ppv = (IPersist*) (IPersistStorage*) this;
 315         return S_OK;
 316     }
 317     else if (IsEqualIID(riid, IID_IPersistStorage))
 318     {
 319         AddRef();
 320         *ppv = (IPersistStorage*) this;
 321         return S_OK;
 322     }
 323     else if (IsEqualIID(riid, IID_IDataObject))
 324     {
 325         AddRef();
 326         *ppv = (IDataObject*) this;
 327         return S_OK;
 328     }
 329     else if (IsEqualIID(riid, IID_IOleObject))
 330     {
 331         AddRef();
 332         *ppv = (IOleObject*) this;
 333         return S_OK;
 334     }
 335     else if (IsEqualIID(riid, IID_IPersistFile))
 336     {
 337         AddRef();
 338         *ppv = (IPersistFile*) this;
 339         return S_OK;
 340     }
 341     else if (IsEqualIID(riid, IID_IRunnableObject))
 342     {
 343         AddRef();
 344         *ppv = (IRunnableObject*) this;
 345         return S_OK;
 346     }
 347     else if (IsEqualIID(riid, IID_IViewObject))
 348     {
 349         AddRef();
 350         *ppv = (IViewObject*) this;
 351         return S_OK;
 352     }
 353     else if (IsEqualIID(riid, IID_IViewObject2))
 354     {
 355         AddRef();
 356         *ppv = (IViewObject2*) this;
 357         return S_OK;
 358     }
 359     else if (IsEqualIID(riid, IID_IOleCache))
 360     {
 361         AddRef();
 362         *ppv = (IOleCache*) &m_aInternalCache;
 363         return S_OK;
 364     }
 365     else if (IsEqualIID(riid, IID_IOleCache2))
 366     {
 367         AddRef();
 368         *ppv = (IOleCache2*) &m_aInternalCache;
 369         return S_OK;
 370     }
 371     else if (IsEqualIID(riid, IID_IOleWindow))
 372     {
 373         AddRef();
 374         *ppv = (IOleWindow*) this;
 375         return S_OK;
 376     }
 377     else if (IsEqualIID(riid, IID_IOleInPlaceObject))
 378     {
 379         AddRef();
 380         *ppv = (IOleInPlaceObject*) this;
 381         return S_OK;
 382     }
 383     else if (IsEqualIID(riid, IID_IDispatch))
 384     {
 385         AddRef();
 386         *ppv = (IDispatch*) this;
 387         return S_OK;
 388     }
 389
 390     *ppv = NULL;
 391     return ResultFromScode(E_NOINTERFACE);
 392 }
 393
 394 //-------------------------------------------------------------------------------
 395 STDMETHODIMP_(ULONG) InprocEmbedDocument_Impl::AddRef()
 396 {
 397     return ++m_refCount;
 398 }
 399
 400 //-------------------------------------------------------------------------------
 401 STDMETHODIMP_(ULONG) InprocEmbedDocument_Impl::Release()
 402 {
 403     // unfortunately there are reentrance problems in mfc that have to be workarounded
 404     sal_Int32 nCount = m_refCount > 0 ? --m_refCount : 0;
 405     if ( nCount == 0 && !m_bDeleted )
 406     {
 407         // deleting of this object can trigger deleting of mfc objects that will try to delete this object one more time
 408         m_bDeleted = TRUE;
 409
 410         Clean();
 411         delete this;
 412     }
 413     return nCount;
 414 }
 415
 416 // IPersist
 417 //-------------------------------------------------------------------------------
 418 STDMETHODIMP InprocEmbedDocument_Impl::GetClassID( CLSID* pClassId )
 419 {
 420     *pClassId = *&m_guid;
 421     return S_OK;
 422 }
 423
 424 // IPersistStorage
 425 //-------------------------------------------------------------------------------
 426 STDMETHODIMP InprocEmbedDocument_Impl::IsDirty()
 427 {
 428     if ( m_pDefHandler == NULL || m_pOleAdvises[0] == NULL || m_pOleAdvises[0]->IsClosed() )
 429         return S_FALSE;
 430
 431     if ( CheckDefHandler() )
 432     {
 433         ComSmart< IPersistStorage > pPersist;
 434         HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, (void**)&pPersist );
 435
 436         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 437         if ( SUCCEEDED( hr ) && pPersist )
 438             return pPersist->IsDirty();
 439     }
 440
 441     return E_FAIL;
 442 }
 443
 444 //-------------------------------------------------------------------------------
 445 STDMETHODIMP InprocEmbedDocument_Impl::InitNew( IStorage *pStg )
 446 {
 447     if ( CheckDefHandler() )
 448     {
 449         ComSmart< IPersistStorage > pPersist;
 450         HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, (void**)&pPersist );
 451
 452         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 453         if ( SUCCEEDED( hr ) && pPersist )
 454         {
 455             hr = pPersist->InitNew( pStg );
 456             if ( SUCCEEDED( hr ) )
 457             {
 458                 m_nInitMode = INIT_FROM_STORAGE;
 459                 m_pStorage = pStg;
 460
 461                 m_nFileOpenMode = 0;
 462                 if ( m_pFileName )
 463                 {
 464                     delete[] m_pFileName;
 465                     m_pFileName = NULL;
 466                 }
 467             }
 468
 469             return hr;
 470         }
 471     }
 472
 473     return E_FAIL;
 474 }
 475
 476 //-------------------------------------------------------------------------------
 477 STDMETHODIMP InprocEmbedDocument_Impl::Load( IStorage *pStg )
 478 {
 479     if ( CheckDefHandler() )
 480     {
 481         ComSmart< IPersistStorage > pPersist;
 482         HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, (void**)&pPersist );
 483
 484         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 485         if ( SUCCEEDED( hr ) && pPersist )
 486         {
 487             hr = pPersist->Load( pStg );
 488             if ( SUCCEEDED( hr ) )
 489             {
 490                 m_nInitMode = LOAD_FROM_STORAGE;
 491                 m_pStorage = pStg;
 492
 493                 m_nFileOpenMode = 0;
 494                 if ( m_pFileName )
 495                 {
 496                     delete[] m_pFileName;
 497                     m_pFileName = NULL;
 498                 }
 499             }
 500
 501             return hr;
 502         }
 503     }
 504
 505     return E_FAIL;
 506 }
 507
 508 //-------------------------------------------------------------------------------
 509 STDMETHODIMP InprocEmbedDocument_Impl::Save( IStorage *pStgSave, BOOL fSameAsLoad )
 510 {
 511     if ( fSameAsLoad && ( m_pDefHandler == NULL || m_pOleAdvises[0] == NULL || m_pOleAdvises[0]->IsClosed() ) )
 512         return S_OK;
 513
 514     if ( CheckDefHandler() )
 515     {
 516         ComSmart< IPersistStorage > pPersist;
 517         HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, (void**)&pPersist );
 518
 519         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 520         if ( SUCCEEDED( hr ) && pPersist )
 521             return pPersist->Save( pStgSave, fSameAsLoad );
 522     }
 523
 524     return E_FAIL;
 525 }
 526
 527 //-------------------------------------------------------------------------------
 528 STDMETHODIMP InprocEmbedDocument_Impl::SaveCompleted( IStorage *pStgNew )
 529 {
 530     if ( m_pDefHandler == NULL || m_pOleAdvises[0] == NULL || m_pOleAdvises[0]->IsClosed() )
 531     {
 532         if ( pStgNew )
 533             m_pStorage = pStgNew;
 534
 535         return S_OK;
 536     }
 537
 538     if ( CheckDefHandler() )
 539     {
 540         ComSmart< IPersistStorage > pPersist;
 541         HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, (void**)&pPersist );
 542
 543         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 544         if ( SUCCEEDED( hr ) && pPersist )
 545         {
 546             hr = pPersist->SaveCompleted( pStgNew );
 547             if ( SUCCEEDED( hr ) )
 548             {
 549                 m_nInitMode = LOAD_FROM_STORAGE;
 550                 if ( pStgNew )
 551                 {
 552                     m_pStorage = pStgNew;
 553                 }
 554
 555                 m_nFileOpenMode = 0;
 556                 if ( m_pFileName )
 557                 {
 558                     delete[] m_pFileName;
 559                     m_pFileName = NULL;
 560                 }
 561             }
 562
 563             return hr;
 564         }
 565     }
 566
 567     return E_FAIL;
 568 }
 569
 570 //-------------------------------------------------------------------------------
 571 STDMETHODIMP InprocEmbedDocument_Impl::HandsOffStorage()
 572 {
 573     if ( CheckDefHandler() )
 574     {
 575         ComSmart< IPersistStorage > pPersist;
 576         HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, (void**)&pPersist );
 577
 578         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 579         if ( SUCCEEDED( hr ) && pPersist )
 580         {
 581             hr = pPersist->HandsOffStorage();
 582             if ( SUCCEEDED( hr ) )
 583             {
 584                 m_pStorage = NULL;
 585             }
 586
 587             return hr;
 588         }
 589     }
 590
 591     return E_FAIL;
 592 }
 593
 594 // IPersistFile
 595 //-------------------------------------------------------------------------------
 596 STDMETHODIMP InprocEmbedDocument_Impl::Load( LPCOLESTR pszFileName, DWORD dwMode )
 597 {
 598     if ( CheckDefHandler() && pszFileName )
 599     {
 600         ComSmart< IPersistFile > pPersist;
 601         HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistFile, (void**)&pPersist );
 602
 603         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 604         if ( SUCCEEDED( hr ) && pPersist )
 605         {
 606             hr = pPersist->Load( pszFileName, dwMode );
 607             if ( SUCCEEDED( hr ) )
 608             {
 609                 m_nInitMode = LOAD_FROM_FILE;
 610                 if ( m_pStorage )
 611                     m_pStorage = NULL;
 612
 613                 m_nFileOpenMode = dwMode;
 614                 // copy the string
 615                 SetName( pszFileName, m_pFileName );
 616             }
 617
 618             return hr;
 619         }
 620     }
 621
 622     return E_FAIL;
 623 }
 624
 625 //-------------------------------------------------------------------------------
 626 STDMETHODIMP InprocEmbedDocument_Impl::Save( LPCOLESTR pszFileName, BOOL fRemember )
 627 {
 628     if ( CheckDefHandler() )
 629     {
 630         ComSmart< IPersistFile > pPersist;
 631         HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistFile, (void**)&pPersist );
 632
 633         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 634         if ( SUCCEEDED( hr ) && pPersist )
 635             return pPersist->Save( pszFileName, fRemember );
 636     }
 637
 638     return E_FAIL;
 639 }
 640
 641 //-------------------------------------------------------------------------------
 642 STDMETHODIMP InprocEmbedDocument_Impl::SaveCompleted( LPCOLESTR pszFileName )
 643 {
 644     if ( CheckDefHandler() )
 645     {
 646         ComSmart< IPersistFile > pPersist;
 647         HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistFile, (void**)&pPersist );
 648
 649         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 650         if ( SUCCEEDED( hr ) && pPersist )
 651         {
 652             hr = pPersist->SaveCompleted( pszFileName );
 653             if ( SUCCEEDED( hr ) )
 654             {
 655                 m_nInitMode = LOAD_FROM_STORAGE;
 656                 if ( m_pStorage )
 657                     m_pStorage = NULL;
 658
 659                 m_nFileOpenMode = STGM_READWRITE; // was just written
 660                 // copy the string
 661                 SetName( pszFileName, m_pFileName );
 662             }
 663         }
 664
 665     }
 666
 667     return E_FAIL;
 668 }
 669
 670 //-------------------------------------------------------------------------------
 671 STDMETHODIMP InprocEmbedDocument_Impl::GetCurFile( LPOLESTR *ppszFileName )
 672 {
 673     if ( CheckDefHandler() )
 674     {
 675         ComSmart< IPersistFile > pPersist;
 676         HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistFile, (void**)&pPersist );
 677
 678         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 679         if ( SUCCEEDED( hr ) && pPersist )
 680             return pPersist->GetCurFile( ppszFileName );
 681     }
 682
 683     return E_FAIL;
 684 }
 685
 686 // IOleObject
 687 //-------------------------------------------------------------------------------
 688 STDMETHODIMP InprocEmbedDocument_Impl::SetClientSite( IOleClientSite* pSite )
 689 {
 690     if ( pSite == m_pClientSite )
 691         return S_OK;
 692
 693     if ( !pSite )
 694     {
 695         m_pClientSite = NULL;
 696         if ( m_pOleContainer )
 697         {
 698             m_pOleContainer->LockContainer( FALSE );
 699             m_pOleContainer = NULL;
 700         }
 701     }
 702
 703     if ( CheckDefHandler() )
 704     {
 705         ComSmart< IOleObject > pOleObject;
 706         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 707
 708         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 709         if ( SUCCEEDED( hr ) && pOleObject )
 710         {
 711             HRESULT hr2 = pOleObject->SetClientSite( pSite );
 712             if ( SUCCEEDED( hr2 ) )
 713             {
 714                 m_pClientSite = pSite;
 715
 716                 if ( m_pOleContainer )
 717                 {
 718                     m_pOleContainer->LockContainer( FALSE );
 719                     m_pOleContainer = NULL;
 720                 }
 721
 722                 m_pClientSite->GetContainer( &m_pOleContainer );
 723                 if ( m_pOleContainer )
 724                     m_pOleContainer->LockContainer( TRUE );
 725             }
 726
 727             return hr2;
 728         }
 729     }
 730
 731     return E_FAIL;
 732 }
 733
 734 //-------------------------------------------------------------------------------
 735 STDMETHODIMP InprocEmbedDocument_Impl::GetClientSite( IOleClientSite** pSite )
 736 {
 737     if ( CheckDefHandler() )
 738     {
 739         ComSmart< IOleObject > pOleObject;
 740         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 741
 742         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 743         if ( SUCCEEDED( hr ) && pOleObject )
 744             return pOleObject->GetClientSite( pSite );
 745     }
 746
 747     return E_FAIL;
 748 }
 749
 750 //-------------------------------------------------------------------------------
 751 STDMETHODIMP InprocEmbedDocument_Impl::SetHostNames( LPCOLESTR szContainerApp, LPCOLESTR szContainerObj )
 752 {
 753
 754     if ( CheckDefHandler() )
 755     {
 756         ComSmart< IOleObject > pOleObject;
 757         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 758
 759         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 760         if ( SUCCEEDED( hr ) && pOleObject )
 761         {
 762             hr = pOleObject->SetHostNames( szContainerApp, szContainerObj );
 763         }
 764     }
 765
 766     return S_OK;
 767 }
 768
 769 //-------------------------------------------------------------------------------
 770 STDMETHODIMP InprocEmbedDocument_Impl::Close( DWORD dwSaveOption )
 771 {
 772     if ( m_pDefHandler && CheckDefHandler() )
 773     {
 774         // no need to close if there is no default handler.
 775         ComSmart< IOleObject > pOleObject;
 776         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 777
 778         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 779         if ( SUCCEEDED( hr ) && pOleObject )
 780         {
 781             hr = pOleObject->Close( dwSaveOption );
 782             hr = CoDisconnectObject( (IUnknown*)(IPersistStorage*)this, 0 );
 783         }
 784     }
 785
 786     // if the object is closed from outside that means that it should go to uninitialized state
 787     Clean();
 788
 789     return S_OK;
 790 }
 791
 792 //-------------------------------------------------------------------------------
 793 STDMETHODIMP InprocEmbedDocument_Impl::SetMoniker( DWORD dwWhichMoniker, IMoniker * pmk )
 794 {
 795     if ( CheckDefHandler() )
 796     {
 797         ComSmart< IOleObject > pOleObject;
 798         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 799
 800         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 801         if ( SUCCEEDED( hr ) && pOleObject )
 802             return pOleObject->SetMoniker( dwWhichMoniker, pmk );
 803     }
 804
 805     return E_FAIL;
 806 }
 807
 808 //-------------------------------------------------------------------------------
 809 STDMETHODIMP InprocEmbedDocument_Impl::GetMoniker( DWORD dwAssign, DWORD dwWhichMoniker, IMoniker ** ppmk )
 810 {
 811     if ( CheckDefHandler() )
 812     {
 813         ComSmart< IOleObject > pOleObject;
 814         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 815
 816         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 817         if ( SUCCEEDED( hr ) && pOleObject )
 818             return pOleObject->GetMoniker( dwAssign, dwWhichMoniker, ppmk );
 819     }
 820
 821     return E_FAIL;
 822 }
 823
 824 //-------------------------------------------------------------------------------
 825 STDMETHODIMP InprocEmbedDocument_Impl::InitFromData( IDataObject * pDataObject, BOOL fCreation, DWORD dwReserved )
 826 {
 827     if ( CheckDefHandler() )
 828     {
 829         ComSmart< IOleObject > pOleObject;
 830         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 831
 832         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 833         if ( SUCCEEDED( hr ) && pOleObject )
 834             return pOleObject->InitFromData( pDataObject, fCreation, dwReserved );
 835     }
 836
 837     return E_FAIL;
 838 }
 839
 840 //-------------------------------------------------------------------------------
 841 STDMETHODIMP InprocEmbedDocument_Impl::GetClipboardData( DWORD dwReserved, IDataObject ** ppDataObject )
 842 {
 843     if ( CheckDefHandler() )
 844     {
 845         ComSmart< IOleObject > pOleObject;
 846         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 847
 848         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 849         if ( SUCCEEDED( hr ) && pOleObject )
 850             return pOleObject->GetClipboardData( dwReserved, ppDataObject );
 851     }
 852
 853     return E_FAIL;
 854 }
 855
 856 //-------------------------------------------------------------------------------
 857 STDMETHODIMP InprocEmbedDocument_Impl::DoVerb(
 858     LONG iVerb,
 859     LPMSG pMsg,
 860     IOleClientSite *pActiveSite,
 861     LONG nLong,
 862     HWND hWin,
 863     LPCRECT pRect )
 864 {
 865     if ( CheckDefHandler() )
 866     {
 867         ComSmart< IOleObject > pOleObject;
 868         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 869
 870         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 871         if ( SUCCEEDED( hr ) && pOleObject )
 872         {
 873             hr = pOleObject->DoVerb( iVerb, pMsg, pActiveSite, nLong, hWin, pRect );
 874             if ( SUCCEEDED( hr ) )
 875             {
 876             }
 877
 878             return hr;
 879         }
 880
 881     }
 882
 883     return E_FAIL;
 884 }
 885
 886 //-------------------------------------------------------------------------------
 887 STDMETHODIMP InprocEmbedDocument_Impl::EnumVerbs( IEnumOLEVERB ** ppEnumOleVerb )
 888 {
 889     if ( CheckDefHandler() )
 890     {
 891         ComSmart< IOleObject > pOleObject;
 892         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 893
 894         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 895         if ( SUCCEEDED( hr ) && pOleObject )
 896             return pOleObject->EnumVerbs( ppEnumOleVerb );
 897     }
 898
 899     return E_FAIL;
 900 }
 901
 902 //-------------------------------------------------------------------------------
 903 STDMETHODIMP InprocEmbedDocument_Impl::Update()
 904 {
 905
 906     if ( m_pDefHandler && CheckDefHandler() )
 907     {
 908         ComSmart< IOleObject > pOleObject;
 909         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 910
 911         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 912         if ( SUCCEEDED( hr ) && pOleObject )
 913             return pOleObject->Update();
 914     }
 915
 916     return S_OK;
 917 }
 918
 919 //-------------------------------------------------------------------------------
 920 STDMETHODIMP InprocEmbedDocument_Impl::IsUpToDate()
 921 {
 922     if ( CheckDefHandler() )
 923     {
 924         ComSmart< IOleObject > pOleObject;
 925         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 926
 927         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 928         if ( SUCCEEDED( hr ) && pOleObject )
 929             return pOleObject->IsUpToDate();
 930     }
 931
 932     return E_FAIL;
 933 }
 934
 935 //-------------------------------------------------------------------------------
 936 STDMETHODIMP InprocEmbedDocument_Impl::GetUserClassID( CLSID *pClsid )
 937 {
 938     if ( pClsid )
 939         *pClsid = m_guid;
 940
 941     return S_OK;
 942 }
 943
 944 //-------------------------------------------------------------------------------
 945 STDMETHODIMP InprocEmbedDocument_Impl::GetUserType( DWORD dwFormOfType, LPOLESTR * pszUserType )
 946 {
 947     if ( CheckDefHandler() )
 948     {
 949         ComSmart< IOleObject > pOleObject;
 950         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 951
 952         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 953         if ( SUCCEEDED( hr ) && pOleObject )
 954             return pOleObject->GetUserType( dwFormOfType, pszUserType );
 955     }
 956
 957     return E_FAIL;
 958 }
 959
 960 //-------------------------------------------------------------------------------
 961 STDMETHODIMP InprocEmbedDocument_Impl::SetExtent( DWORD dwDrawAspect, SIZEL *psizel )
 962 {
 963     if ( CheckDefHandler() )
 964     {
 965         ComSmart< IOleObject > pOleObject;
 966         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 967
 968         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 969         if ( SUCCEEDED( hr ) && pOleObject )
 970             return pOleObject->SetExtent( dwDrawAspect, psizel );
 971     }
 972
 973     return E_FAIL;
 974 }
 975
 976 //-------------------------------------------------------------------------------
 977 STDMETHODIMP InprocEmbedDocument_Impl::GetExtent( DWORD dwDrawAspect, SIZEL * psizel )
 978 {
 979     if ( CheckDefHandler() )
 980     {
 981         ComSmart< IOleObject > pOleObject;
 982         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
 983
 984         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
 985         if ( SUCCEEDED( hr ) && pOleObject )
 986             return pOleObject->GetExtent( dwDrawAspect, psizel );
 987     }
 988
 989     return E_FAIL;
 990 }
 991
 992 //-------------------------------------------------------------------------------
 993 STDMETHODIMP InprocEmbedDocument_Impl::Advise( IAdviseSink *pAdvSink, DWORD *pdwConnection )
 994 {
 995
 996     if ( !pdwConnection )
 997         return E_FAIL;
 998
 999     // CheckDefHandler will set the listener, avoid reusing of old listener
1000     if ( DEFAULT_ARRAY_LEN > *pdwConnection && *pdwConnection > 0 && m_pOleAdvises[*pdwConnection] )
1001     {
1002         m_pOleAdvises[*pdwConnection]->DisconnectOrigAdvise();
1003         m_pOleAdvises[*pdwConnection] = NULL;
1004     }
1005
1006     if ( pAdvSink && CheckDefHandler() )
1007     {
1008         ComSmart< IOleObject > pOleObject;
1009         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
1010
1011         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1012         if ( SUCCEEDED( hr ) && pOleObject )
1013         {
1014             ComSmart< OleWrapperAdviseSink > pOwnAdvise( new OleWrapperAdviseSink( pAdvSink ) );
1015             DWORD nRegID = 0;
1016
1017             if ( SUCCEEDED( pOleObject->Advise( pOwnAdvise, &nRegID ) ) && nRegID > 0 )
1018             {
1019                 pOwnAdvise->SetRegID( nRegID );
1020                 *pdwConnection = InsertAdviseLinkToList( pOwnAdvise, m_pOleAdvises );
1021                 if ( *pdwConnection )
1022                     return S_OK;
1023                 else
1024                     pOleObject->Unadvise( nRegID );
1025             }
1026         }
1027     }
1028
1029     // return success always for now
1030     return S_OK;
1031 }
1032
1033 //-------------------------------------------------------------------------------
1034 STDMETHODIMP InprocEmbedDocument_Impl::Unadvise( DWORD dwConnection )
1035 {
1036     if ( DEFAULT_ARRAY_LEN > dwConnection && dwConnection > 0 && m_pOleAdvises[dwConnection] )
1037     {
1038         if ( m_pDefHandler )
1039         {
1040             ComSmart< IOleObject > pOleObject;
1041             HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
1042
1043             ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1044             if ( SUCCEEDED( hr ) && pOleObject )
1045             {
1046                 DWORD nID = m_pOleAdvises[dwConnection]->GetRegID();
1047                 pOleObject->Unadvise( nID );
1048             }
1049         }
1050
1051         m_pOleAdvises[dwConnection]->DisconnectOrigAdvise();
1052         m_pOleAdvises[dwConnection] = NULL;
1053
1054         return S_OK;
1055     }
1056
1057     return E_FAIL;
1058 }
1059
1060 //-------------------------------------------------------------------------------
1061 STDMETHODIMP InprocEmbedDocument_Impl::EnumAdvise( IEnumSTATDATA ** /*ppenumAdvise*/ )
1062 {
1063     return E_NOTIMPL;
1064 }
1065
1066 //-------------------------------------------------------------------------------
1067 STDMETHODIMP InprocEmbedDocument_Impl::GetMiscStatus( DWORD dwAspect, DWORD * pdwStatus )
1068 {
1069     if ( CheckDefHandler() )
1070     {
1071         ComSmart< IOleObject > pOleObject;
1072         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
1073
1074         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1075         if ( SUCCEEDED( hr ) && pOleObject )
1076             return pOleObject->GetMiscStatus( dwAspect, pdwStatus );
1077     }
1078
1079     return E_FAIL;
1080 }
1081
1082 //-------------------------------------------------------------------------------
1083 STDMETHODIMP InprocEmbedDocument_Impl::SetColorScheme( LOGPALETTE * pLogpal )
1084 {
1085     if ( CheckDefHandler() )
1086     {
1087         ComSmart< IOleObject > pOleObject;
1088         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, (void**)&pOleObject );
1089
1090         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1091         if ( SUCCEEDED( hr ) && pOleObject )
1092             return pOleObject->SetColorScheme( pLogpal );
1093     }
1094
1095     return E_FAIL;
1096 }
1097
1098 //IDataObject
1099 //-------------------------------------------------------------------------------
1100 STDMETHODIMP InprocEmbedDocument_Impl::GetData( FORMATETC * pFormatetc, STGMEDIUM * pMedium )
1101 {
1102     if ( CheckDefHandler() )
1103     {
1104         ComSmart< IDataObject > pIDataObject;
1105         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, (void**)&pIDataObject );
1106
1107         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1108         if ( SUCCEEDED( hr ) && pIDataObject )
1109             return pIDataObject->GetData( pFormatetc, pMedium );
1110     }
1111
1112     return E_FAIL;
1113 }
1114
1115 //-------------------------------------------------------------------------------
1116 STDMETHODIMP InprocEmbedDocument_Impl::GetDataHere( FORMATETC * pFormatetc, STGMEDIUM * pMedium )
1117 {
1118     if ( CheckDefHandler() )
1119     {
1120         ComSmart< IDataObject > pIDataObject;
1121         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, (void**)&pIDataObject );
1122
1123         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1124         if ( SUCCEEDED( hr ) && pIDataObject )
1125             return pIDataObject->GetDataHere( pFormatetc, pMedium );
1126     }
1127
1128     return E_FAIL;
1129 }
1130
1131 //-------------------------------------------------------------------------------
1132 STDMETHODIMP InprocEmbedDocument_Impl::QueryGetData( FORMATETC * pFormatetc )
1133 {
1134     if ( CheckDefHandler() )
1135     {
1136         ComSmart< IDataObject > pIDataObject;
1137         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, (void**)&pIDataObject );
1138
1139         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1140         if ( SUCCEEDED( hr ) && pIDataObject )
1141             return pIDataObject->QueryGetData( pFormatetc );
1142     }
1143
1144     return E_FAIL;
1145 }
1146
1147 //-------------------------------------------------------------------------------
1148 STDMETHODIMP InprocEmbedDocument_Impl::GetCanonicalFormatEtc( FORMATETC * pFormatetcIn, FORMATETC * pFormatetcOut )
1149 {
1150     if ( CheckDefHandler() )
1151     {
1152         ComSmart< IDataObject > pIDataObject;
1153         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, (void**)&pIDataObject );
1154
1155         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1156         if ( SUCCEEDED( hr ) && pIDataObject )
1157             return pIDataObject->GetCanonicalFormatEtc( pFormatetcIn, pFormatetcOut );
1158     }
1159
1160     return E_FAIL;
1161 }
1162
1163 //-------------------------------------------------------------------------------
1164 STDMETHODIMP InprocEmbedDocument_Impl::SetData( FORMATETC * pFormatetc, STGMEDIUM * pMedium, BOOL fRelease )
1165 {
1166     if ( CheckDefHandler() )
1167     {
1168         ComSmart< IDataObject > pIDataObject;
1169         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, (void**)&pIDataObject );
1170
1171         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1172         if ( SUCCEEDED( hr ) && pIDataObject )
1173             return pIDataObject->SetData( pFormatetc, pMedium, fRelease );
1174     }
1175
1176     return E_FAIL;
1177 }
1178
1179 //-------------------------------------------------------------------------------
1180 STDMETHODIMP InprocEmbedDocument_Impl::EnumFormatEtc( DWORD dwDirection, IEnumFORMATETC ** ppFormatetc )
1181 {
1182     if ( CheckDefHandler() )
1183     {
1184         ComSmart< IDataObject > pIDataObject;
1185         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, (void**)&pIDataObject );
1186
1187         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1188         if ( SUCCEEDED( hr ) && pIDataObject )
1189             return pIDataObject->EnumFormatEtc( dwDirection, ppFormatetc );
1190     }
1191
1192     return E_FAIL;
1193 }
1194
1195 //-------------------------------------------------------------------------------
1196 STDMETHODIMP InprocEmbedDocument_Impl::DAdvise( FORMATETC * pFormatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD * pdwConnection )
1197 {
1198
1199     if ( !pdwConnection )
1200         return E_FAIL;
1201
1202     // avoid reusing of the old listener
1203     if ( m_pDefHandler && DEFAULT_ARRAY_LEN > *pdwConnection && *pdwConnection > 0 && m_pDataAdvises[*pdwConnection] )
1204     {
1205         m_pDataAdvises[*pdwConnection]->DisconnectOrigAdvise();
1206         m_pDataAdvises[*pdwConnection] = NULL;
1207     }
1208
1209     if ( pAdvSink && CheckDefHandler() )
1210     {
1211         ComSmart< IDataObject > pIDataObject;
1212         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, (void**)&pIDataObject );
1213
1214         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1215         if ( SUCCEEDED( hr ) && pIDataObject )
1216         {
1217             ComSmart< OleWrapperAdviseSink > pOwnAdvise( new OleWrapperAdviseSink( ComSmart<IAdviseSink>( pAdvSink ), pFormatetc, advf ) );
1218             DWORD nRegID = 0;
1219
1220             if ( SUCCEEDED( pIDataObject->DAdvise( pFormatetc, advf, pOwnAdvise, &nRegID ) ) && nRegID > 0 )
1221             {
1222                 pOwnAdvise->SetRegID( nRegID );
1223                 *pdwConnection = InsertAdviseLinkToList( pOwnAdvise, m_pDataAdvises );
1224                 if ( *pdwConnection )
1225                     return S_OK;
1226                 else
1227                     pIDataObject->DUnadvise( nRegID );
1228             }
1229         }
1230     }
1231
1232     // return success always for now
1233     return S_OK;
1234 }
1235
1236 //-------------------------------------------------------------------------------
1237 STDMETHODIMP InprocEmbedDocument_Impl::DUnadvise( DWORD dwConnection )
1238 {
1239     if ( m_pDefHandler && DEFAULT_ARRAY_LEN > dwConnection && dwConnection > 0 && m_pDataAdvises[dwConnection] )
1240     {
1241         if ( CheckDefHandler() )
1242         {
1243             ComSmart< IDataObject > pIDataObject;
1244             HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, (void**)&pIDataObject );
1245
1246             ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1247             if ( SUCCEEDED( hr ) && pIDataObject )
1248             {
1249                 DWORD nID = m_pDataAdvises[dwConnection]->GetRegID();
1250                 pIDataObject->DUnadvise( nID );
1251             }
1252         }
1253
1254         m_pDataAdvises[dwConnection]->DisconnectOrigAdvise();
1255         m_pDataAdvises[dwConnection] = NULL;
1256
1257         return S_OK;
1258     }
1259
1260     return E_FAIL;
1261 }
1262
1263 //-------------------------------------------------------------------------------
1264 STDMETHODIMP InprocEmbedDocument_Impl::EnumDAdvise( IEnumSTATDATA ** ppenumAdvise )
1265 {
1266     if ( CheckDefHandler() )
1267     {
1268         ComSmart< IDataObject > pIDataObject;
1269         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, (void**)&pIDataObject );
1270
1271         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1272         if ( SUCCEEDED( hr ) && pIDataObject )
1273             return pIDataObject->EnumDAdvise( ppenumAdvise );
1274     }
1275
1276     return E_FAIL;
1277 }
1278
1279 // IRunnableObject
1280 //-------------------------------------------------------------------------------
1281 STDMETHODIMP InprocEmbedDocument_Impl::GetRunningClass( LPCLSID lpClsid )
1282 {
1283     if ( CheckDefHandler() )
1284     {
1285         ComSmart< IRunnableObject > pIRunObj;
1286         HRESULT hr = m_pDefHandler->QueryInterface( IID_IRunnableObject, (void**)&pIRunObj );
1287
1288         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1289         if ( SUCCEEDED( hr ) && pIRunObj )
1290             return pIRunObj->GetRunningClass( lpClsid );
1291     }
1292
1293     return E_FAIL;
1294 }
1295
1296 //-------------------------------------------------------------------------------
1297 STDMETHODIMP InprocEmbedDocument_Impl::Run( LPBINDCTX pbc )
1298 {
1299     if ( CheckDefHandler() )
1300     {
1301         ComSmart< IRunnableObject > pIRunObj;
1302         HRESULT hr = m_pDefHandler->QueryInterface( IID_IRunnableObject, (void**)&pIRunObj );
1303
1304         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1305         if ( SUCCEEDED( hr ) && pIRunObj )
1306             return pIRunObj->Run( pbc );
1307     }
1308
1309     return E_FAIL;
1310 }
1311
1312 //-------------------------------------------------------------------------------
1313 BOOL STDMETHODCALLTYPE InprocEmbedDocument_Impl::IsRunning()
1314 {
1315    if ( CheckDefHandler() )
1316     {
1317         ComSmart< IRunnableObject > pIRunObj;
1318         HRESULT hr = m_pDefHandler->QueryInterface( IID_IRunnableObject, (void**)&pIRunObj );
1319
1320         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1321         if ( SUCCEEDED( hr ) && pIRunObj )
1322             return pIRunObj->IsRunning();
1323     }
1324
1325     return E_FAIL;
1326
1327 }
1328
1329 //-------------------------------------------------------------------------------
1330 STDMETHODIMP InprocEmbedDocument_Impl::LockRunning( BOOL fLock, BOOL fLastUnlockCloses )
1331 {
1332    if ( CheckDefHandler() )
1333     {
1334         ComSmart< IRunnableObject > pIRunObj;
1335         HRESULT hr = m_pDefHandler->QueryInterface( IID_IRunnableObject, (void**)&pIRunObj );
1336
1337         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1338         if ( SUCCEEDED( hr ) && pIRunObj )
1339             return pIRunObj->LockRunning( fLock, fLastUnlockCloses );
1340     }
1341
1342     return E_FAIL;
1343 }
1344
1345 //-------------------------------------------------------------------------------
1346 STDMETHODIMP InprocEmbedDocument_Impl::SetContainedObject( BOOL fContained)
1347 {
1348    if ( CheckDefHandler() )
1349     {
1350         ComSmart< IRunnableObject > pIRunObj;
1351         HRESULT hr = m_pDefHandler->QueryInterface( IID_IRunnableObject, (void**)&pIRunObj );
1352
1353         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1354         if ( SUCCEEDED( hr ) && pIRunObj )
1355             return pIRunObj->SetContainedObject( fContained );
1356     }
1357
1358     return E_FAIL;
1359 }
1360
1361
1362 // IViewObject methods
1363 //-------------------------------------------------------------------------------
1364 STDMETHODIMP InprocEmbedDocument_Impl::Draw( DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL ( STDMETHODCALLTYPE *pfnContinue )( ULONG_PTR dwContinue ), ULONG_PTR dwContinue )
1365 {
1366     if ( CheckDefHandler() )
1367     {
1368         ComSmart< IViewObject > pIViewObject;
1369         HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject, (void**)&pIViewObject );
1370
1371         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1372         if ( SUCCEEDED( hr ) && pIViewObject )
1373             return pIViewObject->Draw( dwDrawAspect, lindex, pvAspect, ptd, hdcTargetDev, hdcDraw, lprcBounds, lprcWBounds, pfnContinue, dwContinue );
1374     }
1375
1376     return E_FAIL;
1377 }
1378
1379 //-------------------------------------------------------------------------------
1380 STDMETHODIMP InprocEmbedDocument_Impl::GetColorSet( DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDev, LOGPALETTE **ppColorSet )
1381 {
1382     if ( CheckDefHandler() )
1383     {
1384         ComSmart< IViewObject > pIViewObject;
1385         HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject, (void**)&pIViewObject );
1386
1387         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1388         if ( SUCCEEDED( hr ) && pIViewObject )
1389             return pIViewObject->GetColorSet( dwDrawAspect, lindex, pvAspect, ptd, hicTargetDev, ppColorSet );
1390     }
1391
1392     return E_FAIL;
1393 }
1394
1395 //-------------------------------------------------------------------------------
1396 STDMETHODIMP InprocEmbedDocument_Impl::Freeze( DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze )
1397 {
1398     if ( CheckDefHandler() )
1399     {
1400         ComSmart< IViewObject > pIViewObject;
1401         HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject, (void**)&pIViewObject );
1402
1403         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1404         if ( SUCCEEDED( hr ) && pIViewObject )
1405             return pIViewObject->Freeze( dwDrawAspect, lindex, pvAspect, pdwFreeze );
1406     }
1407
1408     return E_FAIL;
1409 }
1410
1411 //-------------------------------------------------------------------------------
1412 STDMETHODIMP InprocEmbedDocument_Impl::Unfreeze( DWORD dwFreeze )
1413 {
1414     if ( CheckDefHandler() )
1415     {
1416         ComSmart< IViewObject > pIViewObject;
1417         HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject, (void**)&pIViewObject );
1418
1419         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1420         if ( SUCCEEDED( hr ) && pIViewObject )
1421             return pIViewObject->Unfreeze( dwFreeze );
1422     }
1423
1424     return E_FAIL;
1425 }
1426
1427 //-------------------------------------------------------------------------------
1428 STDMETHODIMP InprocEmbedDocument_Impl::SetAdvise( DWORD aspects, DWORD advf, IAdviseSink *pAdvSink )
1429 {
1430
1431     // CheckDefHandler will set the listener, avoid reusing of old listener
1432     if ( m_pViewAdvise )
1433     {
1434         m_pViewAdvise->DisconnectOrigAdvise();
1435         m_pViewAdvise = NULL;
1436     }
1437
1438     if ( pAdvSink && CheckDefHandler() )
1439     {
1440         ComSmart< IViewObject > pIViewObject;
1441         HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject, (void**)&pIViewObject );
1442
1443         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1444         if ( SUCCEEDED( hr ) && pIViewObject )
1445         {
1446             ComSmart< OleWrapperAdviseSink > pOwnAdvise( new OleWrapperAdviseSink( pAdvSink, aspects, advf ) );
1447
1448             if ( SUCCEEDED( pIViewObject->SetAdvise( aspects, advf, pOwnAdvise ) ) )
1449             {
1450                 m_pViewAdvise = pOwnAdvise;
1451                 return S_OK;
1452             }
1453         }
1454     }
1455
1456     return S_OK;
1457 }
1458
1459 //-------------------------------------------------------------------------------
1460 STDMETHODIMP InprocEmbedDocument_Impl::GetAdvise( DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink )
1461 {
1462     if ( !ppAdvSink )
1463         return E_INVALIDARG;
1464
1465     if ( m_pViewAdvise )
1466     {
1467         if ( pAspects )
1468             *pAspects = m_pViewAdvise->GetAspect();
1469
1470         if ( pAdvf )
1471             *pAdvf = m_pViewAdvise->GetViewAdviseFlag();
1472
1473         *ppAdvSink = m_pViewAdvise->GetOrigAdvise();
1474         if ( *ppAdvSink )
1475             (*ppAdvSink)->AddRef();
1476     }
1477     else
1478         *ppAdvSink = NULL;
1479
1480     return S_OK;
1481 }
1482
1483 // IViewObject2 methods
1484 //-------------------------------------------------------------------------------
1485 STDMETHODIMP InprocEmbedDocument_Impl::GetExtent( DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel )
1486 {
1487     if ( CheckDefHandler() )
1488     {
1489         ComSmart< IViewObject2 > pIViewObject2;
1490         HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject2, (void**)&pIViewObject2 );
1491
1492         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1493         if ( SUCCEEDED( hr ) && pIViewObject2 )
1494             return pIViewObject2->GetExtent( dwDrawAspect, lindex, ptd, lpsizel );
1495     }
1496
1497     return E_FAIL;
1498 }
1499
1500
1501
1502 // IOleWindow methods
1503 //-------------------------------------------------------------------------------
1504 STDMETHODIMP InprocEmbedDocument_Impl::GetWindow( HWND *phwnd )
1505 {
1506     if ( CheckDefHandler() )
1507     {
1508         ComSmart< IOleWindow > pIOleWindow;
1509         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleWindow, (void**)&pIOleWindow );
1510
1511         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1512         if ( SUCCEEDED( hr ) && pIOleWindow )
1513             return pIOleWindow->GetWindow( phwnd );
1514     }
1515
1516     return E_FAIL;
1517 }
1518
1519 //-------------------------------------------------------------------------------
1520 STDMETHODIMP InprocEmbedDocument_Impl::ContextSensitiveHelp( BOOL fEnterMode )
1521 {
1522     if ( CheckDefHandler() )
1523     {
1524         ComSmart< IOleWindow > pIOleWindow;
1525         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleWindow, (void**)&pIOleWindow );
1526
1527         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1528         if ( SUCCEEDED( hr ) && pIOleWindow )
1529             return pIOleWindow->ContextSensitiveHelp( fEnterMode );
1530     }
1531
1532     return E_FAIL;
1533 }
1534
1535
1536 // IOleInPlaceObject methods
1537 //-------------------------------------------------------------------------------
1538 STDMETHODIMP InprocEmbedDocument_Impl::InPlaceDeactivate( void )
1539 {
1540     if ( CheckDefHandler() )
1541     {
1542         ComSmart< IOleInPlaceObject > pIOleInPlaceObject;
1543         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleInPlaceObject, (void**)&pIOleInPlaceObject );
1544
1545         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1546         if ( SUCCEEDED( hr ) && pIOleInPlaceObject )
1547             return pIOleInPlaceObject->InPlaceDeactivate();
1548     }
1549
1550     return E_FAIL;
1551 }
1552
1553 //-------------------------------------------------------------------------------
1554 STDMETHODIMP InprocEmbedDocument_Impl::UIDeactivate( void )
1555 {
1556     if ( CheckDefHandler() )
1557     {
1558         ComSmart< IOleInPlaceObject > pIOleInPlaceObject;
1559         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleInPlaceObject, (void**)&pIOleInPlaceObject );
1560
1561         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1562         if ( SUCCEEDED( hr ) && pIOleInPlaceObject )
1563             return pIOleInPlaceObject->UIDeactivate();
1564     }
1565
1566     return E_FAIL;
1567 }
1568
1569 //-------------------------------------------------------------------------------
1570 STDMETHODIMP InprocEmbedDocument_Impl::SetObjectRects( LPCRECT lprcPosRect, LPCRECT lprcClipRect )
1571 {
1572     if ( CheckDefHandler() )
1573     {
1574         ComSmart< IOleInPlaceObject > pIOleInPlaceObject;
1575         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleInPlaceObject, (void**)&pIOleInPlaceObject );
1576
1577         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1578         if ( SUCCEEDED( hr ) && pIOleInPlaceObject )
1579             return pIOleInPlaceObject->SetObjectRects( lprcPosRect, lprcClipRect );
1580     }
1581
1582     return E_FAIL;
1583 }
1584
1585 //-------------------------------------------------------------------------------
1586 STDMETHODIMP InprocEmbedDocument_Impl::ReactivateAndUndo( void )
1587 {
1588     if ( CheckDefHandler() )
1589     {
1590         ComSmart< IOleInPlaceObject > pIOleInPlaceObject;
1591         HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleInPlaceObject, (void**)&pIOleInPlaceObject );
1592
1593         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1594         if ( SUCCEEDED( hr ) && pIOleInPlaceObject )
1595             return pIOleInPlaceObject->ReactivateAndUndo();
1596     }
1597
1598     return E_FAIL;
1599 }
1600
1601
1602 // IDispatch methods
1603 //-------------------------------------------------------------------------------
1604 STDMETHODIMP InprocEmbedDocument_Impl::GetTypeInfoCount( UINT *pctinfo )
1605 {
1606     if ( CheckDefHandler() )
1607     {
1608         ComSmart< IDispatch > pIDispatch;
1609         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDispatch, (void**)&pIDispatch );
1610
1611         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1612         if ( SUCCEEDED( hr ) && pIDispatch )
1613             return pIDispatch->GetTypeInfoCount( pctinfo );
1614     }
1615
1616     return E_FAIL;
1617 }
1618
1619 //-------------------------------------------------------------------------------
1620 STDMETHODIMP InprocEmbedDocument_Impl::GetTypeInfo( UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo )
1621 {
1622     if ( CheckDefHandler() )
1623     {
1624         ComSmart< IDispatch > pIDispatch;
1625         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDispatch, (void**)&pIDispatch );
1626
1627         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1628         if ( SUCCEEDED( hr ) && pIDispatch )
1629             return pIDispatch->GetTypeInfo( iTInfo, lcid, ppTInfo );
1630     }
1631
1632     return E_FAIL;
1633 }
1634
1635 //-------------------------------------------------------------------------------
1636 STDMETHODIMP InprocEmbedDocument_Impl::GetIDsOfNames( REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId )
1637 {
1638     if ( CheckDefHandler() )
1639     {
1640         ComSmart< IDispatch > pIDispatch;
1641         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDispatch, (void**)&pIDispatch );
1642
1643         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1644         if ( SUCCEEDED( hr ) && pIDispatch )
1645             return pIDispatch->GetIDsOfNames( riid, rgszNames, cNames, lcid, rgDispId );
1646     }
1647
1648     return E_FAIL;
1649 }
1650
1651 //-------------------------------------------------------------------------------
1652 STDMETHODIMP InprocEmbedDocument_Impl::Invoke( DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr )
1653 {
1654     if ( CheckDefHandler() )
1655     {
1656         ComSmart< IDispatch > pIDispatch;
1657         HRESULT hr = m_pDefHandler->QueryInterface( IID_IDispatch, (void**)&pIDispatch );
1658
1659         ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem
1660         if ( SUCCEEDED( hr ) && pIDispatch )
1661             return pIDispatch->Invoke( dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
1662     }
1663
1664     return E_FAIL;
1665 }
1666
1667
1668 // ====
1669 // InternalCacheWrapper
1670 // ====
1671
1672 // IUnknown
1673 //-------------------------------------------------------------------------------
1674 STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::QueryInterface( REFIID riid, void FAR* FAR* ppv )
1675 {
1676     return m_rOwnDocument.QueryInterface( riid, ppv );
1677 }
1678
1679 //-------------------------------------------------------------------------------
1680 STDMETHODIMP_(ULONG) InprocEmbedDocument_Impl::InternalCacheWrapper::AddRef()
1681 {
1682     return m_rOwnDocument.AddRef();
1683 }
1684
1685 //-------------------------------------------------------------------------------
1686 STDMETHODIMP_(ULONG) InprocEmbedDocument_Impl::InternalCacheWrapper::Release()
1687 {
1688     return m_rOwnDocument.Release();
1689 }
1690
1691 // IOleCache methods
1692 //-------------------------------------------------------------------------------
1693 STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::Cache( FORMATETC *pformatetc, DWORD advf, DWORD *pdwConnection )
1694 {
1695     if ( m_rOwnDocument.CheckDefHandler() )
1696     {
1697         ComSmart< IOleCache > pIOleCache;
1698         HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache, (void**)&pIOleCache );
1699
1700         ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem
1701         if ( SUCCEEDED( hr ) && pIOleCache )
1702             return pIOleCache->Cache( pformatetc, advf, pdwConnection );
1703     }
1704
1705     return E_FAIL;
1706 }
1707
1708 //-------------------------------------------------------------------------------
1709 STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::Uncache( DWORD dwConnection )
1710 {
1711     if ( m_rOwnDocument.CheckDefHandler() )
1712     {
1713         ComSmart< IOleCache > pIOleCache;
1714         HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache, (void**)&pIOleCache );
1715
1716         ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem
1717         if ( SUCCEEDED( hr ) && pIOleCache )
1718             return pIOleCache->Uncache( dwConnection );
1719     }
1720
1721     return E_FAIL;
1722 }
1723
1724 //-------------------------------------------------------------------------------
1725 STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::EnumCache( IEnumSTATDATA **ppenumSTATDATA )
1726 {
1727     if ( m_rOwnDocument.CheckDefHandler() )
1728     {
1729         ComSmart< IOleCache > pIOleCache;
1730         HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache, (void**)&pIOleCache );
1731
1732         ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem
1733         if ( SUCCEEDED( hr ) && pIOleCache )
1734             return pIOleCache->EnumCache( ppenumSTATDATA );
1735     }
1736
1737     return E_FAIL;
1738 }
1739
1740 //-------------------------------------------------------------------------------
1741 STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::InitCache( IDataObject *pDataObject )
1742 {
1743     if ( m_rOwnDocument.CheckDefHandler() )
1744     {
1745         ComSmart< IOleCache > pIOleCache;
1746         HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache, (void**)&pIOleCache );
1747
1748         ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem
1749         if ( SUCCEEDED( hr ) && pIOleCache )
1750             return pIOleCache->InitCache( pDataObject );
1751     }
1752
1753     return E_FAIL;
1754 }
1755
1756 //-------------------------------------------------------------------------------
1757 STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::SetData( FORMATETC *pformatetc, STGMEDIUM *pmedium, BOOL fRelease )
1758 {
1759     if ( m_rOwnDocument.CheckDefHandler() )
1760     {
1761         ComSmart< IOleCache > pIOleCache;
1762         HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache, (void**)&pIOleCache );
1763
1764         ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem
1765         if ( SUCCEEDED( hr ) && pIOleCache )
1766             return pIOleCache->SetData( pformatetc, pmedium, fRelease );
1767     }
1768
1769     return E_FAIL;
1770 }
1771
1772 // IOleCache2 methods
1773 //-------------------------------------------------------------------------------
1774 STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::UpdateCache( LPDATAOBJECT pDataObject, DWORD grfUpdf, LPVOID pReserved )
1775 {
1776     if ( m_rOwnDocument.CheckDefHandler() )
1777     {
1778         ComSmart< IOleCache2 > pIOleCache2;
1779         HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache2, (void**)&pIOleCache2 );
1780
1781         ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem
1782         if ( SUCCEEDED( hr ) && pIOleCache2 )
1783             return pIOleCache2->UpdateCache( pDataObject, grfUpdf, pReserved );
1784     }
1785
1786     return E_FAIL;
1787 }
1788
1789 //-------------------------------------------------------------------------------
1790 STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::DiscardCache( DWORD dwDiscardOptions )
1791 {
1792     if ( m_rOwnDocument.CheckDefHandler() )
1793     {
1794         ComSmart< IOleCache2 > pIOleCache2;
1795         HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache2, (void**)&pIOleCache2 );
1796
1797         ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem
1798         if ( SUCCEEDED( hr ) && pIOleCache2 )
1799             return pIOleCache2->DiscardCache( dwDiscardOptions );
1800     }
1801
1802     return E_FAIL;
1803 }
1804
1805 }; // namespace inprocserv
1806
1807 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */