sfx2/source/doc/sfxbasemodel.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 <memory>
  21 #include <config_features.h>
  22
  23 #include <sfx2/sfxbasemodel.hxx>
  24
  25 #include <com/sun/star/datatransfer/UnsupportedFlavorException.hpp>
  26 #include <com/sun/star/task/XInteractionHandler.hpp>
  27 #include <com/sun/star/task/ErrorCodeIOException.hpp>
  28 #include <com/sun/star/task/ErrorCodeRequest.hpp>
  29 #include <com/sun/star/view/XSelectionSupplier.hpp>
  30 #include <com/sun/star/view/XPrintJobListener.hpp>
  31 #include <com/sun/star/lang/DisposedException.hpp>
  32 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  33 #include <com/sun/star/lang/NoSupportException.hpp>
  34 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  35 #include <com/sun/star/lang/NotInitializedException.hpp>
  36 #include <com/sun/star/frame/Desktop.hpp>
  37 #include <com/sun/star/frame/IllegalArgumentIOException.hpp>
  38 #include <com/sun/star/frame/XUntitledNumbers.hpp>
  39 #include <com/sun/star/frame/DoubleInitializationException.hpp>
  40 #include <com/sun/star/embed/XStorage.hpp>
  41 #include <com/sun/star/document/XStorageChangeListener.hpp>
  42 #include <com/sun/star/document/IndexedPropertyValues.hpp>
  43 #include <com/sun/star/beans/XPropertySet.hpp>
  44 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  45 #include <com/sun/star/container/XIndexContainer.hpp>
  46 #include <com/sun/star/script/provider/theMasterScriptProviderFactory.hpp>
  47 #include <com/sun/star/script/provider/XScriptProvider.hpp>
  48 #include <com/sun/star/ui/UIConfigurationManager.hpp>
  49 #include <com/sun/star/embed/ElementModes.hpp>
  50 #include <com/sun/star/embed/Aspects.hpp>
  51 #include <com/sun/star/document/DocumentProperties.hpp>
  52 #include <com/sun/star/frame/XTransientDocumentsDocumentContentFactory.hpp>
  53 #include <com/sun/star/ucb/XCommandEnvironment.hpp>
  54 #include <com/sun/star/ucb/ContentCreationException.hpp>
  55 #include <com/sun/star/ucb/CommandAbortedException.hpp>
  56 #include <com/sun/star/util/XCloneable.hpp>
  57 #include <com/sun/star/util/InvalidStateException.hpp>
  58 #include <com/sun/star/util/CloseVetoException.hpp>
  59 #include <comphelper/enumhelper.hxx>
  60
  61 #include <cppuhelper/implbase.hxx>
  62 #include <cppuhelper/interfacecontainer.hxx>
  63 #include <cppuhelper/exc_hlp.hxx>
  64 #include <comphelper/processfactory.hxx>
  65 #include <comphelper/sequenceashashmap.hxx>
  66 #include <comphelper/namedvaluecollection.hxx>
  67 #include <svl/itemset.hxx>
  68 #include <svl/stritem.hxx>
  69 #include <svl/eitem.hxx>
  70 #include <svl/grabbagitem.hxx>
  71 #include <tools/urlobj.hxx>
  72 #include <tools/debug.hxx>
  73 #include <tools/diagnose_ex.h>
  74 #include <tools/svborder.hxx>
  75 #include <unotools/tempfile.hxx>
  76 #include <osl/mutex.hxx>
  77 #include <vcl/errcode.hxx>
  78 #include <vcl/salctype.hxx>
  79 #include <vcl/gdimtf.hxx>
  80 #include <comphelper/fileformat.h>
  81 #include <comphelper/storagehelper.hxx>
  82 #include <toolkit/helper/vclunohelper.hxx>
  83 #include <vcl/transfer.hxx>
  84 #include <svtools/ehdl.hxx>
  85 #include <svtools/sfxecode.hxx>
  86 #include <sal/log.hxx>
  87 #include <framework/configimporter.hxx>
  88 #include <framework/titlehelper.hxx>
  89 #include <comphelper/numberedcollection.hxx>
  90 #include <unotools/ucbhelper.hxx>
  91 #include <ucbhelper/content.hxx>
  92
  93 #include <sfx2/sfxbasecontroller.hxx>
  94 #include <sfx2/viewfac.hxx>
  95 #include <workwin.hxx>
  96 #include <sfx2/signaturestate.hxx>
  97 #include <sfx2/sfxuno.hxx>
  98 #include <objshimp.hxx>
  99 #include <sfx2/viewfrm.hxx>
 100 #include <sfx2/viewsh.hxx>
 101 #include <sfx2/docfile.hxx>
 102 #include <sfx2/docfilt.hxx>
 103 #include <sfx2/dispatch.hxx>
 104 #include <sfx2/module.hxx>
 105 #include <basic/basmgr.hxx>
 106 #include <sfx2/event.hxx>
 107 #include <eventsupplier.hxx>
 108 #include <sfx2/sfxsids.hrc>
 109 #include <sfx2/strings.hrc>
 110 #include <sfx2/app.hxx>
 111 #include <sfx2/docfac.hxx>
 112 #include <sfx2/fcontnr.hxx>
 113 #include <sfx2/docstoragemodifylistener.hxx>
 114 #include <sfx2/brokenpackageint.hxx>
 115 #include "graphhelp.hxx"
 116 #include <docundomanager.hxx>
 117 #include <openurlhint.hxx>
 118 #include <sfx2/msgpool.hxx>
 119 #include <sfx2/DocumentMetadataAccess.hxx>
 120 #include "printhelper.hxx"
 121 #include <sfx2/sfxresid.hxx>
 122 #include <comphelper/profilezone.hxx>
 123 #include <vcl/threadex.hxx>
 124 #include <unotools/mediadescriptor.hxx>
 125
 126 //  namespaces
 127
 128
 129 using namespace ::com::sun::star;
 130 using namespace ::com::sun::star::uno;
 131 using ::com::sun::star::beans::PropertyValue;
 132 using ::com::sun::star::document::CmisProperty;
 133 using ::com::sun::star::frame::XFrame;
 134 using ::com::sun::star::frame::XController;
 135 using ::com::sun::star::frame::XController2;
 136 using ::com::sun::star::lang::IllegalArgumentException;
 137 using ::com::sun::star::io::IOException;
 138 using ::com::sun::star::uno::Sequence;
 139 using ::com::sun::star::document::XDocumentRecovery;
 140 using ::com::sun::star::document::XUndoManager;
 141 using ::com::sun::star::document::XUndoAction;
 142 using ::com::sun::star::frame::XModel;
 143
 144 namespace {
 145
 146 /** This Listener is used to get notified when the XDocumentProperties of the
 147     XModel change.
 148  */
 149 class SfxDocInfoListener_Impl : public ::cppu::WeakImplHelper<
 150     util::XModifyListener >
 151 {
 152
 153 public:
 154     SfxObjectShell& m_rShell;
 155
 156     explicit SfxDocInfoListener_Impl( SfxObjectShell& i_rDoc )
 157         : m_rShell(i_rDoc)
 158     { };
 159
 160     virtual void SAL_CALL disposing( const lang::EventObject& ) override;
 161     virtual void SAL_CALL modified( const lang::EventObject& ) override;
 162 };
 163
 164 }
 165
 166 void SAL_CALL SfxDocInfoListener_Impl::modified( const lang::EventObject& )
 167 {
 168     SolarMutexGuard aSolarGuard;
 169
 170     // notify changes to the SfxObjectShell
 171     m_rShell.FlushDocInfo();
 172 }
 173
 174 void SAL_CALL SfxDocInfoListener_Impl::disposing( const lang::EventObject& )
 175 {
 176 }
 177
 178
 179 //  impl. declarations
 180
 181
 182 struct IMPL_SfxBaseModel_DataContainer : public ::sfx2::IModifiableDocument
 183 {
 184     // counter for SfxBaseModel instances created.
 185     static sal_Int64                                           g_nInstanceCounter       ;
 186     SfxObjectShellRef                                          m_pObjectShell           ;
 187     OUString                                                   m_sURL                   ;
 188     OUString                                                   m_sRuntimeUID            ;
 189     OUString                                                   m_aPreusedFilterName     ;
 190     ::cppu::OMultiTypeInterfaceContainerHelper                 m_aInterfaceContainer    ;
 191     std::unordered_map<css::uno::Reference< css::drawing::XShape >,
 192                        std::vector<css::uno::Reference< css::document::XShapeEventListener >>> maShapeListeners;
 193     Reference< XInterface >                                    m_xParent                ;
 194     Reference< frame::XController >                            m_xCurrent               ;
 195     Reference< document::XDocumentProperties >                 m_xDocumentProperties    ;
 196     Reference< script::XStarBasicAccess >                      m_xStarBasicAccess       ;
 197     Reference< container::XNameReplace >                       m_xEvents                ;
 198     Sequence< beans::PropertyValue>                            m_seqArguments           ;
 199     std::vector< Reference< frame::XController > >             m_seqControllers         ;
 200     Reference< container::XIndexAccess >                       m_contViewData           ;
 201     sal_uInt16                                                 m_nControllerLockCount   ;
 202     bool                                                       m_bClosed                ;
 203     bool                                                       m_bClosing               ;
 204     bool                                                       m_bSaving                ;
 205     bool                                                       m_bSuicide               ;
 206     bool                                                       m_bExternalTitle         ;
 207     bool                                                       m_bModifiedSinceLastSave ;
 208     Reference< view::XPrintable>                               m_xPrintable             ;
 209     Reference< ui::XUIConfigurationManager2 >                  m_xUIConfigurationManager;
 210     ::rtl::Reference< ::sfx2::DocumentStorageModifyListener >  m_pStorageModifyListen   ;
 211     OUString                                                   m_sModuleIdentifier      ;
 212     Reference< frame::XTitle >                                 m_xTitleHelper           ;
 213     Reference< frame::XUntitledNumbers >                       m_xNumberedControllers   ;
 214     Reference< rdf::XDocumentMetadataAccess>                   m_xDocumentMetadata      ;
 215     ::rtl::Reference< ::sfx2::DocumentUndoManager >            m_pDocumentUndoManager   ;
 216     Sequence< document::CmisProperty>                          m_cmisProperties         ;
 217     std::shared_ptr<SfxGrabBagItem>                            m_xGrabBagItem           ;
 218
 219     IMPL_SfxBaseModel_DataContainer( ::osl::Mutex& rMutex, SfxObjectShell* pObjectShell )
 220             :   m_pObjectShell          ( pObjectShell  )
 221             ,   m_aInterfaceContainer   ( rMutex        )
 222             ,   m_nControllerLockCount  ( 0             )
 223             ,   m_bClosed               ( false     )
 224             ,   m_bClosing              ( false     )
 225             ,   m_bSaving               ( false     )
 226             ,   m_bSuicide              ( false     )
 227             ,   m_bExternalTitle        ( false     )
 228             ,   m_bModifiedSinceLastSave( false     )
 229             ,   m_xTitleHelper          ()
 230             ,   m_xNumberedControllers  ()
 231             ,   m_xDocumentMetadata     () // lazy
 232             ,   m_pDocumentUndoManager  ()
 233             ,   m_cmisProperties  ()
 234     {
 235         // increase global instance counter.
 236         ++g_nInstanceCounter;
 237         // set own Runtime UID
 238         m_sRuntimeUID = OUString::number( g_nInstanceCounter );
 239     }
 240
 241     virtual ~IMPL_SfxBaseModel_DataContainer()
 242     {
 243     }
 244
 245     // ::sfx2::IModifiableDocument
 246     virtual void storageIsModified() override
 247     {
 248         if ( m_pObjectShell.is() && !m_pObjectShell->IsModified() )
 249             m_pObjectShell->SetModified();
 250     }
 251
 252     void impl_setDocumentProperties(
 253             const Reference< document::XDocumentProperties >& );
 254
 255     Reference<rdf::XDocumentMetadataAccess> GetDMA()
 256     {
 257         if (!m_xDocumentMetadata.is())
 258         {
 259             OSL_ENSURE(m_pObjectShell.is(), "GetDMA: no object shell?");
 260             if (!m_pObjectShell.is())
 261             {
 262                 return nullptr;
 263             }
 264
 265             const Reference<XComponentContext> xContext(
 266                 ::comphelper::getProcessComponentContext());
 267             const Reference<frame::XModel> xModel(
 268                 m_pObjectShell->GetModel());
 269             const Reference<lang::XMultiComponentFactory> xMsf(
 270                 xContext->getServiceManager());
 271             const Reference<frame::
 272                 XTransientDocumentsDocumentContentFactory> xTDDCF(
 273                     xMsf->createInstanceWithContext(
 274                         "com.sun.star.frame.TransientDocumentsDocumentContentFactory",
 275                     xContext),
 276                 UNO_QUERY_THROW);
 277             const Reference<ucb::XContent> xContent(
 278                 xTDDCF->createDocumentContent(xModel) );
 279             OSL_ENSURE(xContent.is(), "GetDMA: cannot create DocumentContent");
 280             if (!xContent.is())
 281             {
 282                 return nullptr;
 283             }
 284             OUString uri = xContent->getIdentifier()->getContentIdentifier();
 285             OSL_ENSURE(!uri.isEmpty(), "GetDMA: empty uri?");
 286             if (!uri.isEmpty() && !uri.endsWith("/"))
 287             {
 288                 uri += "/";
 289             }
 290
 291             m_xDocumentMetadata = new ::sfx2::DocumentMetadataAccess(
 292                 xContext, *m_pObjectShell, uri);
 293         }
 294         return m_xDocumentMetadata;
 295     }
 296
 297     Reference<rdf::XDocumentMetadataAccess> CreateDMAUninitialized()
 298     {
 299         return (m_pObjectShell.is())
 300             ? new ::sfx2::DocumentMetadataAccess(
 301                 ::comphelper::getProcessComponentContext(), *m_pObjectShell)
 302             : nullptr;
 303     }
 304 };
 305
 306 // static member initialization.
 307 sal_Int64 IMPL_SfxBaseModel_DataContainer::g_nInstanceCounter = 0;
 308
 309 namespace {
 310
 311 // Listener that forwards notifications from the PrintHelper to the "real" listeners
 312 class SfxPrintHelperListener_Impl : public ::cppu::WeakImplHelper< view::XPrintJobListener >
 313 {
 314 public:
 315     IMPL_SfxBaseModel_DataContainer* m_pData;
 316     explicit SfxPrintHelperListener_Impl( IMPL_SfxBaseModel_DataContainer* pData )
 317         : m_pData( pData )
 318     {}
 319
 320     virtual void SAL_CALL disposing( const lang::EventObject& aEvent ) override ;
 321     virtual void SAL_CALL printJobEvent( const view::PrintJobEvent& rEvent ) override;
 322 };
 323
 324 }
 325
 326 void SAL_CALL SfxPrintHelperListener_Impl::disposing( const lang::EventObject& )
 327 {
 328     m_pData->m_xPrintable = nullptr;
 329 }
 330
 331 void SAL_CALL SfxPrintHelperListener_Impl::printJobEvent( const view::PrintJobEvent& rEvent )
 332 {
 333     ::cppu::OInterfaceContainerHelper* pContainer = m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<view::XPrintJobListener>::get());
 334     if ( pContainer!=nullptr )
 335     {
 336         ::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
 337         while (pIterator.hasMoreElements())
 338             static_cast<view::XPrintJobListener*>(pIterator.next())->printJobEvent( rEvent );
 339     }
 340 }
 341
 342 namespace {
 343
 344 // SfxOwnFramesLocker ====================================================================================
 345 // allows to lock all the frames related to the provided SfxObjectShell
 346 class SfxOwnFramesLocker
 347 {
 348     Sequence< Reference< frame::XFrame > > m_aLockedFrames;
 349
 350     static vcl::Window* GetVCLWindow( const Reference< frame::XFrame >& xFrame );
 351 public:
 352     explicit SfxOwnFramesLocker( SfxObjectShell const * ObjechShell );
 353     ~SfxOwnFramesLocker();
 354 };
 355
 356 }
 357
 358 SfxOwnFramesLocker::SfxOwnFramesLocker( SfxObjectShell const * pObjectShell )
 359 {
 360     if ( !pObjectShell )
 361         return;
 362
 363     for (   SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pObjectShell );
 364             pFrame;
 365             pFrame = SfxViewFrame::GetNext( *pFrame, pObjectShell )
 366         )
 367     {
 368         SfxFrame& rSfxFrame = pFrame->GetFrame();
 369         try
 370         {
 371             // get vcl window related to the frame and lock it if it is still not locked
 372             const Reference< frame::XFrame >& xFrame = rSfxFrame.GetFrameInterface();
 373             vcl::Window* pWindow = GetVCLWindow( xFrame );
 374             if ( !pWindow )
 375                 throw RuntimeException();
 376
 377             if ( pWindow->IsEnabled() )
 378             {
 379                 pWindow->Disable();
 380
 381                 try
 382                 {
 383                     sal_Int32 nLen = m_aLockedFrames.getLength();
 384                     m_aLockedFrames.realloc( nLen + 1 );
 385                     m_aLockedFrames[nLen] = xFrame;
 386                 }
 387                 catch( Exception& )
 388                 {
 389                     pWindow->Enable();
 390                     throw;
 391                 }
 392             }
 393         }
 394         catch( Exception& )
 395         {
 396             OSL_FAIL( "Not possible to lock the frame window!" );
 397         }
 398     }
 399 }
 400
 401 SfxOwnFramesLocker::~SfxOwnFramesLocker()
 402 {
 403     for ( auto& rFrame : m_aLockedFrames )
 404     {
 405         try
 406         {
 407             if ( rFrame.is() )
 408             {
 409                 // get vcl window related to the frame and unlock it
 410                 vcl::Window* pWindow = GetVCLWindow( rFrame );
 411                 if ( !pWindow )
 412                     throw RuntimeException();
 413
 414                 pWindow->Enable();
 415
 416                 rFrame.clear();
 417             }
 418         }
 419         catch( Exception& )
 420         {
 421             OSL_FAIL( "Can't unlock the frame window!" );
 422         }
 423     }
 424 }
 425
 426 vcl::Window* SfxOwnFramesLocker::GetVCLWindow( const Reference< frame::XFrame >& xFrame )
 427 {
 428     VclPtr<vcl::Window> pWindow;
 429
 430     if ( xFrame.is() )
 431     {
 432         Reference< awt::XWindow > xWindow = xFrame->getContainerWindow();
 433         if ( xWindow.is() )
 434                pWindow = VCLUnoHelper::GetWindow( xWindow );
 435     }
 436
 437     return pWindow;
 438 }
 439
 440 namespace {
 441
 442 // SfxSaveGuard ====================================================================================
 443 class SfxSaveGuard
 444 {
 445     private:
 446         Reference< frame::XModel > m_xModel;
 447         IMPL_SfxBaseModel_DataContainer* m_pData;
 448         std::unique_ptr<SfxOwnFramesLocker> m_pFramesLock;
 449
 450         SfxSaveGuard(SfxSaveGuard const &) = delete;
 451         void operator =(const SfxSaveGuard&) = delete;
 452
 453     public:
 454         SfxSaveGuard(const Reference< frame::XModel >&             xModel                      ,
 455                            IMPL_SfxBaseModel_DataContainer* pData);
 456         ~SfxSaveGuard();
 457 };
 458
 459 }
 460
 461 SfxSaveGuard::SfxSaveGuard(const Reference< frame::XModel >&             xModel                      ,
 462                                  IMPL_SfxBaseModel_DataContainer* pData)
 463     : m_xModel     ( xModel )
 464     , m_pData      ( pData )
 465 {
 466     if ( m_pData->m_bClosed )
 467         throw lang::DisposedException("Object already disposed.");
 468
 469     m_pData->m_bSaving = true;
 470     m_pFramesLock.reset(new SfxOwnFramesLocker( m_pData->m_pObjectShell.get() ));
 471 }
 472
 473 SfxSaveGuard::~SfxSaveGuard()
 474 {
 475     m_pFramesLock.reset();
 476
 477     m_pData->m_bSaving = false;
 478
 479     // m_bSuicide was set e.g. in case someone tried to close a document, while it was used for
 480     // storing at the same time. Further m_bSuicide was set to sal_True only if close(sal_True) was called.
 481     // So the ownership was delegated to the place where a veto exception was thrown.
 482     // Now we have to call close() again and delegate the ownership to the next one, which
 483     // can't accept that. Close(sal_False) can't work in this case. Because then the document will may be never closed...
 484
 485     if ( !m_pData->m_bSuicide )
 486         return;
 487
 488     // Reset this state. In case the new close() request is not accepted by someone else...
 489     // it's not a good idea to have two "owners" for close.-)
 490     m_pData->m_bSuicide = false;
 491     try
 492     {
 493         Reference< util::XCloseable > xClose(m_xModel, UNO_QUERY);
 494         if (xClose.is())
 495             xClose->close(true);
 496     }
 497     catch(const util::CloseVetoException&)
 498     {}
 499 }
 500
 501 SfxBaseModel::SfxBaseModel( SfxObjectShell *pObjectShell )
 502 : BaseMutex()
 503 , m_pData( std::make_shared<IMPL_SfxBaseModel_DataContainer>( m_aMutex, pObjectShell ) )
 504 , m_bSupportEmbeddedScripts( pObjectShell && pObjectShell->Get_Impl() && !pObjectShell->Get_Impl()->m_bNoBasicCapabilities )
 505 , m_bSupportDocRecovery( pObjectShell && pObjectShell->Get_Impl() && pObjectShell->Get_Impl()->m_bDocRecoverySupport )
 506 {
 507     if ( pObjectShell != nullptr )
 508     {
 509         StartListening( *pObjectShell ) ;
 510     }
 511 }
 512
 513 //  destructor
 514 SfxBaseModel::~SfxBaseModel()
 515 {
 516 }
 517
 518 //  XInterface
 519 Any SAL_CALL SfxBaseModel::queryInterface( const uno::Type& rType )
 520 {
 521     if  (   ( !m_bSupportEmbeddedScripts && rType.equals( cppu::UnoType<document::XEmbeddedScripts>::get() ) )
 522         ||  ( !m_bSupportDocRecovery && rType.equals( cppu::UnoType<XDocumentRecovery>::get() ) )
 523         )
 524         return Any();
 525
 526     return SfxBaseModel_Base::queryInterface( rType );
 527 }
 528
 529
 530 //  XTypeProvider
 531
 532
 533 namespace
 534 {
 535     void lcl_stripType( Sequence< uno::Type >& io_rTypes, const uno::Type& i_rTypeToStrip )
 536     {
 537         Sequence< uno::Type > aStrippedTypes( io_rTypes.getLength() - 1 );
 538         ::std::remove_copy_if(
 539             io_rTypes.begin(),
 540             io_rTypes.end(),
 541             aStrippedTypes.getArray(),
 542             [&i_rTypeToStrip](const uno::Type& aType) { return aType == i_rTypeToStrip; }
 543         );
 544         io_rTypes = aStrippedTypes;
 545     }
 546 }
 547
 548 Sequence< uno::Type > SAL_CALL SfxBaseModel::getTypes()
 549 {
 550     Sequence< uno::Type > aTypes( SfxBaseModel_Base::getTypes() );
 551
 552     if ( !m_bSupportEmbeddedScripts )
 553         lcl_stripType( aTypes, cppu::UnoType<document::XEmbeddedScripts>::get() );
 554
 555     if ( !m_bSupportDocRecovery )
 556         lcl_stripType( aTypes, cppu::UnoType<XDocumentRecovery>::get() );
 557
 558     return aTypes;
 559 }
 560
 561
 562 //  XTypeProvider
 563
 564
 565 Sequence< sal_Int8 > SAL_CALL SfxBaseModel::getImplementationId()
 566 {
 567     return css::uno::Sequence<sal_Int8>();
 568 }
 569
 570
 571 //  XStarBasicAccess
 572
 573 #if HAVE_FEATURE_SCRIPTING
 574
 575 static Reference< script::XStarBasicAccess > implGetStarBasicAccess( SfxObjectShell const * pObjectShell )
 576 {
 577     Reference< script::XStarBasicAccess > xRet;
 578
 579 #if !HAVE_FEATURE_SCRIPTING
 580     (void) pObjectShell;
 581 #else
 582     if( pObjectShell )
 583     {
 584         BasicManager* pMgr = pObjectShell->GetBasicManager();
 585         xRet = getStarBasicAccess( pMgr );
 586     }
 587 #endif
 588     return xRet;
 589 }
 590
 591 #endif
 592
 593 Reference< container::XNameContainer > SAL_CALL SfxBaseModel::getLibraryContainer()
 594 {
 595 #if !HAVE_FEATURE_SCRIPTING
 596     Reference< container::XNameContainer > dummy;
 597
 598     return dummy;
 599 #else
 600     SfxModelGuard aGuard( *this );
 601
 602     Reference< script::XStarBasicAccess >& rxAccess = m_pData->m_xStarBasicAccess;
 603     if( !rxAccess.is() && m_pData->m_pObjectShell.is() )
 604         rxAccess = implGetStarBasicAccess( m_pData->m_pObjectShell.get() );
 605
 606     Reference< container::XNameContainer > xRet;
 607     if( rxAccess.is() )
 608         xRet = rxAccess->getLibraryContainer();
 609     return xRet;
 610 #endif
 611 }
 612
 613 /**___________________________________________________________________________________________________
 614     @seealso    XStarBasicAccess
 615 */
 616 void SAL_CALL SfxBaseModel::createLibrary( const OUString& LibName, const OUString& Password,
 617     const OUString& ExternalSourceURL, const OUString& LinkTargetURL )
 618 {
 619 #if !HAVE_FEATURE_SCRIPTING
 620     (void) LibName;
 621     (void) Password;
 622     (void) ExternalSourceURL;
 623     (void) LinkTargetURL;
 624 #else
 625     SfxModelGuard aGuard( *this );
 626
 627     Reference< script::XStarBasicAccess >& rxAccess = m_pData->m_xStarBasicAccess;
 628     if( !rxAccess.is() && m_pData->m_pObjectShell.is() )
 629         rxAccess = implGetStarBasicAccess( m_pData->m_pObjectShell.get() );
 630
 631     if( rxAccess.is() )
 632         rxAccess->createLibrary( LibName, Password, ExternalSourceURL, LinkTargetURL );
 633 #endif
 634 }
 635
 636 /**___________________________________________________________________________________________________
 637     @seealso    XStarBasicAccess
 638 */
 639 void SAL_CALL SfxBaseModel::addModule( const OUString& LibraryName, const OUString& ModuleName,
 640     const OUString& Language, const OUString& Source )
 641 {
 642 #if !HAVE_FEATURE_SCRIPTING
 643     (void) LibraryName;
 644     (void) ModuleName;
 645     (void) Language;
 646     (void) Source;
 647 #else
 648     SfxModelGuard aGuard( *this );
 649
 650     Reference< script::XStarBasicAccess >& rxAccess = m_pData->m_xStarBasicAccess;
 651     if( !rxAccess.is() && m_pData->m_pObjectShell.is() )
 652         rxAccess = implGetStarBasicAccess( m_pData->m_pObjectShell.get() );
 653
 654     if( rxAccess.is() )
 655         rxAccess->addModule( LibraryName, ModuleName, Language, Source );
 656 #endif
 657 }
 658
 659 /**___________________________________________________________________________________________________
 660     @seealso    XStarBasicAccess
 661 */
 662 void SAL_CALL SfxBaseModel::addDialog( const OUString& LibraryName, const OUString& DialogName,
 663     const Sequence< sal_Int8 >& Data )
 664 {
 665 #if !HAVE_FEATURE_SCRIPTING
 666     (void) LibraryName;
 667     (void) DialogName;
 668     (void) Data;
 669 #else
 670     SfxModelGuard aGuard( *this );
 671
 672     Reference< script::XStarBasicAccess >& rxAccess = m_pData->m_xStarBasicAccess;
 673     if( !rxAccess.is() && m_pData->m_pObjectShell.is() )
 674         rxAccess = implGetStarBasicAccess( m_pData->m_pObjectShell.get() );
 675
 676     if( rxAccess.is() )
 677         rxAccess->addDialog( LibraryName, DialogName, Data );
 678 #endif
 679 }
 680
 681
 682 //  XChild
 683
 684
 685 Reference< XInterface > SAL_CALL SfxBaseModel::getParent()
 686 {
 687     SfxModelGuard aGuard( *this );
 688
 689     return m_pData->m_xParent;
 690 }
 691
 692
 693 //  XChild
 694
 695
 696 void SAL_CALL SfxBaseModel::setParent(const Reference< XInterface >& Parent)
 697 {
 698     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
 699     m_pData->m_xParent = Parent;
 700 }
 701
 702
 703 //  XChild
 704
 705
 706 void SAL_CALL SfxBaseModel::dispose()
 707 {
 708     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
 709
 710     if  ( !m_pData->m_bClosed )
 711     {
 712         // gracefully accept wrong dispose calls instead of close call
 713         // and try to make it work (may be really disposed later!)
 714         try
 715         {
 716             close( true );
 717         }
 718         catch ( util::CloseVetoException& )
 719         {
 720         }
 721
 722         return;
 723     }
 724
 725     if ( m_pData->m_pStorageModifyListen.is() )
 726     {
 727         m_pData->m_pStorageModifyListen->dispose();
 728         m_pData->m_pStorageModifyListen = nullptr;
 729     }
 730
 731     if ( m_pData->m_pDocumentUndoManager.is() )
 732     {
 733         m_pData->m_pDocumentUndoManager->disposing();
 734         m_pData->m_pDocumentUndoManager = nullptr;
 735     }
 736
 737     lang::EventObject aEvent( static_cast<frame::XModel *>(this) );
 738     m_pData->m_aInterfaceContainer.disposeAndClear( aEvent );
 739
 740     m_pData->m_xDocumentProperties.clear();
 741
 742     m_pData->m_xDocumentMetadata.clear();
 743
 744     if ( m_pData->m_pObjectShell.is() )
 745     {
 746         EndListening( *m_pData->m_pObjectShell );
 747     }
 748
 749     m_pData->m_xCurrent.clear();
 750     m_pData->m_seqControllers.clear();
 751
 752     // m_pData member must be set to zero before delete is called to
 753     // force disposed exception whenever someone tries to access our
 754     // instance while in the dtor.
 755     m_pData.reset();
 756 }
 757
 758
 759 //  XChild
 760
 761
 762 void SAL_CALL SfxBaseModel::addEventListener( const Reference< lang::XEventListener >& aListener )
 763 {
 764     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
 765     m_pData->m_aInterfaceContainer.addInterface( cppu::UnoType<lang::XEventListener>::get(), aListener );
 766 }
 767
 768
 769 //  XChild
 770
 771
 772 void SAL_CALL SfxBaseModel::removeEventListener( const Reference< lang::XEventListener >& aListener )
 773 {
 774     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
 775     m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<lang::XEventListener>::get(), aListener );
 776 }
 777
 778 void
 779 IMPL_SfxBaseModel_DataContainer::impl_setDocumentProperties(
 780         const Reference< document::XDocumentProperties >& rxNewDocProps)
 781 {
 782     m_xDocumentProperties.set(rxNewDocProps, UNO_SET_THROW);
 783     if (m_pObjectShell.is())
 784     {
 785         Reference<util::XModifyBroadcaster> const xMB(
 786             m_xDocumentProperties, UNO_QUERY_THROW);
 787         xMB->addModifyListener(new SfxDocInfoListener_Impl(*m_pObjectShell));
 788     }
 789 }
 790
 791 // document::XDocumentPropertiesSupplier:
 792 Reference< document::XDocumentProperties > SAL_CALL
 793 SfxBaseModel::getDocumentProperties()
 794 {
 795     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
 796     if ( !m_pData->m_xDocumentProperties.is() )
 797     {
 798         Reference< document::XDocumentProperties > xDocProps(
 799             document::DocumentProperties::create( ::comphelper::getProcessComponentContext() ) );
 800         m_pData->impl_setDocumentProperties(xDocProps);
 801     }
 802
 803     return m_pData->m_xDocumentProperties;
 804 }
 805
 806
 807 //  lang::XEventListener
 808
 809
 810 void SAL_CALL SfxBaseModel::disposing( const lang::EventObject& aObject )
 811 {
 812     SolarMutexGuard aGuard;
 813     if ( impl_isDisposed() )
 814         return;
 815
 816     Reference< util::XModifyListener >  xMod( aObject.Source, UNO_QUERY );
 817     Reference< lang::XEventListener >  xListener( aObject.Source, UNO_QUERY );
 818     Reference< document::XEventListener >  xDocListener( aObject.Source, UNO_QUERY );
 819
 820     if ( xMod.is() )
 821         m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<util::XModifyListener>::get(), xMod );
 822     else if ( xListener.is() )
 823         m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<lang::XEventListener>::get(), xListener );
 824     else if ( xDocListener.is() )
 825         m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<document::XEventListener>::get(), xListener );
 826 }
 827
 828
 829 //  frame::XModel
 830
 831
 832 sal_Bool SAL_CALL SfxBaseModel::attachResource( const   OUString&                   rURL    ,
 833                                                 const   Sequence< beans::PropertyValue >&  rArgs   )
 834 {
 835     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
 836     if ( rURL.isEmpty() && rArgs.getLength() == 1 && rArgs[0].Name == "SetEmbedded" )
 837     {
 838         // allows to set a windowless document to EMBEDDED state
 839         // but _only_ before load() or initNew() methods
 840         if ( m_pData->m_pObjectShell.is() && !m_pData->m_pObjectShell->GetMedium() )
 841         {
 842             bool bEmb(false);
 843             if ( ( rArgs[0].Value >>= bEmb ) && bEmb )
 844                 m_pData->m_pObjectShell->SetCreateMode_Impl( SfxObjectCreateMode::EMBEDDED );
 845         }
 846
 847         return true;
 848     }
 849
 850     if ( m_pData->m_pObjectShell.is() )
 851     {
 852         m_pData->m_sURL = rURL;
 853
 854         SfxObjectShell* pObjectShell = m_pData->m_pObjectShell.get();
 855
 856         ::comphelper::NamedValueCollection aArgs( rArgs );
 857
 858         Sequence< sal_Int32 > aWinExtent;
 859         if ( ( aArgs.get( "WinExtent" ) >>= aWinExtent )&& ( aWinExtent.getLength() == 4 ) )
 860         {
 861             tools::Rectangle aVisArea( aWinExtent[0], aWinExtent[1], aWinExtent[2], aWinExtent[3] );
 862             aVisArea = OutputDevice::LogicToLogic(aVisArea, MapMode(MapUnit::Map100thMM), MapMode(pObjectShell->GetMapUnit()));
 863             pObjectShell->SetVisArea( aVisArea );
 864         }
 865
 866         bool bBreakMacroSign = false;
 867         if ( aArgs.get( "BreakMacroSignature" ) >>= bBreakMacroSign )
 868         {
 869             pObjectShell->BreakMacroSign_Impl( bBreakMacroSign );
 870         }
 871
 872         bool bMacroEventRead = false;
 873         if ((aArgs.get("MacroEventRead") >>= bMacroEventRead) && bMacroEventRead)
 874         {
 875             pObjectShell->SetMacroCallsSeenWhileLoading();
 876         }
 877
 878         aArgs.remove( "WinExtent" );
 879         aArgs.remove( "BreakMacroSignature" );
 880         aArgs.remove( "MacroEventRead" );
 881         aArgs.remove( "Stream" );
 882         aArgs.remove( "InputStream" );
 883         aArgs.remove( "URL" );
 884         aArgs.remove( "Frame" );
 885         aArgs.remove( "Password" );
 886         aArgs.remove( "EncryptionData" );
 887
 888         // TODO/LATER: all the parameters that are accepted by ItemSet of the DocShell must be removed here
 889
 890         m_pData->m_seqArguments = aArgs.getPropertyValues();
 891
 892         SfxMedium* pMedium = pObjectShell->GetMedium();
 893         if ( pMedium )
 894         {
 895             SfxAllItemSet aSet( pObjectShell->GetPool() );
 896             TransformParameters( SID_OPENDOC, rArgs, aSet );
 897
 898             // the arguments are not allowed to reach the medium
 899             aSet.ClearItem( SID_FILE_NAME );
 900             aSet.ClearItem( SID_FILLFRAME );
 901
 902             pMedium->GetItemSet()->Put( aSet );
 903             const SfxStringItem* pItem = aSet.GetItem<SfxStringItem>(SID_FILTER_NAME, false);
 904             if ( pItem )
 905                 pMedium->SetFilter(
 906                     pObjectShell->GetFactory().GetFilterContainer()->GetFilter4FilterName( pItem->GetValue() ) );
 907
 908             const SfxStringItem* pTitleItem = aSet.GetItem<SfxStringItem>(SID_DOCINFO_TITLE, false);
 909             if ( pTitleItem )
 910             {
 911                 SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pObjectShell );
 912                 if ( pFrame )
 913                     pFrame->UpdateTitle();
 914             }
 915         }
 916     }
 917
 918     return true ;
 919 }
 920
 921
 922 //  frame::XModel
 923
 924
 925 OUString SAL_CALL SfxBaseModel::getURL()
 926 {
 927     SfxModelGuard aGuard( *this );
 928     return m_pData->m_sURL ;
 929 }
 930
 931
 932 //  frame::XModel
 933
 934
 935 Sequence< beans::PropertyValue > SAL_CALL SfxBaseModel::getArgs()
 936 {
 937     SfxModelGuard aGuard( *this );
 938
 939     if (!SfxApplication::Get()) // tdf#113755
 940     {
 941         SAL_WARN("sfx.appl", "Unexpected operations on model");
 942         return m_pData->m_seqArguments;
 943     }
 944
 945     if ( m_pData->m_pObjectShell.is() )
 946     {
 947         Sequence< beans::PropertyValue > seqArgsNew;
 948         Sequence< beans::PropertyValue > seqArgsOld;
 949         SfxAllItemSet aSet( m_pData->m_pObjectShell->GetPool() );
 950
 951         // we need to know which properties are supported by the transformer
 952         // hopefully it is a temporary solution, I guess nonconvertable properties
 953         // should not be supported so then there will be only ItemSet from medium
 954
 955         TransformItems( SID_OPENDOC, *(m_pData->m_pObjectShell->GetMedium()->GetItemSet()), seqArgsNew );
 956         TransformParameters( SID_OPENDOC, m_pData->m_seqArguments, aSet );
 957         TransformItems( SID_OPENDOC, aSet, seqArgsOld );
 958
 959         sal_Int32 nNewLength = seqArgsNew.getLength();
 960
 961         // "WinExtent" property should be updated always.
 962         // We can store it now to overwrite an old value
 963         // since it is not from ItemSet
 964         tools::Rectangle aTmpRect = m_pData->m_pObjectShell->GetVisArea( ASPECT_CONTENT );
 965         aTmpRect = OutputDevice::LogicToLogic(aTmpRect, MapMode(m_pData->m_pObjectShell->GetMapUnit()), MapMode(MapUnit::Map100thMM));
 966
 967         Sequence< sal_Int32 > aRectSeq(4);
 968         aRectSeq[0] = aTmpRect.Left();
 969         aRectSeq[1] = aTmpRect.Top();
 970         aRectSeq[2] = aTmpRect.IsWidthEmpty() ? aTmpRect.Left() : aTmpRect.Right();
 971         aRectSeq[3] = aTmpRect.IsHeightEmpty() ? aTmpRect.Top() : aTmpRect.Bottom();
 972
 973         seqArgsNew.realloc( ++nNewLength );
 974         seqArgsNew[ nNewLength - 1 ].Name = "WinExtent";
 975         seqArgsNew[ nNewLength - 1 ].Value <<= aRectSeq;
 976
 977         if ( !m_pData->m_aPreusedFilterName.isEmpty() )
 978         {
 979             seqArgsNew.realloc( ++nNewLength );
 980             seqArgsNew[ nNewLength - 1 ].Name = "PreusedFilterName";
 981             seqArgsNew[ nNewLength - 1 ].Value <<= m_pData->m_aPreusedFilterName;
 982         }
 983
 984         SfxViewFrame* pFrame = SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get() );
 985         if ( pFrame )
 986         {
 987             SvBorder aBorder = pFrame->GetBorderPixelImpl();
 988
 989             Sequence< sal_Int32 > aBorderSeq(4);
 990             aBorderSeq[0] = aBorder.Left();
 991             aBorderSeq[1] = aBorder.Top();
 992             aBorderSeq[2] = aBorder.Right();
 993             aBorderSeq[3] = aBorder.Bottom();
 994
 995             seqArgsNew.realloc( ++nNewLength );
 996             seqArgsNew[ nNewLength - 1 ].Name = "DocumentBorder";
 997             seqArgsNew[ nNewLength - 1 ].Value <<= aBorderSeq;
 998         }
 999
1000         // only the values that are not supported by the ItemSet must be cached here
1001         Sequence< beans::PropertyValue > aFinalCache;
1002         sal_Int32 nFinalLength = 0;
1003
1004         for ( const auto& rOrg : std::as_const(m_pData->m_seqArguments) )
1005         {
1006             auto bNew = std::none_of(seqArgsOld.begin(), seqArgsOld.end(),
1007                 [&rOrg](const beans::PropertyValue& rOld){ return rOld.Name == rOrg.Name; });
1008             if ( bNew )
1009             {
1010                 // the entity with this name should be new for seqArgsNew
1011                 // since it is not supported by transformer
1012
1013                 seqArgsNew.realloc( ++nNewLength );
1014                 seqArgsNew[ nNewLength - 1 ] = rOrg;
1015
1016                 aFinalCache.realloc( ++nFinalLength );
1017                 aFinalCache[ nFinalLength - 1 ] = rOrg;
1018             }
1019         }
1020
1021         m_pData->m_seqArguments = aFinalCache;
1022
1023         return seqArgsNew;
1024     }
1025
1026     return m_pData->m_seqArguments;
1027 }
1028
1029 void SAL_CALL SfxBaseModel::setArgs(const Sequence<beans::PropertyValue>& aArgs)
1030 {
1031     SfxModelGuard aGuard( *this );
1032
1033     SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium();
1034     if (!pMedium)
1035     {
1036         throw util::InvalidStateException(
1037             "Medium could not be retrieved, unable to execute setArgs");
1038     }
1039
1040     for (const auto& rArg : aArgs)
1041     {
1042         OUString sValue;
1043         bool bValue;
1044         bool ok = false;
1045         if (rArg.Name == "SuggestedSaveAsName")
1046         {
1047             if (rArg.Value >>= sValue)
1048             {
1049                 pMedium->GetItemSet()->Put(SfxStringItem(SID_SUGGESTEDSAVEASNAME, sValue));
1050                 ok = true;
1051             }
1052         }
1053         else if (rArg.Name == "SuggestedSaveAsDir")
1054         {
1055             if (rArg.Value >>= sValue)
1056             {
1057                 pMedium->GetItemSet()->Put(SfxStringItem(SID_SUGGESTEDSAVEASDIR, sValue));
1058                 ok = true;
1059             }
1060         }
1061         else if (rArg.Name == "LockContentExtraction")
1062         {
1063             if (rArg.Value >>= bValue)
1064             {
1065                 pMedium->GetItemSet()->Put(SfxBoolItem(SID_LOCK_CONTENT_EXTRACTION, bValue));
1066                 ok = true;
1067             }
1068         }
1069         else if (rArg.Name == "LockExport")
1070         {
1071             if (rArg.Value >>= bValue)
1072             {
1073                 pMedium->GetItemSet()->Put(SfxBoolItem(SID_LOCK_EXPORT, bValue));
1074                 ok = true;
1075             }
1076         }
1077         else if (rArg.Name == "LockPrint")
1078         {
1079             if (rArg.Value >>= bValue)
1080             {
1081                 pMedium->GetItemSet()->Put(SfxBoolItem(SID_LOCK_PRINT, bValue));
1082                 ok = true;
1083             }
1084         }
1085         else if (rArg.Name == "LockSave")
1086         {
1087             if (rArg.Value >>= bValue)
1088             {
1089                 pMedium->GetItemSet()->Put(SfxBoolItem(SID_LOCK_SAVE, bValue));
1090                 ok = true;
1091             }
1092         }
1093         else if (rArg.Name == "LockEditDoc")
1094         {
1095             if (rArg.Value >>= bValue)
1096             {
1097                 pMedium->GetItemSet()->Put(SfxBoolItem(SID_LOCK_EDITDOC, bValue));
1098                 ok = true;
1099             }
1100         }
1101         else if (rArg.Name == "Replaceable")
1102         {
1103             if (rArg.Value >>= bValue)
1104             {
1105                 pMedium->GetItemSet()->Put(SfxBoolItem(SID_REPLACEABLE, bValue));
1106                 ok = true;
1107             }
1108         }
1109         else if (rArg.Name == "EncryptionData")
1110         {
1111             pMedium->GetItemSet()->Put(SfxUnoAnyItem(SID_ENCRYPTIONDATA, rArg.Value));
1112             ok = true;
1113         }
1114         if (!ok)
1115         {
1116             throw lang::IllegalArgumentException("Setting property not supported: " + rArg.Name,
1117                                                  comphelper::getProcessComponentContext(), 0);
1118         }
1119     }
1120 }
1121
1122 //  frame::XModel
1123
1124
1125 void SAL_CALL SfxBaseModel::connectController( const Reference< frame::XController >& xController )
1126 {
1127     SfxModelGuard aGuard( *this );
1128     OSL_PRECOND( xController.is(), "SfxBaseModel::connectController: invalid controller!" );
1129     if ( !xController.is() )
1130         return;
1131
1132     m_pData->m_seqControllers.push_back(xController);
1133
1134     if ( m_pData->m_seqControllers.size() == 1 )
1135     {
1136         SfxViewFrame* pViewFrame = SfxViewFrame::Get( xController, GetObjectShell() );
1137         ENSURE_OR_THROW( pViewFrame, "SFX document without SFX view!?" );
1138         pViewFrame->UpdateDocument_Impl();
1139         const OUString sDocumentURL = GetObjectShell()->GetMedium()->GetName();
1140         if ( !sDocumentURL.isEmpty() )
1141             SfxGetpApp()->Broadcast( SfxOpenUrlHint( sDocumentURL ) );
1142     }
1143 }
1144
1145
1146 //  frame::XModel
1147
1148
1149 void SAL_CALL SfxBaseModel::disconnectController( const Reference< frame::XController >& xController )
1150 {
1151     SfxModelGuard aGuard( *this );
1152
1153     if ( m_pData->m_seqControllers.empty() )
1154         return;
1155
1156     auto& vec = m_pData->m_seqControllers;
1157     vec.erase(std::remove(vec.begin(), vec.end(), xController), vec.end());
1158
1159     if ( xController == m_pData->m_xCurrent )
1160         m_pData->m_xCurrent.clear();
1161 }
1162
1163 namespace
1164 {
1165     class ControllerLockUndoAction : public ::cppu::WeakImplHelper< XUndoAction >
1166     {
1167     public:
1168         ControllerLockUndoAction( const Reference< XModel >& i_model, const bool i_undoIsUnlock )
1169             :m_xModel( i_model )
1170             ,m_bUndoIsUnlock( i_undoIsUnlock )
1171         {
1172         }
1173
1174         // XUndoAction
1175         virtual OUString SAL_CALL getTitle() override;
1176         virtual void SAL_CALL undo(  ) override;
1177         virtual void SAL_CALL redo(  ) override;
1178
1179     private:
1180         const Reference< XModel >   m_xModel;
1181         const bool                  m_bUndoIsUnlock;
1182     };
1183
1184     OUString SAL_CALL ControllerLockUndoAction::getTitle()
1185     {
1186         // this action is intended to be used within an UndoContext only, so nobody will ever see this title ...
1187         return OUString();
1188     }
1189
1190     void SAL_CALL ControllerLockUndoAction::undo(  )
1191     {
1192         if ( m_bUndoIsUnlock )
1193             m_xModel->unlockControllers();
1194         else
1195             m_xModel->lockControllers();
1196     }
1197
1198     void SAL_CALL ControllerLockUndoAction::redo(  )
1199     {
1200         if ( m_bUndoIsUnlock )
1201             m_xModel->lockControllers();
1202         else
1203             m_xModel->unlockControllers();
1204     }
1205 }
1206
1207
1208 //  frame::XModel
1209
1210
1211 void SAL_CALL SfxBaseModel::lockControllers()
1212 {
1213     SfxModelGuard aGuard( *this );
1214
1215     ++m_pData->m_nControllerLockCount ;
1216
1217     if  (   m_pData->m_pDocumentUndoManager.is()
1218         &&  m_pData->m_pDocumentUndoManager->isInContext()
1219         &&  !m_pData->m_pDocumentUndoManager->isLocked()
1220         )
1221     {
1222         m_pData->m_pDocumentUndoManager->addUndoAction( new ControllerLockUndoAction( this, true ) );
1223     }
1224 }
1225
1226
1227 //  frame::XModel
1228
1229
1230 void SAL_CALL SfxBaseModel::unlockControllers()
1231 {
1232     SfxModelGuard aGuard( *this );
1233
1234     --m_pData->m_nControllerLockCount ;
1235
1236     if  (   m_pData->m_pDocumentUndoManager.is()
1237         &&  m_pData->m_pDocumentUndoManager->isInContext()
1238         &&  !m_pData->m_pDocumentUndoManager->isLocked()
1239         )
1240     {
1241         m_pData->m_pDocumentUndoManager->addUndoAction( new ControllerLockUndoAction( this, false ) );
1242     }
1243 }
1244
1245
1246 //  frame::XModel
1247
1248
1249 sal_Bool SAL_CALL SfxBaseModel::hasControllersLocked()
1250 {
1251     SfxModelGuard aGuard( *this );
1252     return ( m_pData->m_nControllerLockCount != 0 ) ;
1253 }
1254
1255
1256 //  frame::XModel
1257
1258
1259 Reference< frame::XController > SAL_CALL SfxBaseModel::getCurrentController()
1260 {
1261     SfxModelGuard aGuard( *this );
1262
1263     // get the last active controller of this model
1264     if ( m_pData->m_xCurrent.is() )
1265         return m_pData->m_xCurrent;
1266
1267     // get the first controller of this model
1268     return !m_pData->m_seqControllers.empty() ? m_pData->m_seqControllers.front() : m_pData->m_xCurrent;
1269 }
1270
1271
1272 //  frame::XModel
1273
1274
1275 void SAL_CALL SfxBaseModel::setCurrentController( const Reference< frame::XController >& xCurrentController )
1276 {
1277     SfxModelGuard aGuard( *this );
1278
1279     m_pData->m_xCurrent = xCurrentController;
1280 }
1281
1282
1283 //  frame::XModel
1284
1285
1286 Reference< XInterface > SAL_CALL SfxBaseModel::getCurrentSelection()
1287 {
1288     SfxModelGuard aGuard( *this );
1289
1290     Reference< XInterface >     xReturn;
1291     Reference< frame::XController >    xController =   getCurrentController()      ;
1292
1293     if ( xController.is() )
1294     {
1295         Reference< view::XSelectionSupplier >  xDocView( xController, UNO_QUERY );
1296         if ( xDocView.is() )
1297         {
1298             Any aSel = xDocView->getSelection();
1299             aSel >>= xReturn ;
1300         }
1301     }
1302
1303     return xReturn ;
1304 }
1305
1306
1307 //  XModifiable2
1308
1309
1310 sal_Bool SAL_CALL SfxBaseModel::disableSetModified()
1311 {
1312     SfxModelGuard aGuard( *this );
1313
1314     if ( !m_pData->m_pObjectShell.is() )
1315         throw RuntimeException();
1316
1317     bool bResult = m_pData->m_pObjectShell->IsEnableSetModified();
1318     m_pData->m_pObjectShell->EnableSetModified( false );
1319
1320     return bResult;
1321 }
1322
1323 sal_Bool SAL_CALL SfxBaseModel::enableSetModified()
1324 {
1325     SfxModelGuard aGuard( *this );
1326
1327     if ( !m_pData->m_pObjectShell.is() )
1328         throw RuntimeException();
1329
1330     bool bResult = m_pData->m_pObjectShell->IsEnableSetModified();
1331     m_pData->m_pObjectShell->EnableSetModified();
1332
1333     return bResult;
1334 }
1335
1336 sal_Bool SAL_CALL SfxBaseModel::isSetModifiedEnabled()
1337 {
1338     SfxModelGuard aGuard( *this );
1339
1340     if ( !m_pData->m_pObjectShell.is() )
1341         throw RuntimeException();
1342
1343     return m_pData->m_pObjectShell->IsEnableSetModified();
1344 }
1345
1346
1347 //  XModifiable
1348
1349
1350 sal_Bool SAL_CALL SfxBaseModel::isModified()
1351 {
1352     SfxModelGuard aGuard( *this );
1353
1354     return m_pData->m_pObjectShell.is() && m_pData->m_pObjectShell->IsModified();
1355 }
1356
1357
1358 //  XModifiable
1359
1360
1361 void SAL_CALL SfxBaseModel::setModified( sal_Bool bModified )
1362 {
1363     SfxModelGuard aGuard( *this );
1364
1365     if ( m_pData->m_pObjectShell.is() )
1366         m_pData->m_pObjectShell->SetModified(bModified);
1367 }
1368
1369
1370 //  XModifiable
1371
1372
1373 void SAL_CALL SfxBaseModel::addModifyListener(const Reference< util::XModifyListener >& xListener)
1374 {
1375     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
1376
1377     m_pData->m_aInterfaceContainer.addInterface( cppu::UnoType<util::XModifyListener>::get(),xListener );
1378 }
1379
1380
1381 //  XModifiable
1382
1383
1384 void SAL_CALL SfxBaseModel::removeModifyListener(const Reference< util::XModifyListener >& xListener)
1385 {
1386     SfxModelGuard aGuard( *this );
1387
1388     m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<util::XModifyListener>::get(), xListener );
1389 }
1390
1391
1392 //  XCloseable
1393
1394
1395 void SAL_CALL SfxBaseModel::close( sal_Bool bDeliverOwnership )
1396 {
1397     SolarMutexGuard aGuard;
1398     if ( impl_isDisposed() || m_pData->m_bClosed || m_pData->m_bClosing )
1399         return;
1400
1401     Reference< XInterface > xSelfHold( static_cast< ::cppu::OWeakObject* >(this) );
1402     lang::EventObject       aSource  ( static_cast< ::cppu::OWeakObject* >(this) );
1403     ::cppu::OInterfaceContainerHelper* pContainer = m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<util::XCloseListener>::get());
1404     if (pContainer!=nullptr)
1405     {
1406         ::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
1407         while (pIterator.hasMoreElements())
1408         {
1409             try
1410             {
1411                 static_cast<util::XCloseListener*>(pIterator.next())->queryClosing( aSource, bDeliverOwnership );
1412             }
1413             catch( RuntimeException& )
1414             {
1415                 pIterator.remove();
1416             }
1417         }
1418     }
1419
1420     if ( m_pData->m_bSaving )
1421     {
1422         if (bDeliverOwnership)
1423             m_pData->m_bSuicide = true;
1424         throw util::CloseVetoException(
1425                 "Can not close while saving.",
1426                 static_cast< util::XCloseable* >(this));
1427     }
1428
1429     // no own objections against closing!
1430     m_pData->m_bClosing = true;
1431     pContainer = m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<util::XCloseListener>::get());
1432     if (pContainer!=nullptr)
1433     {
1434         ::cppu::OInterfaceIteratorHelper pCloseIterator(*pContainer);
1435         while (pCloseIterator.hasMoreElements())
1436         {
1437             try
1438             {
1439                 static_cast<util::XCloseListener*>(pCloseIterator.next())->notifyClosing( aSource );
1440             }
1441             catch( RuntimeException& )
1442             {
1443                 pCloseIterator.remove();
1444             }
1445         }
1446     }
1447
1448     m_pData->m_bClosed = true;
1449     m_pData->m_bClosing = false;
1450
1451     dispose();
1452 }
1453
1454
1455 //  XCloseBroadcaster
1456
1457
1458 void SAL_CALL SfxBaseModel::addCloseListener( const Reference< util::XCloseListener >& xListener )
1459 {
1460     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
1461
1462     m_pData->m_aInterfaceContainer.addInterface( cppu::UnoType<util::XCloseListener>::get(), xListener );
1463 }
1464
1465
1466 //  XCloseBroadcaster
1467
1468
1469 void SAL_CALL SfxBaseModel::removeCloseListener( const Reference< util::XCloseListener >& xListener )
1470 {
1471     SfxModelGuard aGuard( *this );
1472
1473     m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<util::XCloseListener>::get(), xListener );
1474 }
1475
1476
1477 //  XPrintable
1478
1479
1480 Sequence< beans::PropertyValue > SAL_CALL SfxBaseModel::getPrinter()
1481 {
1482     SfxModelGuard aGuard( *this );
1483
1484     impl_getPrintHelper();
1485     return m_pData->m_xPrintable->getPrinter();
1486 }
1487
1488 void SAL_CALL SfxBaseModel::setPrinter(const Sequence< beans::PropertyValue >& rPrinter)
1489 {
1490     SfxModelGuard aGuard( *this );
1491
1492     impl_getPrintHelper();
1493     m_pData->m_xPrintable->setPrinter( rPrinter );
1494 }
1495
1496 void SAL_CALL SfxBaseModel::print(const Sequence< beans::PropertyValue >& rOptions)
1497 {
1498     SfxModelGuard aGuard( *this );
1499
1500     impl_getPrintHelper();
1501
1502     // tdf#123728 Always print on main thread to avoid deadlocks
1503     vcl::solarthread::syncExecute([this, &rOptions]() { m_pData->m_xPrintable->print(rOptions); });
1504 }
1505
1506 //  XStorable
1507
1508
1509 sal_Bool SAL_CALL SfxBaseModel::hasLocation()
1510 {
1511     SfxModelGuard aGuard( *this );
1512
1513     return m_pData->m_pObjectShell.is() && m_pData->m_pObjectShell->HasName();
1514 }
1515
1516
1517 //  XStorable
1518
1519
1520 OUString SAL_CALL SfxBaseModel::getLocation()
1521 {
1522     SfxModelGuard aGuard( *this );
1523
1524     if ( m_pData->m_pObjectShell.is() )
1525     {
1526         // TODO/LATER: is it correct that the shared document returns shared file location?
1527         if ( m_pData->m_pObjectShell->IsDocShared() )
1528             return m_pData->m_pObjectShell->GetSharedFileURL();
1529         else
1530             return m_pData->m_pObjectShell->GetMedium()->GetName();
1531     }
1532
1533     return m_pData->m_sURL;
1534 }
1535
1536
1537 //  XStorable
1538
1539
1540 sal_Bool SAL_CALL SfxBaseModel::isReadonly()
1541 {
1542     SfxModelGuard aGuard( *this );
1543
1544     return !m_pData->m_pObjectShell.is() || m_pData->m_pObjectShell->IsReadOnly();
1545 }
1546
1547 //  XStorable2
1548
1549
1550 void SAL_CALL SfxBaseModel::storeSelf( const    Sequence< beans::PropertyValue >&  aSeqArgs )
1551 {
1552     SfxModelGuard aGuard( *this );
1553
1554     if ( !m_pData->m_pObjectShell.is() )
1555         return;
1556
1557     SfxSaveGuard aSaveGuard(this, m_pData.get());
1558
1559     bool bCheckIn = false;
1560     bool bOnMainThread = false;
1561     for ( const auto& rArg : aSeqArgs )
1562     {
1563         // check that only acceptable parameters are provided here
1564         if ( rArg.Name != "VersionComment" && rArg.Name != "Author"
1565           && rArg.Name != "DontTerminateEdit"
1566           && rArg.Name != "InteractionHandler" && rArg.Name != "StatusIndicator"
1567           && rArg.Name != "VersionMajor"
1568           && rArg.Name != "FailOnWarning"
1569           && rArg.Name != "CheckIn"
1570           && rArg.Name != "NoFileSync"
1571           && rArg.Name != "OnMainThread" )
1572         {
1573             const OUString aMessage( "Unexpected MediaDescriptor parameter: " + rArg.Name );
1574             throw lang::IllegalArgumentException( aMessage, Reference< XInterface >(), 1 );
1575         }
1576         else if ( rArg.Name == "CheckIn" )
1577         {
1578             rArg.Value >>= bCheckIn;
1579         }
1580         else if (rArg.Name == "OnMainThread")
1581         {
1582             rArg.Value >>= bOnMainThread;
1583         }
1584     }
1585
1586     // Remove CheckIn property if needed
1587     sal_uInt16 nSlotId = SID_SAVEDOC;
1588     Sequence< beans::PropertyValue >  aArgs = aSeqArgs;
1589     if ( bCheckIn )
1590     {
1591         nSlotId = SID_CHECKIN;
1592         sal_Int32 nLength = aSeqArgs.getLength( );
1593         aArgs = Sequence< beans::PropertyValue >( nLength - 1 );
1594         std::copy_if(aSeqArgs.begin(), aSeqArgs.end(), aArgs.begin(),
1595             [](const beans::PropertyValue& rProp) { return rProp.Name != "CheckIn"; });
1596     }
1597
1598     std::unique_ptr<SfxAllItemSet> pParams(new SfxAllItemSet( SfxGetpApp()->GetPool() ));
1599     TransformParameters( nSlotId, aArgs, *pParams );
1600
1601     SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveDoc, GlobalEventConfig::GetEventName(GlobalEventId::SAVEDOC), m_pData->m_pObjectShell.get() ) );
1602
1603     bool bRet = false;
1604
1605     // TODO/LATER: let the embedded case of saving be handled more careful
1606     if ( m_pData->m_pObjectShell->GetCreateMode() == SfxObjectCreateMode::EMBEDDED )
1607     {
1608         // If this is an embedded object that has no URL based location it should be stored to own storage.
1609         // An embedded object can have a location based on URL in case it is a link, then it should be
1610         // stored in normal way.
1611         if ( !hasLocation() || getLocation().startsWith("private:") )
1612         {
1613             // actually in this very rare case only UI parameters have sense
1614             // TODO/LATER: should be done later, after integration of sb19
1615             bRet = m_pData->m_pObjectShell->DoSave()
1616                 && m_pData->m_pObjectShell->DoSaveCompleted();
1617         }
1618         else
1619         {
1620             bRet = m_pData->m_pObjectShell->Save_Impl( pParams.get() );
1621         }
1622     }
1623     else
1624     {
1625         // Tell the SfxMedium if we are in checkin instead of normal save
1626         m_pData->m_pObjectShell->GetMedium( )->SetInCheckIn( nSlotId == SID_CHECKIN );
1627         if (bOnMainThread)
1628             bRet = vcl::solarthread::syncExecute(
1629                 [this, &pParams] { return m_pData->m_pObjectShell->Save_Impl(pParams.get()); });
1630         else
1631             bRet = m_pData->m_pObjectShell->Save_Impl(pParams.get());
1632         m_pData->m_pObjectShell->GetMedium( )->SetInCheckIn( nSlotId != SID_CHECKIN );
1633     }
1634
1635     pParams.reset();
1636
1637     ErrCode nErrCode = m_pData->m_pObjectShell->GetError() ? m_pData->m_pObjectShell->GetError()
1638                                                            : ERRCODE_IO_CANTWRITE;
1639     m_pData->m_pObjectShell->ResetError();
1640
1641     if ( bRet )
1642     {
1643         m_pData->m_aPreusedFilterName = GetMediumFilterName_Impl();
1644
1645         SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveDocDone, GlobalEventConfig::GetEventName(GlobalEventId::SAVEDOCDONE), m_pData->m_pObjectShell.get() ) );
1646     }
1647     else
1648     {
1649         // write the contents of the logger to the file
1650         SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveDocFailed, GlobalEventConfig::GetEventName(GlobalEventId::SAVEDOCFAILED), m_pData->m_pObjectShell.get() ) );
1651
1652         throw task::ErrorCodeIOException(
1653             "SfxBaseModel::storeSelf: " + nErrCode.toHexString(),
1654             Reference< XInterface >(), sal_uInt32(nErrCode));
1655     }
1656 }
1657
1658
1659 //  XStorable
1660
1661
1662 void SAL_CALL SfxBaseModel::store()
1663 {
1664     comphelper::ProfileZone aZone("store");
1665     storeSelf( Sequence< beans::PropertyValue >() );
1666 }
1667
1668
1669 //  XStorable
1670
1671
1672 void SAL_CALL SfxBaseModel::storeAsURL( const   OUString&                   rURL    ,
1673                                         const   Sequence< beans::PropertyValue >&  rArgs   )
1674 {
1675     SfxModelGuard aGuard( *this );
1676     comphelper::ProfileZone aZone("storeAs");
1677
1678     if ( !m_pData->m_pObjectShell.is() )
1679         return;
1680
1681     SfxSaveGuard aSaveGuard(this, m_pData.get());
1682
1683     impl_store( rURL, rArgs, false );
1684
1685     Sequence< beans::PropertyValue > aSequence ;
1686     TransformItems( SID_OPENDOC, *m_pData->m_pObjectShell->GetMedium()->GetItemSet(), aSequence );
1687     attachResource( rURL, aSequence );
1688
1689     loadCmisProperties( );
1690
1691 #if OSL_DEBUG_LEVEL > 0
1692     const SfxStringItem* pPasswdItem = SfxItemSet::GetItem<SfxStringItem>(m_pData->m_pObjectShell->GetMedium()->GetItemSet(), SID_PASSWORD, false);
1693     OSL_ENSURE( !pPasswdItem, "There should be no Password property in the document MediaDescriptor!" );
1694 #endif
1695 }
1696
1697
1698 //  XUndoManagerSupplier
1699
1700 Reference< XUndoManager > SAL_CALL SfxBaseModel::getUndoManager(  )
1701 {
1702     SfxModelGuard aGuard( *this );
1703     if ( !m_pData->m_pDocumentUndoManager.is() )
1704         m_pData->m_pDocumentUndoManager.set( new ::sfx2::DocumentUndoManager( *this ) );
1705     return m_pData->m_pDocumentUndoManager.get();
1706 }
1707
1708
1709 //  XStorable
1710
1711
1712 void SAL_CALL SfxBaseModel::storeToURL( const   OUString&                   rURL    ,
1713                                         const   Sequence< beans::PropertyValue >&  rArgs   )
1714 {
1715     SfxModelGuard aGuard( *this );
1716     comphelper::ProfileZone aZone("storeToURL");
1717
1718     if ( !m_pData->m_pObjectShell.is() )
1719         return;
1720
1721     SfxSaveGuard aSaveGuard(this, m_pData.get());
1722     try {
1723         utl::MediaDescriptor aDescriptor(rArgs);
1724         bool bOnMainThread = aDescriptor.getUnpackedValueOrDefault("OnMainThread", false);
1725         if (bOnMainThread)
1726             vcl::solarthread::syncExecute([this, rURL, rArgs]() { impl_store(rURL, rArgs, true); });
1727         else
1728             impl_store(rURL, rArgs, true);
1729     }
1730     catch (const uno::Exception &e)
1731     {
1732         // convert to the exception we announce in the throw
1733         // (eg. neon likes to throw InteractiveAugmentedIOException which
1734         // is not an io::IOException)
1735         throw io::IOException(e.Message, e.Context);
1736     }
1737 }
1738
1739 sal_Bool SAL_CALL SfxBaseModel::wasModifiedSinceLastSave()
1740 {
1741     SfxModelGuard aGuard( *this );
1742     return m_pData->m_bModifiedSinceLastSave;
1743 }
1744
1745 void SAL_CALL SfxBaseModel::storeToRecoveryFile( const OUString& i_TargetLocation, const Sequence< PropertyValue >& i_MediaDescriptor )
1746 {
1747     SfxModelGuard aGuard( *this );
1748
1749     // delegate
1750     SfxSaveGuard aSaveGuard( this, m_pData.get() );
1751     impl_store( i_TargetLocation, i_MediaDescriptor, true );
1752
1753     // no need for subsequent calls to storeToRecoveryFile, unless we're modified, again
1754     m_pData->m_bModifiedSinceLastSave = false;
1755 }
1756
1757 void SAL_CALL SfxBaseModel::recoverFromFile( const OUString& i_SourceLocation, const OUString& i_SalvagedFile, const Sequence< PropertyValue >& i_MediaDescriptor )
1758 {
1759     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
1760
1761     // delegate to our "load" method
1762     ::comphelper::NamedValueCollection aMediaDescriptor( i_MediaDescriptor );
1763
1764     // our load implementation expects the SalvagedFile to be in the media descriptor
1765     OSL_ENSURE( !aMediaDescriptor.has( "SalvagedFile" ) || ( aMediaDescriptor.getOrDefault( "SalvagedFile", OUString() ) == i_SalvagedFile ),
1766         "SfxBaseModel::recoverFromFile: inconsistent information!" );
1767     aMediaDescriptor.put( "SalvagedFile", i_SalvagedFile );
1768
1769     // similar for the to-be-loaded file
1770     OSL_ENSURE( !aMediaDescriptor.has( "URL" ) || ( aMediaDescriptor.getOrDefault( "URL", OUString() ) == i_SourceLocation ),
1771         "SfxBaseModel::recoverFromFile: inconsistent information!" );
1772     aMediaDescriptor.put( "URL", i_SourceLocation );
1773
1774     load( aMediaDescriptor.getPropertyValues() );
1775
1776     // Note: The XDocumentRecovery interface specification requires us to do an attachResource after loading.
1777     // However, we will not do this here, as we know that our load implementation (respectively some method
1778     // called from there) already did so.
1779     // In particular, the load process might already have modified some elements of the media
1780     // descriptor, for instance the MacroExecMode (in case the user was involved to decide about it), and we do
1781     // not want to overwrite it with the "old" elements passed to this method here.
1782 }
1783
1784
1785 // XLoadable
1786
1787
1788 void SAL_CALL SfxBaseModel::initNew()
1789 {
1790     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
1791     if ( IsInitialized() )
1792         throw frame::DoubleInitializationException( OUString(), *this );
1793
1794     // the object shell should exist always
1795     DBG_ASSERT( m_pData->m_pObjectShell.is(), "Model is useless without an ObjectShell" );
1796     if ( !m_pData->m_pObjectShell.is() )
1797         return;
1798
1799     if( m_pData->m_pObjectShell->GetMedium() )
1800         throw frame::DoubleInitializationException();
1801
1802     bool bRes = m_pData->m_pObjectShell->DoInitNew();
1803     ErrCode nErrCode = m_pData->m_pObjectShell->GetError() ?
1804                        m_pData->m_pObjectShell->GetError() : ERRCODE_IO_CANTCREATE;
1805     m_pData->m_pObjectShell->ResetError();
1806
1807     if ( !bRes )
1808         throw task::ErrorCodeIOException(
1809             "SfxBaseModel::initNew: " + nErrCode.toHexString(),
1810             Reference< XInterface >(), sal_uInt32(nErrCode));
1811 }
1812
1813 namespace {
1814
1815 OUString getFilterProvider( SfxMedium const & rMedium )
1816 {
1817     const std::shared_ptr<const SfxFilter>& pFilter = rMedium.GetFilter();
1818     if (!pFilter)
1819         return OUString();
1820
1821     return pFilter->GetProviderName();
1822 }
1823
1824 void setUpdatePickList( SfxMedium* pMedium )
1825 {
1826     if (!pMedium)
1827         return;
1828
1829     bool bHidden = false;
1830     const SfxBoolItem* pHidItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_HIDDEN, false);
1831     if (pHidItem)
1832         bHidden = pHidItem->GetValue();
1833
1834     pMedium->SetUpdatePickList(!bHidden);
1835 }
1836
1837 }
1838
1839 void SAL_CALL SfxBaseModel::load(   const Sequence< beans::PropertyValue >& seqArguments )
1840 {
1841     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
1842     if ( IsInitialized() )
1843         throw frame::DoubleInitializationException( OUString(), *this );
1844
1845     // the object shell should exist always
1846     DBG_ASSERT( m_pData->m_pObjectShell.is(), "Model is useless without an ObjectShell" );
1847
1848     if (!m_pData->m_pObjectShell.is())
1849         return;
1850
1851     if( m_pData->m_pObjectShell->GetMedium() )
1852         // if a Medium is present, the document is already initialized
1853         throw frame::DoubleInitializationException();
1854
1855     SfxMedium* pMedium = new SfxMedium( seqArguments );
1856
1857     ErrCode nError = ERRCODE_NONE;
1858     if (!getFilterProvider(*pMedium).isEmpty())
1859     {
1860         if (!m_pData->m_pObjectShell->DoLoadExternal(pMedium))
1861             nError = ERRCODE_IO_GENERAL;
1862
1863         pMedium = handleLoadError(nError, pMedium);
1864         setUpdatePickList(pMedium);
1865         return;
1866     }
1867
1868     OUString aFilterName;
1869     const SfxStringItem* pFilterNameItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_FILTER_NAME, false);
1870     if( pFilterNameItem )
1871         aFilterName = pFilterNameItem->GetValue();
1872     if( !m_pData->m_pObjectShell->GetFactory().GetFilterContainer()->GetFilter4FilterName( aFilterName ) )
1873     {
1874         // filtername is not valid
1875         delete pMedium;
1876         throw frame::IllegalArgumentIOException();
1877     }
1878
1879     const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false);
1880     bool bSalvage = pSalvageItem != nullptr;
1881
1882     // load document
1883     if ( !m_pData->m_pObjectShell->DoLoad(pMedium) )
1884         nError=ERRCODE_IO_GENERAL;
1885
1886     // QUESTION: if the following happens outside of DoLoad, something important is missing there!
1887     Reference< task::XInteractionHandler > xHandler = pMedium->GetInteractionHandler();
1888     if( m_pData->m_pObjectShell->GetErrorCode() )
1889     {
1890         nError = m_pData->m_pObjectShell->GetErrorCode();
1891         if ( nError == ERRCODE_IO_BROKENPACKAGE && xHandler.is() )
1892         {
1893             const OUString aDocName( pMedium->GetURLObject().getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset ) );
1894             const SfxBoolItem* pRepairItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_REPAIRPACKAGE, false);
1895             if ( !pRepairItem || !pRepairItem->GetValue() )
1896             {
1897                 RequestPackageReparation aRequest( aDocName );
1898                 xHandler->handle( aRequest.GetRequest() );
1899                 if( aRequest.isApproved() )
1900                 {
1901                     // broken package: try second loading and allow repair
1902                     pMedium->GetItemSet()->Put( SfxBoolItem( SID_REPAIRPACKAGE, true ) );
1903                     pMedium->GetItemSet()->Put( SfxBoolItem( SID_TEMPLATE, true ) );
1904                     pMedium->GetItemSet()->Put( SfxStringItem( SID_DOCINFO_TITLE, aDocName ) );
1905
1906                     // the error must be reset and the storage must be reopened in new mode
1907                     pMedium->ResetError();
1908                     pMedium->CloseStorage();
1909                     m_pData->m_pObjectShell->PrepareSecondTryLoad_Impl();
1910                     nError = ERRCODE_NONE;
1911                     if ( !m_pData->m_pObjectShell->DoLoad(pMedium) )
1912                         nError=ERRCODE_IO_GENERAL;
1913                     if (m_pData->m_pObjectShell->GetErrorCode())
1914                         nError = m_pData->m_pObjectShell->GetErrorCode();
1915                 }
1916             }
1917
1918             if ( nError == ERRCODE_IO_BROKENPACKAGE )
1919             {
1920                 // repair either not allowed or not successful
1921                 NotifyBrokenPackage aRequest( aDocName );
1922                 xHandler->handle( aRequest.GetRequest() );
1923             }
1924         }
1925     }
1926
1927     if( m_pData->m_pObjectShell->IsAbortingImport() )
1928         nError = ERRCODE_ABORT;
1929
1930     if( bSalvage )
1931     {
1932         // file recovery: restore original filter
1933         const SfxStringItem* pFilterItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_FILTER_NAME, false);
1934         SfxFilterMatcher& rMatcher = SfxGetpApp()->GetFilterMatcher();
1935         std::shared_ptr<const SfxFilter> pSetFilter = rMatcher.GetFilter4FilterName( pFilterItem->GetValue() );
1936         pMedium->SetFilter( pSetFilter );
1937         m_pData->m_pObjectShell->SetModified();
1938     }
1939
1940     // TODO/LATER: maybe the mode should be retrieved from outside and the preused filter should not be set
1941     if ( m_pData->m_pObjectShell->GetCreateMode() == SfxObjectCreateMode::EMBEDDED )
1942     {
1943         const SfxStringItem* pFilterItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_FILTER_NAME, false);
1944         if ( pFilterItem )
1945             m_pData->m_aPreusedFilterName = pFilterItem->GetValue();
1946     }
1947
1948     if ( !nError )
1949         nError = pMedium->GetError();
1950
1951     m_pData->m_pObjectShell->ResetError();
1952
1953     pMedium = handleLoadError(nError, pMedium);
1954     loadCmisProperties();
1955     setUpdatePickList(pMedium);
1956
1957 #if OSL_DEBUG_LEVEL > 0
1958     const SfxStringItem* pPasswdItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_PASSWORD, false);
1959     OSL_ENSURE( !pPasswdItem, "There should be no Password property in the document MediaDescriptor!" );
1960 #endif
1961 }
1962
1963
1964 // XTransferable
1965
1966
1967 Any SAL_CALL SfxBaseModel::getTransferData( const datatransfer::DataFlavor& aFlavor )
1968 {
1969     SfxModelGuard aGuard( *this );
1970
1971     Any aAny;
1972
1973     if ( m_pData->m_pObjectShell.is() )
1974     {
1975         if ( aFlavor.MimeType == "application/x-openoffice-objectdescriptor-xml;windows_formatname=\"Star Object Descriptor (XML)\"" )
1976         {
1977             if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() )
1978                 throw datatransfer::UnsupportedFlavorException();
1979
1980             TransferableObjectDescriptor aDesc;
1981
1982             aDesc.maClassName = m_pData->m_pObjectShell->GetClassName();
1983             aDesc.maTypeName = aFlavor.HumanPresentableName;
1984
1985             // TODO/LATER: ViewAspect needs to be sal_Int64
1986             aDesc.mnViewAspect = sal::static_int_cast< sal_uInt16 >( embed::Aspects::MSOLE_CONTENT );
1987
1988             Size aSize = m_pData->m_pObjectShell->GetVisArea().GetSize();
1989
1990             MapUnit aMapUnit = m_pData->m_pObjectShell->GetMapUnit();
1991             aDesc.maSize = OutputDevice::LogicToLogic(aSize, MapMode(aMapUnit), MapMode(MapUnit::Map100thMM));
1992             aDesc.maDragStartPos = Point();
1993             aDesc.maDisplayName.clear();
1994
1995             SvMemoryStream aMemStm( 1024, 1024 );
1996             WriteTransferableObjectDescriptor( aMemStm, aDesc );
1997             aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( aMemStm.GetData() ), aMemStm.Tell() );
1998         }
1999         else if ( aFlavor.MimeType == "application/x-openoffice-embed-source;windows_formatname=\"Star EMBS\"" )
2000         {
2001             if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() )
2002                 throw datatransfer::UnsupportedFlavorException();
2003
2004             try
2005             {
2006                 utl::TempFile aTmp;
2007                 aTmp.EnableKillingFile();
2008                 storeToURL( aTmp.GetURL(), Sequence < beans::PropertyValue >() );
2009                 std::unique_ptr<SvStream> pStream(aTmp.GetStream( StreamMode::READ ));
2010                 const sal_uInt32 nLen = pStream->TellEnd();
2011                 Sequence< sal_Int8 > aSeq( nLen );
2012                 pStream->ReadBytes(aSeq.getArray(), nLen);
2013                 if( aSeq.hasElements() )
2014                     aAny <<= aSeq;
2015             }
2016             catch ( Exception& )
2017             {
2018             }
2019         }
2020         else if ( aFlavor.MimeType == "application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"" )
2021         {
2022             if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() )
2023                 throw datatransfer::UnsupportedFlavorException();
2024
2025
2026             std::shared_ptr<GDIMetaFile> xMetaFile =
2027                 m_pData->m_pObjectShell->GetPreviewMetaFile( true );
2028
2029             if (xMetaFile)
2030             {
2031                 SvMemoryStream aMemStm( 65535, 65535 );
2032                 aMemStm.SetVersion( SOFFICE_FILEFORMAT_CURRENT );
2033
2034                 xMetaFile->Write( aMemStm );
2035                 aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( aMemStm.GetData() ),
2036                                                 aMemStm.TellEnd() );
2037             }
2038         }
2039         else if ( aFlavor.MimeType == "application/x-openoffice-highcontrast-gdimetafile;windows_formatname=\"GDIMetaFile\"" )
2040         {
2041             if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() )
2042                 throw datatransfer::UnsupportedFlavorException();
2043
2044             std::shared_ptr<GDIMetaFile> xMetaFile =
2045                 m_pData->m_pObjectShell->GetPreviewMetaFile( true );
2046
2047             if (xMetaFile)
2048             {
2049                 SvMemoryStream aMemStm( 65535, 65535 );
2050                 aMemStm.SetVersion( SOFFICE_FILEFORMAT_CURRENT );
2051
2052                 xMetaFile->Write( aMemStm );
2053                 aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( aMemStm.GetData() ),
2054                                                 aMemStm.TellEnd() );
2055             }
2056         }
2057         else if ( aFlavor.MimeType == "application/x-openoffice-emf;windows_formatname=\"Image EMF\"" )
2058         {
2059             if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() )
2060             {
2061                 std::shared_ptr<GDIMetaFile> xMetaFile =
2062                     m_pData->m_pObjectShell->GetPreviewMetaFile( true );
2063
2064                 if (xMetaFile)
2065                 {
2066                     std::unique_ptr<SvMemoryStream> xStream(
2067                         GraphicHelper::getFormatStrFromGDI_Impl(
2068                             xMetaFile.get(), ConvertDataFormat::EMF ) );
2069                     if (xStream)
2070                     {
2071                         xStream->SetVersion( SOFFICE_FILEFORMAT_CURRENT );
2072                         aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( xStream->GetData() ),
2073                                                         xStream->TellEnd() );
2074                     }
2075                 }
2076             }
2077             else if ( GraphicHelper::supportsMetaFileHandle_Impl()
2078               && aFlavor.DataType == cppu::UnoType<sal_uInt64>::get())
2079             {
2080                 std::shared_ptr<GDIMetaFile> xMetaFile =
2081                     m_pData->m_pObjectShell->GetPreviewMetaFile( true );
2082
2083                 if (xMetaFile)
2084                 {
2085                     aAny <<= reinterpret_cast< sal_uInt64 >(
2086                         GraphicHelper::getEnhMetaFileFromGDI_Impl( xMetaFile.get() ) );
2087                 }
2088             }
2089             else
2090                 throw datatransfer::UnsupportedFlavorException();
2091         }
2092         else if ( aFlavor.MimeType == "application/x-openoffice-wmf;windows_formatname=\"Image WMF\"" )
2093         {
2094             if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() )
2095             {
2096                 std::shared_ptr<GDIMetaFile> xMetaFile =
2097                     m_pData->m_pObjectShell->GetPreviewMetaFile( true );
2098
2099                 if (xMetaFile)
2100                 {
2101                     std::unique_ptr<SvMemoryStream> xStream(
2102                         GraphicHelper::getFormatStrFromGDI_Impl(
2103                             xMetaFile.get(), ConvertDataFormat::WMF ) );
2104
2105                     if (xStream)
2106                     {
2107                         xStream->SetVersion( SOFFICE_FILEFORMAT_CURRENT );
2108                         aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( xStream->GetData() ),
2109                                                         xStream->TellEnd() );
2110                     }
2111                 }
2112             }
2113             else if ( GraphicHelper::supportsMetaFileHandle_Impl()
2114               && aFlavor.DataType == cppu::UnoType<sal_uInt64>::get())
2115             {
2116                 // means HGLOBAL handler to memory storage containing METAFILEPICT structure
2117
2118                 std::shared_ptr<GDIMetaFile> xMetaFile =
2119                     m_pData->m_pObjectShell->GetPreviewMetaFile( true );
2120
2121                 if (xMetaFile)
2122                 {
2123                     Size aMetaSize = xMetaFile->GetPrefSize();
2124                     aAny <<= reinterpret_cast< sal_uInt64 >(
2125                         GraphicHelper::getWinMetaFileFromGDI_Impl(
2126                             xMetaFile.get(), aMetaSize ) );
2127                 }
2128             }
2129             else
2130                 throw datatransfer::UnsupportedFlavorException();
2131         }
2132         else if ( aFlavor.MimeType == "application/x-openoffice-bitmap;windows_formatname=\"Bitmap\"" )
2133         {
2134             if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() )
2135                 throw datatransfer::UnsupportedFlavorException();
2136
2137             std::shared_ptr<GDIMetaFile> xMetaFile =
2138                 m_pData->m_pObjectShell->GetPreviewMetaFile( true );
2139
2140             if (xMetaFile)
2141             {
2142                 std::unique_ptr<SvMemoryStream> xStream(
2143                     GraphicHelper::getFormatStrFromGDI_Impl(
2144                         xMetaFile.get(), ConvertDataFormat::BMP ) );
2145
2146                 if (xStream)
2147                 {
2148                     xStream->SetVersion( SOFFICE_FILEFORMAT_CURRENT );
2149                     aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( xStream->GetData() ),
2150                                                     xStream->TellEnd() );
2151                 }
2152             }
2153         }
2154         else if ( aFlavor.MimeType == "image/png" )
2155         {
2156             if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() )
2157                 throw datatransfer::UnsupportedFlavorException();
2158
2159             std::shared_ptr<GDIMetaFile> xMetaFile =
2160                 m_pData->m_pObjectShell->GetPreviewMetaFile( true );
2161
2162             if (xMetaFile)
2163             {
2164                 std::unique_ptr<SvMemoryStream> xStream(
2165                     GraphicHelper::getFormatStrFromGDI_Impl(
2166                         xMetaFile.get(), ConvertDataFormat::PNG ) );
2167
2168                 if (xStream)
2169                 {
2170                     xStream->SetVersion( SOFFICE_FILEFORMAT_CURRENT );
2171                     aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( xStream->GetData() ),
2172                                                     xStream->TellEnd() );
2173                 }
2174             }
2175         }
2176         else
2177             throw datatransfer::UnsupportedFlavorException();
2178     }
2179
2180     return aAny;
2181 }
2182
2183
2184 // XTransferable
2185
2186
2187 Sequence< datatransfer::DataFlavor > SAL_CALL SfxBaseModel::getTransferDataFlavors()
2188 {
2189     SfxModelGuard aGuard( *this );
2190
2191     const sal_Int32 nSuppFlavors = GraphicHelper::supportsMetaFileHandle_Impl() ? 10 : 8;
2192     Sequence< datatransfer::DataFlavor > aFlavorSeq( nSuppFlavors );
2193
2194     aFlavorSeq[0].MimeType =
2195         "application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"";
2196     aFlavorSeq[0].HumanPresentableName =  "GDIMetaFile";
2197     aFlavorSeq[0].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get();
2198
2199     aFlavorSeq[1].MimeType =
2200         "application/x-openoffice-highcontrast-gdimetafile;windows_formatname=\"GDIMetaFile\"";
2201     aFlavorSeq[1].HumanPresentableName = "GDIMetaFile";
2202     aFlavorSeq[1].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get();
2203
2204     aFlavorSeq[2].MimeType =
2205         "application/x-openoffice-emf;windows_formatname=\"Image EMF\"" ;
2206     aFlavorSeq[2].HumanPresentableName = "Enhanced Windows MetaFile";
2207     aFlavorSeq[2].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get();
2208
2209     aFlavorSeq[3].MimeType =
2210         "application/x-openoffice-wmf;windows_formatname=\"Image WMF\"";
2211     aFlavorSeq[3].HumanPresentableName = "Windows MetaFile";
2212     aFlavorSeq[3].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get();
2213
2214     aFlavorSeq[4].MimeType =
2215         "application/x-openoffice-objectdescriptor-xml;windows_formatname=\"Star Object Descriptor (XML)\"";
2216     aFlavorSeq[4].HumanPresentableName = "Star Object Descriptor (XML)";
2217     aFlavorSeq[4].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get();
2218
2219     aFlavorSeq[5].MimeType =
2220         "application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\"";
2221     aFlavorSeq[5].HumanPresentableName = "Star Embed Source (XML)";
2222     aFlavorSeq[5].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get();
2223
2224     aFlavorSeq[6].MimeType =
2225         "application/x-openoffice-bitmap;windows_formatname=\"Bitmap\"";
2226     aFlavorSeq[6].HumanPresentableName = "Bitmap";
2227     aFlavorSeq[6].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get();
2228
2229     aFlavorSeq[7].MimeType = "image/png";
2230     aFlavorSeq[7].HumanPresentableName = "PNG";
2231     aFlavorSeq[7].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get();
2232
2233     if ( nSuppFlavors == 10 )
2234     {
2235         aFlavorSeq[8].MimeType =
2236             "application/x-openoffice-emf;windows_formatname=\"Image EMF\"";
2237         aFlavorSeq[8].HumanPresentableName = "Enhanced Windows MetaFile";
2238         aFlavorSeq[8].DataType = cppu::UnoType<sal_uInt64>::get();
2239
2240         aFlavorSeq[9].MimeType =
2241             "application/x-openoffice-wmf;windows_formatname=\"Image WMF\"";
2242         aFlavorSeq[9].HumanPresentableName = "Windows MetaFile";
2243         aFlavorSeq[9].DataType = cppu::UnoType<sal_uInt64>::get();
2244     }
2245
2246     return aFlavorSeq;
2247 }
2248
2249
2250 // XTransferable
2251
2252
2253 sal_Bool SAL_CALL SfxBaseModel::isDataFlavorSupported( const datatransfer::DataFlavor& aFlavor )
2254 {
2255     SfxModelGuard aGuard( *this );
2256
2257     if ( aFlavor.MimeType == "application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"" )
2258     {
2259         if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() )
2260             return true;
2261     }
2262     else if ( aFlavor.MimeType == "application/x-openoffice-highcontrast-gdimetafile;windows_formatname=\"GDIMetaFile\"" )
2263     {
2264         if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() )
2265             return true;
2266     }
2267     else if ( aFlavor.MimeType == "application/x-openoffice-emf;windows_formatname=\"Image EMF\"" )
2268     {
2269         if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() )
2270             return true;
2271         else if ( GraphicHelper::supportsMetaFileHandle_Impl()
2272           && aFlavor.DataType == cppu::UnoType<sal_uInt64>::get())
2273             return true;
2274     }
2275     else if ( aFlavor.MimeType == "application/x-openoffice-wmf;windows_formatname=\"Image WMF\"" )
2276     {
2277         if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() )
2278             return true;
2279         else if ( GraphicHelper::supportsMetaFileHandle_Impl()
2280           && aFlavor.DataType == cppu::UnoType<sal_uInt64>::get())
2281             return true;
2282     }
2283     else if ( aFlavor.MimeType == "application/x-openoffice-objectdescriptor-xml;windows_formatname=\"Star Object Descriptor (XML)\"" )
2284     {
2285         if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() )
2286             return true;
2287     }
2288     else if ( aFlavor.MimeType == "application/x-openoffice-embed-source;windows_formatname=\"Star EMBS\"" )
2289     {
2290         if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() )
2291             return true;
2292     }
2293     else if ( aFlavor.MimeType == "application/x-openoffice-bitmap;windows_formatname=\"Bitmap\"" )
2294     {
2295         if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() )
2296             return true;
2297     }
2298     else if ( aFlavor.MimeType == "image/png" )
2299     {
2300         if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() )
2301             return true;
2302     }
2303
2304     return false;
2305 }
2306
2307
2308 //  XEventsSupplier
2309
2310
2311 Reference< container::XNameReplace > SAL_CALL SfxBaseModel::getEvents()
2312 {
2313     SfxModelGuard aGuard( *this );
2314
2315     if ( ! m_pData->m_xEvents.is() )
2316     {
2317         m_pData->m_xEvents = new SfxEvents_Impl( m_pData->m_pObjectShell.get(), this );
2318     }
2319
2320     return m_pData->m_xEvents;
2321 }
2322
2323
2324 //  XEmbeddedScripts
2325
2326
2327 Reference< script::XStorageBasedLibraryContainer > SAL_CALL SfxBaseModel::getBasicLibraries()
2328 {
2329     SfxModelGuard aGuard( *this );
2330
2331     Reference< script::XStorageBasedLibraryContainer > xBasicLibraries;
2332     if ( m_pData->m_pObjectShell.is() )
2333         xBasicLibraries.set(m_pData->m_pObjectShell->GetBasicContainer(), UNO_QUERY);
2334     return xBasicLibraries;
2335 }
2336
2337 Reference< script::XStorageBasedLibraryContainer > SAL_CALL SfxBaseModel::getDialogLibraries()
2338 {
2339     SfxModelGuard aGuard( *this );
2340
2341     Reference< script::XStorageBasedLibraryContainer > xDialogLibraries;
2342     if ( m_pData->m_pObjectShell.is() )
2343         xDialogLibraries.set(m_pData->m_pObjectShell->GetDialogContainer(), UNO_QUERY);
2344     return xDialogLibraries;
2345 }
2346
2347 sal_Bool SAL_CALL SfxBaseModel::getAllowMacroExecution()
2348 {
2349     SfxModelGuard aGuard( *this );
2350
2351     if ( m_pData->m_pObjectShell.is() )
2352         return m_pData->m_pObjectShell->AdjustMacroMode();
2353     return false;
2354 }
2355
2356
2357 //  XScriptInvocationContext
2358
2359
2360 Reference< document::XEmbeddedScripts > SAL_CALL SfxBaseModel::getScriptContainer()
2361 {
2362     SfxModelGuard aGuard( *this );
2363
2364     Reference< document::XEmbeddedScripts > xDocumentScripts;
2365
2366     try
2367     {
2368         Reference< frame::XModel > xDocument( this );
2369         xDocumentScripts.set( xDocument, UNO_QUERY );
2370         while ( !xDocumentScripts.is() && xDocument.is() )
2371         {
2372             Reference< container::XChild > xDocAsChild( xDocument, UNO_QUERY );
2373             if ( !xDocAsChild.is() )
2374             {
2375                 xDocument = nullptr;
2376                 break;
2377             }
2378
2379             xDocument.set( xDocAsChild->getParent(), UNO_QUERY );
2380             xDocumentScripts.set( xDocument, UNO_QUERY );
2381         }
2382     }
2383     catch( const Exception& )
2384     {
2385         DBG_UNHANDLED_EXCEPTION("sfx.doc");
2386         xDocumentScripts = nullptr;
2387     }
2388
2389     return xDocumentScripts;
2390 }
2391
2392
2393 //  XEventBroadcaster
2394
2395
2396 void SAL_CALL SfxBaseModel::addEventListener( const Reference< document::XEventListener >& aListener )
2397 {
2398     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
2399
2400     m_pData->m_aInterfaceContainer.addInterface( cppu::UnoType<document::XEventListener>::get(), aListener );
2401 }
2402
2403
2404 //  XEventBroadcaster
2405
2406
2407 void SAL_CALL SfxBaseModel::removeEventListener( const Reference< document::XEventListener >& aListener )
2408 {
2409     SfxModelGuard aGuard( *this );
2410
2411     m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<document::XEventListener>::get(), aListener );
2412 }
2413
2414 //  XShapeEventBroadcaster
2415
2416 void SAL_CALL SfxBaseModel::addShapeEventListener( const css::uno::Reference< css::drawing::XShape >& xShape, const Reference< document::XShapeEventListener >& xListener )
2417 {
2418     assert(xShape.is() && "no shape?");
2419     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
2420
2421     m_pData->maShapeListeners[xShape].push_back(xListener);
2422 }
2423
2424
2425 //  XShapeEventBroadcaster
2426
2427
2428 void SAL_CALL SfxBaseModel::removeShapeEventListener( const css::uno::Reference< css::drawing::XShape >& xShape, const Reference< document::XShapeEventListener >& xListener )
2429 {
2430     SfxModelGuard aGuard( *this );
2431
2432     auto it = m_pData->maShapeListeners.find(xShape);
2433     if (it != m_pData->maShapeListeners.end())
2434     {
2435         auto rVec = it->second;
2436         auto it2 = std::find(rVec.begin(), rVec.end(), xListener);
2437         if (it2 != rVec.end())
2438         {
2439             rVec.erase(it2);
2440             if (rVec.empty())
2441                 m_pData->maShapeListeners.erase(it);
2442         }
2443     }
2444 }
2445
2446 //  XDocumentEventBroadcaster
2447
2448
2449 void SAL_CALL SfxBaseModel::addDocumentEventListener( const Reference< document::XDocumentEventListener >& aListener )
2450 {
2451     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
2452     m_pData->m_aInterfaceContainer.addInterface( cppu::UnoType<document::XDocumentEventListener>::get(), aListener );
2453 }
2454
2455
2456 void SAL_CALL SfxBaseModel::removeDocumentEventListener( const Reference< document::XDocumentEventListener >& aListener )
2457 {
2458     SfxModelGuard aGuard( *this );
2459     m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<document::XDocumentEventListener>::get(), aListener );
2460 }
2461
2462
2463 void SAL_CALL SfxBaseModel::notifyDocumentEvent( const OUString&, const Reference< frame::XController2 >&, const Any& )
2464 {
2465     throw lang::NoSupportException("SfxBaseModel controls all the sent notifications itself!" );
2466 }
2467
2468 Sequence<document::CmisProperty> SAL_CALL SfxBaseModel::getCmisProperties()
2469 {
2470     if (impl_isDisposed())
2471         return Sequence<document::CmisProperty>();
2472     return m_pData->m_cmisProperties;
2473 }
2474
2475 void SAL_CALL SfxBaseModel::setCmisProperties( const Sequence< document::CmisProperty >& _cmisproperties )
2476 {
2477     m_pData->m_cmisProperties = _cmisproperties;
2478 }
2479
2480 void SAL_CALL SfxBaseModel::updateCmisProperties( const Sequence< document::CmisProperty >& aProperties )
2481 {
2482     SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium();
2483     if ( !pMedium )
2484         return;
2485
2486     try
2487     {
2488         ::ucbhelper::Content aContent( pMedium->GetName( ),
2489             Reference<ucb::XCommandEnvironment>(),
2490             comphelper::getProcessComponentContext() );
2491
2492         aContent.executeCommand( "updateProperties", uno::makeAny( aProperties ) );
2493         loadCmisProperties( );
2494     }
2495     catch (const Exception & e)
2496     {
2497         css::uno::Any anyEx = cppu::getCaughtException();
2498         throw lang::WrappedTargetRuntimeException( e.Message,
2499                         e.Context, anyEx );
2500     }
2501
2502 }
2503
2504 void SAL_CALL SfxBaseModel::checkOut(  )
2505 {
2506     SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium();
2507     if ( !pMedium )
2508         return;
2509
2510     try
2511     {
2512         ::ucbhelper::Content aContent( pMedium->GetName(),
2513             Reference<ucb::XCommandEnvironment>(),
2514             comphelper::getProcessComponentContext() );
2515
2516         Any aResult = aContent.executeCommand( "checkout", Any( ) );
2517         OUString sURL;
2518         aResult >>= sURL;
2519
2520         m_pData->m_pObjectShell->GetMedium( )->SetName( sURL );
2521         m_pData->m_pObjectShell->GetMedium( )->GetMedium_Impl( );
2522         m_pData->m_xDocumentProperties->setTitle( getTitle( ) );
2523         Sequence< beans::PropertyValue > aSequence ;
2524         TransformItems( SID_OPENDOC, *pMedium->GetItemSet(), aSequence );
2525         attachResource( sURL, aSequence );
2526
2527         // Reload the CMIS properties
2528         loadCmisProperties( );
2529     }
2530     catch ( const Exception & e )
2531     {
2532         css::uno::Any anyEx = cppu::getCaughtException();
2533         throw lang::WrappedTargetRuntimeException( e.Message,
2534                         e.Context, anyEx );
2535     }
2536 }
2537
2538 void SAL_CALL SfxBaseModel::cancelCheckOut(  )
2539 {
2540     SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium();
2541     if ( !pMedium )
2542         return;
2543
2544     try
2545     {
2546         ::ucbhelper::Content aContent( pMedium->GetName(),
2547             Reference<ucb::XCommandEnvironment>(),
2548             comphelper::getProcessComponentContext() );
2549
2550         Any aResult = aContent.executeCommand( "cancelCheckout", Any( ) );
2551         OUString sURL;
2552         aResult >>= sURL;
2553
2554         m_pData->m_pObjectShell->GetMedium( )->SetName( sURL );
2555     }
2556     catch ( const Exception & e )
2557     {
2558         css::uno::Any anyEx = cppu::getCaughtException();
2559         throw lang::WrappedTargetRuntimeException( e.Message,
2560                         e.Context, anyEx );
2561     }
2562 }
2563
2564 void SAL_CALL SfxBaseModel::checkIn( sal_Bool bIsMajor, const OUString& rMessage )
2565 {
2566     SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium();
2567     if ( !pMedium )
2568         return;
2569
2570     try
2571     {
2572         Sequence< beans::PropertyValue > aProps( 3 );
2573         aProps[0].Name = "VersionMajor";
2574         aProps[0].Value <<= bIsMajor;
2575         aProps[1].Name = "VersionComment";
2576         aProps[1].Value <<= rMessage;
2577         aProps[2].Name = "CheckIn";
2578         aProps[2].Value <<= true;
2579
2580         const OUString sName( pMedium->GetName( ) );
2581         storeSelf( aProps );
2582
2583         // Refresh pMedium as it has probably changed during the storeSelf call
2584         pMedium = m_pData->m_pObjectShell->GetMedium( );
2585         const OUString sNewName( pMedium->GetName( ) );
2586
2587         // URL has changed, update the document
2588         if ( sName != sNewName )
2589         {
2590             m_pData->m_xDocumentProperties->setTitle( getTitle( ) );
2591             Sequence< beans::PropertyValue > aSequence ;
2592             TransformItems( SID_OPENDOC, *pMedium->GetItemSet(), aSequence );
2593             attachResource( sNewName, aSequence );
2594
2595             // Reload the CMIS properties
2596             loadCmisProperties( );
2597         }
2598     }
2599     catch ( const Exception & e )
2600     {
2601         css::uno::Any anyEx = cppu::getCaughtException();
2602         throw lang::WrappedTargetRuntimeException( e.Message,
2603                         e.Context, anyEx );
2604     }
2605 }
2606
2607 uno::Sequence< document::CmisVersion > SAL_CALL SfxBaseModel::getAllVersions( )
2608 {
2609     uno::Sequence<document::CmisVersion> aVersions;
2610     if (impl_isDisposed())
2611         return aVersions;
2612     SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium();
2613     if ( pMedium )
2614     {
2615         try
2616         {
2617             ::ucbhelper::Content aContent( pMedium->GetName(),
2618                 Reference<ucb::XCommandEnvironment>(),
2619                 comphelper::getProcessComponentContext() );
2620
2621             Any aResult = aContent.executeCommand( "getAllVersions", Any( ) );
2622             aResult >>= aVersions;
2623         }
2624         catch ( const Exception & e )
2625         {
2626             css::uno::Any anyEx = cppu::getCaughtException();
2627             throw lang::WrappedTargetRuntimeException( e.Message,
2628                             e.Context, anyEx );
2629         }
2630     }
2631     return aVersions;
2632 }
2633
2634 bool SfxBaseModel::getBoolPropertyValue( const OUString& rName )
2635 {
2636     bool bValue = false;
2637     if ( m_pData->m_pObjectShell.is() )
2638     {
2639         SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium();
2640         if ( pMedium )
2641         {
2642             try
2643             {
2644                 ::ucbhelper::Content aContent( pMedium->GetName( ),
2645                     utl::UCBContentHelper::getDefaultCommandEnvironment(),
2646                     comphelper::getProcessComponentContext() );
2647                 Reference < beans::XPropertySetInfo > xProps = aContent.getProperties();
2648                 if ( xProps->hasPropertyByName( rName ) )
2649                 {
2650                     aContent.getPropertyValue( rName ) >>= bValue;
2651                 }
2652             }
2653             catch ( const Exception & )
2654             {
2655                 // Simply ignore it: it's likely the document isn't versionable in that case
2656                 bValue = false;
2657             }
2658         }
2659     }
2660     return bValue;
2661 }
2662
2663 sal_Bool SAL_CALL SfxBaseModel::isVersionable( )
2664 {
2665     return getBoolPropertyValue( "IsVersionable" );
2666 }
2667
2668 sal_Bool SAL_CALL SfxBaseModel::canCheckOut( )
2669 {
2670     return getBoolPropertyValue( "CanCheckOut" );
2671 }
2672
2673 sal_Bool SAL_CALL SfxBaseModel::canCancelCheckOut( )
2674 {
2675     return getBoolPropertyValue( "CanCancelCheckOut" );
2676 }
2677
2678 sal_Bool SAL_CALL SfxBaseModel::canCheckIn( )
2679 {
2680     return getBoolPropertyValue( "CanCheckIn" );
2681 }
2682
2683 void SfxBaseModel::loadCmisProperties( )
2684 {
2685     SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium();
2686     if ( !pMedium )
2687         return;
2688
2689     try
2690     {
2691         ::ucbhelper::Content aContent( pMedium->GetName( ),
2692             utl::UCBContentHelper::getDefaultCommandEnvironment(),
2693             comphelper::getProcessComponentContext() );
2694         Reference < beans::XPropertySetInfo > xProps = aContent.getProperties();
2695         const OUString aCmisProps( "CmisProperties" );
2696         if ( xProps->hasPropertyByName( aCmisProps ) )
2697         {
2698             Sequence< document::CmisProperty> aCmisProperties;
2699             aContent.getPropertyValue( aCmisProps ) >>= aCmisProperties;
2700             setCmisProperties( aCmisProperties );
2701         }
2702     }
2703     catch (const ucb::ContentCreationException &)
2704     {
2705     }
2706     catch (const ucb::CommandAbortedException &)
2707     {
2708     }
2709 }
2710
2711 SfxMedium* SfxBaseModel::handleLoadError( ErrCode nError, SfxMedium* pMedium )
2712 {
2713     if (!nError)
2714     {
2715         // No error condition.
2716         return pMedium;
2717     }
2718
2719     bool bSilent = false;
2720     const SfxBoolItem* pSilentItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_SILENT, false);
2721     if( pSilentItem )
2722         bSilent = pSilentItem->GetValue();
2723
2724     bool bWarning = nError.IsWarning();
2725     if ( nError != ERRCODE_IO_BROKENPACKAGE && !bSilent )
2726     {
2727         // broken package was handled already
2728         if ( SfxObjectShell::UseInteractionToHandleError(pMedium->GetInteractionHandler(), nError) && !bWarning)
2729         {
2730             // abort loading (except for warnings)
2731             nError = ERRCODE_IO_ABORT;
2732         }
2733     }
2734
2735     if ( m_pData->m_pObjectShell->GetMedium() != pMedium )
2736     {
2737         // for whatever reason document now has another medium
2738         OSL_FAIL("Document has rejected the medium?!");
2739         delete pMedium;
2740         pMedium = nullptr;
2741     }
2742
2743     if ( !bWarning )    // #i30711# don't abort loading if it's only a warning
2744     {
2745         nError = nError ? nError : ERRCODE_IO_CANTREAD;
2746         throw task::ErrorCodeIOException(
2747             "SfxBaseModel::handleLoadError: 0x" + nError.toHexString(),
2748             Reference< XInterface >(), sal_uInt32(nError));
2749     }
2750
2751     return pMedium;
2752 }
2753
2754
2755 //  SfxListener
2756
2757
2758 static void addTitle_Impl( Sequence < beans::PropertyValue >& rSeq, const OUString& rTitle )
2759 {
2760     auto pProp = std::find_if(rSeq.begin(), rSeq.end(),
2761         [](const beans::PropertyValue& rProp) { return rProp.Name == "Title"; });
2762     if (pProp != rSeq.end())
2763     {
2764         pProp->Value <<= rTitle;
2765     }
2766     else
2767     {
2768         sal_Int32 nCount = rSeq.getLength();
2769         rSeq.realloc( nCount+1 );
2770         rSeq[nCount].Name = "Title";
2771         rSeq[nCount].Value <<= rTitle;
2772     }
2773 }
2774
2775 void SfxBaseModel::Notify(          SfxBroadcaster& rBC     ,
2776                              const  SfxHint&        rHint   )
2777 {
2778     if ( !m_pData )
2779         return;
2780
2781     if ( &rBC != m_pData->m_pObjectShell.get() )
2782         return;
2783
2784     if ( rHint.GetId() == SfxHintId::DocChanged )
2785         changing();
2786
2787     const SfxEventHint* pNamedHint = dynamic_cast<const SfxEventHint*>(&rHint);
2788     if ( pNamedHint )
2789     {
2790
2791         switch ( pNamedHint->GetEventId() )
2792         {
2793         case SfxEventHintId::StorageChanged:
2794         {
2795             if ( m_pData->m_xUIConfigurationManager.is()
2796               && m_pData->m_pObjectShell->GetCreateMode() != SfxObjectCreateMode::EMBEDDED )
2797             {
2798                 Reference< embed::XStorage > xConfigStorage;
2799                 const OUString aUIConfigFolderName( "Configurations2" );
2800
2801                 xConfigStorage = getDocumentSubStorage( aUIConfigFolderName, embed::ElementModes::READWRITE );
2802                 if ( !xConfigStorage.is() )
2803                     xConfigStorage = getDocumentSubStorage( aUIConfigFolderName, embed::ElementModes::READ );
2804
2805                 if ( xConfigStorage.is() || !m_pData->m_pObjectShell->GetStorage()->hasByName( aUIConfigFolderName ) )
2806                 {
2807                     // the storage is different, since otherwise it could not be opened, so it must be exchanged
2808                     m_pData->m_xUIConfigurationManager->setStorage( xConfigStorage );
2809                 }
2810                 else
2811                 {
2812                     OSL_FAIL( "Unexpected scenario!" );
2813                 }
2814             }
2815
2816             ListenForStorage_Impl( m_pData->m_pObjectShell->GetStorage() );
2817         }
2818         break;
2819
2820         case SfxEventHintId::LoadFinished:
2821         {
2822             impl_getPrintHelper();
2823             ListenForStorage_Impl( m_pData->m_pObjectShell->GetStorage() );
2824             m_pData->m_bModifiedSinceLastSave = false;
2825         }
2826         break;
2827
2828         case SfxEventHintId::SaveAsDocDone:
2829         {
2830             m_pData->m_sURL = m_pData->m_pObjectShell->GetMedium()->GetName();
2831
2832             SfxItemSet *pSet = m_pData->m_pObjectShell->GetMedium()->GetItemSet();
2833             Sequence< beans::PropertyValue > aArgs;
2834             TransformItems( SID_SAVEASDOC, *pSet, aArgs );
2835             addTitle_Impl( aArgs, m_pData->m_pObjectShell->GetTitle() );
2836             attachResource( m_pData->m_pObjectShell->GetMedium()->GetName(), aArgs );
2837         }
2838         break;
2839
2840         case SfxEventHintId::DocCreated:
2841         {
2842             impl_getPrintHelper();
2843             m_pData->m_bModifiedSinceLastSave = false;
2844         }
2845         break;
2846
2847         case SfxEventHintId::ModifyChanged:
2848         {
2849             m_pData->m_bModifiedSinceLastSave = isModified();
2850         }
2851         break;
2852         default: break;
2853         }
2854
2855         const SfxViewEventHint* pViewHint = dynamic_cast<const SfxViewEventHint*>(&rHint);
2856         postEvent_Impl( pNamedHint->GetEventName(), pViewHint ? pViewHint->GetController() : Reference< frame::XController2 >() );
2857     }
2858
2859     if ( rHint.GetId() == SfxHintId::TitleChanged )
2860     {
2861         addTitle_Impl( m_pData->m_seqArguments, m_pData->m_pObjectShell->GetTitle() );
2862         postEvent_Impl( GlobalEventConfig::GetEventName( GlobalEventId::TITLECHANGED ) );
2863     }
2864     else if ( rHint.GetId() == SfxHintId::ModeChanged )
2865     {
2866         postEvent_Impl( GlobalEventConfig::GetEventName( GlobalEventId::MODECHANGED ) );
2867     }
2868 }
2869
2870
2871 //  public impl.
2872
2873
2874 void SfxBaseModel::NotifyModifyListeners_Impl() const
2875 {
2876     ::cppu::OInterfaceContainerHelper* pIC = m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<util::XModifyListener>::get());
2877     if ( pIC )
2878     {
2879         lang::EventObject aEvent( static_cast<frame::XModel *>(const_cast<SfxBaseModel *>(this)) );
2880         pIC->notifyEach( &util::XModifyListener::modified, aEvent );
2881     }
2882
2883     // this notification here is done too generously, we cannot simply assume that we're really modified
2884     // now, but we need to check it ...
2885     m_pData->m_bModifiedSinceLastSave = const_cast< SfxBaseModel* >( this )->isModified();
2886 }
2887
2888 void SfxBaseModel::changing()
2889 {
2890     SfxModelGuard aGuard( *this );
2891
2892     // the notification should not be sent if the document can not be modified
2893     if ( !m_pData->m_pObjectShell.is() || !m_pData->m_pObjectShell->IsEnableSetModified() )
2894         return;
2895
2896     NotifyModifyListeners_Impl();
2897 }
2898
2899
2900 //  public impl.
2901
2902
2903 SfxObjectShell* SfxBaseModel::GetObjectShell() const
2904 {
2905     return m_pData ? m_pData->m_pObjectShell.get() : nullptr;
2906 }
2907
2908
2909 //  public impl.
2910
2911
2912 bool SfxBaseModel::IsInitialized() const
2913 {
2914     if ( !m_pData || !m_pData->m_pObjectShell.is() )
2915     {
2916         OSL_FAIL( "SfxBaseModel::IsInitialized: this should have been caught earlier!" );
2917         return false;
2918     }
2919
2920     return m_pData->m_pObjectShell->GetMedium() != nullptr;
2921 }
2922
2923 void SfxBaseModel::MethodEntryCheck( const bool i_mustBeInitialized ) const
2924 {
2925     if ( impl_isDisposed() )
2926         throw lang::DisposedException( OUString(), *const_cast< SfxBaseModel* >( this ) );
2927     if ( i_mustBeInitialized && !IsInitialized() )
2928         throw lang::NotInitializedException( OUString(), *const_cast< SfxBaseModel* >( this ) );
2929 }
2930
2931 bool SfxBaseModel::impl_isDisposed() const
2932 {
2933     return ( m_pData == nullptr ) ;
2934 }
2935
2936
2937 //  private impl.
2938
2939
2940 OUString SfxBaseModel::GetMediumFilterName_Impl() const
2941 {
2942     std::shared_ptr<const SfxFilter> pFilter;
2943     SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium();
2944     if ( pMedium )
2945         pFilter = pMedium->GetFilter();
2946
2947     if ( pFilter )
2948         return pFilter->GetName();
2949
2950     return OUString();
2951 }
2952
2953 void SfxBaseModel::impl_store(  const   OUString&                   sURL            ,
2954                                 const   Sequence< beans::PropertyValue >&  seqArguments    ,
2955                                         bool                        bSaveTo         )
2956 {
2957     if( sURL.isEmpty() )
2958         throw frame::IllegalArgumentIOException();
2959
2960     bool bSaved = false;
2961     if ( !bSaveTo && m_pData->m_pObjectShell.is() && !sURL.isEmpty()
2962       && !sURL.startsWith( "private:stream" )
2963       && ::utl::UCBContentHelper::EqualURLs( getLocation(), sURL ) )
2964     {
2965         // this is the same file URL as the current document location, try to use storeOwn if possible
2966
2967         ::comphelper::SequenceAsHashMap aArgHash( seqArguments );
2968         const OUString aFilterString( "FilterName"  );
2969         const OUString aFilterName( aArgHash.getUnpackedValueOrDefault( aFilterString, OUString() ) );
2970         if ( !aFilterName.isEmpty() )
2971         {
2972             SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium();
2973             if ( pMedium )
2974             {
2975                 const std::shared_ptr<const SfxFilter>& pFilter = pMedium->GetFilter();
2976                 if ( pFilter && aFilterName == pFilter->GetFilterName() )
2977                 {
2978                     // #i119366# - If the former file saving with password, do not trying in StoreSelf anyway...
2979                     bool bFormerPassword = false;
2980                     {
2981                         uno::Sequence< beans::NamedValue > aOldEncryptionData;
2982                         if (GetEncryptionData_Impl( pMedium->GetItemSet(), aOldEncryptionData ))
2983                         {
2984                             bFormerPassword = true;
2985                         }
2986                     }
2987                     if ( !bFormerPassword )
2988                     {
2989                         aArgHash.erase( aFilterString );
2990                         aArgHash.erase( "URL" );
2991
2992                         try
2993                         {
2994                             storeSelf( aArgHash.getAsConstPropertyValueList() );
2995                             bSaved = true;
2996                         }
2997                         catch( const lang::IllegalArgumentException& )
2998                         {
2999 #if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
3000                             // some additional arguments do not allow to use saving, SaveAs should be done
3001                             // but only for normal documents, the shared documents would be overwritten in this case
3002                             // that would mean an information loss
3003                             // TODO/LATER: need a new interaction for this case
3004                             if ( m_pData->m_pObjectShell->IsDocShared() )
3005                             {
3006                                 uno::Sequence< beans::NamedValue > aNewEncryptionData = aArgHash.getUnpackedValueOrDefault("EncryptionData", uno::Sequence< beans::NamedValue >() );
3007                                 if ( !aNewEncryptionData.hasElements() )
3008                                 {
3009                                     aNewEncryptionData = ::comphelper::OStorageHelper::CreatePackageEncryptionData( aArgHash.getUnpackedValueOrDefault("Password", OUString()) );
3010                                 }
3011
3012                                 uno::Sequence< beans::NamedValue > aOldEncryptionData;
3013                                 (void)GetEncryptionData_Impl( pMedium->GetItemSet(), aOldEncryptionData );
3014
3015                                 if ( !aOldEncryptionData.hasElements() && !aNewEncryptionData.hasElements() )
3016                                     throw;
3017                                 else
3018                                 {
3019                                     // if the password is changed a special error should be used in case of shared document
3020                                     throw task::ErrorCodeIOException("Can not change password for shared document.", uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_SFX_SHARED_NOPASSWORDCHANGE) );
3021                                 }
3022                             }
3023 #endif
3024                         }
3025                     }
3026                 }
3027             }
3028         }
3029     }
3030
3031     if ( bSaved || !m_pData->m_pObjectShell.is() )
3032         return;
3033
3034     SfxGetpApp()->NotifyEvent( SfxEventHint( bSaveTo ? SfxEventHintId::SaveToDoc : SfxEventHintId::SaveAsDoc, GlobalEventConfig::GetEventName( bSaveTo ? GlobalEventId::SAVETODOC : GlobalEventId::SAVEASDOC ),
3035                                             m_pData->m_pObjectShell.get() ) );
3036
3037     std::unique_ptr<SfxAllItemSet> pItemSet(new SfxAllItemSet(SfxGetpApp()->GetPool()));
3038     pItemSet->Put(SfxStringItem(SID_FILE_NAME, sURL));
3039     if ( bSaveTo )
3040         pItemSet->Put(SfxBoolItem(SID_SAVETO, true));
3041
3042     TransformParameters(SID_SAVEASDOC, seqArguments, *pItemSet);
3043
3044     const SfxBoolItem* pCopyStreamItem = pItemSet->GetItem<SfxBoolItem>(SID_COPY_STREAM_IF_POSSIBLE, false);
3045
3046     if ( pCopyStreamItem && pCopyStreamItem->GetValue() && !bSaveTo )
3047     {
3048         throw frame::IllegalArgumentIOException(
3049                 "CopyStreamIfPossible parameter is not acceptable for storeAsURL() call!" );
3050     }
3051
3052     sal_uInt32 nModifyPasswordHash = 0;
3053     Sequence< beans::PropertyValue > aModifyPasswordInfo;
3054     const SfxUnoAnyItem* pModifyPasswordInfoItem = pItemSet->GetItem<SfxUnoAnyItem>(SID_MODIFYPASSWORDINFO, false);
3055     if ( pModifyPasswordInfoItem )
3056     {
3057         // it contains either a simple hash or a set of PropertyValues
3058         // TODO/LATER: the sequence of PropertyValue should replace the hash completely in future
3059         sal_Int32 nMPHTmp = 0;
3060         pModifyPasswordInfoItem->GetValue() >>= nMPHTmp;
3061         nModifyPasswordHash = static_cast<sal_uInt32>(nMPHTmp);
3062         pModifyPasswordInfoItem->GetValue() >>= aModifyPasswordInfo;
3063     }
3064     pItemSet->ClearItem(SID_MODIFYPASSWORDINFO);
3065     sal_uInt32 nOldModifyPasswordHash = m_pData->m_pObjectShell->GetModifyPasswordHash();
3066     m_pData->m_pObjectShell->SetModifyPasswordHash( nModifyPasswordHash );
3067     Sequence< beans::PropertyValue > aOldModifyPasswordInfo = m_pData->m_pObjectShell->GetModifyPasswordInfo();
3068     m_pData->m_pObjectShell->SetModifyPasswordInfo( aModifyPasswordInfo );
3069
3070     // since saving a document modifies its DocumentProperties, the current
3071     // DocumentProperties must be saved on "SaveTo", so it can be restored
3072     // after saving
3073     bool bCopyTo =  bSaveTo ||
3074         m_pData->m_pObjectShell->GetCreateMode() == SfxObjectCreateMode::EMBEDDED;
3075     Reference<document::XDocumentProperties> xOldDocProps;
3076     if ( bCopyTo )
3077     {
3078         xOldDocProps = getDocumentProperties();
3079         const Reference<util::XCloneable> xCloneable(xOldDocProps,
3080             UNO_QUERY_THROW);
3081         const Reference<document::XDocumentProperties> xNewDocProps(
3082             xCloneable->createClone(), UNO_QUERY_THROW);
3083         m_pData->m_xDocumentProperties = xNewDocProps;
3084     }
3085
3086     bool bRet = m_pData->m_pObjectShell->APISaveAs_Impl(sURL, *pItemSet, seqArguments);
3087
3088     if ( bCopyTo )
3089     {
3090         // restore DocumentProperties if a copy was created
3091         m_pData->m_xDocumentProperties = xOldDocProps;
3092     }
3093
3094     Reference < task::XInteractionHandler > xHandler;
3095     const SfxUnoAnyItem* pItem = pItemSet->GetItem<SfxUnoAnyItem>(SID_INTERACTIONHANDLER, false);
3096     if ( pItem )
3097         pItem->GetValue() >>= xHandler;
3098
3099     pItemSet.reset();
3100
3101     ErrCode nErrCode = m_pData->m_pObjectShell->GetErrorCode();
3102     if ( !bRet && !nErrCode )
3103     {
3104         SAL_WARN("sfx.doc", "Storing has failed, no error is set!");
3105         nErrCode = ERRCODE_IO_CANTWRITE;
3106     }
3107     m_pData->m_pObjectShell->ResetError();
3108
3109     if ( bRet )
3110     {
3111         if ( nErrCode )
3112         {
3113             // must be a warning - use Interactionhandler if possible or abandon
3114             if ( xHandler.is() )
3115             {
3116                 // TODO/LATER: a general way to set the error context should be available
3117                 SfxErrorContext aEc( ERRCTX_SFX_SAVEASDOC, m_pData->m_pObjectShell->GetTitle() );
3118
3119                 task::ErrorCodeRequest aErrorCode;
3120                 aErrorCode.ErrCode = sal_uInt32(nErrCode);
3121                 SfxMedium::CallApproveHandler( xHandler, makeAny( aErrorCode ), false );
3122             }
3123         }
3124
3125         if ( !bSaveTo )
3126         {
3127             m_pData->m_aPreusedFilterName = GetMediumFilterName_Impl();
3128             m_pData->m_pObjectShell->SetModifyPasswordEntered();
3129
3130             SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveAsDocDone, GlobalEventConfig::GetEventName(GlobalEventId::SAVEASDOCDONE), m_pData->m_pObjectShell.get() ) );
3131         }
3132         else
3133         {
3134             m_pData->m_pObjectShell->SetModifyPasswordHash( nOldModifyPasswordHash );
3135             m_pData->m_pObjectShell->SetModifyPasswordInfo( aOldModifyPasswordInfo );
3136
3137             SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveToDocDone, GlobalEventConfig::GetEventName(GlobalEventId::SAVETODOCDONE), m_pData->m_pObjectShell.get() ) );
3138         }
3139     }
3140     else
3141     {
3142         m_pData->m_pObjectShell->SetModifyPasswordHash( nOldModifyPasswordHash );
3143         m_pData->m_pObjectShell->SetModifyPasswordInfo( aOldModifyPasswordInfo );
3144
3145
3146         SfxGetpApp()->NotifyEvent( SfxEventHint( bSaveTo ? SfxEventHintId::SaveToDocFailed : SfxEventHintId::SaveAsDocFailed, GlobalEventConfig::GetEventName( bSaveTo ? GlobalEventId::SAVETODOCFAILED : GlobalEventId::SAVEASDOCFAILED),
3147                                                 m_pData->m_pObjectShell.get() ) );
3148
3149         std::stringstream aErrCode;
3150         aErrCode << nErrCode;
3151         throw task::ErrorCodeIOException(
3152             "SfxBaseModel::impl_store <" + sURL + "> failed: " + OUString::fromUtf8(aErrCode.str().c_str()),
3153             Reference< XInterface >(), sal_uInt32(nErrCode));
3154     }
3155 }
3156
3157
3158 namespace {
3159 template< typename ListenerT, typename EventT >
3160 class NotifySingleListenerIgnoreRE
3161 {
3162 private:
3163     typedef void ( SAL_CALL ListenerT::*NotificationMethod )( const EventT& );
3164     NotificationMethod  m_pMethod;
3165     const EventT&       m_rEvent;
3166 public:
3167     NotifySingleListenerIgnoreRE( NotificationMethod method, const EventT& event ) : m_pMethod( method ), m_rEvent( event ) { }
3168
3169     void operator()( const Reference<ListenerT>& listener ) const
3170     {
3171         try
3172         {
3173             (listener.get()->*m_pMethod)( m_rEvent );
3174         }
3175         catch( RuntimeException& )
3176         {
3177             // this exception is ignored to avoid problems with invalid listeners, the listener should be probably thrown away in future
3178         }
3179     }
3180 };
3181 } // anonymous namespace
3182
3183 void SfxBaseModel::postEvent_Impl( const OUString& aName, const Reference< frame::XController2 >& xController )
3184 {
3185     // object already disposed?
3186     if ( impl_isDisposed() )
3187         return;
3188
3189     // keep m_pData alive, if notified target would dispose the document
3190     std::shared_ptr<IMPL_SfxBaseModel_DataContainer> xKeepAlive(m_pData);
3191
3192     // also make sure this object doesn't self-destruct while notifying
3193     rtl::Reference<SfxBaseModel> xHoldAlive(this);
3194
3195     DBG_ASSERT( !aName.isEmpty(), "Empty event name!" );
3196     if (aName.isEmpty())
3197         return;
3198
3199     ::cppu::OInterfaceContainerHelper* pIC =
3200         m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<document::XDocumentEventListener>::get());
3201     if ( pIC )
3202     {
3203         SAL_INFO("sfx.doc", "SfxDocumentEvent: " + aName);
3204
3205         document::DocumentEvent aDocumentEvent( static_cast<frame::XModel*>(this), aName, xController, Any() );
3206
3207         pIC->forEach< document::XDocumentEventListener, NotifySingleListenerIgnoreRE< document::XDocumentEventListener, document::DocumentEvent > >(
3208             NotifySingleListenerIgnoreRE< document::XDocumentEventListener, document::DocumentEvent >(
3209                 &document::XDocumentEventListener::documentEventOccured,
3210                 aDocumentEvent ) );
3211     }
3212
3213     pIC = m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<document::XEventListener>::get());
3214     if ( pIC )
3215     {
3216         SAL_INFO("sfx.doc", "SfxEvent: " + aName);
3217
3218         document::EventObject aEvent( static_cast<frame::XModel*>(this), aName );
3219
3220         pIC->forEach< document::XEventListener, NotifySingleListenerIgnoreRE< document::XEventListener, document::EventObject > >(
3221             NotifySingleListenerIgnoreRE< document::XEventListener, document::EventObject >(
3222                 &document::XEventListener::notifyEvent,
3223                 aEvent ) );
3224     }
3225
3226 }
3227
3228 Reference < container::XIndexAccess > SAL_CALL SfxBaseModel::getViewData()
3229 {
3230     SfxModelGuard aGuard( *this );
3231
3232     if ( m_pData->m_pObjectShell.is() && !m_pData->m_contViewData.is() )
3233     {
3234         SfxViewFrame *pActFrame = SfxViewFrame::Current();
3235         if ( !pActFrame || pActFrame->GetObjectShell() != m_pData->m_pObjectShell.get() )
3236             pActFrame = SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get() );
3237
3238         if ( !pActFrame || !pActFrame->GetViewShell() )
3239             // currently no frame for this document at all or View is under construction
3240             return Reference < container::XIndexAccess >();
3241
3242         m_pData->m_contViewData = document::IndexedPropertyValues::create( ::comphelper::getProcessComponentContext() );
3243
3244         if ( !m_pData->m_contViewData.is() )
3245         {
3246             // error: no container class available!
3247             return Reference < container::XIndexAccess >();
3248         }
3249
3250         Reference < container::XIndexContainer > xCont( m_pData->m_contViewData, UNO_QUERY );
3251         sal_Int32 nCount = 0;
3252         Sequence < beans::PropertyValue > aSeq;
3253         for ( SfxViewFrame *pFrame = SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get() ); pFrame;
3254                 pFrame = SfxViewFrame::GetNext( *pFrame, m_pData->m_pObjectShell.get() ) )
3255         {
3256             bool bIsActive = ( pFrame == pActFrame );
3257             pFrame->GetViewShell()->WriteUserDataSequence( aSeq );
3258             xCont->insertByIndex( bIsActive ? 0 : nCount, Any(aSeq) );
3259             nCount++;
3260         }
3261     }
3262
3263     return m_pData->m_contViewData;
3264 }
3265
3266 void SAL_CALL SfxBaseModel::setViewData( const Reference < container::XIndexAccess >& aData )
3267 {
3268     SfxModelGuard aGuard( *this );
3269
3270     m_pData->m_contViewData = aData;
3271 }
3272
3273 /** calls all XEventListeners */
3274 void SfxBaseModel::notifyEvent( const document::EventObject& aEvent ) const
3275 {
3276     // object already disposed?
3277     if ( impl_isDisposed() )
3278         return;
3279
3280     ::cppu::OInterfaceContainerHelper* pIC = m_pData->m_aInterfaceContainer.getContainer(
3281                                         cppu::UnoType<document::XEventListener>::get());
3282     if( !pIC )
3283
3284         return;
3285
3286     ::cppu::OInterfaceIteratorHelper aIt( *pIC );
3287     while( aIt.hasMoreElements() )
3288     {
3289         try
3290         {
3291             static_cast<document::XEventListener *>(aIt.next())->notifyEvent( aEvent );
3292         }
3293         catch( RuntimeException& )
3294         {
3295             aIt.remove();
3296         }
3297     }
3298     // for right now, we're only doing the event that this particular performance problem needed
3299     if (aEvent.EventName == "ShapeModified")
3300     {
3301         uno::Reference<drawing::XShape> xShape(aEvent.Source, uno::UNO_QUERY);
3302         if (xShape.is())
3303         {
3304             auto it = m_pData->maShapeListeners.find(xShape);
3305             if (it != m_pData->maShapeListeners.end())
3306                 for (auto const & rListenerUnoRef : it->second)
3307                     rListenerUnoRef->notifyShapeEvent(aEvent);
3308         }
3309     }
3310 }
3311
3312 /** returns true if someone added a XEventListener to this XEventBroadcaster */
3313 bool SfxBaseModel::hasEventListeners() const
3314 {
3315     return !impl_isDisposed()
3316         && ( (nullptr != m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<document::XEventListener>::get()) )
3317              || !m_pData->maShapeListeners.empty());
3318 }
3319
3320 void SAL_CALL SfxBaseModel::addPrintJobListener( const Reference< view::XPrintJobListener >& xListener )
3321 {
3322     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
3323
3324     impl_getPrintHelper();
3325     Reference < view::XPrintJobBroadcaster > xPJB( m_pData->m_xPrintable, UNO_QUERY );
3326     if ( xPJB.is() )
3327         xPJB->addPrintJobListener( xListener );
3328 }
3329
3330 void SAL_CALL SfxBaseModel::removePrintJobListener( const Reference< view::XPrintJobListener >& xListener )
3331 {
3332     SfxModelGuard aGuard( *this );
3333
3334     impl_getPrintHelper();
3335     Reference < view::XPrintJobBroadcaster > xPJB( m_pData->m_xPrintable, UNO_QUERY );
3336     if ( xPJB.is() )
3337         xPJB->removePrintJobListener( xListener );
3338 }
3339
3340 sal_Int64 SAL_CALL SfxBaseModel::getSomething( const Sequence< sal_Int8 >& aIdentifier )
3341 {
3342     SvGlobalName aName( aIdentifier );
3343     if (aName == SvGlobalName( SFX_GLOBAL_CLASSID ))
3344     {
3345         SolarMutexGuard aGuard;
3346         SfxObjectShell *const pObjectShell(GetObjectShell());
3347         if (pObjectShell)
3348         {
3349             return reinterpret_cast<sal_Int64>(pObjectShell);
3350         }
3351     }
3352
3353     return 0;
3354 }
3355
3356
3357 //  XDocumentSubStorageSupplier
3358
3359
3360 void SfxBaseModel::ListenForStorage_Impl( const Reference< embed::XStorage >& xStorage )
3361 {
3362     Reference< util::XModifiable > xModifiable( xStorage, UNO_QUERY );
3363     if ( xModifiable.is() )
3364     {
3365         if ( !m_pData->m_pStorageModifyListen.is() )
3366         {
3367             m_pData->m_pStorageModifyListen = new ::sfx2::DocumentStorageModifyListener( *m_pData, Application::GetSolarMutex() );
3368         }
3369
3370         // no need to deregister the listening for old storage since it should be disposed automatically
3371         xModifiable->addModifyListener( m_pData->m_pStorageModifyListen.get() );
3372     }
3373 }
3374
3375 Reference< embed::XStorage > SAL_CALL SfxBaseModel::getDocumentSubStorage( const OUString& aStorageName, sal_Int32 nMode )
3376 {
3377     SfxModelGuard aGuard( *this );
3378
3379     Reference< embed::XStorage > xResult;
3380     if ( m_pData->m_pObjectShell.is() )
3381     {
3382         Reference< embed::XStorage > xStorage = m_pData->m_pObjectShell->GetStorage();
3383         if ( xStorage.is() )
3384         {
3385             try
3386             {
3387                 xResult = xStorage->openStorageElement( aStorageName, nMode );
3388             }
3389             catch ( Exception& )
3390             {
3391             }
3392         }
3393     }
3394
3395     return xResult;
3396 }
3397
3398 Sequence< OUString > SAL_CALL SfxBaseModel::getDocumentSubStoragesNames()
3399 {
3400     SfxModelGuard aGuard( *this );
3401
3402     Sequence< OUString > aResult;
3403     bool bSuccess = false;
3404     if ( m_pData->m_pObjectShell.is() )
3405     {
3406         Reference < embed::XStorage > xStorage = m_pData->m_pObjectShell->GetStorage();
3407         if ( xStorage.is() )
3408         {
3409             const Sequence< OUString > aTemp = xStorage->getElementNames();
3410             sal_Int32 nResultSize = 0;
3411             for ( const auto& rName : aTemp )
3412             {
3413                 if ( xStorage->isStorageElement( rName ) )
3414                 {
3415                     aResult.realloc( ++nResultSize );
3416                     aResult[ nResultSize - 1 ] = rName;
3417                 }
3418             }
3419
3420             bSuccess = true;
3421         }
3422     }
3423
3424     if ( !bSuccess )
3425         throw io::IOException();
3426
3427     return aResult;
3428 }
3429
3430
3431 //  XScriptProviderSupplier
3432
3433
3434 Reference< script::provider::XScriptProvider > SAL_CALL SfxBaseModel::getScriptProvider()
3435 {
3436     SfxModelGuard aGuard( *this );
3437
3438     Reference< script::provider::XScriptProviderFactory > xScriptProviderFactory =
3439         script::provider::theMasterScriptProviderFactory::get( ::comphelper::getProcessComponentContext() );
3440
3441     Reference< XScriptInvocationContext > xScriptContext( this );
3442
3443     Reference< script::provider::XScriptProvider > xScriptProvider(
3444         xScriptProviderFactory->createScriptProvider( makeAny( xScriptContext ) ),
3445         UNO_SET_THROW );
3446
3447     return xScriptProvider;
3448 }
3449
3450
3451 //  XUIConfigurationManagerSupplier
3452
3453
3454 OUString const & SfxBaseModel::getRuntimeUID() const
3455 {
3456     OSL_ENSURE( !m_pData->m_sRuntimeUID.isEmpty(),
3457                 "SfxBaseModel::getRuntimeUID - ID is empty!" );
3458     return m_pData->m_sRuntimeUID;
3459 }
3460
3461 bool SfxBaseModel::hasValidSignatures() const
3462 {
3463     SolarMutexGuard aGuard;
3464     if ( m_pData->m_pObjectShell.is() )
3465         return ( m_pData->m_pObjectShell->ImplGetSignatureState() == SignatureState::OK );
3466     return false;
3467 }
3468
3469 void SfxBaseModel::getGrabBagItem(css::uno::Any& rVal) const
3470 {
3471     if (m_pData->m_xGrabBagItem)
3472         m_pData->m_xGrabBagItem->QueryValue(rVal);
3473     else
3474         rVal <<= uno::Sequence<beans::PropertyValue>();
3475 }
3476
3477 void SfxBaseModel::setGrabBagItem(const css::uno::Any& rVal)
3478 {
3479     if (!m_pData->m_xGrabBagItem)
3480         m_pData->m_xGrabBagItem = std::make_shared<SfxGrabBagItem>();
3481
3482     m_pData->m_xGrabBagItem->PutValue(rVal, 0);
3483 }
3484
3485 static void GetCommandFromSequence( OUString& rCommand, sal_Int32& nIndex, const Sequence< beans::PropertyValue >& rSeqPropValue )
3486 {
3487     nIndex = -1;
3488
3489     auto pPropValue = std::find_if(rSeqPropValue.begin(), rSeqPropValue.end(),
3490         [](const beans::PropertyValue& rPropValue) { return rPropValue.Name == "Command"; });
3491     if (pPropValue != rSeqPropValue.end())
3492     {
3493         pPropValue->Value >>= rCommand;
3494         nIndex = static_cast<sal_Int32>(std::distance(rSeqPropValue.begin(), pPropValue));
3495     }
3496 }
3497
3498 static void ConvertSlotsToCommands( SfxObjectShell const * pDoc, Reference< container::XIndexContainer > const & rToolbarDefinition )
3499 {
3500     if ( !pDoc )
3501         return;
3502
3503     SfxModule*    pModule( pDoc->GetFactory().GetModule() );
3504     Sequence< beans::PropertyValue > aSeqPropValue;
3505
3506     for ( sal_Int32 i = 0; i < rToolbarDefinition->getCount(); i++ )
3507     {
3508         if ( rToolbarDefinition->getByIndex( i ) >>= aSeqPropValue )
3509         {
3510             OUString aCommand;
3511             sal_Int32 nIndex( -1 );
3512             GetCommandFromSequence( aCommand, nIndex, aSeqPropValue );
3513             if ( nIndex >= 0 && aCommand.startsWith( "slot:" ) )
3514             {
3515                 const sal_uInt16 nSlot = aCommand.copy( 5 ).toInt32();
3516
3517                 // We have to replace the old "slot-Command" with our new ".uno:-Command"
3518                 const SfxSlot* pSlot = pModule->GetSlotPool()->GetSlot( nSlot );
3519                 if ( pSlot )
3520                 {
3521                     OUStringBuffer aStrBuf( ".uno:"  );
3522                     aStrBuf.appendAscii( pSlot->GetUnoName() );
3523
3524                     aCommand = aStrBuf.makeStringAndClear();
3525                     aSeqPropValue[nIndex].Value <<= aCommand;
3526                     rToolbarDefinition->replaceByIndex( i, Any( aSeqPropValue ));
3527                 }
3528             }
3529         }
3530     }
3531 }
3532
3533 Reference< ui::XUIConfigurationManager > SAL_CALL SfxBaseModel::getUIConfigurationManager()
3534 {
3535     return Reference< ui::XUIConfigurationManager >( getUIConfigurationManager2(), UNO_QUERY_THROW );
3536 }
3537
3538 Reference< ui::XUIConfigurationManager2 > SfxBaseModel::getUIConfigurationManager2()
3539 {
3540     SfxModelGuard aGuard( *this );
3541
3542     if ( !m_pData->m_xUIConfigurationManager.is() )
3543     {
3544         Reference< ui::XUIConfigurationManager2 > xNewUIConfMan =
3545             ui::UIConfigurationManager::create( comphelper::getProcessComponentContext() );
3546
3547         Reference< embed::XStorage > xConfigStorage;
3548
3549         OUString aUIConfigFolderName( "Configurations2" );
3550         // First try to open with READWRITE and then READ
3551         xConfigStorage = getDocumentSubStorage( aUIConfigFolderName, embed::ElementModes::READWRITE );
3552         if ( xConfigStorage.is() )
3553         {
3554             const OUString aMediaTypeProp( "MediaType" );
3555             OUString aMediaType;
3556             Reference< beans::XPropertySet > xPropSet( xConfigStorage, UNO_QUERY );
3557             Any a = xPropSet->getPropertyValue( aMediaTypeProp );
3558             if ( !( a >>= aMediaType ) ||  aMediaType.isEmpty())
3559             {
3560                 xPropSet->setPropertyValue( aMediaTypeProp, Any(OUString("application/vnd.sun.xml.ui.configuration")) );
3561             }
3562         }
3563         else
3564             xConfigStorage = getDocumentSubStorage( aUIConfigFolderName, embed::ElementModes::READ );
3565
3566         // initialize ui configuration manager with document substorage
3567         xNewUIConfMan->setStorage( xConfigStorage );
3568
3569         // embedded objects did not support local configuration data until OOo 3.0, so there's nothing to
3570         // migrate
3571         if ( m_pData->m_pObjectShell->GetCreateMode() != SfxObjectCreateMode::EMBEDDED )
3572         {
3573             // Import old UI configuration from OOo 1.x
3574
3575             // Try to open with READ
3576             Reference< embed::XStorage > xOOo1ConfigStorage = getDocumentSubStorage( "Configurations", embed::ElementModes::READ );
3577             if ( xOOo1ConfigStorage.is() )
3578             {
3579                 Reference< XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
3580                 std::vector< Reference< container::XIndexContainer > > rToolbars;
3581
3582                 bool bImported = framework::UIConfigurationImporterOOo1x::ImportCustomToolbars(
3583                                         xNewUIConfMan, rToolbars, xContext, xOOo1ConfigStorage );
3584                 if ( bImported )
3585                 {
3586                     SfxObjectShell* pObjShell = SfxBaseModel::GetObjectShell();
3587
3588                     for ( size_t i = 0; i < rToolbars.size(); i++ )
3589                     {
3590                         const OUString sId(OUString::number( i + 1 ));
3591                         const OUString aCustomTbxName = "private:resource/toolbar/custom_OOo1x_" + sId;
3592
3593                         Reference< container::XIndexContainer > xToolbar = rToolbars[i];
3594                         ConvertSlotsToCommands( pObjShell, xToolbar );
3595                         if ( !xNewUIConfMan->hasSettings( aCustomTbxName ))
3596                         {
3597                             // Set UIName for the toolbar with container property
3598                             Reference< beans::XPropertySet > xPropSet( xToolbar, UNO_QUERY );
3599                             if ( xPropSet.is() )
3600                             {
3601                                 try
3602                                 {
3603                                     xPropSet->setPropertyValue( "UIName", Any( "Toolbar " + sId ) );
3604                                 }
3605                                 catch ( beans::UnknownPropertyException& )
3606                                 {
3607                                 }
3608                             }
3609
3610                             xNewUIConfMan->insertSettings( aCustomTbxName, xToolbar );
3611                             xNewUIConfMan->store();
3612                         }
3613                     }
3614                 }
3615             }
3616         }
3617
3618         m_pData->m_xUIConfigurationManager = xNewUIConfMan;
3619     }
3620
3621     return m_pData->m_xUIConfigurationManager;
3622 }
3623
3624
3625 //  XVisualObject
3626
3627
3628 void SAL_CALL SfxBaseModel::setVisualAreaSize( sal_Int64 nAspect, const awt::Size& aSize )
3629 {
3630     SfxModelGuard aGuard( *this );
3631
3632     if ( !m_pData->m_pObjectShell.is() )
3633         throw Exception("no object shell", nullptr); // TODO: error handling
3634
3635     SfxViewFrame* pViewFrm = SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get(), false );
3636     if ( pViewFrm && m_pData->m_pObjectShell->GetCreateMode() == SfxObjectCreateMode::EMBEDDED && !pViewFrm->GetFrame().IsInPlace() )
3637     {
3638         VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( pViewFrm->GetFrame().GetFrameInterface()->getContainerWindow() );
3639         Size aWinSize = pWindow->GetSizePixel();
3640         awt::Size aCurrent = getVisualAreaSize( nAspect );
3641         Size aDiff( aSize.Width-aCurrent.Width, aSize.Height-aCurrent.Height );
3642         aDiff = pViewFrm->GetViewShell()->GetWindow()->LogicToPixel( aDiff );
3643         aWinSize.AdjustWidth(aDiff.Width() );
3644         aWinSize.AdjustHeight(aDiff.Height() );
3645         pWindow->SetSizePixel( aWinSize );
3646     }
3647     else
3648     {
3649         tools::Rectangle aTmpRect = m_pData->m_pObjectShell->GetVisArea( ASPECT_CONTENT );
3650         aTmpRect.SetSize( Size( aSize.Width, aSize.Height ) );
3651         m_pData->m_pObjectShell->SetVisArea( aTmpRect );
3652     }
3653 }
3654
3655 awt::Size SAL_CALL SfxBaseModel::getVisualAreaSize( sal_Int64 /*nAspect*/ )
3656 {
3657     SfxModelGuard aGuard( *this );
3658
3659     if ( !m_pData->m_pObjectShell.is() )
3660         throw Exception("no object shell", nullptr); // TODO: error handling
3661
3662     tools::Rectangle aTmpRect = m_pData->m_pObjectShell->GetVisArea( ASPECT_CONTENT );
3663
3664     return awt::Size( aTmpRect.GetWidth(), aTmpRect.GetHeight() );
3665 }
3666
3667
3668 sal_Int32 SAL_CALL SfxBaseModel::getMapUnit( sal_Int64 /*nAspect*/ )
3669 {
3670     SfxModelGuard aGuard( *this );
3671
3672     if ( !m_pData->m_pObjectShell.is() )
3673         throw Exception("no object shell", nullptr); // TODO: error handling
3674
3675     return VCLUnoHelper::VCL2UnoEmbedMapUnit( m_pData->m_pObjectShell->GetMapUnit() );
3676 }
3677
3678 embed::VisualRepresentation SAL_CALL SfxBaseModel::getPreferredVisualRepresentation( ::sal_Int64 /*nAspect*/ )
3679 {
3680     SfxModelGuard aGuard( *this );
3681
3682     datatransfer::DataFlavor aDataFlavor(
3683             "application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"",
3684             "GDIMetaFile",
3685             cppu::UnoType<Sequence< sal_Int8 >>::get() );
3686
3687     embed::VisualRepresentation aVisualRepresentation;
3688     aVisualRepresentation.Data = getTransferData( aDataFlavor );
3689     aVisualRepresentation.Flavor = aDataFlavor;
3690
3691     return aVisualRepresentation;
3692 }
3693
3694
3695 //  XStorageBasedDocument
3696
3697
3698 void SAL_CALL SfxBaseModel::loadFromStorage( const Reference< embed::XStorage >& xStorage,
3699                                              const Sequence< beans::PropertyValue >& aMediaDescriptor )
3700 {
3701     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
3702     if ( IsInitialized() )
3703         throw frame::DoubleInitializationException( OUString(), *this );
3704
3705     // after i36090 is fixed the pool from object shell can be used
3706     // SfxAllItemSet aSet( m_pData->m_pObjectShell->GetPool() );
3707     SfxAllItemSet aSet( SfxGetpApp()->GetPool() );
3708
3709     // the BaseURL is part of the ItemSet
3710     SfxMedium* pMedium = new SfxMedium( xStorage, OUString() );
3711     TransformParameters( SID_OPENDOC, aMediaDescriptor, aSet );
3712     pMedium->GetItemSet()->Put( aSet );
3713
3714     // allow to use an interactionhandler (if there is one)
3715     pMedium->UseInteractionHandler( true );
3716
3717     const SfxBoolItem* pTemplateItem = aSet.GetItem<SfxBoolItem>(SID_TEMPLATE, false);
3718     bool bTemplate = pTemplateItem && pTemplateItem->GetValue();
3719     m_pData->m_pObjectShell->SetActivateEvent_Impl( bTemplate ? SfxEventHintId::CreateDoc : SfxEventHintId::OpenDoc );
3720     m_pData->m_pObjectShell->Get_Impl()->bOwnsStorage = false;
3721
3722     // load document
3723     if ( !m_pData->m_pObjectShell->DoLoad(pMedium) )
3724     {
3725         ErrCode nError = m_pData->m_pObjectShell->GetErrorCode();
3726         nError = nError ? nError : ERRCODE_IO_CANTREAD;
3727         throw task::ErrorCodeIOException(
3728             "SfxBaseModel::loadFromStorage: " + nError.toHexString(),
3729             Reference< XInterface >(), sal_uInt32(nError));
3730     }
3731     loadCmisProperties( );
3732 }
3733
3734 void SAL_CALL SfxBaseModel::storeToStorage( const Reference< embed::XStorage >& xStorage,
3735                                 const Sequence< beans::PropertyValue >& aMediaDescriptor )
3736 {
3737     SfxModelGuard aGuard( *this );
3738
3739     if ( !m_pData->m_pObjectShell.is() )
3740         throw io::IOException(); // TODO:
3741
3742     auto xSet = std::make_shared<SfxAllItemSet>(m_pData->m_pObjectShell->GetPool());
3743     TransformParameters( SID_SAVEASDOC, aMediaDescriptor, *xSet );
3744
3745     // TODO/LATER: maybe a special URL "private:storage" should be used
3746     const SfxStringItem* pItem = xSet->GetItem<SfxStringItem>(SID_FILTER_NAME, false);
3747     sal_Int32 nVersion = SOFFICE_FILEFORMAT_CURRENT;
3748     if( pItem )
3749     {
3750         std::shared_ptr<const SfxFilter> pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4FilterName( pItem->GetValue() );
3751         if ( pFilter && pFilter->UsesStorage() )
3752             nVersion = pFilter->GetVersion();
3753     }
3754
3755     bool bSuccess = false;
3756     if ( xStorage == m_pData->m_pObjectShell->GetStorage() )
3757     {
3758         // storing to the own storage
3759         bSuccess = m_pData->m_pObjectShell->DoSave();
3760     }
3761     else
3762     {
3763         // TODO/LATER: if the provided storage has some data inside the storing might fail, probably the storage must be truncated
3764         // TODO/LATER: is it possible to have a template here?
3765         m_pData->m_pObjectShell->SetupStorage( xStorage, nVersion, false );
3766
3767         // BaseURL is part of the ItemSet
3768         SfxMedium aMedium( xStorage, OUString(), xSet );
3769         aMedium.CanDisposeStorage_Impl( false );
3770         if ( aMedium.GetFilter() )
3771         {
3772             // storing without a valid filter will often crash
3773             bSuccess = m_pData->m_pObjectShell->DoSaveObjectAs( aMedium, true );
3774             m_pData->m_pObjectShell->DoSaveCompleted();
3775         }
3776     }
3777
3778     ErrCode nError = m_pData->m_pObjectShell->GetErrorCode();
3779     m_pData->m_pObjectShell->ResetError();
3780
3781     // the warnings are currently not transported
3782     if ( !bSuccess )
3783     {
3784         nError = nError ? nError : ERRCODE_IO_GENERAL;
3785         throw task::ErrorCodeIOException(
3786             "SfxBaseModel::storeToStorage: " + nError.toHexString(),
3787             Reference< XInterface >(), sal_uInt32(nError));
3788     }
3789 }
3790
3791 void SAL_CALL SfxBaseModel::switchToStorage( const Reference< embed::XStorage >& xStorage )
3792 {
3793     SfxModelGuard aGuard( *this );
3794
3795     if ( !m_pData->m_pObjectShell.is() )
3796         throw io::IOException(); // TODO:
3797
3798     // the persistence should be switched only if the storage is different
3799     if ( xStorage != m_pData->m_pObjectShell->GetStorage() )
3800     {
3801         if ( !m_pData->m_pObjectShell->SwitchPersistance( xStorage ) )
3802         {
3803             ErrCode nError = m_pData->m_pObjectShell->GetErrorCode();
3804             nError = nError ? nError : ERRCODE_IO_GENERAL;
3805             throw task::ErrorCodeIOException(
3806                 "SfxBaseModel::switchToStorage: " + nError.toHexString(),
3807                 Reference< XInterface >(), sal_uInt32(nError));
3808         }
3809         else
3810         {
3811             // UICfgMgr has a reference to the old storage, update it
3812             getUIConfigurationManager2()->setStorage( xStorage );
3813         }
3814     }
3815     m_pData->m_pObjectShell->Get_Impl()->bOwnsStorage = false;
3816 }
3817
3818 Reference< embed::XStorage > SAL_CALL SfxBaseModel::getDocumentStorage()
3819 {
3820     SfxModelGuard aGuard( *this );
3821
3822     if ( !m_pData->m_pObjectShell.is() )
3823         throw io::IOException(); // TODO
3824
3825     return m_pData->m_pObjectShell->GetStorage();
3826 }
3827
3828 void SAL_CALL SfxBaseModel::addStorageChangeListener(
3829             const Reference< document::XStorageChangeListener >& xListener )
3830 {
3831     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
3832
3833     m_pData->m_aInterfaceContainer.addInterface(
3834                                     cppu::UnoType<document::XStorageChangeListener>::get(), xListener );
3835 }
3836
3837 void SAL_CALL SfxBaseModel::removeStorageChangeListener(
3838             const Reference< document::XStorageChangeListener >& xListener )
3839 {
3840     SfxModelGuard aGuard( *this );
3841
3842     m_pData->m_aInterfaceContainer.removeInterface(
3843                                     cppu::UnoType<document::XStorageChangeListener>::get(), xListener );
3844 }
3845
3846 void SfxBaseModel::impl_getPrintHelper()
3847 {
3848     if ( m_pData->m_xPrintable.is() )
3849         return;
3850     m_pData->m_xPrintable = new SfxPrintHelper();
3851     Reference < lang::XInitialization > xInit( m_pData->m_xPrintable, UNO_QUERY );
3852     Sequence < Any > aValues(1);
3853     aValues[0] <<= Reference < frame::XModel > (static_cast< frame::XModel* >(this), UNO_QUERY );
3854     xInit->initialize( aValues );
3855     Reference < view::XPrintJobBroadcaster > xBrd( m_pData->m_xPrintable, UNO_QUERY );
3856     xBrd->addPrintJobListener( new SfxPrintHelperListener_Impl( m_pData.get() ) );
3857 }
3858
3859
3860 // css.frame.XModule
3861  void SAL_CALL SfxBaseModel::setIdentifier(const OUString& Identifier)
3862 {
3863     SfxModelGuard aGuard( *this );
3864     m_pData->m_sModuleIdentifier = Identifier;
3865 }
3866
3867
3868 // css.frame.XModule
3869  OUString SAL_CALL SfxBaseModel::getIdentifier()
3870 {
3871     SfxModelGuard aGuard( *this );
3872     if (!m_pData->m_sModuleIdentifier.isEmpty())
3873         return m_pData->m_sModuleIdentifier;
3874     if (m_pData->m_pObjectShell.is())
3875         return m_pData->m_pObjectShell->GetFactory().GetDocumentServiceName();
3876     return OUString();
3877 }
3878
3879
3880 Reference< frame::XTitle > SfxBaseModel::impl_getTitleHelper ()
3881 {
3882     SfxModelGuard aGuard( *this );
3883
3884     if ( ! m_pData->m_xTitleHelper.is ())
3885     {
3886         Reference< XComponentContext >     xContext = ::comphelper::getProcessComponentContext();
3887         Reference< frame::XUntitledNumbers >    xDesktop( frame::Desktop::create(xContext), UNO_QUERY_THROW);
3888         Reference< frame::XModel >              xThis   (static_cast< frame::XModel* >(this), UNO_QUERY_THROW);
3889
3890         ::framework::TitleHelper* pHelper = new ::framework::TitleHelper(xContext);
3891         m_pData->m_xTitleHelper.set(static_cast< ::cppu::OWeakObject* >(pHelper), UNO_QUERY_THROW);
3892         pHelper->setOwner                   (xThis   );
3893         pHelper->connectWithUntitledNumbers (xDesktop);
3894     }
3895
3896     return m_pData->m_xTitleHelper;
3897 }
3898
3899
3900 Reference< frame::XUntitledNumbers > SfxBaseModel::impl_getUntitledHelper ()
3901 {
3902     SfxModelGuard aGuard( *this );
3903
3904     if ( ! m_pData->m_xNumberedControllers.is ())
3905     {
3906         Reference< frame::XModel > xThis   (static_cast< frame::XModel* >(this), UNO_QUERY_THROW);
3907         ::comphelper::NumberedCollection*         pHelper = new ::comphelper::NumberedCollection();
3908
3909         m_pData->m_xNumberedControllers.set(static_cast< ::cppu::OWeakObject* >(pHelper), UNO_QUERY_THROW);
3910
3911         pHelper->setOwner          (xThis);
3912         pHelper->setUntitledPrefix (" : ");
3913     }
3914
3915     return m_pData->m_xNumberedControllers;
3916 }
3917
3918
3919 // css.frame.XTitle
3920 OUString SAL_CALL SfxBaseModel::getTitle()
3921 {
3922     // SYNCHRONIZED ->
3923     SfxModelGuard aGuard( *this );
3924
3925     OUString aResult = impl_getTitleHelper()->getTitle ();
3926     if ( !m_pData->m_bExternalTitle && m_pData->m_pObjectShell )
3927     {
3928         SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium();
3929         if ( pMedium )
3930         {
3931             try {
3932                 ::ucbhelper::Content aContent( pMedium->GetName(),
3933                     utl::UCBContentHelper::getDefaultCommandEnvironment(),
3934                     comphelper::getProcessComponentContext() );
3935                 const Reference < beans::XPropertySetInfo > xProps
3936                      = aContent.getProperties();
3937                 if ( xProps.is() )
3938                 {
3939                     const OUString aServerTitle( "TitleOnServer" );
3940                     if ( xProps->hasPropertyByName( aServerTitle ) )
3941                     {
3942                         Any aAny = aContent.getPropertyValue( aServerTitle );
3943                         aAny >>= aResult;
3944                     }
3945                 }
3946             }
3947             catch (const ucb::ContentCreationException &)
3948             {
3949             }
3950             catch (const ucb::CommandAbortedException &)
3951             {
3952             }
3953             const SfxBoolItem* pRepairedDocItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_REPAIRPACKAGE, false);
3954             if ( pRepairedDocItem && pRepairedDocItem->GetValue() )
3955                 aResult += SfxResId(STR_REPAIREDDOCUMENT);
3956         }
3957
3958         if ( m_pData->m_pObjectShell->IsReadOnlyUI() || (pMedium && pMedium->IsReadOnly()) )
3959             aResult += SfxResId(STR_READONLY);
3960         else if ( m_pData->m_pObjectShell->IsDocShared() )
3961             aResult += SfxResId(STR_SHARED);
3962
3963         if ( m_pData->m_pObjectShell->GetDocumentSignatureState() == SignatureState::OK )
3964             aResult += SfxResId(RID_XMLSEC_DOCUMENTSIGNED);
3965     }
3966
3967     return aResult;
3968 }
3969
3970
3971 // css.frame.XTitle
3972 void SAL_CALL SfxBaseModel::setTitle( const OUString& sTitle )
3973 {
3974     // SYNCHRONIZED ->
3975     SfxModelGuard aGuard( *this );
3976
3977     impl_getTitleHelper()->setTitle (sTitle);
3978     m_pData->m_bExternalTitle = true;
3979 }
3980
3981
3982 // css.frame.XTitleChangeBroadcaster
3983 void SAL_CALL SfxBaseModel::addTitleChangeListener( const Reference< frame::XTitleChangeListener >& xListener )
3984 {
3985     // SYNCHRONIZED ->
3986     SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING );
3987
3988     Reference< frame::XTitleChangeBroadcaster > xBroadcaster(impl_getTitleHelper(), UNO_QUERY);
3989     if (xBroadcaster.is ())
3990         xBroadcaster->addTitleChangeListener (xListener);
3991 }
3992
3993
3994 // css.frame.XTitleChangeBroadcaster
3995 void SAL_CALL SfxBaseModel::removeTitleChangeListener( const Reference< frame::XTitleChangeListener >& xListener )
3996 {
3997     // SYNCHRONIZED ->
3998     SfxModelGuard aGuard( *this );
3999
4000     Reference< frame::XTitleChangeBroadcaster > xBroadcaster(impl_getTitleHelper(), UNO_QUERY);
4001     if (xBroadcaster.is ())
4002         xBroadcaster->removeTitleChangeListener (xListener);
4003 }
4004
4005
4006 // css.frame.XUntitledNumbers
4007 ::sal_Int32 SAL_CALL SfxBaseModel::leaseNumber( const Reference< XInterface >& xComponent )
4008 {
4009     SfxModelGuard aGuard( *this );
4010
4011     return impl_getUntitledHelper ()->leaseNumber (xComponent);
4012 }
4013
4014
4015 // css.frame.XUntitledNumbers
4016 void SAL_CALL SfxBaseModel::releaseNumber( ::sal_Int32 nNumber )
4017 {
4018     SfxModelGuard aGuard( *this );
4019     impl_getUntitledHelper ()->releaseNumber (nNumber);
4020 }
4021
4022
4023 // css.frame.XUntitledNumbers
4024 void SAL_CALL SfxBaseModel::releaseNumberForComponent( const Reference< XInterface >& xComponent )
4025 {
4026     SfxModelGuard aGuard( *this );
4027     impl_getUntitledHelper ()->releaseNumberForComponent (xComponent);
4028 }
4029
4030
4031 // css.frame.XUntitledNumbers
4032 OUString SAL_CALL SfxBaseModel::getUntitledPrefix()
4033 {
4034     SfxModelGuard aGuard( *this );
4035     return impl_getUntitledHelper ()->getUntitledPrefix ();
4036 }
4037
4038
4039 // frame::XModel2
4040 Reference< container::XEnumeration > SAL_CALL SfxBaseModel::getControllers()
4041 {
4042     SfxModelGuard aGuard( *this );
4043
4044     sal_Int32 c = m_pData->m_seqControllers.size();
4045     sal_Int32 i = 0;
4046     Sequence< Any > lEnum(c);
4047     for (i=0; i<c; ++i)
4048         lEnum[i] <<= m_pData->m_seqControllers[i];
4049
4050     ::comphelper::OAnyEnumeration*                      pEnum = new ::comphelper::OAnyEnumeration(lEnum);
4051     Reference< container::XEnumeration > xEnum(static_cast< container::XEnumeration* >(pEnum), UNO_QUERY_THROW);
4052     return xEnum;
4053 }
4054
4055
4056 // frame::XModel2
4057 Sequence< OUString > SAL_CALL SfxBaseModel::getAvailableViewControllerNames()
4058 {
4059     SfxModelGuard aGuard( *this );
4060
4061     const SfxObjectFactory& rDocumentFactory = GetObjectShell()->GetFactory();
4062     const sal_Int16 nViewFactoryCount = rDocumentFactory.GetViewFactoryCount();
4063
4064     Sequence< OUString > aViewNames( nViewFactoryCount );
4065     for ( sal_Int16 nViewNo = 0; nViewNo < nViewFactoryCount; ++nViewNo )
4066         aViewNames[nViewNo] = rDocumentFactory.GetViewFactory( nViewNo ).GetAPIViewName();
4067     return aViewNames;
4068 }
4069
4070
4071 // frame::XModel2
4072 Reference< frame::XController2 > SAL_CALL SfxBaseModel::createDefaultViewController( const Reference< frame::XFrame >& i_rFrame )
4073 {
4074     SfxModelGuard aGuard( *this );
4075
4076     const SfxObjectFactory& rDocumentFactory = GetObjectShell()->GetFactory();
4077     const OUString sDefaultViewName = rDocumentFactory.GetViewFactory().GetAPIViewName();
4078
4079     aGuard.clear();
4080
4081     return createViewController( sDefaultViewName, Sequence< PropertyValue >(), i_rFrame );
4082 }
4083
4084
4085 namespace sfx::intern {
4086
4087     /** a class which, in its dtor, cleans up various objects (well, at the moment only the frame) collected during
4088         the creation of a document view, unless the creation was successful.
4089     */
4090     class ViewCreationGuard
4091     {
4092     public:
4093         ViewCreationGuard()
4094             :m_bSuccess( false )
4095         {
4096         }
4097
4098         ~ViewCreationGuard()
4099         {
4100             if ( !m_bSuccess && m_aWeakFrame && !m_aWeakFrame->GetCurrentDocument() )
4101             {
4102                 m_aWeakFrame->SetFrameInterface_Impl( nullptr );
4103                 m_aWeakFrame->DoClose();
4104             }
4105         }
4106
4107         void takeFrameOwnership( SfxFrame* i_pFrame )
4108         {
4109             OSL_PRECOND( !m_aWeakFrame, "ViewCreationGuard::takeFrameOwnership: already have a frame!" );
4110             OSL_PRECOND( i_pFrame != nullptr, "ViewCreationGuard::takeFrameOwnership: invalid frame!" );
4111             m_aWeakFrame = i_pFrame;
4112         }
4113
4114         void    releaseAll()
4115         {
4116             m_bSuccess = true;
4117         }
4118
4119     private:
4120         bool             m_bSuccess;
4121         SfxFrameWeakRef  m_aWeakFrame;
4122     };
4123 }
4124
4125
4126 SfxViewFrame* SfxBaseModel::FindOrCreateViewFrame_Impl( const Reference< XFrame >& i_rFrame, ::sfx::intern::ViewCreationGuard& i_rGuard ) const
4127 {
4128     SfxViewFrame* pViewFrame = nullptr;
4129     for (   pViewFrame = SfxViewFrame::GetFirst( GetObjectShell(), false );
4130             pViewFrame;
4131             pViewFrame= SfxViewFrame::GetNext( *pViewFrame, GetObjectShell(), false )
4132         )
4133     {
4134         if ( pViewFrame->GetFrame().GetFrameInterface() == i_rFrame )
4135             break;
4136     }
4137     if ( !pViewFrame )
4138     {
4139     #if OSL_DEBUG_LEVEL > 0
4140         for (   SfxFrame* pCheckFrame = SfxFrame::GetFirst();
4141                 pCheckFrame;
4142                 pCheckFrame = SfxFrame::GetNext( *pCheckFrame )
4143              )
4144         {
4145             if ( pCheckFrame->GetFrameInterface() == i_rFrame )
4146             {
4147                 if  (   ( pCheckFrame->GetCurrentViewFrame() != nullptr )
4148                     ||  ( pCheckFrame->GetCurrentDocument() != nullptr )
4149                     )
4150                     // Note that it is perfectly legitimate that during loading into an XFrame which already contains
4151                     // a document, there exist two SfxFrame instances bound to this XFrame - the old one, which will be
4152                     // destroyed later, and the new one, which we're going to create
4153                     continue;
4154
4155                 OSL_FAIL( "SfxBaseModel::FindOrCreateViewFrame_Impl: there already is an SfxFrame for the given XFrame, but no view in it!" );
4156                     // nowadays, we're the only instance allowed to create an SfxFrame for an XFrame, so this case here should not happen
4157                 break;
4158             }
4159         }
4160     #endif
4161
4162         SfxFrame* pTargetFrame = SfxFrame::Create( i_rFrame );
4163         ENSURE_OR_THROW( pTargetFrame, "could not create an SfxFrame" );
4164         i_rGuard.takeFrameOwnership( pTargetFrame );
4165
4166         // prepare it
4167         pTargetFrame->PrepareForDoc_Impl( *GetObjectShell() );
4168
4169         // create view frame
4170         pViewFrame = new SfxViewFrame( *pTargetFrame, GetObjectShell() );
4171     }
4172     return pViewFrame;
4173 }
4174
4175
4176 // frame::XModel2
4177 Reference< frame::XController2 > SAL_CALL SfxBaseModel::createViewController(
4178         const OUString& i_rViewName, const Sequence< PropertyValue >& i_rArguments, const Reference< XFrame >& i_rFrame )
4179 {
4180     SfxModelGuard aGuard( *this );
4181
4182     if ( !i_rFrame.is() )
4183         throw lang::IllegalArgumentException( OUString(), *this, 3 );
4184
4185     // find the proper SFX view factory
4186     SfxViewFactory* pViewFactory = GetObjectShell()->GetFactory().GetViewFactoryByViewName( i_rViewName );
4187     if ( !pViewFactory )
4188         throw IllegalArgumentException( OUString(), *this, 1 );
4189
4190     // determine previous shell (used in some special cases)
4191     Reference< XController > xPreviousController( i_rFrame->getController() );
4192     const Reference< XModel > xMe( this );
4193     if  (   ( xPreviousController.is() )
4194         &&  ( xMe != xPreviousController->getModel() )
4195         )
4196     {
4197         xPreviousController.clear();
4198     }
4199     SfxViewShell* pOldViewShell = SfxViewShell::Get( xPreviousController );
4200     OSL_ENSURE( !xPreviousController.is() || ( pOldViewShell != nullptr ),
4201         "SfxBaseModel::createViewController: invalid old controller!" );
4202
4203     // a guard which will clean up in case of failure
4204     ::sfx::intern::ViewCreationGuard aViewCreationGuard;
4205
4206     // determine the ViewFrame belonging to the given XFrame
4207     SfxViewFrame* pViewFrame = FindOrCreateViewFrame_Impl( i_rFrame, aViewCreationGuard );
4208     SAL_WARN_IF( !pViewFrame , "sfx.doc", "SfxBaseModel::createViewController: no frame?" );
4209
4210     // delegate to SFX' view factory
4211     pViewFrame->GetBindings().ENTERREGISTRATIONS();
4212     SfxViewShell* pViewShell = pViewFactory->CreateInstance( pViewFrame, pOldViewShell );
4213     pViewFrame->GetBindings().LEAVEREGISTRATIONS();
4214     ENSURE_OR_THROW( pViewShell, "invalid view shell provided by factory" );
4215
4216     // by setting the ViewShell it is prevented that disposing the Controller will destroy this ViewFrame also
4217     pViewFrame->GetDispatcher()->SetDisableFlags( SfxDisableFlags::NONE );
4218     pViewFrame->SetViewShell_Impl( pViewShell );
4219
4220     // remember ViewID
4221     pViewFrame->SetCurViewId_Impl( pViewFactory->GetOrdinal() );
4222
4223     // ensure a default controller, if the view shell did not provide an own implementation
4224     if ( !pViewShell->GetController().is() )
4225         pViewShell->SetController( new SfxBaseController( pViewShell ) );
4226
4227     // pass the creation arguments to the controller
4228     SfxBaseController* pBaseController = pViewShell->GetBaseController_Impl();
4229     ENSURE_OR_THROW( pBaseController, "invalid controller implementation!" );
4230     pBaseController->SetCreationArguments_Impl( i_rArguments );
4231
4232     // some initial view settings, coming from our most recent attachResource call
4233     ::comphelper::NamedValueCollection aDocumentLoadArgs( getArgs() );
4234     if ( aDocumentLoadArgs.getOrDefault( "ViewOnly", false ) )
4235         pViewFrame->GetFrame().SetMenuBarOn_Impl( false );
4236
4237     const sal_Int16 nPluginMode = aDocumentLoadArgs.getOrDefault( "PluginMode", sal_Int16( 0 ) );
4238     if ( nPluginMode == 1 )
4239     {
4240         pViewFrame->ForceOuterResize_Impl();
4241         pViewFrame->GetBindings().HidePopups();
4242
4243         SfxFrame& rFrame = pViewFrame->GetFrame();
4244         // MBA: layoutmanager of inplace frame starts locked and invisible
4245         rFrame.GetWorkWindow_Impl()->MakeVisible_Impl( false );
4246         rFrame.GetWorkWindow_Impl()->Lock_Impl( true );
4247
4248         rFrame.GetWindow().SetBorderStyle( WindowBorderStyle::NOBORDER );
4249         pViewFrame->GetWindow().SetBorderStyle( WindowBorderStyle::NOBORDER );
4250     }
4251
4252     // tell the guard we were successful
4253     aViewCreationGuard.releaseAll();
4254
4255     // outta here
4256     return pBaseController;
4257 }
4258
4259
4260 // RDF DocumentMetadataAccess
4261
4262 // rdf::XRepositorySupplier:
4263 Reference< rdf::XRepository > SAL_CALL
4264 SfxBaseModel::getRDFRepository()
4265 {
4266     SfxModelGuard aGuard( *this );
4267
4268     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4269     if (!xDMA.is()) {
4270         throw RuntimeException( "model has no document metadata", *this );
4271     }
4272
4273     return xDMA->getRDFRepository();
4274 }
4275
4276 // rdf::XNode:
4277 OUString SAL_CALL
4278 SfxBaseModel::getStringValue()
4279 {
4280     SfxModelGuard aGuard( *this );
4281
4282     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4283     if (!xDMA.is()) {
4284         throw RuntimeException( "model has no document metadata", *this );
4285     }
4286
4287     return xDMA->getStringValue();
4288 }
4289
4290 // rdf::XURI:
4291 OUString SAL_CALL
4292 SfxBaseModel::getNamespace()
4293 {
4294     SfxModelGuard aGuard( *this );
4295
4296     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4297     if (!xDMA.is()) {
4298         throw RuntimeException( "model has no document metadata", *this );
4299     }
4300
4301     return xDMA->getNamespace();
4302 }
4303
4304 OUString SAL_CALL
4305 SfxBaseModel::getLocalName()
4306 {
4307     SfxModelGuard aGuard( *this );
4308
4309     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4310     if (!xDMA.is()) {
4311         throw RuntimeException( "model has no document metadata", *this );
4312     }
4313
4314     return xDMA->getLocalName();
4315 }
4316
4317 // rdf::XDocumentMetadataAccess:
4318 Reference< rdf::XMetadatable > SAL_CALL
4319 SfxBaseModel::getElementByMetadataReference(
4320     const beans::StringPair & i_rReference)
4321 {
4322     SfxModelGuard aGuard( *this );
4323
4324     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4325     if (!xDMA.is()) {
4326         throw RuntimeException( "model has no document metadata", *this );
4327     }
4328
4329     return xDMA->getElementByMetadataReference(i_rReference);
4330 }
4331
4332 Reference< rdf::XMetadatable > SAL_CALL
4333 SfxBaseModel::getElementByURI(const Reference< rdf::XURI > & i_xURI)
4334 {
4335     SfxModelGuard aGuard( *this );
4336
4337     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4338     if (!xDMA.is()) {
4339         throw RuntimeException( "model has no document metadata", *this );
4340     }
4341
4342     return xDMA->getElementByURI(i_xURI);
4343 }
4344
4345 Sequence< Reference< rdf::XURI > > SAL_CALL
4346 SfxBaseModel::getMetadataGraphsWithType(
4347     const Reference<rdf::XURI> & i_xType)
4348 {
4349     SfxModelGuard aGuard( *this );
4350
4351     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4352     if (!xDMA.is()) {
4353         throw RuntimeException( "model has no document metadata", *this );
4354     }
4355
4356     return xDMA->getMetadataGraphsWithType(i_xType);
4357 }
4358
4359 Reference<rdf::XURI> SAL_CALL
4360 SfxBaseModel::addMetadataFile(const OUString & i_rFileName,
4361     const Sequence < Reference< rdf::XURI > > & i_rTypes)
4362 {
4363     SfxModelGuard aGuard( *this );
4364
4365     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4366     if (!xDMA.is()) {
4367         throw RuntimeException( "model has no document metadata", *this );
4368     }
4369
4370     return xDMA->addMetadataFile(i_rFileName, i_rTypes);
4371 }
4372
4373 Reference<rdf::XURI> SAL_CALL
4374 SfxBaseModel::importMetadataFile(::sal_Int16 i_Format,
4375     const Reference< io::XInputStream > & i_xInStream,
4376     const OUString & i_rFileName,
4377     const Reference< rdf::XURI > & i_xBaseURI,
4378     const Sequence < Reference< rdf::XURI > > & i_rTypes)
4379 {
4380     SfxModelGuard aGuard( *this );
4381
4382     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4383     if (!xDMA.is()) {
4384         throw RuntimeException( "model has no document metadata", *this );
4385     }
4386
4387     return xDMA->importMetadataFile(i_Format,
4388         i_xInStream, i_rFileName, i_xBaseURI, i_rTypes);
4389 }
4390
4391 void SAL_CALL
4392 SfxBaseModel::removeMetadataFile(
4393     const Reference< rdf::XURI > & i_xGraphName)
4394 {
4395     SfxModelGuard aGuard( *this );
4396
4397     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4398     if (!xDMA.is()) {
4399         throw RuntimeException( "model has no document metadata", *this );
4400     }
4401
4402     return xDMA->removeMetadataFile(i_xGraphName);
4403 }
4404
4405 void SAL_CALL
4406 SfxBaseModel::addContentOrStylesFile(const OUString & i_rFileName)
4407 {
4408     SfxModelGuard aGuard( *this );
4409
4410     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4411     if (!xDMA.is()) {
4412         throw RuntimeException( "model has no document metadata", *this );
4413     }
4414
4415     return xDMA->addContentOrStylesFile(i_rFileName);
4416 }
4417
4418 void SAL_CALL
4419 SfxBaseModel::removeContentOrStylesFile(const OUString & i_rFileName)
4420 {
4421     SfxModelGuard aGuard( *this );
4422
4423     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4424     if (!xDMA.is()) {
4425         throw RuntimeException( "model has no document metadata", *this );
4426     }
4427
4428     return xDMA->removeContentOrStylesFile(i_rFileName);
4429 }
4430
4431 void SAL_CALL
4432 SfxBaseModel::loadMetadataFromStorage(
4433     Reference< embed::XStorage > const & i_xStorage,
4434     Reference<rdf::XURI> const & i_xBaseURI,
4435     Reference<task::XInteractionHandler> const & i_xHandler)
4436 {
4437     SfxModelGuard aGuard( *this );
4438
4439     const Reference<rdf::XDocumentMetadataAccess> xDMA(
4440         m_pData->CreateDMAUninitialized());
4441     if (!xDMA.is()) {
4442         throw RuntimeException( "model has no document metadata", *this );
4443     }
4444
4445     try {
4446         xDMA->loadMetadataFromStorage(i_xStorage, i_xBaseURI, i_xHandler);
4447     } catch (lang::IllegalArgumentException &) {
4448         throw; // not initialized
4449     } catch (Exception &) {
4450         // UGLY: if it's a RuntimeException, we can't be sure DMA is initialized
4451         m_pData->m_xDocumentMetadata = xDMA;
4452         throw;
4453     }
4454     m_pData->m_xDocumentMetadata = xDMA;
4455
4456 }
4457
4458 void SAL_CALL
4459 SfxBaseModel::storeMetadataToStorage(
4460     Reference< embed::XStorage > const & i_xStorage)
4461 {
4462     SfxModelGuard aGuard( *this );
4463
4464     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4465     if (!xDMA.is()) {
4466         throw RuntimeException( "model has no document metadata", *this );
4467     }
4468
4469     return xDMA->storeMetadataToStorage(i_xStorage);
4470 }
4471
4472 void SAL_CALL
4473 SfxBaseModel::loadMetadataFromMedium(
4474     const Sequence< beans::PropertyValue > & i_rMedium)
4475 {
4476     SfxModelGuard aGuard( *this );
4477
4478     const Reference<rdf::XDocumentMetadataAccess> xDMA(
4479         m_pData->CreateDMAUninitialized());
4480     if (!xDMA.is()) {
4481         throw RuntimeException( "model has no document metadata", *this );
4482     }
4483
4484     try {
4485         xDMA->loadMetadataFromMedium(i_rMedium);
4486     } catch (lang::IllegalArgumentException &) {
4487         throw; // not initialized
4488     } catch (Exception &) {
4489         // UGLY: if it's a RuntimeException, we can't be sure DMA is initialized
4490         m_pData->m_xDocumentMetadata = xDMA;
4491         throw;
4492     }
4493     m_pData->m_xDocumentMetadata = xDMA;
4494 }
4495
4496 void SAL_CALL
4497 SfxBaseModel::storeMetadataToMedium(
4498     const Sequence< beans::PropertyValue > & i_rMedium)
4499 {
4500     SfxModelGuard aGuard( *this );
4501
4502     const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA());
4503     if (!xDMA.is()) {
4504         throw RuntimeException( "model has no document metadata", *this );
4505     }
4506
4507     return xDMA->storeMetadataToMedium(i_rMedium);
4508 }
4509
4510
4511 // = SfxModelSubComponent
4512
4513
4514 SfxModelSubComponent::~SfxModelSubComponent()
4515 {
4516 }
4517
4518 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */