1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #include "precompiled_embeddedobj.hxx" 25 #include <com/sun/star/embed/EmbedStates.hpp> 26 #include <com/sun/star/embed/EmbedVerbs.hpp> 27 #include <com/sun/star/embed/EmbedUpdateModes.hpp> 28 #include <com/sun/star/embed/XEmbeddedClient.hpp> 29 #include <com/sun/star/embed/XInplaceClient.hpp> 30 #include <com/sun/star/embed/XWindowSupplier.hpp> 31 #include <com/sun/star/embed/StateChangeInProgressException.hpp> 32 #include <com/sun/star/embed/EmbedStates.hpp> 33 #include <com/sun/star/embed/Aspects.hpp> 34 #include <com/sun/star/embed/EmbedMapUnits.hpp> 35 #include <com/sun/star/embed/EntryInitModes.hpp> 36 #include <com/sun/star/embed/NoVisualAreaSizeException.hpp> 37 #include <com/sun/star/lang/DisposedException.hpp> 38 39 #include <cppuhelper/interfacecontainer.h> 40 41 #include <dummyobject.hxx> 42 43 44 using namespace ::com::sun::star; 45 46 //---------------------------------------------- 47 void ODummyEmbeddedObject::CheckInit() 48 { 49 if ( m_bDisposed ) 50 throw lang::DisposedException(); 51 52 if ( m_nObjectState == -1 ) 53 throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ), 54 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 55 } 56 57 //---------------------------------------------- 58 void ODummyEmbeddedObject::PostEvent_Impl( const ::rtl::OUString& aEventName, 59 const uno::Reference< uno::XInterface >& /*xSource*/ ) 60 { 61 if ( m_pInterfaceContainer ) 62 { 63 ::cppu::OInterfaceContainerHelper* pIC = m_pInterfaceContainer->getContainer( 64 ::getCppuType((const uno::Reference< document::XEventListener >*)0) ); 65 if( pIC ) 66 { 67 document::EventObject aEvent; 68 aEvent.EventName = aEventName; 69 aEvent.Source = uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >( this ) ); 70 // For now all the events are sent as object events 71 // aEvent.Source = ( xSource.is() ? xSource 72 // : uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >( this ) ) ); 73 ::cppu::OInterfaceIteratorHelper aIt( *pIC ); 74 while( aIt.hasMoreElements() ) 75 { 76 try 77 { 78 ((document::XEventListener *)aIt.next())->notifyEvent( aEvent ); 79 } 80 catch( uno::RuntimeException& ) 81 { 82 aIt.remove(); 83 } 84 85 // the listener could dispose the object. 86 if ( m_bDisposed ) 87 return; 88 } 89 } 90 } 91 } 92 93 //---------------------------------------------- 94 ODummyEmbeddedObject::~ODummyEmbeddedObject() 95 { 96 } 97 98 //---------------------------------------------- 99 void SAL_CALL ODummyEmbeddedObject::changeState( sal_Int32 nNewState ) 100 throw ( embed::UnreachableStateException, 101 embed::WrongStateException, 102 uno::Exception, 103 uno::RuntimeException ) 104 { 105 ::osl::MutexGuard aGuard( m_aMutex ); 106 CheckInit(); 107 108 if ( nNewState == embed::EmbedStates::LOADED ) 109 return; 110 111 throw embed::UnreachableStateException(); 112 } 113 114 //---------------------------------------------- 115 uno::Sequence< sal_Int32 > SAL_CALL ODummyEmbeddedObject::getReachableStates() 116 throw ( embed::WrongStateException, 117 uno::RuntimeException ) 118 { 119 ::osl::MutexGuard aGuard( m_aMutex ); 120 CheckInit(); 121 122 uno::Sequence< sal_Int32 > aResult( 1 ); 123 aResult[0] = embed::EmbedStates::LOADED; 124 125 return aResult; 126 } 127 128 //---------------------------------------------- 129 sal_Int32 SAL_CALL ODummyEmbeddedObject::getCurrentState() 130 throw ( embed::WrongStateException, 131 uno::RuntimeException ) 132 { 133 ::osl::MutexGuard aGuard( m_aMutex ); 134 CheckInit(); 135 136 return m_nObjectState; 137 } 138 139 //---------------------------------------------- 140 void SAL_CALL ODummyEmbeddedObject::doVerb( sal_Int32 ) 141 throw ( lang::IllegalArgumentException, 142 embed::WrongStateException, 143 embed::UnreachableStateException, 144 uno::Exception, 145 uno::RuntimeException ) 146 { 147 ::osl::MutexGuard aGuard( m_aMutex ); 148 CheckInit(); 149 150 // no supported verbs 151 } 152 153 //---------------------------------------------- 154 uno::Sequence< embed::VerbDescriptor > SAL_CALL ODummyEmbeddedObject::getSupportedVerbs() 155 throw ( embed::WrongStateException, 156 uno::RuntimeException ) 157 { 158 ::osl::MutexGuard aGuard( m_aMutex ); 159 CheckInit(); 160 161 return uno::Sequence< embed::VerbDescriptor >(); 162 } 163 164 //---------------------------------------------- 165 void SAL_CALL ODummyEmbeddedObject::setClientSite( 166 const uno::Reference< embed::XEmbeddedClient >& xClient ) 167 throw ( embed::WrongStateException, 168 uno::RuntimeException ) 169 { 170 ::osl::MutexGuard aGuard( m_aMutex ); 171 CheckInit(); 172 173 m_xClientSite = xClient; 174 } 175 176 //---------------------------------------------- 177 uno::Reference< embed::XEmbeddedClient > SAL_CALL ODummyEmbeddedObject::getClientSite() 178 throw ( embed::WrongStateException, 179 uno::RuntimeException ) 180 { 181 ::osl::MutexGuard aGuard( m_aMutex ); 182 CheckInit(); 183 184 return m_xClientSite; 185 } 186 187 //---------------------------------------------- 188 void SAL_CALL ODummyEmbeddedObject::update() 189 throw ( embed::WrongStateException, 190 uno::Exception, 191 uno::RuntimeException ) 192 { 193 ::osl::MutexGuard aGuard( m_aMutex ); 194 CheckInit(); 195 } 196 197 //---------------------------------------------- 198 void SAL_CALL ODummyEmbeddedObject::setUpdateMode( sal_Int32 ) 199 throw ( embed::WrongStateException, 200 uno::RuntimeException ) 201 { 202 ::osl::MutexGuard aGuard( m_aMutex ); 203 CheckInit(); 204 } 205 206 //---------------------------------------------- 207 sal_Int64 SAL_CALL ODummyEmbeddedObject::getStatus( sal_Int64 ) 208 throw ( embed::WrongStateException, 209 uno::RuntimeException ) 210 { 211 ::osl::MutexGuard aGuard( m_aMutex ); 212 CheckInit(); 213 214 return 0; 215 } 216 217 //---------------------------------------------- 218 void SAL_CALL ODummyEmbeddedObject::setContainerName( const ::rtl::OUString& ) 219 throw ( uno::RuntimeException ) 220 { 221 ::osl::MutexGuard aGuard( m_aMutex ); 222 CheckInit(); 223 } 224 225 //---------------------------------------------- 226 void SAL_CALL ODummyEmbeddedObject::setVisualAreaSize( sal_Int64 nAspect, const awt::Size& aSize ) 227 throw ( lang::IllegalArgumentException, 228 embed::WrongStateException, 229 uno::Exception, 230 uno::RuntimeException ) 231 { 232 ::osl::MutexGuard aGuard( m_aMutex ); 233 CheckInit(); 234 235 OSL_ENSURE( nAspect != embed::Aspects::MSOLE_ICON, "For iconified objects no graphical replacement is required!\n" ); 236 if ( nAspect == embed::Aspects::MSOLE_ICON ) 237 // no representation can be retrieved 238 throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "Illegal call!\n" ), 239 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 240 241 m_nCachedAspect = nAspect; 242 m_aCachedSize = aSize; 243 m_bHasCachedSize = sal_True; 244 } 245 246 //---------------------------------------------- 247 awt::Size SAL_CALL ODummyEmbeddedObject::getVisualAreaSize( sal_Int64 nAspect ) 248 throw ( lang::IllegalArgumentException, 249 embed::WrongStateException, 250 uno::Exception, 251 uno::RuntimeException ) 252 { 253 ::osl::MutexGuard aGuard( m_aMutex ); 254 CheckInit(); 255 256 OSL_ENSURE( nAspect != embed::Aspects::MSOLE_ICON, "For iconified objects no graphical replacement is required!\n" ); 257 if ( nAspect == embed::Aspects::MSOLE_ICON ) 258 // no representation can be retrieved 259 throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "Illegal call!\n" ), 260 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 261 262 if ( !m_bHasCachedSize || m_nCachedAspect != nAspect ) 263 throw embed::NoVisualAreaSizeException( 264 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "No size available!\n" ) ), 265 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 266 267 return m_aCachedSize; 268 } 269 270 //---------------------------------------------- 271 sal_Int32 SAL_CALL ODummyEmbeddedObject::getMapUnit( sal_Int64 nAspect ) 272 throw ( uno::Exception, 273 uno::RuntimeException) 274 { 275 ::osl::MutexGuard aGuard( m_aMutex ); 276 CheckInit(); 277 278 OSL_ENSURE( nAspect != embed::Aspects::MSOLE_ICON, "For iconified objects no graphical replacement is required!\n" ); 279 if ( nAspect == embed::Aspects::MSOLE_ICON ) 280 // no representation can be retrieved 281 throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "Illegal call!\n" ), 282 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 283 284 return embed::EmbedMapUnits::ONE_100TH_MM; 285 } 286 287 //---------------------------------------------- 288 embed::VisualRepresentation SAL_CALL ODummyEmbeddedObject::getPreferredVisualRepresentation( sal_Int64 ) 289 throw ( lang::IllegalArgumentException, 290 embed::WrongStateException, 291 uno::Exception, 292 uno::RuntimeException ) 293 { 294 ::osl::MutexGuard aGuard( m_aMutex ); 295 CheckInit(); 296 297 // no representation can be retrieved 298 throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "Illegal call!\n" ), 299 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 300 } 301 302 //---------------------------------------------- 303 void SAL_CALL ODummyEmbeddedObject::setPersistentEntry( 304 const uno::Reference< embed::XStorage >& xStorage, 305 const ::rtl::OUString& sEntName, 306 sal_Int32 nEntryConnectionMode, 307 const uno::Sequence< beans::PropertyValue >& /* lArguments */, 308 const uno::Sequence< beans::PropertyValue >& /* lObjArgs */ ) 309 throw ( lang::IllegalArgumentException, 310 embed::WrongStateException, 311 io::IOException, 312 uno::Exception, 313 uno::RuntimeException ) 314 { 315 ::osl::MutexGuard aGuard( m_aMutex ); 316 if ( m_bDisposed ) 317 throw lang::DisposedException(); // TODO 318 319 if ( !xStorage.is() ) 320 throw lang::IllegalArgumentException( ::rtl::OUString::createFromAscii( "No parent storage is provided!\n" ), 321 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ), 322 1 ); 323 324 if ( !sEntName.getLength() ) 325 throw lang::IllegalArgumentException( ::rtl::OUString::createFromAscii( "Empty element name is provided!\n" ), 326 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ), 327 2 ); 328 329 if ( ( m_nObjectState != -1 || nEntryConnectionMode == embed::EntryInitModes::NO_INIT ) 330 && ( m_nObjectState == -1 || nEntryConnectionMode != embed::EntryInitModes::NO_INIT ) ) 331 { 332 throw embed::WrongStateException( 333 ::rtl::OUString::createFromAscii( "Can't change persistant representation of activated object!\n" ), 334 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 335 } 336 337 if ( m_bWaitSaveCompleted ) 338 { 339 if ( nEntryConnectionMode == embed::EntryInitModes::NO_INIT ) 340 saveCompleted( ( m_xParentStorage != xStorage || !m_aEntryName.equals( sEntName ) ) ); 341 else 342 throw embed::WrongStateException( 343 ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 344 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 345 } 346 347 if ( nEntryConnectionMode == embed::EntryInitModes::DEFAULT_INIT 348 || nEntryConnectionMode == embed::EntryInitModes::NO_INIT ) 349 { 350 if ( xStorage->hasByName( sEntName ) ) 351 352 { 353 m_xParentStorage = xStorage; 354 m_aEntryName = sEntName; 355 m_nObjectState = embed::EmbedStates::LOADED; 356 } 357 else 358 throw lang::IllegalArgumentException( ::rtl::OUString::createFromAscii( "Wrong entry is provided!\n" ), 359 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ), 360 2 ); 361 362 } 363 else 364 throw lang::IllegalArgumentException( ::rtl::OUString::createFromAscii( "Wrong connection mode is provided!\n" ), 365 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ), 366 3 ); 367 } 368 369 //------------------------------------------------------ 370 void SAL_CALL ODummyEmbeddedObject::storeToEntry( const uno::Reference< embed::XStorage >& xStorage, 371 const ::rtl::OUString& sEntName, 372 const uno::Sequence< beans::PropertyValue >& /* lArguments */, 373 const uno::Sequence< beans::PropertyValue >& /* lObjArgs */ ) 374 throw ( lang::IllegalArgumentException, 375 embed::WrongStateException, 376 io::IOException, 377 uno::Exception, 378 uno::RuntimeException ) 379 { 380 ::osl::MutexGuard aGuard( m_aMutex ); 381 CheckInit(); 382 383 if ( m_bWaitSaveCompleted ) 384 throw embed::WrongStateException( 385 ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 386 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 387 388 m_xParentStorage->copyElementTo( m_aEntryName, xStorage, sEntName ); 389 } 390 391 //------------------------------------------------------ 392 void SAL_CALL ODummyEmbeddedObject::storeAsEntry( const uno::Reference< embed::XStorage >& xStorage, 393 const ::rtl::OUString& sEntName, 394 const uno::Sequence< beans::PropertyValue >& /* lArguments */, 395 const uno::Sequence< beans::PropertyValue >& /* lObjArgs */ ) 396 throw ( lang::IllegalArgumentException, 397 embed::WrongStateException, 398 io::IOException, 399 uno::Exception, 400 uno::RuntimeException ) 401 { 402 ::osl::MutexGuard aGuard( m_aMutex ); 403 CheckInit(); 404 405 if ( m_bWaitSaveCompleted ) 406 throw embed::WrongStateException( 407 ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 408 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 409 410 PostEvent_Impl( ::rtl::OUString::createFromAscii( "OnSaveAs" ), 411 uno::Reference< uno::XInterface >( static_cast< cppu::OWeakObject* >( this ) ) ); 412 413 m_xParentStorage->copyElementTo( m_aEntryName, xStorage, sEntName ); 414 415 m_bWaitSaveCompleted = sal_True; 416 m_xNewParentStorage = xStorage; 417 m_aNewEntryName = sEntName; 418 } 419 420 //------------------------------------------------------ 421 void SAL_CALL ODummyEmbeddedObject::saveCompleted( sal_Bool bUseNew ) 422 throw ( embed::WrongStateException, 423 uno::Exception, 424 uno::RuntimeException ) 425 { 426 ::osl::MutexGuard aGuard( m_aMutex ); 427 CheckInit(); 428 429 // it is allowed to call saveCompleted( false ) for nonstored objects 430 if ( !m_bWaitSaveCompleted && !bUseNew ) 431 return; 432 433 OSL_ENSURE( m_bWaitSaveCompleted, "Unexpected saveCompleted() call!\n" ); 434 if ( !m_bWaitSaveCompleted ) 435 throw io::IOException(); // TODO: illegal call 436 437 OSL_ENSURE( m_xNewParentStorage.is() , "Internal object information is broken!\n" ); 438 if ( !m_xNewParentStorage.is() ) 439 throw uno::RuntimeException(); // TODO: broken internal information 440 441 if ( bUseNew ) 442 { 443 m_xParentStorage = m_xNewParentStorage; 444 m_aEntryName = m_aNewEntryName; 445 446 PostEvent_Impl( ::rtl::OUString::createFromAscii( "OnSaveAsDone" ), 447 uno::Reference< uno::XInterface >( static_cast< cppu::OWeakObject* >( this ) ) ); 448 } 449 450 m_xNewParentStorage = uno::Reference< embed::XStorage >(); 451 m_aNewEntryName = ::rtl::OUString(); 452 m_bWaitSaveCompleted = sal_False; 453 } 454 455 //------------------------------------------------------ 456 sal_Bool SAL_CALL ODummyEmbeddedObject::hasEntry() 457 throw ( embed::WrongStateException, 458 uno::RuntimeException ) 459 { 460 ::osl::MutexGuard aGuard( m_aMutex ); 461 CheckInit(); 462 463 if ( m_bWaitSaveCompleted ) 464 throw embed::WrongStateException( 465 ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 466 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 467 468 if ( m_aEntryName.getLength() ) 469 return sal_True; 470 471 return sal_False; 472 } 473 474 //------------------------------------------------------ 475 ::rtl::OUString SAL_CALL ODummyEmbeddedObject::getEntryName() 476 throw ( embed::WrongStateException, 477 uno::RuntimeException ) 478 { 479 ::osl::MutexGuard aGuard( m_aMutex ); 480 CheckInit(); 481 482 if ( m_bWaitSaveCompleted ) 483 throw embed::WrongStateException( 484 ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 485 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 486 487 return m_aEntryName; 488 } 489 490 //------------------------------------------------------ 491 void SAL_CALL ODummyEmbeddedObject::storeOwn() 492 throw ( embed::WrongStateException, 493 io::IOException, 494 uno::Exception, 495 uno::RuntimeException ) 496 { 497 ::osl::MutexGuard aGuard( m_aMutex ); 498 CheckInit(); 499 500 if ( m_bWaitSaveCompleted ) 501 throw embed::WrongStateException( 502 ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 503 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 504 505 // the object can not be activated or changed 506 return; 507 } 508 509 //------------------------------------------------------ 510 sal_Bool SAL_CALL ODummyEmbeddedObject::isReadonly() 511 throw ( embed::WrongStateException, 512 uno::RuntimeException ) 513 { 514 ::osl::MutexGuard aGuard( m_aMutex ); 515 CheckInit(); 516 517 if ( m_bWaitSaveCompleted ) 518 throw embed::WrongStateException( 519 ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 520 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 521 522 // this object can not be changed 523 return sal_True; 524 } 525 526 //------------------------------------------------------ 527 void SAL_CALL ODummyEmbeddedObject::reload( 528 const uno::Sequence< beans::PropertyValue >& /* lArguments */, 529 const uno::Sequence< beans::PropertyValue >& /* lObjArgs */ ) 530 throw ( lang::IllegalArgumentException, 531 embed::WrongStateException, 532 io::IOException, 533 uno::Exception, 534 uno::RuntimeException ) 535 { 536 ::osl::MutexGuard aGuard( m_aMutex ); 537 CheckInit(); 538 539 if ( m_bWaitSaveCompleted ) 540 throw embed::WrongStateException( 541 ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 542 uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 543 544 // nothing to reload 545 } 546 547 //------------------------------------------------------ 548 uno::Sequence< sal_Int8 > SAL_CALL ODummyEmbeddedObject::getClassID() 549 throw ( uno::RuntimeException ) 550 { 551 ::osl::MutexGuard aGuard( m_aMutex ); 552 CheckInit(); 553 554 // currently the class ID is empty 555 // TODO/LATER: should a special class ID be used in this case? 556 return uno::Sequence< sal_Int8 >(); 557 } 558 559 //------------------------------------------------------ 560 ::rtl::OUString SAL_CALL ODummyEmbeddedObject::getClassName() 561 throw ( uno::RuntimeException ) 562 { 563 ::osl::MutexGuard aGuard( m_aMutex ); 564 if ( m_bDisposed ) 565 throw lang::DisposedException(); // TODO 566 567 return ::rtl::OUString(); 568 } 569 570 //------------------------------------------------------ 571 void SAL_CALL ODummyEmbeddedObject::setClassInfo( 572 const uno::Sequence< sal_Int8 >& /*aClassID*/, const ::rtl::OUString& /*aClassName*/ ) 573 throw ( lang::NoSupportException, 574 uno::RuntimeException ) 575 { 576 throw lang::NoSupportException(); 577 } 578 579 //------------------------------------------------------ 580 uno::Reference< util::XCloseable > SAL_CALL ODummyEmbeddedObject::getComponent() 581 throw ( uno::RuntimeException ) 582 { 583 ::osl::MutexGuard aGuard( m_aMutex ); 584 CheckInit(); 585 586 return uno::Reference< util::XCloseable >(); 587 } 588 589 //---------------------------------------------- 590 void SAL_CALL ODummyEmbeddedObject::addStateChangeListener( const uno::Reference< embed::XStateChangeListener >& xListener ) 591 throw ( uno::RuntimeException ) 592 { 593 ::osl::MutexGuard aGuard( m_aMutex ); 594 if ( m_bDisposed ) 595 return; 596 597 if ( !m_pInterfaceContainer ) 598 m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex ); 599 600 m_pInterfaceContainer->addInterface( ::getCppuType( (const uno::Reference< embed::XStateChangeListener >*)0 ), 601 xListener ); 602 } 603 604 //---------------------------------------------- 605 void SAL_CALL ODummyEmbeddedObject::removeStateChangeListener( 606 const uno::Reference< embed::XStateChangeListener >& xListener ) 607 throw (uno::RuntimeException) 608 { 609 ::osl::MutexGuard aGuard( m_aMutex ); 610 if ( m_pInterfaceContainer ) 611 m_pInterfaceContainer->removeInterface( ::getCppuType( (const uno::Reference< embed::XStateChangeListener >*)0 ), 612 xListener ); 613 } 614 615 //---------------------------------------------- 616 void SAL_CALL ODummyEmbeddedObject::close( sal_Bool bDeliverOwnership ) 617 throw ( util::CloseVetoException, 618 uno::RuntimeException ) 619 { 620 ::osl::MutexGuard aGuard( m_aMutex ); 621 if ( m_bDisposed ) 622 throw lang::DisposedException(); // TODO 623 624 uno::Reference< uno::XInterface > xSelfHold( static_cast< ::cppu::OWeakObject* >( this ) ); 625 lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) ); 626 627 if ( m_pInterfaceContainer ) 628 { 629 ::cppu::OInterfaceContainerHelper* pContainer = 630 m_pInterfaceContainer->getContainer( ::getCppuType( ( const uno::Reference< util::XCloseListener >*) NULL ) ); 631 if ( pContainer != NULL ) 632 { 633 ::cppu::OInterfaceIteratorHelper pIterator(*pContainer); 634 while (pIterator.hasMoreElements()) 635 { 636 try 637 { 638 ((util::XCloseListener*)pIterator.next())->queryClosing( aSource, bDeliverOwnership ); 639 } 640 catch( uno::RuntimeException& ) 641 { 642 pIterator.remove(); 643 } 644 } 645 } 646 647 pContainer = m_pInterfaceContainer->getContainer( 648 ::getCppuType( ( const uno::Reference< util::XCloseListener >*) NULL ) ); 649 if ( pContainer != NULL ) 650 { 651 ::cppu::OInterfaceIteratorHelper pCloseIterator(*pContainer); 652 while (pCloseIterator.hasMoreElements()) 653 { 654 try 655 { 656 ((util::XCloseListener*)pCloseIterator.next())->notifyClosing( aSource ); 657 } 658 catch( uno::RuntimeException& ) 659 { 660 pCloseIterator.remove(); 661 } 662 } 663 } 664 665 m_pInterfaceContainer->disposeAndClear( aSource ); 666 } 667 668 m_bDisposed = sal_True; // the object is disposed now for outside 669 } 670 671 //---------------------------------------------- 672 void SAL_CALL ODummyEmbeddedObject::addCloseListener( const uno::Reference< util::XCloseListener >& xListener ) 673 throw ( uno::RuntimeException ) 674 { 675 ::osl::MutexGuard aGuard( m_aMutex ); 676 if ( m_bDisposed ) 677 return; 678 679 if ( !m_pInterfaceContainer ) 680 m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex ); 681 682 m_pInterfaceContainer->addInterface( ::getCppuType( (const uno::Reference< util::XCloseListener >*)0 ), xListener ); 683 } 684 685 //---------------------------------------------- 686 void SAL_CALL ODummyEmbeddedObject::removeCloseListener( const uno::Reference< util::XCloseListener >& xListener ) 687 throw (uno::RuntimeException) 688 { 689 ::osl::MutexGuard aGuard( m_aMutex ); 690 if ( m_pInterfaceContainer ) 691 m_pInterfaceContainer->removeInterface( ::getCppuType( (const uno::Reference< util::XCloseListener >*)0 ), 692 xListener ); 693 } 694 695 //------------------------------------------------------ 696 void SAL_CALL ODummyEmbeddedObject::addEventListener( const uno::Reference< document::XEventListener >& xListener ) 697 throw ( uno::RuntimeException ) 698 { 699 ::osl::MutexGuard aGuard( m_aMutex ); 700 if ( m_bDisposed ) 701 return; 702 703 if ( !m_pInterfaceContainer ) 704 m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex ); 705 706 m_pInterfaceContainer->addInterface( ::getCppuType( (const uno::Reference< document::XEventListener >*)0 ), xListener ); 707 } 708 709 //------------------------------------------------------ 710 void SAL_CALL ODummyEmbeddedObject::removeEventListener( const uno::Reference< document::XEventListener >& xListener ) 711 throw ( uno::RuntimeException ) 712 { 713 ::osl::MutexGuard aGuard( m_aMutex ); 714 if ( m_pInterfaceContainer ) 715 m_pInterfaceContainer->removeInterface( ::getCppuType( (const uno::Reference< document::XEventListener >*)0 ), 716 xListener ); 717 } 718 719