embeddedobj/source/commonembedding/miscobj.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 <commonembobj.hxx>
  21 #include <com/sun/star/embed/EmbedStates.hpp>
  22 #include <com/sun/star/embed/EmbedVerbs.hpp>
  23 #include <com/sun/star/embed/XStorage.hpp>
  24 #include <com/sun/star/embed/EmbedUpdateModes.hpp>
  25 #include <com/sun/star/embed/XInplaceClient.hpp>
  26 #include <com/sun/star/lang/DisposedException.hpp>
  27 #include <com/sun/star/lang/NoSupportException.hpp>
  28 #include <com/sun/star/beans/NamedValue.hpp>
  29
  30 #include <cppuhelper/typeprovider.hxx>
  31 #include <cppuhelper/queryinterface.hxx>
  32 #include <cppuhelper/interfacecontainer.h>
  33 #include <comphelper/mimeconfighelper.hxx>
  34
  35 #include <vcl/svapp.hxx>
  36
  37 #include <closepreventer.hxx>
  38 #include <intercept.hxx>
  39 #include "persistence.hxx"
  40
  41 using namespace ::com::sun::star;
  42
  43
  44 OCommonEmbeddedObject::OCommonEmbeddedObject( const uno::Reference< uno::XComponentContext >& rxContext,
  45                                                 const uno::Sequence< beans::NamedValue >& aObjProps )
  46 : m_pInterfaceContainer( nullptr )
  47 , m_bReadOnly( false )
  48 , m_bDisposed( false )
  49 , m_bClosed( false )
  50 , m_nObjectState( -1 )
  51 , m_nTargetState( -1 )
  52 , m_nUpdateMode ( embed::EmbedUpdateModes::ALWAYS_UPDATE )
  53 , m_xContext( rxContext )
  54 , m_nMiscStatus( 0 )
  55 , m_bEmbeddedScriptSupport( true )
  56 , m_bDocumentRecoverySupport( true )
  57 , m_bWaitSaveCompleted( false )
  58 , m_bIsLink( false )
  59 , m_bLinkHasPassword( false )
  60 , m_bHasClonedSize( false )
  61 , m_nClonedMapUnit( 0 )
  62 {
  63     CommonInit_Impl( aObjProps );
  64 }
  65
  66
  67 OCommonEmbeddedObject::OCommonEmbeddedObject(
  68         const uno::Reference< uno::XComponentContext >& rxContext,
  69         const uno::Sequence< beans::NamedValue >& aObjProps,
  70         const uno::Sequence< beans::PropertyValue >& aMediaDescr,
  71         const uno::Sequence< beans::PropertyValue >& aObjectDescr )
  72 : m_pInterfaceContainer( nullptr )
  73 , m_bReadOnly( false )
  74 , m_bDisposed( false )
  75 , m_bClosed( false )
  76 , m_nObjectState( embed::EmbedStates::LOADED )
  77 , m_nTargetState( -1 )
  78 , m_nUpdateMode ( embed::EmbedUpdateModes::ALWAYS_UPDATE )
  79 , m_xContext( rxContext )
  80 , m_nMiscStatus( 0 )
  81 , m_bEmbeddedScriptSupport( true )
  82 , m_bDocumentRecoverySupport( true )
  83 , m_bWaitSaveCompleted( false )
  84 , m_bIsLink( true )
  85 , m_bLinkHasPassword( false )
  86 , m_bHasClonedSize( false )
  87 , m_nClonedMapUnit( 0 )
  88 {
  89     // linked object has no own persistence so it is in loaded state starting from creation
  90     LinkInit_Impl( aObjProps, aMediaDescr, aObjectDescr );
  91 }
  92
  93
  94 void OCommonEmbeddedObject::CommonInit_Impl( const uno::Sequence< beans::NamedValue >& aObjectProps )
  95 {
  96     OSL_ENSURE( m_xContext.is(), "No ServiceFactory is provided!" );
  97     if ( !m_xContext.is() )
  98         throw uno::RuntimeException();
  99
 100     m_xDocHolder = new DocumentHolder( m_xContext, this );
 101
 102     // parse configuration entries
 103     // TODO/LATER: in future UI names can be also provided here
 104     for ( sal_Int32 nInd = 0; nInd < aObjectProps.getLength(); nInd++ )
 105     {
 106         if ( aObjectProps[nInd].Name == "ClassID" )
 107             aObjectProps[nInd].Value >>= m_aClassID;
 108         else if ( aObjectProps[nInd].Name == "ObjectDocumentServiceName" )
 109             aObjectProps[nInd].Value >>= m_aDocServiceName;
 110         else if ( aObjectProps[nInd].Name == "ObjectDocumentFilterName" )
 111             aObjectProps[nInd].Value >>= m_aPresetFilterName;
 112         else if ( aObjectProps[nInd].Name == "ObjectMiscStatus" )
 113             aObjectProps[nInd].Value >>= m_nMiscStatus;
 114         else if ( aObjectProps[nInd].Name == "ObjectVerbs" )
 115             aObjectProps[nInd].Value >>= m_aObjectVerbs;
 116     }
 117
 118     if ( m_aClassID.getLength() != 16 /*|| !m_aDocServiceName.getLength()*/ )
 119         throw uno::RuntimeException(); // something goes really wrong
 120
 121     // accepted states
 122     m_aAcceptedStates.realloc( NUM_SUPPORTED_STATES );
 123
 124     m_aAcceptedStates[0] = embed::EmbedStates::LOADED;
 125     m_aAcceptedStates[1] = embed::EmbedStates::RUNNING;
 126     m_aAcceptedStates[2] = embed::EmbedStates::INPLACE_ACTIVE;
 127     m_aAcceptedStates[3] = embed::EmbedStates::UI_ACTIVE;
 128     m_aAcceptedStates[4] = embed::EmbedStates::ACTIVE;
 129
 130
 131     // intermediate states
 132     // In the following table the first index points to starting state,
 133     // the second one to the target state, and the sequence referenced by
 134     // first two indexes contains intermediate states, that should be
 135     // passed by object to reach the target state.
 136     // If the sequence is empty that means that indirect switch from start
 137     // state to the target state is forbidden, only if direct switch is possible
 138     // the state can be reached.
 139
 140     m_pIntermediateStatesSeqs[0][2].realloc( 1 );
 141     m_pIntermediateStatesSeqs[0][2][0] = embed::EmbedStates::RUNNING;
 142
 143     m_pIntermediateStatesSeqs[0][3].realloc( 2 );
 144     m_pIntermediateStatesSeqs[0][3][0] = embed::EmbedStates::RUNNING;
 145     m_pIntermediateStatesSeqs[0][3][1] = embed::EmbedStates::INPLACE_ACTIVE;
 146
 147     m_pIntermediateStatesSeqs[0][4].realloc( 1 );
 148     m_pIntermediateStatesSeqs[0][4][0] = embed::EmbedStates::RUNNING;
 149
 150     m_pIntermediateStatesSeqs[1][3].realloc( 1 );
 151     m_pIntermediateStatesSeqs[1][3][0] = embed::EmbedStates::INPLACE_ACTIVE;
 152
 153     m_pIntermediateStatesSeqs[2][0].realloc( 1 );
 154     m_pIntermediateStatesSeqs[2][0][0] = embed::EmbedStates::RUNNING;
 155
 156     m_pIntermediateStatesSeqs[3][0].realloc( 2 );
 157     m_pIntermediateStatesSeqs[3][0][0] = embed::EmbedStates::INPLACE_ACTIVE;
 158     m_pIntermediateStatesSeqs[3][0][1] = embed::EmbedStates::RUNNING;
 159
 160     m_pIntermediateStatesSeqs[3][1].realloc( 1 );
 161     m_pIntermediateStatesSeqs[3][1][0] = embed::EmbedStates::INPLACE_ACTIVE;
 162
 163     m_pIntermediateStatesSeqs[4][0].realloc( 1 );
 164     m_pIntermediateStatesSeqs[4][0][0] = embed::EmbedStates::RUNNING;
 165
 166     // verbs table
 167     sal_Int32 nVerbTableSize = 0;
 168     for ( sal_Int32 nVerbInd = 0; nVerbInd < m_aObjectVerbs.getLength(); nVerbInd++ )
 169     {
 170         if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_PRIMARY )
 171         {
 172             m_aVerbTable.realloc( ++nVerbTableSize );
 173             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 174             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 175             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::UI_ACTIVE;
 176         }
 177         else if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_SHOW )
 178         {
 179             m_aVerbTable.realloc( ++nVerbTableSize );
 180             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 181             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 182             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::UI_ACTIVE;
 183         }
 184         else if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_OPEN )
 185         {
 186             m_aVerbTable.realloc( ++nVerbTableSize );
 187             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 188             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 189             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::ACTIVE;
 190         }
 191         else if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_IPACTIVATE )
 192         {
 193             m_aVerbTable.realloc( ++nVerbTableSize );
 194             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 195             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 196             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::INPLACE_ACTIVE;
 197         }
 198         else if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_UIACTIVATE )
 199         {
 200             m_aVerbTable.realloc( ++nVerbTableSize );
 201             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 202             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 203             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::UI_ACTIVE;
 204         }
 205         else if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_HIDE )
 206         {
 207             m_aVerbTable.realloc( ++nVerbTableSize );
 208             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 209             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 210             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::RUNNING;
 211         }
 212     }
 213 }
 214
 215
 216 void OCommonEmbeddedObject::LinkInit_Impl(
 217                                 const uno::Sequence< beans::NamedValue >& aObjectProps,
 218                                 const uno::Sequence< beans::PropertyValue >& aMediaDescr,
 219                                 const uno::Sequence< beans::PropertyValue >& aObjectDescr )
 220 {
 221     // setPersistance has no effect on own links, so the complete initialization must be done here
 222
 223     for ( sal_Int32 nInd = 0; nInd < aMediaDescr.getLength(); nInd++ )
 224         if ( aMediaDescr[nInd].Name == "URL" )
 225             aMediaDescr[nInd].Value >>= m_aLinkURL;
 226         else if ( aMediaDescr[nInd].Name == "FilterName" )
 227             aMediaDescr[nInd].Value >>= m_aLinkFilterName;
 228
 229     OSL_ENSURE( m_aLinkURL.getLength() && m_aLinkFilterName.getLength(), "Filter and URL must be provided!" );
 230
 231     m_bReadOnly = true;
 232     if ( m_aLinkFilterName.getLength() )
 233     {
 234         ::comphelper::MimeConfigurationHelper aHelper( m_xContext );
 235         OUString aExportFilterName = aHelper.GetExportFilterFromImportFilter( m_aLinkFilterName );
 236         m_bReadOnly = aExportFilterName != m_aLinkFilterName;
 237     }
 238
 239     m_aDocMediaDescriptor = GetValuableArgs_Impl( aMediaDescr, false );
 240
 241     uno::Reference< frame::XDispatchProviderInterceptor > xDispatchInterceptor;
 242     for ( sal_Int32 nObjInd = 0; nObjInd < aObjectDescr.getLength(); nObjInd++ )
 243         if ( aObjectDescr[nObjInd].Name == "OutplaceDispatchInterceptor" )
 244         {
 245             aObjectDescr[nObjInd].Value >>= xDispatchInterceptor;
 246             break;
 247         }
 248         else if ( aObjectDescr[nObjInd].Name == "Parent" )
 249         {
 250             aObjectDescr[nObjInd].Value >>= m_xParent;
 251         }
 252
 253     CommonInit_Impl( aObjectProps );
 254
 255     if ( xDispatchInterceptor.is() )
 256         m_xDocHolder->SetOutplaceDispatchInterceptor( xDispatchInterceptor );
 257 }
 258
 259
 260 OCommonEmbeddedObject::~OCommonEmbeddedObject()
 261 {
 262     if ( m_pInterfaceContainer || m_xDocHolder.is() )
 263     {
 264         m_refCount++;
 265         try {
 266             lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
 267
 268             if ( m_pInterfaceContainer )
 269             {
 270                 m_pInterfaceContainer->disposeAndClear( aSource );
 271
 272                 delete m_pInterfaceContainer;
 273                 m_pInterfaceContainer = nullptr;
 274             }
 275         } catch( const uno::Exception& ) {}
 276
 277         try {
 278             if ( m_xDocHolder.is() )
 279             {
 280                 m_xDocHolder->CloseFrame();
 281                 try {
 282                     m_xDocHolder->CloseDocument( true, true );
 283                 } catch ( const uno::Exception& ) {}
 284                 m_xDocHolder->FreeOffice();
 285
 286                 m_xDocHolder.clear();
 287             }
 288         } catch( const uno::Exception& ) {}
 289     }
 290 }
 291
 292
 293 void OCommonEmbeddedObject::requestPositioning( const awt::Rectangle& aRect )
 294 {
 295     // the method is called in case object is inplace active and the object window was resized
 296
 297     OSL_ENSURE( m_xClientSite.is(), "The client site must be set for inplace active object!" );
 298     if ( m_xClientSite.is() )
 299     {
 300         uno::Reference< embed::XInplaceClient > xInplaceClient( m_xClientSite, uno::UNO_QUERY );
 301
 302         OSL_ENSURE( xInplaceClient.is(), "The client site must support XInplaceClient to allow inplace activation!" );
 303         if ( xInplaceClient.is() )
 304         {
 305             try {
 306                 xInplaceClient->changedPlacement( aRect );
 307             }
 308             catch( const uno::Exception& )
 309             {
 310                 OSL_FAIL( "Exception on request to resize!" );
 311             }
 312         }
 313     }
 314 }
 315
 316
 317 void OCommonEmbeddedObject::PostEvent_Impl( const OUString& aEventName )
 318 {
 319     if ( m_pInterfaceContainer )
 320     {
 321         ::cppu::OInterfaceContainerHelper* pIC = m_pInterfaceContainer->getContainer(
 322                                             cppu::UnoType<document::XEventListener>::get());
 323         if( pIC )
 324         {
 325             document::EventObject aEvent;
 326             aEvent.EventName = aEventName;
 327             aEvent.Source.set( static_cast< ::cppu::OWeakObject* >( this ) );
 328             // For now all the events are sent as object events
 329             // aEvent.Source = ( xSource.is() ? xSource
 330             //                       : uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >( this ) ) );
 331             ::cppu::OInterfaceIteratorHelper aIt( *pIC );
 332             while( aIt.hasMoreElements() )
 333             {
 334                 try
 335                 {
 336                     static_cast<document::XEventListener *>(aIt.next())->notifyEvent( aEvent );
 337                 }
 338                 catch( const uno::RuntimeException& )
 339                 {
 340                     aIt.remove();
 341                 }
 342
 343                 // the listener could dispose the object.
 344                 if ( m_bDisposed )
 345                     return;
 346             }
 347         }
 348     }
 349 }
 350
 351
 352 uno::Any SAL_CALL OCommonEmbeddedObject::queryInterface( const uno::Type& rType )
 353 {
 354     uno::Any aReturn;
 355
 356     if ( rType == cppu::UnoType<embed::XEmbeddedObject>::get() )
 357     {
 358         void * p = static_cast< embed::XEmbeddedObject * >( this );
 359         return uno::Any( &p, rType );
 360     }
 361     else if (rType == cppu::UnoType<embed::XEmbedPersist2>::get())
 362     {
 363         void* p = static_cast<embed::XEmbedPersist2*>(this);
 364         return uno::Any(&p, rType);
 365     }
 366     else
 367         aReturn = ::cppu::queryInterface(
 368                     rType,
 369                     static_cast< embed::XInplaceObject* >( this ),
 370                     static_cast< embed::XVisualObject* >( this ),
 371                     static_cast< embed::XCommonEmbedPersist* >( static_cast< embed::XEmbedPersist* >( this ) ),
 372                     static_cast< embed::XEmbedPersist* >( this ),
 373                     static_cast< embed::XLinkageSupport* >( this ),
 374                     static_cast< embed::XStateChangeBroadcaster* >( this ),
 375                     static_cast< embed::XClassifiedObject* >( this ),
 376                     static_cast< embed::XComponentSupplier* >( this ),
 377                     static_cast< util::XCloseable* >( this ),
 378                     static_cast< container::XChild* >( this ),
 379                     static_cast< chart2::XDefaultSizeTransmitter* >( this ),
 380                     static_cast< document::XEventBroadcaster* >( this ) );
 381
 382     if ( aReturn.hasValue() )
 383         return aReturn;
 384     else
 385         return ::cppu::OWeakObject::queryInterface( rType ) ;
 386
 387 }
 388
 389
 390 void SAL_CALL OCommonEmbeddedObject::acquire()
 391         throw()
 392 {
 393     ::cppu::OWeakObject::acquire() ;
 394 }
 395
 396
 397 void SAL_CALL OCommonEmbeddedObject::release()
 398         throw()
 399 {
 400     ::cppu::OWeakObject::release() ;
 401 }
 402
 403
 404 uno::Sequence< sal_Int8 > SAL_CALL OCommonEmbeddedObject::getClassID()
 405 {
 406     if ( m_bDisposed )
 407         throw lang::DisposedException();
 408
 409     return m_aClassID;
 410 }
 411
 412 OUString SAL_CALL OCommonEmbeddedObject::getClassName()
 413 {
 414     if ( m_bDisposed )
 415         throw lang::DisposedException();
 416
 417     return m_aClassName;
 418 }
 419
 420 void SAL_CALL OCommonEmbeddedObject::setClassInfo(
 421                 const uno::Sequence< sal_Int8 >& /*aClassID*/, const OUString& /*aClassName*/ )
 422 {
 423     // the object class info can not be changed explicitly
 424     throw lang::NoSupportException(); //TODO:
 425 }
 426
 427
 428 uno::Reference< util::XCloseable > SAL_CALL OCommonEmbeddedObject::getComponent()
 429 {
 430     SolarMutexGuard aGuard;
 431     if ( m_bDisposed )
 432         throw lang::DisposedException(); // TODO
 433
 434     // add an exception
 435     if ( m_nObjectState == -1 )
 436     {
 437         // the object is still not loaded
 438         throw uno::RuntimeException( "Can't store object without persistence!",
 439                                      static_cast< ::cppu::OWeakObject* >(this) );
 440     }
 441
 442     return uno::Reference< util::XCloseable >( m_xDocHolder->GetComponent(), uno::UNO_QUERY );
 443 }
 444
 445
 446 void SAL_CALL OCommonEmbeddedObject::addStateChangeListener( const uno::Reference< embed::XStateChangeListener >& xListener )
 447 {
 448     SolarMutexGuard aGuard;
 449     if ( m_bDisposed )
 450         throw lang::DisposedException(); // TODO
 451
 452     if ( !m_pInterfaceContainer )
 453         m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex );
 454
 455     m_pInterfaceContainer->addInterface( cppu::UnoType<embed::XStateChangeListener>::get(),
 456                                                         xListener );
 457 }
 458
 459
 460 void SAL_CALL OCommonEmbeddedObject::removeStateChangeListener(
 461                     const uno::Reference< embed::XStateChangeListener >& xListener )
 462 {
 463     SolarMutexGuard aGuard;
 464     if ( m_pInterfaceContainer )
 465         m_pInterfaceContainer->removeInterface( cppu::UnoType<embed::XStateChangeListener>::get(),
 466                                                 xListener );
 467 }
 468
 469
 470 void SAL_CALL OCommonEmbeddedObject::close( sal_Bool bDeliverOwnership )
 471 {
 472     SolarMutexGuard aGuard;
 473     if ( m_bClosed )
 474         throw lang::DisposedException(); // TODO
 475
 476     uno::Reference< uno::XInterface > xSelfHold( static_cast< ::cppu::OWeakObject* >( this ) );
 477     lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
 478
 479     if ( m_pInterfaceContainer )
 480     {
 481         ::cppu::OInterfaceContainerHelper* pContainer =
 482             m_pInterfaceContainer->getContainer( cppu::UnoType<util::XCloseListener>::get());
 483         if ( pContainer != nullptr )
 484         {
 485             ::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
 486             while (pIterator.hasMoreElements())
 487             {
 488                 try
 489                 {
 490                     static_cast<util::XCloseListener*>(pIterator.next())->queryClosing( aSource, bDeliverOwnership );
 491                 }
 492                 catch( const uno::RuntimeException& )
 493                 {
 494                     pIterator.remove();
 495                 }
 496             }
 497         }
 498
 499         pContainer = m_pInterfaceContainer->getContainer(
 500                                     cppu::UnoType<util::XCloseListener>::get());
 501         if ( pContainer != nullptr )
 502         {
 503             ::cppu::OInterfaceIteratorHelper pCloseIterator(*pContainer);
 504             while (pCloseIterator.hasMoreElements())
 505             {
 506                 try
 507                 {
 508                     static_cast<util::XCloseListener*>(pCloseIterator.next())->notifyClosing( aSource );
 509                 }
 510                 catch( const uno::RuntimeException& )
 511                 {
 512                     pCloseIterator.remove();
 513                 }
 514             }
 515         }
 516
 517         m_pInterfaceContainer->disposeAndClear( aSource );
 518     }
 519
 520     m_bDisposed = true; // the object is disposed now for outside
 521
 522     // it is possible that the document can not be closed, in this case if the argument is false
 523     // the exception will be thrown otherwise in addition to exception the object must register itself
 524     // as termination listener and listen for document events
 525
 526     if ( m_xDocHolder.is() )
 527     {
 528         m_xDocHolder->CloseFrame();
 529
 530         try {
 531             m_xDocHolder->CloseDocument( bDeliverOwnership, bDeliverOwnership );
 532         }
 533         catch( const uno::Exception& )
 534         {
 535             if ( bDeliverOwnership )
 536             {
 537                 m_xDocHolder.clear();
 538                 m_bClosed = true;
 539             }
 540
 541             throw;
 542         }
 543
 544         m_xDocHolder->FreeOffice();
 545
 546         m_xDocHolder.clear();
 547     }
 548
 549     // TODO: for now the storage will be disposed by the object, but after the document
 550     // will use the storage, the storage will be disposed by the document and recreated by the object
 551     if ( m_xObjectStorage.is() )
 552     {
 553         uno::Reference< lang::XComponent > xComp( m_xObjectStorage, uno::UNO_QUERY );
 554         OSL_ENSURE( xComp.is(), "Storage does not support XComponent!" );
 555
 556         if ( xComp.is() )
 557         {
 558             try {
 559                 xComp->dispose();
 560             } catch ( const uno::Exception& ) {}
 561         }
 562
 563         m_xObjectStorage.clear();
 564         m_xRecoveryStorage.clear();
 565     }
 566
 567     m_bClosed = true; // the closing succeeded
 568 }
 569
 570
 571 void SAL_CALL OCommonEmbeddedObject::addCloseListener( const uno::Reference< util::XCloseListener >& xListener )
 572 {
 573     SolarMutexGuard aGuard;
 574     if ( m_bDisposed )
 575         throw lang::DisposedException(); // TODO
 576
 577     if ( !m_pInterfaceContainer )
 578         m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper(m_aMutex);
 579
 580     m_pInterfaceContainer->addInterface( cppu::UnoType<util::XCloseListener>::get(), xListener );
 581 }
 582
 583
 584 void SAL_CALL OCommonEmbeddedObject::removeCloseListener( const uno::Reference< util::XCloseListener >& xListener )
 585 {
 586     SolarMutexGuard aGuard;
 587     if ( m_pInterfaceContainer )
 588         m_pInterfaceContainer->removeInterface( cppu::UnoType<util::XCloseListener>::get(),
 589                                                 xListener );
 590 }
 591
 592
 593 void SAL_CALL OCommonEmbeddedObject::addEventListener( const uno::Reference< document::XEventListener >& xListener )
 594 {
 595     SolarMutexGuard aGuard;
 596     if ( m_bDisposed )
 597         throw lang::DisposedException(); // TODO
 598
 599     if ( !m_pInterfaceContainer )
 600         m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper(m_aMutex);
 601
 602     m_pInterfaceContainer->addInterface( cppu::UnoType<document::XEventListener>::get(), xListener );
 603 }
 604
 605
 606 void SAL_CALL OCommonEmbeddedObject::removeEventListener( const uno::Reference< document::XEventListener >& xListener )
 607 {
 608     SolarMutexGuard aGuard;
 609     if ( m_pInterfaceContainer )
 610         m_pInterfaceContainer->removeInterface( cppu::UnoType<document::XEventListener>::get(),
 611                                                 xListener );
 612 }
 613
 614 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */