embeddedobj/source/commonembedding/miscobj.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: miscobj.cxx,v $
  10  * $Revision: 1.25 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_embeddedobj.hxx"
  33
  34 #include <commonembobj.hxx>
  35 #include <com/sun/star/embed/EmbedStates.hpp>
  36 #include <com/sun/star/embed/EmbedVerbs.hpp>
  37 #include <com/sun/star/embed/XStorage.hpp>
  38 #include <com/sun/star/embed/EmbedUpdateModes.hpp>
  39 #include <com/sun/star/embed/XInplaceClient.hpp>
  40 #include <com/sun/star/lang/DisposedException.hpp>
  41 #include <com/sun/star/beans/NamedValue.hpp>
  42
  43 #include <cppuhelper/typeprovider.hxx>
  44 #include <cppuhelper/interfacecontainer.h>
  45
  46 #include "closepreventer.hxx"
  47 #include "intercept.hxx"
  48
  49 using namespace ::com::sun::star;
  50
  51
  52 uno::Sequence< beans::PropertyValue > GetValuableArgs_Impl( const uno::Sequence< beans::PropertyValue >& aMedDescr,
  53                                                             sal_Bool bCanUseDocumentBaseURL );
  54
  55 //------------------------------------------------------
  56 OCommonEmbeddedObject::OCommonEmbeddedObject( const uno::Reference< lang::XMultiServiceFactory >& xFactory,
  57                                                 const uno::Sequence< beans::NamedValue >& aObjProps )
  58 : m_pDocHolder( NULL )
  59 , m_pInterfaceContainer( NULL )
  60 , m_bReadOnly( sal_False )
  61 , m_bDisposed( sal_False )
  62 , m_bClosed( sal_False )
  63 , m_nObjectState( -1 )
  64 , m_nTargetState( -1 )
  65 , m_nUpdateMode ( embed::EmbedUpdateModes::ALWAYS_UPDATE )
  66 , m_xFactory( xFactory )
  67 , m_nMiscStatus( 0 )
  68 , m_bEmbeddedScriptSupport( sal_True )
  69 , m_bWaitSaveCompleted( sal_False )
  70 , m_bIsLink( sal_False )
  71 , m_bLinkHasPassword( sal_False )
  72 , m_bHasClonedSize( sal_False )
  73 , m_nClonedMapUnit( 0 )
  74 {
  75     CommonInit_Impl( aObjProps );
  76 }
  77
  78 //------------------------------------------------------
  79 OCommonEmbeddedObject::OCommonEmbeddedObject(
  80         const uno::Reference< lang::XMultiServiceFactory >& xFactory,
  81         const uno::Sequence< beans::NamedValue >& aObjProps,
  82         const uno::Sequence< beans::PropertyValue >& aMediaDescr,
  83         const uno::Sequence< beans::PropertyValue >& aObjectDescr )
  84 : m_pDocHolder( NULL )
  85 , m_pInterfaceContainer( NULL )
  86 , m_bReadOnly( sal_False )
  87 , m_bDisposed( sal_False )
  88 , m_bClosed( sal_False )
  89 , m_nObjectState( embed::EmbedStates::LOADED )
  90 , m_nTargetState( -1 )
  91 , m_nUpdateMode ( embed::EmbedUpdateModes::ALWAYS_UPDATE )
  92 , m_xFactory( xFactory )
  93 , m_nMiscStatus( 0 )
  94 , m_bEmbeddedScriptSupport( sal_True )
  95 , m_bWaitSaveCompleted( sal_False )
  96 , m_bIsLink( sal_True )
  97 , m_bLinkHasPassword( sal_False )
  98 , m_bHasClonedSize( sal_False )
  99 , m_nClonedMapUnit( 0 )
 100 {
 101     // linked object has no own persistence so it is in loaded state starting from creation
 102     LinkInit_Impl( aObjProps, aMediaDescr, aObjectDescr );
 103 }
 104
 105 //------------------------------------------------------
 106 void OCommonEmbeddedObject::CommonInit_Impl( const uno::Sequence< beans::NamedValue >& aObjectProps )
 107 {
 108     OSL_ENSURE( m_xFactory.is(), "No ServiceFactory is provided!\n" );
 109     if ( !m_xFactory.is() )
 110         throw uno::RuntimeException();
 111
 112     m_pDocHolder = new DocumentHolder( m_xFactory, this );
 113     m_pDocHolder->acquire();
 114
 115     // parse configuration entries
 116     // TODO/LATER: in future UI names can be also provided here
 117     for ( sal_Int32 nInd = 0; nInd < aObjectProps.getLength(); nInd++ )
 118     {
 119         if ( aObjectProps[nInd].Name.equalsAscii( "ClassID" ) )
 120             aObjectProps[nInd].Value >>= m_aClassID;
 121         else if ( aObjectProps[nInd].Name.equalsAscii( "ObjectDocumentServiceName" ) )
 122             aObjectProps[nInd].Value >>= m_aDocServiceName;
 123         else if ( aObjectProps[nInd].Name.equalsAscii( "ObjectDocumentFilterName" ) )
 124             aObjectProps[nInd].Value >>= m_aPresetFilterName;
 125         else if ( aObjectProps[nInd].Name.equalsAscii( "ObjectMiscStatus" ) )
 126             aObjectProps[nInd].Value >>= m_nMiscStatus;
 127         else if ( aObjectProps[nInd].Name.equalsAscii( "ObjectVerbs" ) )
 128             aObjectProps[nInd].Value >>= m_aObjectVerbs;
 129     }
 130
 131     if ( m_aClassID.getLength() != 16 /*|| !m_aDocServiceName.getLength()*/ )
 132         throw uno::RuntimeException(); // something goes really wrong
 133
 134     // accepted states
 135     m_aAcceptedStates.realloc( NUM_SUPPORTED_STATES );
 136
 137     m_aAcceptedStates[0] = embed::EmbedStates::LOADED;
 138     m_aAcceptedStates[1] = embed::EmbedStates::RUNNING;
 139     m_aAcceptedStates[2] = embed::EmbedStates::INPLACE_ACTIVE;
 140     m_aAcceptedStates[3] = embed::EmbedStates::UI_ACTIVE;
 141     m_aAcceptedStates[4] = embed::EmbedStates::ACTIVE;
 142
 143
 144     // intermediate states
 145     // In the following table the first index points to starting state,
 146     // the second one to the target state, and the sequence referenced by
 147     // first two indexes contains intermediate states, that should be
 148     // passed by object to reach the target state.
 149     // If the sequence is empty that means that indirect switch from start
 150     // state to the target state is forbidden, only if direct switch is possible
 151     // the state can be reached.
 152
 153     m_pIntermediateStatesSeqs[0][2].realloc( 1 );
 154     m_pIntermediateStatesSeqs[0][2][0] = embed::EmbedStates::RUNNING;
 155
 156     m_pIntermediateStatesSeqs[0][3].realloc( 2 );
 157     m_pIntermediateStatesSeqs[0][3][0] = embed::EmbedStates::RUNNING;
 158     m_pIntermediateStatesSeqs[0][3][1] = embed::EmbedStates::INPLACE_ACTIVE;
 159
 160     m_pIntermediateStatesSeqs[0][4].realloc( 1 );
 161     m_pIntermediateStatesSeqs[0][4][0] = embed::EmbedStates::RUNNING;
 162
 163     m_pIntermediateStatesSeqs[1][3].realloc( 1 );
 164     m_pIntermediateStatesSeqs[1][3][0] = embed::EmbedStates::INPLACE_ACTIVE;
 165
 166     m_pIntermediateStatesSeqs[2][0].realloc( 1 );
 167     m_pIntermediateStatesSeqs[2][0][0] = embed::EmbedStates::RUNNING;
 168
 169     m_pIntermediateStatesSeqs[3][0].realloc( 2 );
 170     m_pIntermediateStatesSeqs[3][0][0] = embed::EmbedStates::INPLACE_ACTIVE;
 171     m_pIntermediateStatesSeqs[3][0][1] = embed::EmbedStates::RUNNING;
 172
 173     m_pIntermediateStatesSeqs[3][1].realloc( 1 );
 174     m_pIntermediateStatesSeqs[3][1][0] = embed::EmbedStates::INPLACE_ACTIVE;
 175
 176     m_pIntermediateStatesSeqs[4][0].realloc( 1 );
 177     m_pIntermediateStatesSeqs[4][0][0] = embed::EmbedStates::RUNNING;
 178
 179     // verbs table
 180     sal_Int32 nVerbTableSize = 0;
 181     for ( sal_Int32 nVerbInd = 0; nVerbInd < m_aObjectVerbs.getLength(); nVerbInd++ )
 182     {
 183         if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_PRIMARY )
 184         {
 185             m_aVerbTable.realloc( ++nVerbTableSize );
 186             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 187             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 188             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::UI_ACTIVE;
 189         }
 190         else if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_SHOW )
 191         {
 192             m_aVerbTable.realloc( ++nVerbTableSize );
 193             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 194             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 195             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::UI_ACTIVE;
 196         }
 197         else if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_OPEN )
 198         {
 199             m_aVerbTable.realloc( ++nVerbTableSize );
 200             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 201             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 202             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::ACTIVE;
 203         }
 204         else if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_IPACTIVATE )
 205         {
 206             m_aVerbTable.realloc( ++nVerbTableSize );
 207             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 208             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 209             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::INPLACE_ACTIVE;
 210         }
 211         else if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_UIACTIVATE )
 212         {
 213             m_aVerbTable.realloc( ++nVerbTableSize );
 214             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 215             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 216             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::UI_ACTIVE;
 217         }
 218         else if ( m_aObjectVerbs[nVerbInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_HIDE )
 219         {
 220             m_aVerbTable.realloc( ++nVerbTableSize );
 221             m_aVerbTable[nVerbTableSize - 1].realloc( 2 );
 222             m_aVerbTable[nVerbTableSize - 1][0] = m_aObjectVerbs[nVerbInd].VerbID;
 223             m_aVerbTable[nVerbTableSize - 1][1] = embed::EmbedStates::RUNNING;
 224         }
 225     }
 226 }
 227
 228 //------------------------------------------------------
 229 void OCommonEmbeddedObject::LinkInit_Impl(
 230                                 const uno::Sequence< beans::NamedValue >& aObjectProps,
 231                                 const uno::Sequence< beans::PropertyValue >& aMediaDescr,
 232                                 const uno::Sequence< beans::PropertyValue >& aObjectDescr )
 233 {
 234     // setPersistance has no effect on own links, so the complete initialization must be done here
 235
 236     for ( sal_Int32 nInd = 0; nInd < aMediaDescr.getLength(); nInd++ )
 237         if ( aMediaDescr[nInd].Name.equalsAscii( "URL" ) )
 238             aMediaDescr[nInd].Value >>= m_aLinkURL;
 239         else if ( aMediaDescr[nInd].Name.equalsAscii( "FilterName" ) )
 240             aMediaDescr[nInd].Value >>= m_aLinkFilterName;
 241
 242     OSL_ENSURE( m_aLinkURL.getLength() && m_aLinkFilterName.getLength(), "Filter and URL must be provided!\n" );
 243
 244     m_aDocMediaDescriptor = GetValuableArgs_Impl( aMediaDescr, sal_False );
 245
 246     uno::Reference< frame::XDispatchProviderInterceptor > xDispatchInterceptor;
 247     for ( sal_Int32 nObjInd = 0; nObjInd < aObjectDescr.getLength(); nObjInd++ )
 248         if ( aObjectDescr[nObjInd].Name.equalsAscii( "OutplaceDispatchInterceptor" ) )
 249         {
 250             aObjectDescr[nObjInd].Value >>= xDispatchInterceptor;
 251             break;
 252         }
 253         else if ( aObjectDescr[nObjInd].Name.equalsAscii( "Parent" ) )
 254         {
 255             aObjectDescr[nObjInd].Value >>= m_xParent;
 256         }
 257
 258     CommonInit_Impl( aObjectProps );
 259
 260     if ( xDispatchInterceptor.is() )
 261         m_pDocHolder->SetOutplaceDispatchInterceptor( xDispatchInterceptor );
 262 }
 263
 264 //------------------------------------------------------
 265 OCommonEmbeddedObject::~OCommonEmbeddedObject()
 266 {
 267     if ( m_pInterfaceContainer || m_pDocHolder )
 268     {
 269         m_refCount++;
 270         try {
 271             lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
 272
 273             if ( m_pInterfaceContainer )
 274             {
 275                 m_pInterfaceContainer->disposeAndClear( aSource );
 276
 277                 delete m_pInterfaceContainer;
 278                 m_pInterfaceContainer = NULL;
 279             }
 280         } catch( uno::Exception& ) {}
 281
 282         try {
 283             if ( m_pDocHolder )
 284             {
 285                 m_pDocHolder->CloseFrame();
 286                 try {
 287                     m_pDocHolder->CloseDocument( sal_True, sal_True );
 288                 } catch ( uno::Exception& ) {}
 289                 m_pDocHolder->FreeOffice();
 290
 291                 m_pDocHolder->release();
 292                 m_pDocHolder = NULL;
 293             }
 294         } catch( uno::Exception& ) {}
 295     }
 296 }
 297
 298 //------------------------------------------------------
 299 void OCommonEmbeddedObject::requestPositioning( const awt::Rectangle& aRect )
 300 {
 301     // the method is called in case object is inplace active and the object window was resized
 302
 303     OSL_ENSURE( m_xClientSite.is(), "The client site must be set for inplace active object!\n" );
 304     if ( m_xClientSite.is() )
 305     {
 306         uno::Reference< embed::XInplaceClient > xInplaceClient( m_xClientSite, uno::UNO_QUERY );
 307
 308         OSL_ENSURE( xInplaceClient.is(), "The client site must support XInplaceClient to allow inplace activation!\n" );
 309         if ( xInplaceClient.is() )
 310         {
 311             try {
 312                 xInplaceClient->changedPlacement( aRect );
 313             }
 314             catch( uno::Exception& )
 315             {
 316                 OSL_ENSURE( sal_False, "Exception on request to resize!\n" );
 317             }
 318         }
 319     }
 320 }
 321
 322 //------------------------------------------------------
 323 void OCommonEmbeddedObject::PostEvent_Impl( const ::rtl::OUString& aEventName,
 324                                             const uno::Reference< uno::XInterface >& /*xSource*/ )
 325 {
 326     if ( m_pInterfaceContainer )
 327     {
 328         ::cppu::OInterfaceContainerHelper* pIC = m_pInterfaceContainer->getContainer(
 329                                             ::getCppuType((const uno::Reference< document::XEventListener >*)0) );
 330         if( pIC )
 331         {
 332             document::EventObject aEvent;
 333             aEvent.EventName = aEventName;
 334             aEvent.Source = uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >( this ) );
 335             // For now all the events are sent as object events
 336             // aEvent.Source = ( xSource.is() ? xSource
 337             //                                     : uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >( this ) ) );
 338             ::cppu::OInterfaceIteratorHelper aIt( *pIC );
 339             while( aIt.hasMoreElements() )
 340             {
 341                 try
 342                 {
 343                     ((document::XEventListener *)aIt.next())->notifyEvent( aEvent );
 344                 }
 345                 catch( uno::RuntimeException& )
 346                 {
 347                     aIt.remove();
 348                 }
 349
 350                 // the listener could dispose the object.
 351                 if ( m_bDisposed )
 352                     return;
 353             }
 354         }
 355     }
 356 }
 357
 358 //------------------------------------------------------
 359 uno::Any SAL_CALL OCommonEmbeddedObject::queryInterface( const uno::Type& rType )
 360         throw( uno::RuntimeException )
 361 {
 362     uno::Any aReturn;
 363
 364     if ( rType == ::getCppuType( (uno::Reference< embed::XEmbeddedObject > const *)0 ))
 365     {
 366         void * p = static_cast< embed::XEmbeddedObject * >( this );
 367         return uno::Any( &p, rType );
 368     }
 369     else
 370         aReturn <<= ::cppu::queryInterface(
 371                     rType,
 372                     static_cast< embed::XInplaceObject* >( this ),
 373                     static_cast< embed::XVisualObject* >( this ),
 374                     static_cast< embed::XCommonEmbedPersist* >( static_cast< embed::XEmbedPersist* >( this ) ),
 375                     static_cast< embed::XEmbedPersist* >( this ),
 376                     static_cast< embed::XLinkageSupport* >( this ),
 377                     static_cast< embed::XStateChangeBroadcaster* >( this ),
 378                     static_cast< embed::XClassifiedObject* >( this ),
 379                     static_cast< embed::XComponentSupplier* >( this ),
 380                     static_cast< util::XCloseable* >( this ),
 381                     static_cast< container::XChild* >( this ),
 382                     static_cast< chart2::XDefaultSizeTransmitter* >( this ),
 383                     static_cast< document::XEventBroadcaster* >( this ) );
 384
 385     if ( aReturn.hasValue() )
 386         return aReturn;
 387     else
 388         return ::cppu::OWeakObject::queryInterface( rType ) ;
 389
 390 }
 391
 392 //------------------------------------------------------
 393 void SAL_CALL OCommonEmbeddedObject::acquire()
 394         throw()
 395 {
 396     ::cppu::OWeakObject::acquire() ;
 397 }
 398
 399 //------------------------------------------------------
 400 void SAL_CALL OCommonEmbeddedObject::release()
 401         throw()
 402 {
 403     ::cppu::OWeakObject::release() ;
 404 }
 405
 406 //------------------------------------------------------
 407 uno::Sequence< uno::Type > SAL_CALL OCommonEmbeddedObject::getTypes()
 408         throw( uno::RuntimeException )
 409 {
 410     static ::cppu::OTypeCollection* pTypeCollection = NULL;
 411
 412     if ( !pTypeCollection )
 413     {
 414         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 415         if ( !pTypeCollection )
 416         {
 417             if ( m_bIsLink )
 418             {
 419                 static ::cppu::OTypeCollection aTypeCollection(
 420                                             ::getCppuType( (const uno::Reference< lang::XTypeProvider >*)NULL ),
 421                                             ::getCppuType( (const uno::Reference< embed::XEmbeddedObject >*)NULL ),
 422                                             ::getCppuType( (const uno::Reference< embed::XInplaceObject >*)NULL ),
 423                                             ::getCppuType( (const uno::Reference< embed::XCommonEmbedPersist >*)NULL ),
 424                                             ::getCppuType( (const uno::Reference< container::XChild >*)NULL ),
 425                                             ::getCppuType( (const uno::Reference< embed::XLinkageSupport >*)NULL ) );
 426
 427                 pTypeCollection = &aTypeCollection ;
 428             }
 429             else
 430             {
 431                    static ::cppu::OTypeCollection aTypeCollection(
 432                                             ::getCppuType( (const uno::Reference< lang::XTypeProvider >*)NULL ),
 433                                             ::getCppuType( (const uno::Reference< embed::XEmbeddedObject >*)NULL ),
 434                                             ::getCppuType( (const uno::Reference< embed::XInplaceObject >*)NULL ),
 435                                             ::getCppuType( (const uno::Reference< embed::XCommonEmbedPersist >*)NULL ),
 436                                             ::getCppuType( (const uno::Reference< container::XChild >*)NULL ),
 437                                             ::getCppuType( (const uno::Reference< embed::XEmbedPersist >*)NULL ) );
 438
 439                 pTypeCollection = &aTypeCollection ;
 440             }
 441         }
 442     }
 443
 444     return pTypeCollection->getTypes() ;
 445
 446 }
 447
 448 //------------------------------------------------------
 449 uno::Sequence< sal_Int8 > SAL_CALL OCommonEmbeddedObject::getImplementationId()
 450         throw( uno::RuntimeException )
 451 {
 452     static ::cppu::OImplementationId* pID = NULL ;
 453
 454     if ( !pID )
 455     {
 456         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ) ;
 457         if ( !pID )
 458         {
 459             static ::cppu::OImplementationId aID( sal_False ) ;
 460             pID = &aID ;
 461         }
 462     }
 463
 464     return pID->getImplementationId() ;
 465 }
 466
 467 //------------------------------------------------------
 468 uno::Sequence< sal_Int8 > SAL_CALL OCommonEmbeddedObject::getClassID()
 469         throw ( uno::RuntimeException )
 470 {
 471     ::osl::MutexGuard aGuard( m_aMutex );
 472     if ( m_bDisposed )
 473         throw lang::DisposedException(); // TODO
 474
 475     return m_aClassID;
 476 }
 477
 478 //------------------------------------------------------
 479 ::rtl::OUString SAL_CALL OCommonEmbeddedObject::getClassName()
 480         throw ( uno::RuntimeException )
 481 {
 482     ::osl::MutexGuard aGuard( m_aMutex );
 483     if ( m_bDisposed )
 484         throw lang::DisposedException(); // TODO
 485
 486     return m_aClassName;
 487 }
 488
 489 //------------------------------------------------------
 490 void SAL_CALL OCommonEmbeddedObject::setClassInfo(
 491                 const uno::Sequence< sal_Int8 >& /*aClassID*/, const ::rtl::OUString& /*aClassName*/ )
 492         throw ( lang::NoSupportException,
 493                 uno::RuntimeException )
 494 {
 495     // the object class info can not be changed explicitly
 496     throw lang::NoSupportException(); //TODO:
 497 }
 498
 499 //------------------------------------------------------
 500 uno::Reference< util::XCloseable > SAL_CALL OCommonEmbeddedObject::getComponent()
 501         throw ( uno::RuntimeException )
 502 {
 503     ::osl::MutexGuard aGuard( m_aMutex );
 504     if ( m_bDisposed )
 505         throw lang::DisposedException(); // TODO
 506
 507     // add an exception
 508     if ( m_nObjectState == -1 )
 509     {
 510         // the object is still not loaded
 511         throw uno::RuntimeException( ::rtl::OUString::createFromAscii( "Can't store object without persistence!\n" ),
 512                                         uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
 513     }
 514
 515     // if ( m_bWaitSaveCompleted )
 516     //  throw embed::WrongStateException(
 517     //                          ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ),
 518     //                          uno::Reference< uno::XInterface >( reinterpret_cast< ::cppu::OWeakObject* >(this) ) );
 519
 520     return uno::Reference< util::XCloseable >( m_pDocHolder->GetComponent(), uno::UNO_QUERY );
 521 }
 522
 523 //----------------------------------------------
 524 void SAL_CALL OCommonEmbeddedObject::addStateChangeListener( const uno::Reference< embed::XStateChangeListener >& xListener )
 525     throw ( uno::RuntimeException )
 526 {
 527     ::osl::MutexGuard aGuard( m_aMutex );
 528     if ( m_bDisposed )
 529         throw lang::DisposedException(); // TODO
 530
 531     if ( !m_pInterfaceContainer )
 532         m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex );
 533
 534     m_pInterfaceContainer->addInterface( ::getCppuType( (const uno::Reference< embed::XStateChangeListener >*)0 ),
 535                                                         xListener );
 536 }
 537
 538 //----------------------------------------------
 539 void SAL_CALL OCommonEmbeddedObject::removeStateChangeListener(
 540                     const uno::Reference< embed::XStateChangeListener >& xListener )
 541     throw (uno::RuntimeException)
 542 {
 543     ::osl::MutexGuard aGuard( m_aMutex );
 544     if ( m_pInterfaceContainer )
 545         m_pInterfaceContainer->removeInterface( ::getCppuType( (const uno::Reference< embed::XStateChangeListener >*)0 ),
 546                                                 xListener );
 547 }
 548
 549 //----------------------------------------------
 550 void SAL_CALL OCommonEmbeddedObject::close( sal_Bool bDeliverOwnership )
 551     throw ( util::CloseVetoException,
 552             uno::RuntimeException )
 553 {
 554     ::osl::MutexGuard aGuard( m_aMutex );
 555     if ( m_bClosed )
 556         throw lang::DisposedException(); // TODO
 557
 558     uno::Reference< uno::XInterface > xSelfHold( static_cast< ::cppu::OWeakObject* >( this ) );
 559     lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
 560
 561     if ( m_pInterfaceContainer )
 562     {
 563         ::cppu::OInterfaceContainerHelper* pContainer =
 564             m_pInterfaceContainer->getContainer( ::getCppuType( ( const uno::Reference< util::XCloseListener >*) NULL ) );
 565         if ( pContainer != NULL )
 566         {
 567             ::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
 568             while (pIterator.hasMoreElements())
 569             {
 570                 try
 571                 {
 572                     ((util::XCloseListener*)pIterator.next())->queryClosing( aSource, bDeliverOwnership );
 573                 }
 574                 catch( uno::RuntimeException& )
 575                 {
 576                     pIterator.remove();
 577                 }
 578             }
 579         }
 580
 581         pContainer = m_pInterfaceContainer->getContainer(
 582                                     ::getCppuType( ( const uno::Reference< util::XCloseListener >*) NULL ) );
 583         if ( pContainer != NULL )
 584         {
 585             ::cppu::OInterfaceIteratorHelper pCloseIterator(*pContainer);
 586             while (pCloseIterator.hasMoreElements())
 587             {
 588                 try
 589                 {
 590                     ((util::XCloseListener*)pCloseIterator.next())->notifyClosing( aSource );
 591                 }
 592                 catch( uno::RuntimeException& )
 593                 {
 594                     pCloseIterator.remove();
 595                 }
 596             }
 597         }
 598
 599         m_pInterfaceContainer->disposeAndClear( aSource );
 600     }
 601
 602     m_bDisposed = sal_True; // the object is disposed now for outside
 603
 604     // it is possible that the document can not be closed, in this case if the argument is false
 605     // the exception will be thrown otherwise in addition to exception the object must register itself
 606     // as termination listener and listen for document events
 607
 608     if ( m_pDocHolder )
 609     {
 610         m_pDocHolder->CloseFrame();
 611
 612         try {
 613             m_pDocHolder->CloseDocument( bDeliverOwnership, bDeliverOwnership );
 614         }
 615         catch( uno::Exception& )
 616         {
 617             if ( bDeliverOwnership )
 618             {
 619                 m_pDocHolder->release();
 620                 m_pDocHolder = NULL;
 621                 m_bClosed = sal_True;
 622             }
 623
 624             throw;
 625         }
 626
 627         m_pDocHolder->FreeOffice();
 628
 629         m_pDocHolder->release();
 630         m_pDocHolder = NULL;
 631     }
 632
 633     // TODO: for now the storage will be disposed by the object, but after the document
 634     // will use the storage, the storage will be disposed by the document and recreated by the object
 635     if ( m_xObjectStorage.is() )
 636     {
 637         uno::Reference< lang::XComponent > xComp( m_xObjectStorage, uno::UNO_QUERY );
 638         OSL_ENSURE( xComp.is(), "Storage does not support XComponent!\n" );
 639
 640         if ( xComp.is() )
 641         {
 642             try {
 643                 xComp->dispose();
 644             } catch ( uno::Exception& ) {}
 645         }
 646
 647         m_xObjectStorage = uno::Reference< embed::XStorage >();
 648     }
 649
 650     m_bClosed = sal_True; // the closing succeeded
 651 }
 652
 653 //----------------------------------------------
 654 void SAL_CALL OCommonEmbeddedObject::addCloseListener( const uno::Reference< util::XCloseListener >& xListener )
 655     throw ( uno::RuntimeException )
 656 {
 657     ::osl::MutexGuard aGuard( m_aMutex );
 658     if ( m_bDisposed )
 659         throw lang::DisposedException(); // TODO
 660
 661     if ( !m_pInterfaceContainer )
 662         m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex );
 663
 664     m_pInterfaceContainer->addInterface( ::getCppuType( (const uno::Reference< util::XCloseListener >*)0 ), xListener );
 665 }
 666
 667 //----------------------------------------------
 668 void SAL_CALL OCommonEmbeddedObject::removeCloseListener( const uno::Reference< util::XCloseListener >& xListener )
 669     throw (uno::RuntimeException)
 670 {
 671     ::osl::MutexGuard aGuard( m_aMutex );
 672     if ( m_pInterfaceContainer )
 673         m_pInterfaceContainer->removeInterface( ::getCppuType( (const uno::Reference< util::XCloseListener >*)0 ),
 674                                                 xListener );
 675 }
 676
 677 //------------------------------------------------------
 678 void SAL_CALL OCommonEmbeddedObject::addEventListener( const uno::Reference< document::XEventListener >& xListener )
 679         throw ( uno::RuntimeException )
 680 {
 681     ::osl::MutexGuard aGuard( m_aMutex );
 682     if ( m_bDisposed )
 683         throw lang::DisposedException(); // TODO
 684
 685     if ( !m_pInterfaceContainer )
 686         m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex );
 687
 688     m_pInterfaceContainer->addInterface( ::getCppuType( (const uno::Reference< document::XEventListener >*)0 ), xListener );
 689 }
 690
 691 //------------------------------------------------------
 692 void SAL_CALL OCommonEmbeddedObject::removeEventListener( const uno::Reference< document::XEventListener >& xListener )
 693         throw ( uno::RuntimeException )
 694 {
 695     ::osl::MutexGuard aGuard( m_aMutex );
 696     if ( m_pInterfaceContainer )
 697         m_pInterfaceContainer->removeInterface( ::getCppuType( (const uno::Reference< document::XEventListener >*)0 ),
 698                                                 xListener );
 699 }
 700