embeddedobj/source/msole/olemisc.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/config.h>
  21
  22 #include <cassert>
  23
  24 #include <com/sun/star/embed/EmbedUpdateModes.hpp>
  25 #include <com/sun/star/embed/EmbedStates.hpp>
  26 #include <com/sun/star/embed/WrongStateException.hpp>
  27 #include <com/sun/star/lang/NoSupportException.hpp>
  28 #include <com/sun/star/lang/XComponent.hpp>
  29 #include <com/sun/star/lang/DisposedException.hpp>
  30
  31 #include <comphelper/multicontainer2.hxx>
  32 #include <comphelper/sequenceashashmap.hxx>
  33 #include <cppuhelper/supportsservice.hxx>
  34 #include <osl/diagnose.h>
  35
  36 #include <oleembobj.hxx>
  37 #include <utility>
  38 #include "olepersist.hxx"
  39
  40 #include "ownview.hxx"
  41
  42 #include "olecomponent.hxx"
  43
  44 using namespace ::com::sun::star;
  45
  46
  47 OleEmbeddedObject::OleEmbeddedObject( uno::Reference< uno::XComponentContext > xContext,
  48                                       const uno::Sequence< sal_Int8 >& aClassID,
  49                                       OUString aClassName )
  50 : m_bReadOnly( false )
  51 , m_bDisposed( false )
  52 , m_nObjectState( -1 )
  53 , m_nTargetState( -1 )
  54 , m_nUpdateMode ( embed::EmbedUpdateModes::ALWAYS_UPDATE )
  55 , m_xContext(std::move( xContext ))
  56 , m_aClassID( aClassID )
  57 , m_aClassName(std::move( aClassName ))
  58 , m_bWaitSaveCompleted( false )
  59 , m_bNewVisReplInStream( true )
  60 , m_bStoreLoaded( false )
  61 , m_bVisReplInitialized( false )
  62 , m_bVisReplInStream( false )
  63 , m_bStoreVisRepl( false )
  64 , m_bIsLink( false )
  65 , m_bHasCachedSize( false )
  66 , m_nCachedAspect( 0 )
  67 , m_bHasSizeToSet( false )
  68 , m_nAspectToSet( 0 )
  69 , m_bGotStatus( false )
  70 , m_nStatus( 0 )
  71 , m_nStatusAspect( 0 )
  72 , m_bFromClipboard( false )
  73 , m_bTriedConversion( false )
  74 {
  75 }
  76
  77
  78 // In case of loading from persistent entry the classID of the object
  79 // will be retrieved from the entry, during construction it is unknown
  80 OleEmbeddedObject::OleEmbeddedObject( uno::Reference< uno::XComponentContext > xContext, bool bLink )
  81 : m_bReadOnly( false )
  82 , m_bDisposed( false )
  83 , m_nObjectState( -1 )
  84 , m_nTargetState( -1 )
  85 , m_nUpdateMode( embed::EmbedUpdateModes::ALWAYS_UPDATE )
  86 , m_xContext(std::move( xContext ))
  87 , m_bWaitSaveCompleted( false )
  88 , m_bNewVisReplInStream( true )
  89 , m_bStoreLoaded( false )
  90 , m_bVisReplInitialized( false )
  91 , m_bVisReplInStream( false )
  92 , m_bStoreVisRepl( false )
  93 , m_bIsLink( bLink )
  94 , m_bHasCachedSize( false )
  95 , m_nCachedAspect( 0 )
  96 , m_bHasSizeToSet( false )
  97 , m_nAspectToSet( 0 )
  98 , m_bGotStatus( false )
  99 , m_nStatus( 0 )
 100 , m_nStatusAspect( 0 )
 101 , m_bFromClipboard( false )
 102 , m_bTriedConversion( false )
 103 {
 104 }
 105 #ifdef _WIN32
 106
 107 // this constructor let object be initialized from clipboard
 108 OleEmbeddedObject::OleEmbeddedObject( const uno::Reference< uno::XComponentContext >& xContext )
 109 : m_bReadOnly( false )
 110 , m_bDisposed( false )
 111 , m_nObjectState( -1 )
 112 , m_nTargetState( -1 )
 113 , m_nUpdateMode( embed::EmbedUpdateModes::ALWAYS_UPDATE )
 114 , m_xContext( xContext )
 115 , m_bWaitSaveCompleted( false )
 116 , m_bNewVisReplInStream( true )
 117 , m_bStoreLoaded( false )
 118 , m_bVisReplInitialized( false )
 119 , m_bVisReplInStream( false )
 120 , m_bStoreVisRepl( false )
 121 , m_bIsLink( false )
 122 , m_bHasCachedSize( false )
 123 , m_nCachedAspect( 0 )
 124 , m_bHasSizeToSet( false )
 125 , m_nAspectToSet( 0 )
 126 , m_bGotStatus( false )
 127 , m_nStatus( 0 )
 128 , m_nStatusAspect( 0 )
 129 , m_bFromClipboard( true )
 130 , m_bTriedConversion( false )
 131 {
 132 }
 133 #endif
 134
 135 OleEmbeddedObject::~OleEmbeddedObject()
 136 {
 137     OSL_ENSURE( !m_pInterfaceContainer && !m_pOleComponent && !m_xObjectStream.is(),
 138                     "The object is not closed! DISASTER is possible!" );
 139
 140     if ( m_pOleComponent || m_pInterfaceContainer || m_xObjectStream.is() )
 141     {
 142         // the component must be cleaned during closing
 143         osl_atomic_increment(&m_refCount); // to avoid crash
 144         try {
 145             Dispose();
 146         } catch( const uno::Exception& ) {}
 147     }
 148
 149     if ( !m_aTempURL.isEmpty() )
 150            KillFile_Impl( m_aTempURL, m_xContext );
 151
 152     if ( !m_aTempDumpURL.isEmpty() )
 153            KillFile_Impl( m_aTempDumpURL, m_xContext );
 154 }
 155
 156
 157 void OleEmbeddedObject::MakeEventListenerNotification_Impl( const OUString& aEventName )
 158 {
 159     if ( !m_pInterfaceContainer )
 160         return;
 161
 162     comphelper::OInterfaceContainerHelper2* pContainer =
 163         m_pInterfaceContainer->getContainer(
 164                                 cppu::UnoType<document::XEventListener>::get());
 165     if ( pContainer == nullptr )
 166         return;
 167
 168     document::EventObject aEvent( static_cast< ::cppu::OWeakObject* >( this ), aEventName );
 169     comphelper::OInterfaceIteratorHelper2 pIterator(*pContainer);
 170     while (pIterator.hasMoreElements())
 171     {
 172         try
 173         {
 174             static_cast<document::XEventListener*>(pIterator.next())->notifyEvent( aEvent );
 175         }
 176         catch( const uno::RuntimeException& )
 177         {
 178         }
 179     }
 180 }
 181 #ifdef _WIN32
 182
 183 void OleEmbeddedObject::StateChangeNotification_Impl( bool bBeforeChange, sal_Int32 nOldState, sal_Int32 nNewState )
 184 {
 185     if ( m_pInterfaceContainer )
 186     {
 187         comphelper::OInterfaceContainerHelper2* pContainer = m_pInterfaceContainer->getContainer(
 188                             cppu::UnoType<embed::XStateChangeListener>::get());
 189         if ( pContainer != nullptr )
 190         {
 191             lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
 192             comphelper::OInterfaceIteratorHelper2 pIterator(*pContainer);
 193
 194             while (pIterator.hasMoreElements())
 195             {
 196                 if ( bBeforeChange )
 197                 {
 198                     try
 199                     {
 200                         static_cast<embed::XStateChangeListener*>(pIterator.next())->changingState( aSource, nOldState, nNewState );
 201                     }
 202                     catch( const uno::Exception& )
 203                     {
 204                         // even if the listener complains ignore it for now
 205                     }
 206                 }
 207                 else
 208                 {
 209                        try
 210                     {
 211                         static_cast<embed::XStateChangeListener*>(pIterator.next())->stateChanged( aSource, nOldState, nNewState );
 212                     }
 213                     catch( const uno::Exception& )
 214                     {
 215                         // if anything happened it is problem of listener, ignore it
 216                     }
 217                 }
 218             }
 219         }
 220     }
 221 }
 222 #endif
 223
 224 void OleEmbeddedObject::GetRidOfComponent()
 225 {
 226 #ifdef _WIN32
 227     if ( m_pOleComponent )
 228     {
 229         if ( m_nObjectState != -1 && m_nObjectState != embed::EmbedStates::LOADED )
 230             SaveObject_Impl();
 231
 232         m_pOleComponent->removeCloseListener( m_xClosePreventer );
 233         try
 234         {
 235             m_pOleComponent->close( false );
 236         }
 237         catch( const uno::Exception& )
 238         {
 239             // TODO: there should be a special listener to wait for component closing
 240             //       and to notify object, may be object itself can be such a listener
 241             m_pOleComponent->addCloseListener( m_xClosePreventer );
 242             throw;
 243         }
 244
 245         m_pOleComponent->disconnectEmbeddedObject();
 246         m_pOleComponent.clear();
 247     }
 248 #endif
 249 }
 250
 251
 252 void OleEmbeddedObject::Dispose()
 253 {
 254     if ( m_pInterfaceContainer )
 255     {
 256         lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
 257         m_pInterfaceContainer->disposeAndClear( aSource );
 258         m_pInterfaceContainer.reset();
 259     }
 260
 261     if ( m_xOwnView.is() )
 262     {
 263         m_xOwnView->Close();
 264         m_xOwnView.clear();
 265     }
 266
 267     if ( m_pOleComponent )
 268         try {
 269             GetRidOfComponent();
 270         } catch( const uno::Exception& )
 271         {
 272             m_bDisposed = true;
 273             throw; // TODO: there should be a special listener that will close object when
 274                     // component is finally closed
 275         }
 276
 277     if ( m_xObjectStream.is() )
 278     {
 279         uno::Reference< lang::XComponent > xComp( m_xObjectStream, uno::UNO_QUERY );
 280         OSL_ENSURE( xComp.is(), "Storage stream doesn't support XComponent!" );
 281
 282         if ( xComp.is() )
 283         {
 284             try {
 285                 xComp->dispose();
 286             } catch( const uno::Exception& ) {}
 287         }
 288         m_xObjectStream.clear();
 289     }
 290
 291     m_xParentStorage.clear();
 292
 293     m_bDisposed = true;
 294 }
 295
 296
 297 uno::Sequence< sal_Int8 > SAL_CALL OleEmbeddedObject::getClassID()
 298 {
 299     // begin wrapping related part ====================
 300     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 301     if ( xWrappedObject.is() )
 302     {
 303         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 304         return xWrappedObject->getClassID();
 305     }
 306     // end wrapping related part ====================
 307
 308     ::osl::MutexGuard aGuard( m_aMutex );
 309     if ( m_bDisposed )
 310         throw lang::DisposedException(); // TODO
 311
 312     return m_aClassID;
 313 }
 314
 315
 316 OUString SAL_CALL OleEmbeddedObject::getClassName()
 317 {
 318     // begin wrapping related part ====================
 319     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 320     if ( xWrappedObject.is() )
 321     {
 322         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 323         return xWrappedObject->getClassName();
 324     }
 325     // end wrapping related part ====================
 326
 327     ::osl::MutexGuard aGuard( m_aMutex );
 328     if ( m_bDisposed )
 329         throw lang::DisposedException(); // TODO
 330
 331     return m_aClassName;
 332 }
 333
 334
 335 void SAL_CALL OleEmbeddedObject::setClassInfo(
 336                 const uno::Sequence< sal_Int8 >& aClassID, const OUString& aClassName )
 337 {
 338     // begin wrapping related part ====================
 339     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 340     if ( xWrappedObject.is() )
 341     {
 342         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 343         xWrappedObject->setClassInfo( aClassID, aClassName );
 344         return;
 345     }
 346     // end wrapping related part ====================
 347
 348     // the object class info can not be changed explicitly
 349     throw lang::NoSupportException(); //TODO:
 350 }
 351
 352
 353 uno::Reference< util::XCloseable > SAL_CALL OleEmbeddedObject::getComponent()
 354 {
 355     // begin wrapping related part ====================
 356     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 357     if ( xWrappedObject.is() )
 358     {
 359         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 360         return xWrappedObject->getComponent();
 361     }
 362     // end wrapping related part ====================
 363
 364     ::osl::MutexGuard aGuard( m_aMutex );
 365     if ( m_bDisposed )
 366         throw lang::DisposedException(); // TODO
 367
 368     if ( m_nObjectState == -1 ) // || m_nObjectState == embed::EmbedStates::LOADED )
 369     {
 370         // the object is still not running
 371         throw uno::RuntimeException( "The object is not loaded!",
 372                                         static_cast< ::cppu::OWeakObject* >(this) );
 373     }
 374
 375 #if defined(_WIN32)
 376     if (m_pOleComponent.is())
 377     {
 378         return uno::Reference< util::XCloseable >( m_pOleComponent );
 379     }
 380 #endif
 381
 382     assert(!m_pOleComponent.is());
 383     // TODO/LATER: Is it correct???
 384     return uno::Reference< util::XCloseable >();
 385     // throw uno::RuntimeException(); // TODO
 386 }
 387
 388
 389 void SAL_CALL OleEmbeddedObject::addStateChangeListener( const uno::Reference< embed::XStateChangeListener >& xListener )
 390 {
 391     // begin wrapping related part ====================
 392     if ( m_xWrappedObject.is() )
 393     {
 394         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 395         m_xWrappedObject->addStateChangeListener( xListener );
 396         return;
 397     }
 398     // end wrapping related part ====================
 399
 400     ::osl::MutexGuard aGuard( m_aMutex );
 401     if ( m_bDisposed )
 402         throw lang::DisposedException(); // TODO
 403
 404     if ( !m_pInterfaceContainer )
 405         m_pInterfaceContainer.reset(new comphelper::OMultiTypeInterfaceContainerHelper2( m_aMutex ));
 406
 407     m_pInterfaceContainer->addInterface( cppu::UnoType<embed::XStateChangeListener>::get(),
 408                                                         xListener );
 409 }
 410
 411
 412 void SAL_CALL OleEmbeddedObject::removeStateChangeListener(
 413                     const uno::Reference< embed::XStateChangeListener >& xListener )
 414 {
 415     // begin wrapping related part ====================
 416     if ( m_xWrappedObject.is() )
 417     {
 418         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 419         m_xWrappedObject->removeStateChangeListener( xListener );
 420         return;
 421     }
 422     // end wrapping related part ====================
 423
 424     ::osl::MutexGuard aGuard( m_aMutex );
 425     if ( m_pInterfaceContainer )
 426         m_pInterfaceContainer->removeInterface( cppu::UnoType<embed::XStateChangeListener>::get(),
 427                                                 xListener );
 428 }
 429
 430
 431 void SAL_CALL OleEmbeddedObject::close( sal_Bool bDeliverOwnership )
 432 {
 433     // begin wrapping related part ====================
 434     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 435     if ( xWrappedObject.is() )
 436     {
 437         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 438         xWrappedObject->close( bDeliverOwnership );
 439         return;
 440     }
 441     // end wrapping related part ====================
 442
 443     ::osl::MutexGuard aGuard( m_aMutex );
 444     if ( m_bDisposed )
 445         throw lang::DisposedException(); // TODO
 446
 447     uno::Reference< uno::XInterface > xSelfHold( static_cast< ::cppu::OWeakObject* >( this ) );
 448     lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
 449
 450     if ( m_pInterfaceContainer )
 451     {
 452         comphelper::OInterfaceContainerHelper2* pContainer =
 453             m_pInterfaceContainer->getContainer( cppu::UnoType<util::XCloseListener>::get());
 454         if ( pContainer != nullptr )
 455         {
 456             comphelper::OInterfaceIteratorHelper2 pIterator(*pContainer);
 457             while (pIterator.hasMoreElements())
 458             {
 459                 try
 460                 {
 461                     static_cast<util::XCloseListener*>(pIterator.next())->queryClosing( aSource, bDeliverOwnership );
 462                 }
 463                 catch( const uno::RuntimeException& )
 464                 {
 465                     pIterator.remove();
 466                 }
 467             }
 468         }
 469
 470         pContainer = m_pInterfaceContainer->getContainer(
 471                                     cppu::UnoType<util::XCloseListener>::get());
 472         if ( pContainer != nullptr )
 473         {
 474             comphelper::OInterfaceIteratorHelper2 pCloseIterator(*pContainer);
 475             while (pCloseIterator.hasMoreElements())
 476             {
 477                 try
 478                 {
 479                     static_cast<util::XCloseListener*>(pCloseIterator.next())->notifyClosing( aSource );
 480                 }
 481                 catch( const uno::RuntimeException& )
 482                 {
 483                     pCloseIterator.remove();
 484                 }
 485             }
 486         }
 487     }
 488
 489     Dispose();
 490 }
 491
 492
 493 void SAL_CALL OleEmbeddedObject::addCloseListener( const uno::Reference< util::XCloseListener >& xListener )
 494 {
 495     // begin wrapping related part ====================
 496     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 497     if ( xWrappedObject.is() )
 498     {
 499         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 500         xWrappedObject->addCloseListener( xListener );
 501         return;
 502     }
 503     // end wrapping related part ====================
 504
 505     ::osl::MutexGuard aGuard( m_aMutex );
 506     if ( m_bDisposed )
 507         throw lang::DisposedException(); // TODO
 508
 509     if ( !m_pInterfaceContainer )
 510         m_pInterfaceContainer.reset(new comphelper::OMultiTypeInterfaceContainerHelper2( m_aMutex ));
 511
 512     m_pInterfaceContainer->addInterface( cppu::UnoType<util::XCloseListener>::get(), xListener );
 513 }
 514
 515
 516 void SAL_CALL OleEmbeddedObject::removeCloseListener( const uno::Reference< util::XCloseListener >& xListener )
 517 {
 518     // begin wrapping related part ====================
 519     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 520     if ( xWrappedObject.is() )
 521     {
 522         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 523         xWrappedObject->removeCloseListener( xListener );
 524         return;
 525     }
 526     // end wrapping related part ====================
 527
 528     ::osl::MutexGuard aGuard( m_aMutex );
 529     if ( m_bDisposed )
 530         throw lang::DisposedException(); // TODO
 531
 532     if ( m_pInterfaceContainer )
 533         m_pInterfaceContainer->removeInterface( cppu::UnoType<util::XCloseListener>::get(),
 534                                                 xListener );
 535 }
 536
 537
 538 void SAL_CALL OleEmbeddedObject::addEventListener( const uno::Reference< document::XEventListener >& xListener )
 539 {
 540     // begin wrapping related part ====================
 541     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 542     if ( xWrappedObject.is() )
 543     {
 544         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 545         xWrappedObject->addEventListener( xListener );
 546         return;
 547     }
 548     // end wrapping related part ====================
 549
 550     ::osl::MutexGuard aGuard( m_aMutex );
 551     if ( m_bDisposed )
 552         throw lang::DisposedException(); // TODO
 553
 554     if ( !m_pInterfaceContainer )
 555         m_pInterfaceContainer.reset(new comphelper::OMultiTypeInterfaceContainerHelper2( m_aMutex ));
 556
 557     m_pInterfaceContainer->addInterface( cppu::UnoType<document::XEventListener>::get(), xListener );
 558 }
 559
 560
 561 void SAL_CALL OleEmbeddedObject::removeEventListener(
 562                 const uno::Reference< document::XEventListener >& xListener )
 563 {
 564     // begin wrapping related part ====================
 565     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 566     if ( xWrappedObject.is() )
 567     {
 568         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 569         xWrappedObject->removeEventListener( xListener );
 570         return;
 571     }
 572     // end wrapping related part ====================
 573
 574     ::osl::MutexGuard aGuard( m_aMutex );
 575     if ( m_bDisposed )
 576         throw lang::DisposedException(); // TODO
 577
 578     if ( m_pInterfaceContainer )
 579         m_pInterfaceContainer->removeInterface( cppu::UnoType<document::XEventListener>::get(),
 580                                                 xListener );
 581 }
 582
 583 // XInplaceObject ( wrapper related implementation )
 584
 585 void SAL_CALL OleEmbeddedObject::setObjectRectangles( const awt::Rectangle& aPosRect,
 586                                                            const awt::Rectangle& aClipRect )
 587 {
 588     // begin wrapping related part ====================
 589     uno::Reference< embed::XInplaceObject > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
 590     if ( xWrappedObject.is() )
 591     {
 592         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 593         xWrappedObject->setObjectRectangles( aPosRect, aClipRect );
 594         return;
 595     }
 596     // end wrapping related part ====================
 597
 598     throw embed::WrongStateException();
 599 }
 600
 601
 602 void SAL_CALL OleEmbeddedObject::enableModeless( sal_Bool bEnable )
 603 {
 604     // begin wrapping related part ====================
 605     uno::Reference< embed::XInplaceObject > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
 606     if ( xWrappedObject.is() )
 607     {
 608         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 609         xWrappedObject->enableModeless( bEnable );
 610         return;
 611     }
 612     // end wrapping related part ====================
 613
 614     throw embed::WrongStateException();
 615 }
 616
 617
 618 void SAL_CALL OleEmbeddedObject::translateAccelerators(
 619                     const uno::Sequence< awt::KeyEvent >& aKeys )
 620 {
 621     // begin wrapping related part ====================
 622     uno::Reference< embed::XInplaceObject > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
 623     if ( xWrappedObject.is() )
 624     {
 625         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 626         xWrappedObject->translateAccelerators( aKeys );
 627         return;
 628     }
 629     // end wrapping related part ====================
 630
 631 }
 632
 633 // XChild
 634
 635 css::uno::Reference< css::uno::XInterface > SAL_CALL OleEmbeddedObject::getParent()
 636 {
 637     // begin wrapping related part ====================
 638     uno::Reference< container::XChild > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
 639     if ( xWrappedObject.is() )
 640     {
 641         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 642         return xWrappedObject->getParent();
 643     }
 644     // end wrapping related part ====================
 645
 646     return m_xParent;
 647 }
 648
 649
 650 void SAL_CALL OleEmbeddedObject::setParent( const css::uno::Reference< css::uno::XInterface >& xParent )
 651 {
 652     // begin wrapping related part ====================
 653     uno::Reference< container::XChild > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
 654     if ( xWrappedObject.is() )
 655     {
 656         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 657         xWrappedObject->setParent( xParent );
 658         return;
 659     }
 660     // end wrapping related part ====================
 661
 662     m_xParent = xParent;
 663 }
 664
 665 void OleEmbeddedObject::setStream(const css::uno::Reference<css::io::XStream>& xStream)
 666 {
 667     m_xObjectStream = xStream;
 668 }
 669
 670 css::uno::Reference<css::io::XStream> OleEmbeddedObject::getStream()
 671 {
 672     return m_xObjectStream;
 673 }
 674
 675 void OleEmbeddedObject::initialize(const uno::Sequence<uno::Any>& rArguments)
 676 {
 677     if (!rArguments.hasElements())
 678         return;
 679
 680     comphelper::SequenceAsHashMap aValues(rArguments[0]);
 681     auto it = aValues.find("StreamReadOnly");
 682     if (it != aValues.end())
 683         it->second >>= m_bStreamReadOnly;
 684 }
 685
 686 OUString SAL_CALL OleEmbeddedObject::getImplementationName()
 687 {
 688     return "com.sun.star.comp.embed.OleEmbeddedObject";
 689 }
 690
 691 sal_Bool SAL_CALL OleEmbeddedObject::supportsService(const OUString& ServiceName)
 692 {
 693     return cppu::supportsService(this, ServiceName);
 694 }
 695
 696 uno::Sequence<OUString> SAL_CALL OleEmbeddedObject::getSupportedServiceNames()
 697 {
 698     return { "com.sun.star.comp.embed.OleEmbeddedObject" };
 699 }
 700
 701 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */