embeddedobj/source/msole/oleembed.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 <string_view>
  23
  24 #include <oleembobj.hxx>
  25 #include <com/sun/star/embed/EmbedStates.hpp>
  26 #include <com/sun/star/embed/EmbedVerbs.hpp>
  27 #include <com/sun/star/embed/UnreachableStateException.hpp>
  28 #include <com/sun/star/embed/XStorage.hpp>
  29 #include <com/sun/star/embed/ElementModes.hpp>
  30 #include <com/sun/star/embed/EmbedUpdateModes.hpp>
  31 #include <com/sun/star/embed/NeedsRunningStateException.hpp>
  32 #include <com/sun/star/embed/StateChangeInProgressException.hpp>
  33 #include <com/sun/star/embed/EmbedMisc.hpp>
  34 #include <com/sun/star/embed/XEmbedObjectCreator.hpp>
  35 #include <com/sun/star/io/TempFile.hpp>
  36 #include <com/sun/star/io/XSeekable.hpp>
  37 #include <com/sun/star/lang/DisposedException.hpp>
  38 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  39 #include <com/sun/star/beans/NamedValue.hpp>
  40 #include <com/sun/star/beans/XPropertySet.hpp>
  41 #include <com/sun/star/frame/XLoadable.hpp>
  42 #include <com/sun/star/document/XStorageBasedDocument.hpp>
  43 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
  44 #include <com/sun/star/container/XNameAccess.hpp>
  45 #include <com/sun/star/container/XNameContainer.hpp>
  46 #include <com/sun/star/system/SystemShellExecute.hpp>
  47 #include <com/sun/star/system/SystemShellExecuteFlags.hpp>
  48
  49 #include <cppuhelper/exc_hlp.hxx>
  50 #include <cppuhelper/interfacecontainer.h>
  51 #include <comphelper/mimeconfighelper.hxx>
  52 #include <sal/log.hxx>
  53 #include <tools/diagnose_ex.h>
  54
  55
  56 #include <targetstatecontrol.hxx>
  57
  58 #include "ownview.hxx"
  59
  60 #if defined(_WIN32)
  61 #include "olecomponent.hxx"
  62 #endif
  63
  64 using namespace ::com::sun::star;
  65
  66 #ifdef _WIN32
  67
  68 void OleEmbeddedObject::SwitchComponentToRunningState_Impl()
  69 {
  70     if ( !m_pOleComponent )
  71     {
  72         throw embed::UnreachableStateException();
  73     }
  74     try
  75     {
  76         m_pOleComponent->RunObject();
  77     }
  78     catch( const embed::UnreachableStateException& )
  79     {
  80         GetRidOfComponent();
  81         throw;
  82     }
  83     catch( const embed::WrongStateException& )
  84     {
  85         GetRidOfComponent();
  86         throw;
  87     }
  88 }
  89
  90
  91 uno::Sequence< sal_Int32 > OleEmbeddedObject::GetReachableStatesList_Impl(
  92                                                         const uno::Sequence< embed::VerbDescriptor >& aVerbList )
  93 {
  94     uno::Sequence< sal_Int32 > aStates(2);
  95     aStates[0] = embed::EmbedStates::LOADED;
  96     aStates[1] = embed::EmbedStates::RUNNING;
  97     for ( embed::VerbDescriptor const & vd : aVerbList )
  98         if ( vd.VerbID == embed::EmbedVerbs::MS_OLEVERB_OPEN )
  99         {
 100             aStates.realloc(3);
 101             aStates[2] = embed::EmbedStates::ACTIVE;
 102         }
 103
 104     return aStates;
 105 }
 106
 107
 108 uno::Sequence< sal_Int32 > OleEmbeddedObject::GetIntermediateVerbsSequence_Impl( sal_Int32 nNewState )
 109 {
 110     SAL_WARN_IF( m_nObjectState == embed::EmbedStates::LOADED, "embeddedobj.ole", "Loaded object is switched to running state without verbs using!" );
 111
 112     // actually there will be only one verb
 113     if ( m_nObjectState == embed::EmbedStates::RUNNING && nNewState == embed::EmbedStates::ACTIVE )
 114     {
 115         uno::Sequence< sal_Int32 > aVerbs( 1 );
 116         aVerbs[0] = embed::EmbedVerbs::MS_OLEVERB_OPEN;
 117     }
 118
 119     return uno::Sequence< sal_Int32 >();
 120 }
 121 #endif
 122
 123 void OleEmbeddedObject::MoveListeners()
 124 {
 125     if ( !m_pInterfaceContainer )
 126         return;
 127
 128     // move state change listeners
 129     {
 130         ::cppu::OInterfaceContainerHelper* pStateChangeContainer =
 131             m_pInterfaceContainer->getContainer( cppu::UnoType<embed::XStateChangeListener>::get());
 132         if ( pStateChangeContainer != nullptr )
 133         {
 134             if ( m_xWrappedObject.is() )
 135             {
 136                 ::cppu::OInterfaceIteratorHelper pIterator( *pStateChangeContainer );
 137                 while ( pIterator.hasMoreElements() )
 138                 {
 139                     try
 140                     {
 141                         m_xWrappedObject->addStateChangeListener( static_cast<embed::XStateChangeListener*>(pIterator.next()) );
 142                     }
 143                     catch( const uno::RuntimeException& )
 144                     {
 145                         pIterator.remove();
 146                     }
 147                 }
 148             }
 149         }
 150     }
 151
 152     // move event listeners
 153     {
 154         ::cppu::OInterfaceContainerHelper* pEventContainer =
 155             m_pInterfaceContainer->getContainer( cppu::UnoType<document::XEventListener>::get());
 156         if ( pEventContainer != nullptr )
 157         {
 158             if ( m_xWrappedObject.is() )
 159             {
 160                 ::cppu::OInterfaceIteratorHelper pIterator( *pEventContainer );
 161                 while ( pIterator.hasMoreElements() )
 162                 {
 163                     try
 164                     {
 165                         m_xWrappedObject->addEventListener( static_cast<document::XEventListener*>(pIterator.next()) );
 166                     }
 167                     catch( const uno::RuntimeException& )
 168                     {
 169                         pIterator.remove();
 170                     }
 171                 }
 172             }
 173         }
 174     }
 175
 176     // move close listeners
 177     {
 178         ::cppu::OInterfaceContainerHelper* pCloseContainer =
 179             m_pInterfaceContainer->getContainer( cppu::UnoType<util::XCloseListener>::get());
 180         if ( pCloseContainer != nullptr )
 181         {
 182             if ( m_xWrappedObject.is() )
 183             {
 184                 ::cppu::OInterfaceIteratorHelper pIterator( *pCloseContainer );
 185                 while ( pIterator.hasMoreElements() )
 186                 {
 187                     try
 188                     {
 189                         m_xWrappedObject->addCloseListener( static_cast<util::XCloseListener*>(pIterator.next()) );
 190                     }
 191                     catch( const uno::RuntimeException& )
 192                     {
 193                         pIterator.remove();
 194                     }
 195                 }
 196             }
 197         }
 198     }
 199
 200     m_pInterfaceContainer.reset();
 201 }
 202
 203
 204 uno::Reference< embed::XStorage > OleEmbeddedObject::CreateTemporarySubstorage( OUString& o_aStorageName )
 205 {
 206     uno::Reference< embed::XStorage > xResult;
 207
 208     for ( sal_Int32 nInd = 0; nInd < 32000 && !xResult.is(); nInd++ )
 209     {
 210         OUString aName = OUString::number( nInd ) + "TMPSTOR" + m_aEntryName;
 211         if ( !m_xParentStorage->hasByName( aName ) )
 212         {
 213             xResult = m_xParentStorage->openStorageElement( aName, embed::ElementModes::READWRITE );
 214             o_aStorageName = aName;
 215         }
 216     }
 217
 218     if ( !xResult.is() )
 219     {
 220         o_aStorageName.clear();
 221         throw uno::RuntimeException();
 222     }
 223
 224     return xResult;
 225 }
 226
 227
 228 OUString OleEmbeddedObject::MoveToTemporarySubstream()
 229 {
 230     OUString aResult;
 231     for ( sal_Int32 nInd = 0; nInd < 32000 && aResult.isEmpty(); nInd++ )
 232     {
 233         OUString aName = OUString::number( nInd ) + "TMPSTREAM" + m_aEntryName;
 234         if ( !m_xParentStorage->hasByName( aName ) )
 235         {
 236             m_xParentStorage->renameElement( m_aEntryName, aName );
 237             aResult = aName;
 238         }
 239     }
 240
 241     if ( aResult.isEmpty() )
 242         throw uno::RuntimeException();
 243
 244     return aResult;
 245 }
 246
 247
 248 bool OleEmbeddedObject::TryToConvertToOOo( const uno::Reference< io::XStream >& xStream )
 249 {
 250     bool bResult = false;
 251
 252     OUString aStorageName;
 253     OUString aTmpStreamName;
 254     sal_Int32 nStep = 0;
 255
 256     if ( m_pOleComponent || m_bReadOnly )
 257         return false;
 258
 259     try
 260     {
 261         changeState( embed::EmbedStates::LOADED );
 262
 263         // the stream must be seekable
 264         uno::Reference< io::XSeekable > xSeekable( xStream, uno::UNO_QUERY_THROW );
 265         xSeekable->seek( 0 );
 266         m_aFilterName = OwnView_Impl::GetFilterNameFromExtentionAndInStream( m_xContext, OUString(), xStream->getInputStream() );
 267
 268         if ( !m_aFilterName.isEmpty()
 269           && ( m_aFilterName == "Calc MS Excel 2007 XML" || m_aFilterName == "Impress MS PowerPoint 2007 XML" || m_aFilterName == "MS Word 2007 XML"
 270               || m_aFilterName == "MS Excel 97 Vorlage/Template" || m_aFilterName == "MS Word 97 Vorlage" ) )
 271         {
 272             uno::Reference< container::XNameAccess > xFilterFactory(
 273                 m_xContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.FilterFactory", m_xContext),
 274                 uno::UNO_QUERY_THROW );
 275
 276             OUString aDocServiceName;
 277             uno::Any aFilterAnyData = xFilterFactory->getByName( m_aFilterName );
 278             uno::Sequence< beans::PropertyValue > aFilterData;
 279             if ( aFilterAnyData >>= aFilterData )
 280             {
 281                 for ( beans::PropertyValue const & prop : std::as_const(aFilterData) )
 282                     if ( prop.Name == "DocumentService" )
 283                         prop.Value >>= aDocServiceName;
 284             }
 285
 286             if ( !aDocServiceName.isEmpty() )
 287             {
 288                 // create the model
 289                 uno::Sequence< uno::Any > aArguments(1);
 290                 aArguments[0] <<= beans::NamedValue( "EmbeddedObject", uno::makeAny( true ));
 291
 292                 uno::Reference< util::XCloseable > xDocument( m_xContext->getServiceManager()->createInstanceWithArgumentsAndContext( aDocServiceName, aArguments, m_xContext ), uno::UNO_QUERY_THROW );
 293                 uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY_THROW );
 294                 uno::Reference< document::XStorageBasedDocument > xStorDoc( xDocument, uno::UNO_QUERY_THROW );
 295
 296                 // let the model behave as embedded one
 297                 uno::Reference< frame::XModel > xModel( xDocument, uno::UNO_QUERY_THROW );
 298                 uno::Sequence< beans::PropertyValue > aSeq( 1 );
 299                 aSeq[0].Name = "SetEmbedded";
 300                 aSeq[0].Value <<= true;
 301                 xModel->attachResource( OUString(), aSeq );
 302
 303                 // load the model from the stream
 304                 uno::Sequence< beans::PropertyValue > aArgs( 5 );
 305                 aArgs[0].Name = "HierarchicalDocumentName";
 306                 aArgs[0].Value <<= m_aEntryName;
 307                 aArgs[1].Name = "ReadOnly";
 308                 aArgs[1].Value <<= true;
 309                 aArgs[2].Name = "FilterName";
 310                 aArgs[2].Value <<= m_aFilterName;
 311                 aArgs[3].Name = "URL";
 312                 aArgs[3].Value <<= OUString( "private:stream" );
 313                 aArgs[4].Name = "InputStream";
 314                 aArgs[4].Value <<= xStream->getInputStream();
 315
 316                 xSeekable->seek( 0 );
 317                 xLoadable->load( aArgs );
 318
 319                 // the model is successfully loaded, create a new storage and store the model to the storage
 320                 uno::Reference< embed::XStorage > xTmpStorage = CreateTemporarySubstorage( aStorageName );
 321                 xStorDoc->storeToStorage( xTmpStorage, uno::Sequence< beans::PropertyValue >() );
 322                 xDocument->close( true );
 323                 uno::Reference< beans::XPropertySet > xStorProps( xTmpStorage, uno::UNO_QUERY_THROW );
 324                 OUString aMediaType;
 325                 xStorProps->getPropertyValue("MediaType") >>= aMediaType;
 326                 xTmpStorage->dispose();
 327
 328                 // look for the related embedded object factory
 329                 ::comphelper::MimeConfigurationHelper aConfigHelper( m_xContext );
 330                 OUString aEmbedFactory;
 331                 if ( !aMediaType.isEmpty() )
 332                     aEmbedFactory = aConfigHelper.GetFactoryNameByMediaType( aMediaType );
 333
 334                 if ( aEmbedFactory.isEmpty() )
 335                     throw uno::RuntimeException();
 336
 337                 uno::Reference< uno::XInterface > xFact = m_xContext->getServiceManager()->createInstanceWithContext( aEmbedFactory, m_xContext );
 338
 339                 uno::Reference< embed::XEmbedObjectCreator > xEmbCreator( xFact, uno::UNO_QUERY_THROW );
 340
 341                 // now the object should be adjusted to become the wrapper
 342                 nStep = 1;
 343                 uno::Reference< lang::XComponent > xComp( m_xObjectStream, uno::UNO_QUERY_THROW );
 344                 xComp->dispose();
 345                 m_xObjectStream.clear();
 346                 m_nObjectState = -1;
 347
 348                 nStep = 2;
 349                 aTmpStreamName = MoveToTemporarySubstream();
 350
 351                 nStep = 3;
 352                 m_xParentStorage->renameElement( aStorageName, m_aEntryName );
 353
 354                 nStep = 4;
 355                 m_xWrappedObject.set( xEmbCreator->createInstanceInitFromEntry( m_xParentStorage, m_aEntryName, uno::Sequence< beans::PropertyValue >(), uno::Sequence< beans::PropertyValue >() ), uno::UNO_QUERY_THROW );
 356
 357                 // remember parent document name to show in the title bar
 358                 m_xWrappedObject->setContainerName( m_aContainerName );
 359
 360                 bResult = true; // the change is no more revertable
 361                 try
 362                 {
 363                     m_xParentStorage->removeElement( aTmpStreamName );
 364                 }
 365                 catch( const uno::Exception& )
 366                 {
 367                     // the success of the removing is not so important
 368                 }
 369             }
 370         }
 371     }
 372     catch( const uno::Exception& )
 373     {
 374         // repair the object if necessary
 375         switch( nStep )
 376         {
 377             case 4:
 378             case 3:
 379             if ( !aTmpStreamName.isEmpty() && aTmpStreamName != m_aEntryName )
 380                 try
 381                 {
 382                     if ( m_xParentStorage->hasByName( m_aEntryName ) )
 383                         m_xParentStorage->removeElement( m_aEntryName );
 384                     m_xParentStorage->renameElement( aTmpStreamName, m_aEntryName );
 385                 }
 386                 catch ( const uno::Exception& ex )
 387                 {
 388                     css::uno::Any anyEx = cppu::getCaughtException();
 389                     try {
 390                         close( true );
 391                     } catch( const uno::Exception& ) {}
 392
 393                     m_xParentStorage->dispose(); // ??? the storage has information loss, it should be closed without committing!
 394                     throw css::lang::WrappedTargetRuntimeException( ex.Message,
 395                                     nullptr, anyEx ); // the repairing is not possible
 396                 }
 397             [[fallthrough]];
 398             case 2:
 399                 try
 400                 {
 401                     m_xObjectStream = m_xParentStorage->openStreamElement( m_aEntryName, m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE );
 402                     m_nObjectState = embed::EmbedStates::LOADED;
 403                 }
 404                 catch( const uno::Exception& ex )
 405                 {
 406                     css::uno::Any anyEx = cppu::getCaughtException();
 407                     try {
 408                         close( true );
 409                     } catch( const uno::Exception& ) {}
 410
 411                     throw css::lang::WrappedTargetRuntimeException( ex.Message,
 412                                     nullptr, anyEx ); // the repairing is not possible
 413                 }
 414                 [[fallthrough]];
 415
 416             case 1:
 417             case 0:
 418                 if ( !aStorageName.isEmpty() )
 419                     try {
 420                         m_xParentStorage->removeElement( aStorageName );
 421                     } catch( const uno::Exception& ) { SAL_WARN( "embeddedobj.ole", "Can not remove temporary storage!" ); }
 422                 break;
 423         }
 424     }
 425
 426     if ( bResult )
 427     {
 428         // the conversion was done successfully, now the additional initializations should happen
 429
 430         MoveListeners();
 431         m_xWrappedObject->setClientSite( m_xClientSite );
 432         if ( m_xParent.is() )
 433         {
 434             uno::Reference< container::XChild > xChild( m_xWrappedObject, uno::UNO_QUERY );
 435             if ( xChild.is() )
 436                 xChild->setParent( m_xParent );
 437         }
 438
 439     }
 440
 441     return bResult;
 442 }
 443
 444
 445 void SAL_CALL OleEmbeddedObject::changeState( sal_Int32 nNewState )
 446 {
 447     // begin wrapping related part ====================
 448     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 449     if ( xWrappedObject.is() )
 450     {
 451         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 452         xWrappedObject->changeState( nNewState );
 453         return;
 454     }
 455     // end wrapping related part ====================
 456
 457     ::osl::ResettableMutexGuard aGuard( m_aMutex );
 458
 459     if ( m_bDisposed )
 460         throw lang::DisposedException(); // TODO
 461
 462     if ( m_nObjectState == -1 )
 463         throw embed::WrongStateException( "The object has no persistence!",
 464                                         static_cast< ::cppu::OWeakObject* >(this) );
 465
 466     // in case the object is already in requested state
 467     if ( m_nObjectState == nNewState )
 468         return;
 469
 470 #ifdef _WIN32
 471     if ( m_pOleComponent )
 472     {
 473         if ( m_nTargetState != -1 )
 474         {
 475             // means that the object is currently trying to reach the target state
 476             throw embed::StateChangeInProgressException( OUString(),
 477                                                         uno::Reference< uno::XInterface >(),
 478                                                         m_nTargetState );
 479         }
 480
 481         TargetStateControl_Impl aControl( m_nTargetState, nNewState );
 482
 483         // TODO: additional verbs can be a problem, since nobody knows how the object
 484         //       will behave after activation
 485
 486         sal_Int32 nOldState = m_nObjectState;
 487         aGuard.clear();
 488         StateChangeNotification_Impl( true, nOldState, nNewState );
 489         aGuard.reset();
 490
 491         try
 492         {
 493             if ( nNewState == embed::EmbedStates::LOADED )
 494             {
 495                 // This means just closing of the current object
 496                 // If component can not be closed the object stays in loaded state
 497                 // and it holds reference to "incomplete" component
 498                 // If the object is switched to running state later
 499                 // the component will become "complete"
 500
 501                 // the loaded state must be set before, because of notifications!
 502                 m_nObjectState = nNewState;
 503
 504                 {
 505                     VerbExecutionControllerGuard aVerbGuard( m_aVerbExecutionController );
 506                     m_pOleComponent->CloseObject();
 507                 }
 508
 509                 aGuard.clear();
 510                 StateChangeNotification_Impl( false, nOldState, m_nObjectState );
 511                 aGuard.reset();
 512             }
 513             else if ( nNewState == embed::EmbedStates::RUNNING || nNewState == embed::EmbedStates::ACTIVE )
 514             {
 515                 if ( m_nObjectState == embed::EmbedStates::LOADED )
 516                 {
 517                     // if the target object is in loaded state and a different state is specified
 518                     // as a new one the object first must be switched to running state.
 519
 520                     // the component can exist already in nonrunning state
 521                     // it can be created during loading to detect type of object
 522                     CreateOleComponentAndLoad_Impl( m_pOleComponent );
 523
 524                     SwitchComponentToRunningState_Impl();
 525                     m_nObjectState = embed::EmbedStates::RUNNING;
 526                     aGuard.clear();
 527                     StateChangeNotification_Impl( false, nOldState, m_nObjectState );
 528                     aGuard.reset();
 529
 530                     if ( m_pOleComponent && m_bHasSizeToSet )
 531                     {
 532                         aGuard.clear();
 533                         try {
 534                             m_pOleComponent->SetExtent( m_aSizeToSet, m_nAspectToSet );
 535                             m_bHasSizeToSet = false;
 536                         }
 537                         catch( const uno::Exception& ) {}
 538                         aGuard.reset();
 539                     }
 540
 541                     if ( m_nObjectState == nNewState )
 542                         return;
 543                 }
 544
 545                 // so now the object is either switched from Active to Running state or viceversa
 546                 // the notification about object state change will be done asynchronously
 547                 if ( m_nObjectState == embed::EmbedStates::RUNNING && nNewState == embed::EmbedStates::ACTIVE )
 548                 {
 549                     // execute OPEN verb, if object does not reach active state it is an object's problem
 550                     aGuard.clear();
 551                     m_pOleComponent->ExecuteVerb( embed::EmbedVerbs::MS_OLEVERB_OPEN );
 552                     aGuard.reset();
 553
 554                     // some objects do not allow to set the size even in running state
 555                     if ( m_pOleComponent && m_bHasSizeToSet )
 556                     {
 557                         aGuard.clear();
 558                         try {
 559                             m_pOleComponent->SetExtent( m_aSizeToSet, m_nAspectToSet );
 560                             m_bHasSizeToSet = false;
 561                         }
 562                         catch( uno::Exception& ) {}
 563                         aGuard.reset();
 564                     }
 565
 566                     m_nObjectState = nNewState;
 567                 }
 568                 else if ( m_nObjectState == embed::EmbedStates::ACTIVE && nNewState == embed::EmbedStates::RUNNING )
 569                 {
 570                     aGuard.clear();
 571                     m_pOleComponent->CloseObject();
 572                     m_pOleComponent->RunObject(); // Should not fail, the object already was active
 573                     aGuard.reset();
 574                     m_nObjectState = nNewState;
 575                 }
 576                 else
 577                 {
 578                     throw embed::UnreachableStateException();
 579                 }
 580             }
 581             else
 582                 throw embed::UnreachableStateException();
 583         }
 584         catch( uno::Exception& )
 585         {
 586             aGuard.clear();
 587             StateChangeNotification_Impl( false, nOldState, m_nObjectState );
 588             throw;
 589         }
 590     }
 591     else
 592 #endif
 593     {
 594         throw embed::UnreachableStateException();
 595     }
 596 }
 597
 598
 599 uno::Sequence< sal_Int32 > SAL_CALL OleEmbeddedObject::getReachableStates()
 600 {
 601     // begin wrapping related part ====================
 602     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 603     if ( xWrappedObject.is() )
 604     {
 605         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 606         return xWrappedObject->getReachableStates();
 607     }
 608     // end wrapping related part ====================
 609
 610     ::osl::MutexGuard aGuard( m_aMutex );
 611     if ( m_bDisposed )
 612         throw lang::DisposedException(); // TODO
 613
 614     if ( m_nObjectState == -1 )
 615         throw embed::WrongStateException( "The object has no persistence!",
 616                                         static_cast< ::cppu::OWeakObject* >(this) );
 617
 618 #ifdef _WIN32
 619     if ( m_pOleComponent )
 620     {
 621         if ( m_nObjectState == embed::EmbedStates::LOADED )
 622         {
 623             // the list of supported verbs can be retrieved only when object is in running state
 624             throw embed::NeedsRunningStateException(); // TODO:
 625         }
 626
 627         // the list of states can only be guessed based on standard verbs,
 628         // since there is no way to detect what additional verbs do
 629         return GetReachableStatesList_Impl( m_pOleComponent->GetVerbList() );
 630     }
 631     else
 632 #endif
 633     {
 634         return uno::Sequence< sal_Int32 >();
 635     }
 636 }
 637
 638
 639 sal_Int32 SAL_CALL OleEmbeddedObject::getCurrentState()
 640 {
 641     // begin wrapping related part ====================
 642     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 643     if ( xWrappedObject.is() )
 644     {
 645         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 646         return xWrappedObject->getCurrentState();
 647     }
 648     // end wrapping related part ====================
 649
 650     ::osl::MutexGuard aGuard( m_aMutex );
 651     if ( m_bDisposed )
 652         throw lang::DisposedException(); // TODO
 653
 654     if ( m_nObjectState == -1 )
 655         throw embed::WrongStateException( "The object has no persistence!",
 656                                         static_cast< ::cppu::OWeakObject* >(this) );
 657
 658     // TODO: Shouldn't we ask object? ( I guess no )
 659     return m_nObjectState;
 660 }
 661
 662 namespace
 663 {
 664     bool lcl_CopyStream(const uno::Reference<io::XInputStream>& xIn, const uno::Reference<io::XOutputStream>& xOut, sal_Int32 nMaxCopy = SAL_MAX_INT32)
 665     {
 666         if (nMaxCopy <= 0)
 667             return false;
 668
 669         const sal_Int32 nChunkSize = 4096;
 670         uno::Sequence< sal_Int8 > aData(nChunkSize);
 671         sal_Int32 nTotalRead = 0;
 672         sal_Int32 nRead;
 673         do
 674         {
 675             if (nTotalRead + aData.getLength() > nMaxCopy)
 676             {
 677                 aData.realloc(nMaxCopy - nTotalRead);
 678             }
 679             nRead = xIn->readBytes(aData, aData.getLength());
 680             nTotalRead += nRead;
 681             xOut->writeBytes(aData);
 682         } while (nRead == nChunkSize && nTotalRead <= nMaxCopy);
 683         return nTotalRead != 0;
 684     }
 685
 686     uno::Reference < io::XStream > lcl_GetExtractedStream( OUString& rUrl,
 687         const css::uno::Reference< css::uno::XComponentContext >& xContext,
 688         const css::uno::Reference< css::io::XStream >& xObjectStream )
 689     {
 690         uno::Reference <beans::XPropertySet> xNativeTempFile(
 691             io::TempFile::create(xContext),
 692             uno::UNO_QUERY_THROW);
 693         uno::Reference < io::XStream > xStream(xNativeTempFile, uno::UNO_QUERY_THROW);
 694
 695         uno::Sequence< uno::Any > aArgs( 2 );
 696         aArgs[0] <<= xObjectStream;
 697         aArgs[1] <<= true; // do not create copy
 698         uno::Reference< container::XNameContainer > xNameContainer(
 699             xContext->getServiceManager()->createInstanceWithArgumentsAndContext(
 700                 "com.sun.star.embed.OLESimpleStorage",
 701                 aArgs, xContext ), uno::UNO_QUERY_THROW );
 702
 703         //various stream names that can contain the real document contents for
 704         //this object in a straightforward direct way
 705         static const std::u16string_view aStreamNames[] =
 706         {
 707             u"CONTENTS",
 708             u"Package",
 709             u"EmbeddedOdf",
 710             u"WordDocument",
 711             u"Workbook",
 712             u"PowerPoint Document"
 713         };
 714
 715         bool bCopied = false;
 716         for (size_t i = 0; i < SAL_N_ELEMENTS(aStreamNames) && !bCopied; ++i)
 717         {
 718             uno::Reference<io::XStream> xEmbeddedFile;
 719             try
 720             {
 721                 xNameContainer->getByName(aStreamNames[i]) >>= xEmbeddedFile;
 722             }
 723             catch (const container::NoSuchElementException&)
 724             {
 725                 // ignore
 726             }
 727             bCopied = xEmbeddedFile.is() && lcl_CopyStream(xEmbeddedFile->getInputStream(), xStream->getOutputStream());
 728         }
 729
 730         if (!bCopied)
 731         {
 732             uno::Reference< io::XStream > xOle10Native;
 733             try
 734             {
 735                 xNameContainer->getByName("\1Ole10Native") >>= xOle10Native;
 736             }
 737             catch (container::NoSuchElementException const&)
 738             {
 739                 // ignore
 740             }
 741             if (xOle10Native.is())
 742             {
 743                 const uno::Reference<io::XInputStream> xIn = xOle10Native->getInputStream();
 744                 xIn->skipBytes(4); //size of the entire stream minus 4 bytes
 745                 xIn->skipBytes(2); //word that represent the directory type
 746                 uno::Sequence< sal_Int8 > aData(1);
 747                 sal_Int32 nRead;
 748                 do
 749                 {
 750                     nRead = xIn->readBytes(aData, 1);
 751                 } while (nRead == 1 && aData[0] != 0);  // file name plus extension of the attachment null terminated
 752                 do
 753                 {
 754                     nRead = xIn->readBytes(aData, 1);
 755                 } while (nRead == 1 && aData[0] != 0);  // Fully Qualified File name with extension
 756                 xIn->skipBytes(1); //single byte
 757                 xIn->skipBytes(1); //single byte
 758                 xIn->skipBytes(2); //Word that represent the directory type
 759                 xIn->skipBytes(4); //len of string
 760                 do
 761                 {
 762                     nRead = xIn->readBytes(aData, 1);
 763                 } while (nRead == 1 && aData[0] != 0);  // Actual string representing the file path
 764                 uno::Sequence< sal_Int8 > aLenData(4);
 765                 xIn->readBytes(aLenData, 4); //len of attachment
 766                 sal_uInt32 nLen = static_cast<sal_uInt32>(
 767                                               (aLenData[0] & 0xFF) |
 768                                               ((aLenData[1] & 0xFF) <<  8) |
 769                                               ((aLenData[2] & 0xFF) << 16) |
 770                                               ((aLenData[3] & 0xFF) << 24));
 771
 772                 bCopied = lcl_CopyStream(xIn, xStream->getOutputStream(), nLen);
 773             }
 774         }
 775
 776         uno::Reference< io::XSeekable > xSeekableStor(xObjectStream, uno::UNO_QUERY);
 777         if (xSeekableStor.is())
 778             xSeekableStor->seek(0);
 779
 780         if (!bCopied)
 781             bCopied = lcl_CopyStream(xObjectStream->getInputStream(), xStream->getOutputStream());
 782
 783         if (bCopied)
 784         {
 785             xNativeTempFile->setPropertyValue("RemoveFile",
 786                 uno::makeAny(false));
 787             uno::Any aUrl = xNativeTempFile->getPropertyValue("Uri");
 788             aUrl >>= rUrl;
 789
 790             xNativeTempFile.clear();
 791
 792             uno::Reference < ucb::XSimpleFileAccess3 > xSimpleFileAccess(
 793                     ucb::SimpleFileAccess::create( xContext ) );
 794
 795             xSimpleFileAccess->setReadOnly(rUrl, true);
 796         }
 797         else
 798         {
 799             xNativeTempFile->setPropertyValue("RemoveFile",
 800                 uno::makeAny(true));
 801         }
 802
 803         return xStream;
 804     }
 805
 806     //Dump the objects content to a tempfile, just the "CONTENTS" stream if
 807     //there is one for non-compound documents, otherwise the whole content.
 808     //On success a file is returned which must be removed by the caller
 809     OUString lcl_ExtractObject(const css::uno::Reference< css::uno::XComponentContext >& xContext,
 810         const css::uno::Reference< css::io::XStream >& xObjectStream)
 811     {
 812         OUString sUrl;
 813
 814         // the solution is only active for Unix systems
 815 #ifndef _WIN32
 816         lcl_GetExtractedStream(sUrl, xContext, xObjectStream);
 817 #else
 818         (void) xContext;
 819         (void) xObjectStream;
 820 #endif
 821         return sUrl;
 822     }
 823
 824     uno::Reference < io::XStream > lcl_ExtractObjectStream( const css::uno::Reference< css::uno::XComponentContext >& xContext,
 825         const css::uno::Reference< css::io::XStream >& xObjectStream )
 826     {
 827         OUString sUrl;
 828         return lcl_GetExtractedStream( sUrl, xContext, xObjectStream );
 829     }
 830 }
 831
 832
 833 void SAL_CALL OleEmbeddedObject::doVerb( sal_Int32 nVerbID )
 834 {
 835     // begin wrapping related part ====================
 836     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 837     if ( xWrappedObject.is() )
 838     {
 839         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 840         xWrappedObject->doVerb(embed::EmbedVerbs::MS_OLEVERB_OPEN); // open content in the window not in-place
 841         return;
 842     }
 843     // end wrapping related part ====================
 844
 845     ::osl::ResettableMutexGuard aGuard( m_aMutex );
 846     if ( m_bDisposed )
 847         throw lang::DisposedException(); // TODO
 848
 849     if ( m_nObjectState == -1 )
 850         throw embed::WrongStateException( "The object has no persistence!",
 851                                         static_cast< ::cppu::OWeakObject* >(this) );
 852
 853 #ifdef _WIN32
 854     if ( m_pOleComponent )
 855     {
 856         sal_Int32 nOldState = m_nObjectState;
 857
 858         // TODO/LATER detect target state here and do a notification
 859         // StateChangeNotification_Impl( sal_True, nOldState, nNewState );
 860         if ( m_nObjectState == embed::EmbedStates::LOADED )
 861         {
 862             // if the target object is in loaded state
 863             // it must be switched to running state to execute verb
 864             aGuard.clear();
 865             changeState( embed::EmbedStates::RUNNING );
 866             aGuard.reset();
 867         }
 868
 869         try {
 870             if ( !m_pOleComponent )
 871                 throw uno::RuntimeException();
 872
 873             // ==== the STAMPIT related solution =============================
 874             m_aVerbExecutionController.StartControlExecution();
 875
 876
 877             m_pOleComponent->ExecuteVerb( nVerbID );
 878             m_pOleComponent->SetHostName( OUString(), m_aContainerName );
 879
 880             // ==== the STAMPIT related solution =============================
 881             bool bModifiedOnExecution = m_aVerbExecutionController.EndControlExecution_WasModified();
 882
 883             // this workaround is implemented for STAMPIT object
 884             // if object was modified during verb execution it is saved here
 885             if ( bModifiedOnExecution && m_pOleComponent->IsDirty() )
 886                 SaveObject_Impl();
 887
 888         }
 889         catch( uno::Exception& )
 890         {
 891             // ==== the STAMPIT related solution =============================
 892             m_aVerbExecutionController.EndControlExecution_WasModified();
 893
 894
 895             aGuard.clear();
 896             StateChangeNotification_Impl( false, nOldState, m_nObjectState );
 897             throw;
 898         }
 899
 900     }
 901     else
 902 #endif
 903     {
 904         if ( nVerbID != -9 )
 905         {
 906
 907             throw embed::UnreachableStateException();
 908         }
 909
 910         // the workaround verb to show the object in case no server is available
 911
 912         // if it is possible, the object will be converted to OOo format
 913         if ( !m_bTriedConversion )
 914         {
 915             m_bTriedConversion = true;
 916             if ( TryToConvertToOOo( m_xObjectStream ) )
 917             {
 918                 changeState( embed::EmbedStates::ACTIVE );
 919                 return;
 920             }
 921         }
 922
 923         if ( !m_xOwnView.is() && m_xObjectStream.is() && m_aFilterName != "Text" )
 924         {
 925             try {
 926                 uno::Reference< io::XSeekable > xSeekable( m_xObjectStream, uno::UNO_QUERY );
 927                 if ( xSeekable.is() )
 928                     xSeekable->seek( 0 );
 929
 930                 m_xOwnView = new OwnView_Impl( m_xContext, m_xObjectStream->getInputStream() );
 931             }
 932             catch( uno::RuntimeException& )
 933             {
 934                 throw;
 935             }
 936             catch (uno::Exception const&)
 937             {
 938                 TOOLS_WARN_EXCEPTION("embeddedobj.ole", "OleEmbeddedObject::doVerb: -9 fallback path:");
 939             }
 940         }
 941
 942         // it may be the OLE Storage, try to extract stream
 943         if ( !m_xOwnView.is() && m_xObjectStream.is() && m_aFilterName == "Text" )
 944         {
 945             uno::Reference< io::XStream > xStream = lcl_ExtractObjectStream( m_xContext, m_xObjectStream );
 946
 947             if ( TryToConvertToOOo( xStream ) )
 948             {
 949                 changeState( embed::EmbedStates::ACTIVE );
 950                 return;
 951             }
 952         }
 953
 954         if (!m_xOwnView.is() || !m_xOwnView->Open())
 955         {
 956             //Make a RO copy and see if the OS can find something to at
 957             //least display the content for us
 958             if (m_aTempDumpURL.isEmpty())
 959                 m_aTempDumpURL = lcl_ExtractObject(m_xContext, m_xObjectStream);
 960
 961             if (m_aTempDumpURL.isEmpty())
 962                 throw embed::UnreachableStateException();
 963
 964             uno::Reference< css::system::XSystemShellExecute > xSystemShellExecute(
 965                 css::system::SystemShellExecute::create( m_xContext ) );
 966             xSystemShellExecute->execute(m_aTempDumpURL, OUString(), css::system::SystemShellExecuteFlags::URIS_ONLY);
 967
 968         }
 969
 970     }
 971 }
 972
 973
 974 uno::Sequence< embed::VerbDescriptor > SAL_CALL OleEmbeddedObject::getSupportedVerbs()
 975 {
 976     // begin wrapping related part ====================
 977     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
 978     if ( xWrappedObject.is() )
 979     {
 980         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
 981         return xWrappedObject->getSupportedVerbs();
 982     }
 983     // end wrapping related part ====================
 984
 985     ::osl::MutexGuard aGuard( m_aMutex );
 986     if ( m_bDisposed )
 987         throw lang::DisposedException(); // TODO
 988
 989     if ( m_nObjectState == -1 )
 990         throw embed::WrongStateException( "The object has no persistence!",
 991                                         static_cast< ::cppu::OWeakObject* >(this) );
 992 #ifdef _WIN32
 993     if ( m_pOleComponent )
 994     {
 995         // registry could be used in this case
 996         // if ( m_nObjectState == embed::EmbedStates::LOADED )
 997         // {
 998         //  // the list of supported verbs can be retrieved only when object is in running state
 999         //  throw embed::NeedsRunningStateException(); // TODO:
1000         // }
1001
1002         return m_pOleComponent->GetVerbList();
1003     }
1004     else
1005 #endif
1006     {
1007         // tdf#140079 Claim support for the OleEmbeddedObject::doVerb -9 fallback.
1008         // So in SfxViewFrame::GetState_Impl in case SID_OBJECT hasVerbs is not
1009         // empty, so that the doVerb attempt with -9 fallback is attempted
1010         uno::Sequence<embed::VerbDescriptor> aRet(1);
1011         aRet[0].VerbID = -9;
1012         return aRet;
1013     }
1014 }
1015
1016
1017 void SAL_CALL OleEmbeddedObject::setClientSite(
1018                 const uno::Reference< embed::XEmbeddedClient >& xClient )
1019 {
1020     // begin wrapping related part ====================
1021     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
1022     if ( xWrappedObject.is() )
1023     {
1024         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
1025         xWrappedObject->setClientSite( xClient );
1026         return;
1027     }
1028     // end wrapping related part ====================
1029
1030     ::osl::MutexGuard aGuard( m_aMutex );
1031     if ( m_bDisposed )
1032         throw lang::DisposedException(); // TODO
1033
1034     if ( m_xClientSite != xClient)
1035     {
1036         if ( m_nObjectState != embed::EmbedStates::LOADED && m_nObjectState != embed::EmbedStates::RUNNING )
1037             throw embed::WrongStateException(
1038                                     "The client site can not be set currently!",
1039                                     static_cast< ::cppu::OWeakObject* >(this) );
1040
1041         m_xClientSite = xClient;
1042     }
1043 }
1044
1045
1046 uno::Reference< embed::XEmbeddedClient > SAL_CALL OleEmbeddedObject::getClientSite()
1047 {
1048     // begin wrapping related part ====================
1049     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
1050     if ( xWrappedObject.is() )
1051     {
1052         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
1053         return xWrappedObject->getClientSite();
1054     }
1055     // end wrapping related part ====================
1056
1057     ::osl::MutexGuard aGuard( m_aMutex );
1058     if ( m_bDisposed )
1059         throw lang::DisposedException(); // TODO
1060
1061     if ( m_nObjectState == -1 )
1062         throw embed::WrongStateException( "The object has no persistence!",
1063                                         static_cast< ::cppu::OWeakObject* >(this) );
1064
1065     return m_xClientSite;
1066 }
1067
1068
1069 void SAL_CALL OleEmbeddedObject::update()
1070 {
1071     // begin wrapping related part ====================
1072     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
1073     if ( xWrappedObject.is() )
1074     {
1075         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
1076         xWrappedObject->update();
1077         return;
1078     }
1079     // end wrapping related part ====================
1080
1081     ::osl::MutexGuard aGuard( m_aMutex );
1082     if ( m_bDisposed )
1083         throw lang::DisposedException(); // TODO
1084
1085     if ( m_nObjectState == -1 )
1086         throw embed::WrongStateException( "The object has no persistence!",
1087                                         static_cast< ::cppu::OWeakObject* >(this) );
1088
1089     if ( m_nUpdateMode == embed::EmbedUpdateModes::EXPLICIT_UPDATE )
1090     {
1091         // TODO: update view representation
1092     }
1093     else
1094     {
1095         // the object must be up to date
1096         SAL_WARN_IF( m_nUpdateMode != embed::EmbedUpdateModes::ALWAYS_UPDATE, "embeddedobj.ole", "Unknown update mode!" );
1097     }
1098 }
1099
1100
1101 void SAL_CALL OleEmbeddedObject::setUpdateMode( sal_Int32 nMode )
1102 {
1103     // begin wrapping related part ====================
1104     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
1105     if ( xWrappedObject.is() )
1106     {
1107         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
1108         xWrappedObject->setUpdateMode( nMode );
1109         return;
1110     }
1111     // end wrapping related part ====================
1112
1113     ::osl::MutexGuard aGuard( m_aMutex );
1114     if ( m_bDisposed )
1115         throw lang::DisposedException(); // TODO
1116
1117     if ( m_nObjectState == -1 )
1118         throw embed::WrongStateException( "The object has no persistence!",
1119                                        static_cast< ::cppu::OWeakObject* >(this) );
1120
1121     OSL_ENSURE( nMode == embed::EmbedUpdateModes::ALWAYS_UPDATE
1122                     || nMode == embed::EmbedUpdateModes::EXPLICIT_UPDATE,
1123                 "Unknown update mode!" );
1124     m_nUpdateMode = nMode;
1125 }
1126
1127
1128 sal_Int64 SAL_CALL OleEmbeddedObject::getStatus( sal_Int64
1129     nAspect
1130 )
1131 {
1132     // begin wrapping related part ====================
1133     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
1134     if ( xWrappedObject.is() )
1135     {
1136         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
1137         return xWrappedObject->getStatus( nAspect );
1138     }
1139     // end wrapping related part ====================
1140
1141     ::osl::MutexGuard aGuard( m_aMutex );
1142     if ( m_bDisposed )
1143         throw lang::DisposedException(); // TODO
1144
1145     if ( m_nObjectState == -1 )
1146         throw embed::WrongStateException( "The object must be in running state!",
1147                                     static_cast< ::cppu::OWeakObject* >(this) );
1148
1149     sal_Int64 nResult = 0;
1150
1151 #ifdef _WIN32
1152     if ( m_bGotStatus && m_nStatusAspect == nAspect )
1153         nResult = m_nStatus;
1154     else if ( m_pOleComponent )
1155     {
1156
1157         m_nStatus = m_pOleComponent->GetMiscStatus( nAspect );
1158         m_nStatusAspect = nAspect;
1159         m_bGotStatus = true;
1160         nResult = m_nStatus;
1161     }
1162 #endif
1163
1164     // this implementation needs size to be provided after object loading/creating to work in optimal way
1165     return ( nResult | embed::EmbedMisc::EMBED_NEEDSSIZEONLOAD );
1166 }
1167
1168
1169 void SAL_CALL OleEmbeddedObject::setContainerName( const OUString& sName )
1170 {
1171     // begin wrapping related part ====================
1172     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
1173     if ( xWrappedObject.is() )
1174     {
1175         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
1176         xWrappedObject->setContainerName( sName );
1177         return;
1178     }
1179     // end wrapping related part ====================
1180
1181     ::osl::MutexGuard aGuard( m_aMutex );
1182     if ( m_bDisposed )
1183         throw lang::DisposedException(); // TODO
1184
1185     m_aContainerName = sName;
1186 }
1187
1188
1189 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */