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                                                       osl::ResettableMutexGuard& guard )
 159 {
 160     if ( !m_pInterfaceContainer )
 161         return;
 162
 163     comphelper::OInterfaceContainerHelper2* pContainer =
 164         m_pInterfaceContainer->getContainer(
 165                                 cppu::UnoType<document::XEventListener>::get());
 166     if ( pContainer == nullptr )
 167         return;
 168
 169     auto proc = [&guard, aEvent = document::EventObject(getXWeak(), aEventName)](
 170                     const uno::Reference<document::XEventListener>& xListener)
 171     {
 172         try
 173         {
 174             osl::ResettableMutexGuardScopedReleaser area(guard);
 175             xListener->notifyEvent(aEvent);
 176         }
 177         catch (const lang::DisposedException&)
 178         {
 179             throw; // forEach handles this
 180         }
 181         catch (const uno::RuntimeException&)
 182         {
 183         }
 184     };
 185     pContainer->forEach<document::XEventListener>(proc);
 186 }
 187 #ifdef _WIN32
 188
 189 void OleEmbeddedObject::StateChangeNotification_Impl( bool bBeforeChange, sal_Int32 nOldState, sal_Int32 nNewState,
 190                                                       osl::ResettableMutexGuard& guard )
 191 {
 192     if (!m_pInterfaceContainer)
 193         return;
 194
 195     comphelper::OInterfaceContainerHelper2* pContainer = m_pInterfaceContainer->getContainer(
 196                         cppu::UnoType<embed::XStateChangeListener>::get());
 197     if (!pContainer)
 198         return;
 199
 200     auto proc
 201         = [bBeforeChange, nOldState, nNewState, &guard, aSource = lang::EventObject(getXWeak())](
 202               const uno::Reference<embed::XStateChangeListener>& xListener)
 203     {
 204         try
 205         {
 206             osl::ResettableMutexGuardScopedReleaser area(guard);
 207             if (bBeforeChange)
 208                 xListener->changingState(aSource, nOldState, nNewState);
 209             else
 210                 xListener->stateChanged(aSource, nOldState, nNewState);
 211         }
 212         catch (const lang::DisposedException&)
 213         {
 214             throw; // forEach handles this
 215         }
 216         catch (const uno::Exception&)
 217         {
 218             // even if the listener complains ignore it for now
 219         }
 220     };
 221     pContainer->forEach<embed::XStateChangeListener>(proc);
 222 }
 223 #endif
 224
 225 void OleEmbeddedObject::GetRidOfComponent(osl::ResettableMutexGuard* guard)
 226 {
 227 #ifdef _WIN32
 228     if ( m_pOleComponent )
 229     {
 230         if ( m_nObjectState != -1 && m_nObjectState != embed::EmbedStates::LOADED )
 231             SaveObject_Impl();
 232
 233         m_pOleComponent->removeCloseListener( m_xClosePreventer );
 234         // When releasing the guard below, avoid a case when two threads are doing the same;
 235         // store the reference on stack and clear m_pOleComponent in advance
 236         rtl::Reference<OleComponent> pOleComponent(std::move(m_pOleComponent));
 237         try
 238         {
 239             std::optional<osl::ResettableMutexGuardScopedReleaser> oReleaser;
 240             if (guard)
 241                 oReleaser.emplace(*guard);
 242             pOleComponent->close(false);
 243         }
 244         catch( const uno::Exception& )
 245         {
 246             m_pOleComponent = std::move(pOleComponent);
 247             // TODO: there should be a special listener to wait for component closing
 248             //       and to notify object, may be object itself can be such a listener
 249             m_pOleComponent->addCloseListener( m_xClosePreventer );
 250             throw;
 251         }
 252
 253         pOleComponent->disconnectEmbeddedObject();
 254     }
 255 #else
 256     (void)guard;
 257 #endif
 258 }
 259
 260
 261 void OleEmbeddedObject::Dispose(osl::ResettableMutexGuard* guard)
 262 {
 263     if ( m_pInterfaceContainer )
 264     {
 265         lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
 266         m_pInterfaceContainer->disposeAndClear( aSource );
 267         m_pInterfaceContainer.reset();
 268     }
 269
 270     if ( m_xOwnView.is() )
 271     {
 272         m_xOwnView->Close();
 273         m_xOwnView.clear();
 274     }
 275
 276     if ( m_pOleComponent )
 277         try {
 278             GetRidOfComponent(guard);
 279         } catch( const uno::Exception& )
 280         {
 281             m_bDisposed = true;
 282             throw; // TODO: there should be a special listener that will close object when
 283                     // component is finally closed
 284         }
 285
 286     if ( m_xObjectStream.is() )
 287     {
 288         uno::Reference< lang::XComponent > xComp( m_xObjectStream, uno::UNO_QUERY );
 289         OSL_ENSURE( xComp.is(), "Storage stream doesn't support XComponent!" );
 290
 291         if ( xComp.is() )
 292         {
 293             try {
 294                 xComp->dispose();
 295             } catch( const uno::Exception& ) {}
 296         }
 297         m_xObjectStream.clear();
 298     }
 299
 300     m_xParentStorage.clear();
 301     m_xClientSite.clear();
 302     m_xClosePreventer.clear();
 303     m_xNewCachedVisRepl.clear();
 304     m_xNewParentStorage.clear();
 305     m_xNewObjectStream.clear();
 306     m_xCachedVisualRepresentation.clear();
 307     m_xWrappedObject.clear();
 308     m_xParent.clear();
 309     m_pOleComponent.clear();
 310
 311     m_bDisposed = true;
 312 }
 313
 314
 315 uno::Sequence< sal_Int8 > SAL_CALL OleEmbeddedObject::getClassID()
 316 {
 317     // begin wrapping related part ====================
 318     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 319     if ( xWrappedObject.is() )
 320     {
 321         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 322         return xWrappedObject->getClassID();
 323     }
 324     // end wrapping related part ====================
 325
 326     ::osl::MutexGuard aGuard( m_aMutex );
 327     if ( m_bDisposed )
 328         throw lang::DisposedException(); // TODO
 329
 330     return m_aClassID;
 331 }
 332
 333
 334 OUString SAL_CALL OleEmbeddedObject::getClassName()
 335 {
 336     // begin wrapping related part ====================
 337     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 338     if ( xWrappedObject.is() )
 339     {
 340         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 341         return xWrappedObject->getClassName();
 342     }
 343     // end wrapping related part ====================
 344
 345     ::osl::MutexGuard aGuard( m_aMutex );
 346     if ( m_bDisposed )
 347         throw lang::DisposedException(); // TODO
 348
 349     return m_aClassName;
 350 }
 351
 352
 353 void SAL_CALL OleEmbeddedObject::setClassInfo(
 354                 const uno::Sequence< sal_Int8 >& aClassID, const OUString& aClassName )
 355 {
 356     // begin wrapping related part ====================
 357     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 358     if ( xWrappedObject.is() )
 359     {
 360         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 361         xWrappedObject->setClassInfo( aClassID, aClassName );
 362         return;
 363     }
 364     // end wrapping related part ====================
 365
 366     // the object class info can not be changed explicitly
 367     throw lang::NoSupportException(); //TODO:
 368 }
 369
 370
 371 uno::Reference< util::XCloseable > SAL_CALL OleEmbeddedObject::getComponent()
 372 {
 373     // begin wrapping related part ====================
 374     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 375     if ( xWrappedObject.is() )
 376     {
 377         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 378         return xWrappedObject->getComponent();
 379     }
 380     // end wrapping related part ====================
 381
 382     ::osl::MutexGuard aGuard( m_aMutex );
 383     if ( m_bDisposed )
 384         throw lang::DisposedException(); // TODO
 385
 386     if ( m_nObjectState == -1 ) // || m_nObjectState == embed::EmbedStates::LOADED )
 387     {
 388         // the object is still not running
 389         throw uno::RuntimeException( u"The object is not loaded!"_ustr,
 390                                         static_cast< ::cppu::OWeakObject* >(this) );
 391     }
 392
 393 #if defined(_WIN32)
 394     if (m_pOleComponent.is())
 395     {
 396         return uno::Reference< util::XCloseable >( m_pOleComponent );
 397     }
 398 #endif
 399
 400     assert(!m_pOleComponent.is());
 401     // TODO/LATER: Is it correct???
 402     return uno::Reference< util::XCloseable >();
 403     // throw uno::RuntimeException(); // TODO
 404 }
 405
 406
 407 void SAL_CALL OleEmbeddedObject::addStateChangeListener( const uno::Reference< embed::XStateChangeListener >& xListener )
 408 {
 409     // begin wrapping related part ====================
 410     if ( m_xWrappedObject.is() )
 411     {
 412         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 413         m_xWrappedObject->addStateChangeListener( xListener );
 414         return;
 415     }
 416     // end wrapping related part ====================
 417
 418     ::osl::MutexGuard aGuard( m_aMutex );
 419     if ( m_bDisposed )
 420         throw lang::DisposedException(); // TODO
 421
 422     if ( !m_pInterfaceContainer )
 423         m_pInterfaceContainer.reset(new comphelper::OMultiTypeInterfaceContainerHelper2( m_aMutex ));
 424
 425     m_pInterfaceContainer->addInterface( cppu::UnoType<embed::XStateChangeListener>::get(),
 426                                                         xListener );
 427 }
 428
 429
 430 void SAL_CALL OleEmbeddedObject::removeStateChangeListener(
 431                     const uno::Reference< embed::XStateChangeListener >& xListener )
 432 {
 433     // begin wrapping related part ====================
 434     if ( m_xWrappedObject.is() )
 435     {
 436         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 437         m_xWrappedObject->removeStateChangeListener( xListener );
 438         return;
 439     }
 440     // end wrapping related part ====================
 441
 442     ::osl::MutexGuard aGuard( m_aMutex );
 443     if ( m_pInterfaceContainer )
 444         m_pInterfaceContainer->removeInterface( cppu::UnoType<embed::XStateChangeListener>::get(),
 445                                                 xListener );
 446 }
 447
 448
 449 void SAL_CALL OleEmbeddedObject::close( sal_Bool bDeliverOwnership )
 450 {
 451     // begin wrapping related part ====================
 452     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 453     if ( xWrappedObject.is() )
 454     {
 455         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 456         xWrappedObject->close( bDeliverOwnership );
 457         return;
 458     }
 459     // end wrapping related part ====================
 460
 461     osl::ResettableMutexGuard aGuard(m_aMutex);
 462     if ( m_bDisposed )
 463         throw lang::DisposedException(); // TODO
 464
 465     uno::Reference< uno::XInterface > xSelfHold( static_cast< ::cppu::OWeakObject* >( this ) );
 466     lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
 467
 468     if ( m_pInterfaceContainer )
 469     {
 470         comphelper::OInterfaceContainerHelper2* pContainer =
 471             m_pInterfaceContainer->getContainer( cppu::UnoType<util::XCloseListener>::get());
 472         if ( pContainer != nullptr )
 473         {
 474             comphelper::OInterfaceIteratorHelper2 pIterator(*pContainer);
 475             while (pIterator.hasMoreElements())
 476             {
 477                 try
 478                 {
 479                     static_cast<util::XCloseListener*>(pIterator.next())->queryClosing( aSource, bDeliverOwnership );
 480                 }
 481                 catch( const uno::RuntimeException& )
 482                 {
 483                     pIterator.remove();
 484                 }
 485             }
 486         }
 487
 488         pContainer = m_pInterfaceContainer->getContainer(
 489                                     cppu::UnoType<util::XCloseListener>::get());
 490         if ( pContainer != nullptr )
 491         {
 492             comphelper::OInterfaceIteratorHelper2 pCloseIterator(*pContainer);
 493             while (pCloseIterator.hasMoreElements())
 494             {
 495                 try
 496                 {
 497                     static_cast<util::XCloseListener*>(pCloseIterator.next())->notifyClosing( aSource );
 498                 }
 499                 catch( const uno::RuntimeException& )
 500                 {
 501                     pCloseIterator.remove();
 502                 }
 503             }
 504         }
 505     }
 506
 507     Dispose(&aGuard);
 508 }
 509
 510
 511 void SAL_CALL OleEmbeddedObject::addCloseListener( const uno::Reference< util::XCloseListener >& xListener )
 512 {
 513     // begin wrapping related part ====================
 514     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 515     if ( xWrappedObject.is() )
 516     {
 517         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 518         xWrappedObject->addCloseListener( xListener );
 519         return;
 520     }
 521     // end wrapping related part ====================
 522
 523     ::osl::MutexGuard aGuard( m_aMutex );
 524     if ( m_bDisposed )
 525         throw lang::DisposedException(); // TODO
 526
 527     if ( !m_pInterfaceContainer )
 528         m_pInterfaceContainer.reset(new comphelper::OMultiTypeInterfaceContainerHelper2( m_aMutex ));
 529
 530     m_pInterfaceContainer->addInterface( cppu::UnoType<util::XCloseListener>::get(), xListener );
 531 }
 532
 533
 534 void SAL_CALL OleEmbeddedObject::removeCloseListener( const uno::Reference< util::XCloseListener >& xListener )
 535 {
 536     // begin wrapping related part ====================
 537     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 538     if ( xWrappedObject.is() )
 539     {
 540         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 541         xWrappedObject->removeCloseListener( xListener );
 542         return;
 543     }
 544     // end wrapping related part ====================
 545
 546     ::osl::MutexGuard aGuard( m_aMutex );
 547     if ( m_bDisposed )
 548         throw lang::DisposedException(); // TODO
 549
 550     if ( m_pInterfaceContainer )
 551         m_pInterfaceContainer->removeInterface( cppu::UnoType<util::XCloseListener>::get(),
 552                                                 xListener );
 553 }
 554
 555
 556 void SAL_CALL OleEmbeddedObject::addEventListener( const uno::Reference< document::XEventListener >& xListener )
 557 {
 558     // begin wrapping related part ====================
 559     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 560     if ( xWrappedObject.is() )
 561     {
 562         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 563         xWrappedObject->addEventListener( xListener );
 564         return;
 565     }
 566     // end wrapping related part ====================
 567
 568     ::osl::MutexGuard aGuard( m_aMutex );
 569     if ( m_bDisposed )
 570         throw lang::DisposedException(); // TODO
 571
 572     if ( !m_pInterfaceContainer )
 573         m_pInterfaceContainer.reset(new comphelper::OMultiTypeInterfaceContainerHelper2( m_aMutex ));
 574
 575     m_pInterfaceContainer->addInterface( cppu::UnoType<document::XEventListener>::get(), xListener );
 576 }
 577
 578
 579 void SAL_CALL OleEmbeddedObject::removeEventListener(
 580                 const uno::Reference< document::XEventListener >& xListener )
 581 {
 582     // begin wrapping related part ====================
 583     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 584     if ( xWrappedObject.is() )
 585     {
 586         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 587         xWrappedObject->removeEventListener( xListener );
 588         return;
 589     }
 590     // end wrapping related part ====================
 591
 592     ::osl::MutexGuard aGuard( m_aMutex );
 593     if ( m_bDisposed )
 594         throw lang::DisposedException(); // TODO
 595
 596     if ( m_pInterfaceContainer )
 597         m_pInterfaceContainer->removeInterface( cppu::UnoType<document::XEventListener>::get(),
 598                                                 xListener );
 599 }
 600
 601 // XInplaceObject ( wrapper related implementation )
 602
 603 void SAL_CALL OleEmbeddedObject::setObjectRectangles( const awt::Rectangle& aPosRect,
 604                                                            const awt::Rectangle& aClipRect )
 605 {
 606     // begin wrapping related part ====================
 607     uno::Reference< embed::XInplaceObject > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
 608     if ( xWrappedObject.is() )
 609     {
 610         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 611         xWrappedObject->setObjectRectangles( aPosRect, aClipRect );
 612         return;
 613     }
 614     // end wrapping related part ====================
 615
 616     throw embed::WrongStateException();
 617 }
 618
 619
 620 void SAL_CALL OleEmbeddedObject::enableModeless( sal_Bool bEnable )
 621 {
 622     // begin wrapping related part ====================
 623     uno::Reference< embed::XInplaceObject > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
 624     if ( xWrappedObject.is() )
 625     {
 626         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 627         xWrappedObject->enableModeless( bEnable );
 628         return;
 629     }
 630     // end wrapping related part ====================
 631
 632     throw embed::WrongStateException();
 633 }
 634
 635
 636 void SAL_CALL OleEmbeddedObject::translateAccelerators(
 637                     const uno::Sequence< awt::KeyEvent >& aKeys )
 638 {
 639     // begin wrapping related part ====================
 640     uno::Reference< embed::XInplaceObject > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
 641     if ( xWrappedObject.is() )
 642     {
 643         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 644         xWrappedObject->translateAccelerators( aKeys );
 645         return;
 646     }
 647     // end wrapping related part ====================
 648
 649 }
 650
 651 // XChild
 652
 653 css::uno::Reference< css::uno::XInterface > SAL_CALL OleEmbeddedObject::getParent()
 654 {
 655     // begin wrapping related part ====================
 656     uno::Reference< container::XChild > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
 657     if ( xWrappedObject.is() )
 658     {
 659         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 660         return xWrappedObject->getParent();
 661     }
 662     // end wrapping related part ====================
 663
 664     return m_xParent;
 665 }
 666
 667
 668 void SAL_CALL OleEmbeddedObject::setParent( const css::uno::Reference< css::uno::XInterface >& xParent )
 669 {
 670     // begin wrapping related part ====================
 671     uno::Reference< container::XChild > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
 672     if ( xWrappedObject.is() )
 673     {
 674         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 675         xWrappedObject->setParent( xParent );
 676         return;
 677     }
 678     // end wrapping related part ====================
 679
 680     m_xParent = xParent;
 681 }
 682
 683 void OleEmbeddedObject::setStream(const css::uno::Reference<css::io::XStream>& xStream)
 684 {
 685     m_xObjectStream = xStream;
 686 }
 687
 688 css::uno::Reference<css::io::XStream> OleEmbeddedObject::getStream()
 689 {
 690     return m_xObjectStream;
 691 }
 692
 693 void OleEmbeddedObject::initialize(const uno::Sequence<uno::Any>& rArguments)
 694 {
 695     if (!rArguments.hasElements())
 696         return;
 697
 698     comphelper::SequenceAsHashMap aValues(rArguments[0]);
 699     auto it = aValues.find(u"StreamReadOnly"_ustr);
 700     if (it != aValues.end())
 701         it->second >>= m_bStreamReadOnly;
 702 }
 703
 704 OUString SAL_CALL OleEmbeddedObject::getImplementationName()
 705 {
 706     return u"com.sun.star.comp.embed.OleEmbeddedObject"_ustr;
 707 }
 708
 709 sal_Bool SAL_CALL OleEmbeddedObject::supportsService(const OUString& ServiceName)
 710 {
 711     return cppu::supportsService(this, ServiceName);
 712 }
 713
 714 uno::Sequence<OUString> SAL_CALL OleEmbeddedObject::getSupportedServiceNames()
 715 {
 716     return { u"com.sun.star.comp.embed.OleEmbeddedObject"_ustr };
 717 }
 718
 719 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */