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