Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1920 insertions, 0 deletions

diff --git a/sfx2/source/doc/objmisc.cxx b/sfx2/source/doc/objmisc.cxx
new file mode 100644
index 000000000..873ab8b9b
--- /dev/null
+++ b/sfx2/source/doc/objmisc.cxx
@@ -0,0 +1,1920 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_features.h>
+
+#include <tools/inetmsg.hxx>
+#include <tools/diagnose_ex.h>
+#include <svl/eitem.hxx>
+#include <svl/stritem.hxx>
+#include <svl/intitem.hxx>
+#include <svtools/svparser.hxx>
+#include <cppuhelper/exc_hlp.hxx>
+#include <sal/log.hxx>
+#include <o3tl/string_view.hxx>
+
+#include <com/sun/star/awt/XTopWindow.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/container/XChild.hpp>
+#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
+#include <com/sun/star/document/XDocumentProperties.hpp>
+#include <com/sun/star/document/MacroExecMode.hpp>
+#include <com/sun/star/document/XScriptInvocationContext.hpp>
+#include <com/sun/star/embed/EmbedStates.hpp>
+#include <com/sun/star/embed/XEmbeddedObject.hpp>
+#include <com/sun/star/script/provider/theMasterScriptProviderFactory.hpp>
+#include <com/sun/star/script/provider/XScript.hpp>
+#include <com/sun/star/script/provider/XScriptProvider.hpp>
+#include <com/sun/star/script/provider/XScriptProviderSupplier.hpp>
+#include <com/sun/star/uri/UriReferenceFactory.hpp>
+#include <com/sun/star/uri/XVndSunStarScriptUrl.hpp>
+#include <com/sun/star/util/XModifiable.hpp>
+
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/uno/Any.h>
+#include <com/sun/star/task/ErrorCodeRequest.hpp>
+
+#include <comphelper/processfactory.hxx>
+#include <comphelper/string.hxx>
+
+#include <com/sun/star/security/DocumentDigitalSignatures.hpp>
+#include <com/sun/star/task/DocumentMacroConfirmationRequest.hpp>
+#include <com/sun/star/task/InteractionClassification.hpp>
+#include <com/sun/star/task/XInteractionHandler.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+
+#include <basic/basmgr.hxx>
+#include <basic/sberrors.hxx>
+#include <vcl/weld.hxx>
+#include <basic/sbx.hxx>
+#include <svtools/sfxecode.hxx>
+
+#include <unotools/ucbhelper.hxx>
+#include <tools/urlobj.hxx>
+#include <svl/sharecontrolfile.hxx>
+#include <rtl/uri.hxx>
+#include <vcl/svapp.hxx>
+#include <framework/interaction.hxx>
+#include <framework/documentundoguard.hxx>
+#include <comphelper/interaction.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <comphelper/documentconstants.hxx>
+#include <comphelper/namedvaluecollection.hxx>
+#include <officecfg/Office/Common.hxx>
+
+#include <sfx2/signaturestate.hxx>
+#include <sfx2/app.hxx>
+#include <appdata.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/objsh.hxx>
+#include <objshimp.hxx>
+#include <sfx2/event.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/sfxuno.hxx>
+#include <sfx2/module.hxx>
+#include <sfx2/docfac.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/strings.hrc>
+#include <workwin.hxx>
+#include <sfx2/sfxdlg.hxx>
+#include <sfx2/infobar.hxx>
+#include <sfx2/sfxbasemodel.hxx>
+#include <openflag.hxx>
+#include "objstor.hxx"
+#include <appopen.hxx>
+
+#include <memory>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::ucb;
+using namespace ::com::sun::star::document;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::script;
+using namespace ::com::sun::star::script::provider;
+using namespace ::com::sun::star::container;
+
+// class SfxHeaderAttributes_Impl ----------------------------------------
+
+namespace {
+
+class SfxHeaderAttributes_Impl : public SvKeyValueIterator
+{
+private:
+    SfxObjectShell* pDoc;
+    SvKeyValueIteratorRef xIter;
+    bool bAlert;
+
+public:
+    explicit SfxHeaderAttributes_Impl( SfxObjectShell* pSh ) :
+         pDoc( pSh ),
+        xIter( pSh->GetMedium()->GetHeaderAttributes_Impl() ),
+        bAlert( false ) {}
+
+    virtual bool GetFirst( SvKeyValue& rKV ) override { return xIter->GetFirst( rKV ); }
+    virtual bool GetNext( SvKeyValue& rKV ) override { return xIter->GetNext( rKV ); }
+    virtual void Append( const SvKeyValue& rKV ) override;
+
+    void ClearForSourceView() { xIter = new SvKeyValueIterator; bAlert = false; }
+    void SetAttributes();
+    void SetAttribute( const SvKeyValue& rKV );
+};
+
+}
+
+sal_uInt16 const aTitleMap_Impl[3][2] =
+{
+                                //  local               remote
+    /*  SFX_TITLE_CAPTION   */  {   SFX_TITLE_FILENAME, SFX_TITLE_TITLE },
+    /*  SFX_TITLE_PICKLIST  */  {   32,                 SFX_TITLE_FULLNAME },
+    /*  SFX_TITLE_HISTORY   */  {   32,                 SFX_TITLE_FULLNAME }
+};
+
+
+bool SfxObjectShell::IsAbortingImport() const
+{
+    return pImpl->bIsAbortingImport;
+}
+
+
+uno::Reference<document::XDocumentProperties>
+SfxObjectShell::getDocProperties() const
+{
+    uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
+        GetModel(), uno::UNO_QUERY_THROW);
+    uno::Reference<document::XDocumentProperties> xDocProps(
+        xDPS->getDocumentProperties());
+    DBG_ASSERT(xDocProps.is(),
+        "SfxObjectShell: model has no DocumentProperties");
+    return xDocProps;
+}
+
+
+void SfxObjectShell::DoFlushDocInfo()
+{
+}
+
+
+// Note: the only thing that calls this is the modification event handler
+// that is installed at the XDocumentProperties
+void SfxObjectShell::FlushDocInfo()
+{
+    if ( IsLoading() )
+        return;
+
+    SetModified();
+    uno::Reference<document::XDocumentProperties> xDocProps(getDocProperties());
+    DoFlushDocInfo(); // call template method
+    const OUString url(xDocProps->getAutoloadURL());
+    sal_Int32 delay(xDocProps->getAutoloadSecs());
+    SetAutoLoad( INetURLObject(url), delay * 1000,
+                 (delay > 0) || !url.isEmpty() );
+}
+
+void SfxObjectShell::AppendInfoBarWhenReady(const OUString& sId, const OUString& sPrimaryMessage,
+                                          const OUString& sSecondaryMessage,
+                                          InfobarType aInfobarType, bool bShowCloseButton)
+{
+    InfobarData aInfobarData;
+    aInfobarData.msId = sId;
+    aInfobarData.msPrimaryMessage = sPrimaryMessage;
+    aInfobarData.msSecondaryMessage = sSecondaryMessage;
+    aInfobarData.maInfobarType = aInfobarType;
+    aInfobarData.mbShowCloseButton = bShowCloseButton;
+    Get_Impl()->m_aPendingInfobars.emplace_back(aInfobarData);
+}
+
+std::vector<InfobarData>& SfxObjectShell::getPendingInfobars()
+{
+    return Get_Impl()->m_aPendingInfobars;
+}
+
+void SfxObjectShell::SetError(ErrCode lErr)
+{
+    if (pImpl->lErr==ERRCODE_NONE)
+    {
+        pImpl->lErr=lErr;
+    }
+}
+
+ErrCode SfxObjectShell::GetError() const
+{
+    return GetErrorCode().IgnoreWarning();
+}
+
+ErrCode SfxObjectShell::GetErrorCode() const
+{
+    ErrCode lError=pImpl->lErr;
+    if(!lError && GetMedium())
+        lError=GetMedium()->GetErrorCode();
+    return lError;
+}
+
+void SfxObjectShell::ResetError()
+{
+    pImpl->lErr=ERRCODE_NONE;
+    SfxMedium * pMed = GetMedium();
+    if( pMed )
+        pMed->ResetError();
+}
+
+void SfxObjectShell::EnableSetModified( bool bEnable )
+{
+    SAL_INFO_IF( bEnable == pImpl->m_bEnableSetModified, "sfx", "SFX_PERSIST: EnableSetModified 2x called with the same value" );
+    pImpl->m_bEnableSetModified = bEnable;
+}
+
+
+bool SfxObjectShell::IsEnableSetModified() const
+{
+    return pImpl->m_bEnableSetModified && !IsReadOnly();
+}
+
+
+bool SfxObjectShell::IsModified() const
+{
+    if ( pImpl->m_bIsModified )
+        return true;
+
+    if ( !pImpl->m_xDocStorage.is() || IsReadOnly() )
+    {
+        // if the document still has no storage and is not set to be modified explicitly it is not modified
+        // a readonly document is also not modified
+
+        return false;
+    }
+
+    if (pImpl->mxObjectContainer)
+    {
+        const uno::Sequence < OUString > aNames = GetEmbeddedObjectContainer().GetObjectNames();
+        for ( const auto& rName : aNames )
+        {
+            uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObjectContainer().GetEmbeddedObject( rName );
+            OSL_ENSURE( xObj.is(), "An empty entry in the embedded objects list!" );
+            if ( xObj.is() )
+            {
+                try
+                {
+                    sal_Int32 nState = xObj->getCurrentState();
+                    if ( nState != embed::EmbedStates::LOADED )
+                    {
+                        uno::Reference< util::XModifiable > xModifiable( xObj->getComponent(), uno::UNO_QUERY );
+                        if ( xModifiable.is() && xModifiable->isModified() )
+                            return true;
+                    }
+                }
+                catch( uno::Exception& )
+                {}
+            }
+        }
+    }
+
+    return false;
+}
+
+
+void SfxObjectShell::SetModified( bool bModifiedP )
+{
+    SAL_INFO_IF( !bModifiedP && !IsEnableSetModified(), "sfx",
+        "SFX_PERSIST: SetModified( sal_False ), although IsEnableSetModified() == sal_False" );
+
+    if( !IsEnableSetModified() )
+        return;
+
+    if( pImpl->m_bIsModified != bModifiedP )
+    {
+        pImpl->m_bIsModified = bModifiedP;
+        ModifyChanged();
+    }
+}
+
+
+void SfxObjectShell::ModifyChanged()
+{
+    if ( pImpl->bClosing )
+        // SetModified dispose of the models!
+        return;
+
+
+    SfxViewFrame* pViewFrame = SfxViewFrame::Current();
+    if ( pViewFrame )
+        pViewFrame->GetBindings().Invalidate( SID_SAVEDOCS );
+
+    Invalidate( SID_SIGNATURE );
+    Invalidate( SID_MACRO_SIGNATURE );
+    Broadcast( SfxHint( SfxHintId::TitleChanged ) );    // xmlsec05, signed state might change in title...
+
+    SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::ModifyChanged, GlobalEventConfig::GetEventName(GlobalEventId::MODIFYCHANGED), this ) );
+}
+
+
+bool SfxObjectShell::IsReadOnlyUI() const
+
+/*  [Description]
+
+    Returns sal_True if the document for the UI is treated as r/o. This is
+    regardless of the actual r/o, which can be checked with <IsReadOnly()>.
+*/
+
+{
+    return pImpl->bReadOnlyUI;
+}
+
+
+bool SfxObjectShell::IsReadOnlyMedium() const
+
+/*  [Description]
+
+    Returns sal_True when the medium is r/o, for instance when opened as r/o.
+*/
+
+{
+    if ( !pMedium )
+        return true;
+    return pMedium->IsReadOnly();
+}
+
+bool SfxObjectShell::IsOriginallyReadOnlyMedium() const
+{
+    return pMedium == nullptr || pMedium->IsOriginallyReadOnly();
+}
+
+bool SfxObjectShell::IsOriginallyLoadedReadOnlyMedium() const
+{
+    return pMedium != nullptr && pMedium->IsOriginallyLoadedReadOnly();
+}
+
+
+void SfxObjectShell::SetReadOnlyUI( bool bReadOnly )
+
+/*  [Description]
+
+    Turns the document in a r/o and r/w state respectively without reloading
+    it and without changing the open mode of the medium.
+*/
+
+{
+    if ( bReadOnly != pImpl->bReadOnlyUI )
+    {
+        pImpl->bReadOnlyUI = bReadOnly;
+        Broadcast( SfxHint(SfxHintId::ModeChanged) );
+    }
+}
+
+
+void SfxObjectShell::SetReadOnly()
+{
+    // Let the document be completely readonly, means that the
+    // medium open mode is adjusted accordingly, and the write lock
+    // on the file is removed.
+
+    if ( !pMedium || IsReadOnlyMedium() )
+        return;
+
+    bool bWasROUI = IsReadOnly();
+
+    pMedium->UnlockFile( false );
+
+    // the storage-based mediums are already based on the temporary file
+    // so UnlockFile has already closed the locking stream
+    if ( !pMedium->HasStorage_Impl() && IsLoadingFinished() )
+        pMedium->CloseInStream();
+
+    pMedium->SetOpenMode( SFX_STREAM_READONLY, true );
+    pMedium->GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
+
+    if ( !bWasROUI )
+        Broadcast( SfxHint(SfxHintId::ModeChanged) );
+}
+
+
+bool SfxObjectShell::IsReadOnly() const
+{
+    return pImpl->bReadOnlyUI || pMedium == nullptr;
+}
+
+
+bool SfxObjectShell::IsInModalMode() const
+{
+    return pImpl->bModalMode || pImpl->bRunningMacro;
+}
+
+bool SfxObjectShell::AcceptStateUpdate() const
+{
+    return !IsInModalMode();
+}
+
+
+void SfxObjectShell::SetMacroMode_Impl( bool bModal )
+{
+    if ( !pImpl->bRunningMacro != !bModal )
+    {
+        pImpl->bRunningMacro = bModal;
+        Broadcast( SfxHint( SfxHintId::ModeChanged ) );
+    }
+}
+
+
+void SfxObjectShell::SetModalMode_Impl( bool bModal )
+{
+    // Broadcast only if modified, or otherwise it will possibly go into
+    // an endless loop
+    if ( pImpl->bModalMode == bModal )
+        return;
+
+    // Central count
+    sal_uInt16 &rDocModalCount = SfxGetpApp()->Get_Impl()->nDocModalMode;
+    if ( bModal )
+        ++rDocModalCount;
+    else
+        --rDocModalCount;
+
+    // Switch
+    pImpl->bModalMode = bModal;
+    Broadcast( SfxHint( SfxHintId::ModeChanged ) );
+}
+
+#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
+
+bool SfxObjectShell::SwitchToShared( bool bShared, bool bSave )
+{
+    bool bResult = true;
+
+    if ( bShared != IsDocShared() )
+    {
+        OUString aOrigURL = GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE );
+
+        if ( aOrigURL.isEmpty() && bSave )
+        {
+            // this is a new document, let it be stored before switching to the shared mode;
+            // the storing should be done without shared flag, since it is possible that the
+            // target location does not allow to create sharing control file;
+            // the shared flag will be set later after creation of sharing control file
+            SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst( this );
+
+            if ( pViewFrame )
+            {
+                // TODO/LATER: currently the application guards against the reentrance problem
+                const SfxPoolItem* pItem = pViewFrame->GetBindings().ExecuteSynchron( HasName() ? SID_SAVEDOC : SID_SAVEASDOC );
+                const SfxBoolItem* pResult = dynamic_cast<const SfxBoolItem*>( pItem  );
+                bResult = ( pResult && pResult->GetValue() );
+                if ( bResult )
+                    aOrigURL = GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE );
+            }
+        }
+
+        bool bOldValue = HasSharedXMLFlagSet();
+        SetSharedXMLFlag( bShared );
+
+        bool bRemoveEntryOnError = false;
+        if ( bResult && bShared )
+        {
+            try
+            {
+                ::svt::ShareControlFile aControlFile( aOrigURL );
+                aControlFile.InsertOwnEntry();
+                bRemoveEntryOnError = true;
+            }
+            catch( uno::Exception& )
+            {
+                bResult = false;
+            }
+        }
+
+        if ( bResult && bSave )
+        {
+            SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst( this );
+
+            if ( pViewFrame )
+            {
+                // TODO/LATER: currently the application guards against the reentrance problem
+                SetModified(); // the modified flag has to be set to let the document be stored with the shared flag
+                try
+                {
+                    // Do *not* use dispatch mechanism in this place - we don't want others (extensions etc.) to intercept this.
+                    pImpl->pBaseModel->store();
+                    bResult = true;
+                }
+                catch (...)
+                {
+                    bResult = false;
+                }
+            }
+        }
+
+        if ( bResult )
+        {
+            // TODO/LATER: Is it possible that the following calls fail?
+            if ( bShared )
+            {
+                pImpl->m_aSharedFileURL = aOrigURL;
+                GetMedium()->SwitchDocumentToTempFile();
+            }
+            else
+            {
+                const OUString aTempFileURL = pMedium->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE );
+                GetMedium()->SwitchDocumentToFile( GetSharedFileURL() );
+                pImpl->m_aSharedFileURL.clear();
+
+                // now remove the temporary file the document was based on
+                ::utl::UCBContentHelper::Kill( aTempFileURL );
+
+                try
+                {
+                    // aOrigURL can not be used since it contains an old value
+                    ::svt::ShareControlFile aControlFile( GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
+                    aControlFile.RemoveFile();
+                }
+                catch( uno::Exception& )
+                {
+                }
+            }
+        }
+        else
+        {
+            // the saving has failed!
+            if ( bRemoveEntryOnError )
+            {
+                try
+                {
+                    ::svt::ShareControlFile aControlFile( aOrigURL );
+                    aControlFile.RemoveEntry();
+                }
+                catch( uno::Exception& )
+                {}
+            }
+
+            SetSharedXMLFlag( bOldValue );
+        }
+    }
+    else
+        bResult = false; // the second switch to the same mode
+
+    if ( bResult )
+        SetTitle( "" );
+
+    return bResult;
+}
+
+
+void SfxObjectShell::FreeSharedFile( const OUString& aTempFileURL )
+{
+    SetSharedXMLFlag( false );
+
+    if ( !IsDocShared() || aTempFileURL.isEmpty()
+      || ::utl::UCBContentHelper::EqualURLs( aTempFileURL, GetSharedFileURL() ) )
+        return;
+
+    if ( pImpl->m_bAllowShareControlFileClean )
+    {
+        try
+        {
+            ::svt::ShareControlFile aControlFile( GetSharedFileURL() );
+            aControlFile.RemoveEntry();
+        }
+        catch( uno::Exception& )
+        {
+        }
+    }
+
+    // the cleaning is forbidden only once
+    pImpl->m_bAllowShareControlFileClean = true;
+
+    // now remove the temporary file the document is based currently on
+    ::utl::UCBContentHelper::Kill( aTempFileURL );
+
+    pImpl->m_aSharedFileURL.clear();
+}
+
+
+void SfxObjectShell::DoNotCleanShareControlFile()
+{
+    pImpl->m_bAllowShareControlFileClean = false;
+}
+
+
+void SfxObjectShell::SetSharedXMLFlag( bool bFlag ) const
+{
+    pImpl->m_bSharedXMLFlag = bFlag;
+}
+
+
+bool SfxObjectShell::HasSharedXMLFlagSet() const
+{
+    return pImpl->m_bSharedXMLFlag;
+}
+
+#endif
+
+bool SfxObjectShell::IsDocShared() const
+{
+#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
+    return ( !pImpl->m_aSharedFileURL.isEmpty() );
+#else
+    return false;
+#endif
+}
+
+
+OUString SfxObjectShell::GetSharedFileURL() const
+{
+#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT
+    return pImpl->m_aSharedFileURL;
+#else
+    return OUString();
+#endif
+}
+
+Size SfxObjectShell::GetFirstPageSize() const
+{
+    return GetVisArea(ASPECT_THUMBNAIL).GetSize();
+}
+
+
+IndexBitSet& SfxObjectShell::GetNoSet_Impl()
+{
+    return pImpl->aBitSet;
+}
+
+
+// changes the title of the document
+
+void SfxObjectShell::SetTitle
+(
+    const OUString& rTitle                // the new Document Title
+)
+
+/*  [Description]
+
+    With this method, the title of the document can be set.
+    This corresponds initially to the full file name. A setting of the
+    title does not affect the file name, but it will be shown in the
+    Caption-Bars of the MDI-window.
+*/
+
+{
+
+    // Nothing to do?
+    if ( ( ( HasName() && pImpl->aTitle == rTitle )
+        || ( !HasName() && GetTitle() == rTitle ) )
+      && !IsDocShared() )
+        return;
+
+    SfxApplication *pSfxApp = SfxGetpApp();
+
+    // If possible release the unnamed number.
+    if ( pImpl->bIsNamedVisible && USHRT_MAX != pImpl->nVisualDocumentNumber )
+    {
+        pSfxApp->ReleaseIndex(pImpl->nVisualDocumentNumber);
+        pImpl->bIsNamedVisible = false;
+    }
+
+    // Set Title
+    pImpl->aTitle = rTitle;
+
+    // Notification
+    if ( GetMedium() )
+    {
+        SfxShell::SetName( GetTitle(SFX_TITLE_APINAME) );
+        Broadcast( SfxHint(SfxHintId::TitleChanged) );
+    }
+}
+
+
+
+OUString SfxObjectShell::GetTitle( sal_uInt16  nMaxLength ) const
+
+/*  [Description]
+
+    Returns the title or logical file name of the document, depending on the
+    'nMaxLength'.
+
+    If the file name with path is used, the Name shortened by replacing one or
+    more directory names with "...", URLs are currently always returned
+    in complete form.
+*/
+
+{
+    SfxMedium *pMed = GetMedium();
+    if ( IsLoading() )
+        return OUString();
+
+    // Create Title?
+    if ( SFX_TITLE_DETECT == nMaxLength && pImpl->aTitle.isEmpty() )
+    {
+        static bool bRecur = false;
+        if ( bRecur )
+            return "-not available-";
+        bRecur = true;
+
+        OUString aTitle;
+
+        if ( pMed )
+        {
+            const SfxStringItem* pNameItem = SfxItemSet::GetItem<SfxStringItem>(pMed->GetItemSet(), SID_DOCINFO_TITLE, false);
+            if ( pNameItem )
+                aTitle = pNameItem->GetValue();
+        }
+
+        if ( aTitle.isEmpty() )
+            aTitle = GetTitle( SFX_TITLE_FILENAME );
+
+        bRecur = false;
+        return aTitle;
+    }
+
+    if (SFX_TITLE_APINAME == nMaxLength )
+        return GetAPIName();
+
+    // Picklist/Caption is mapped
+    if ( pMed && ( nMaxLength == SFX_TITLE_CAPTION || nMaxLength == SFX_TITLE_PICKLIST ) )
+    {
+        // If a specific title was given at open:
+        // important for URLs: use INetProtocol::File for which the set title is not
+        // considered. (See below, analysis of aTitleMap_Impl)
+        const SfxStringItem* pNameItem = SfxItemSet::GetItem<SfxStringItem>(pMed->GetItemSet(), SID_DOCINFO_TITLE, false);
+        if ( pNameItem )
+            return pNameItem->GetValue();
+    }
+
+    // Still unnamed?
+    DBG_ASSERT( !HasName() || pMed, "HasName() but no Medium?!?" );
+    if ( !HasName() || !pMed )
+    {
+        // Title already set?
+        if ( !pImpl->aTitle.isEmpty() )
+            return pImpl->aTitle;
+
+        // must it be numbered?
+        const OUString aNoName(SfxResId(STR_NONAME));
+        if (pImpl->bIsNamedVisible)
+        {
+            // Append number
+            return aNoName + " " + OUString::number(pImpl->nVisualDocumentNumber);
+        }
+
+        // Document called "Untitled" for the time being
+        return aNoName;
+    }
+    assert(pMed);
+
+    const INetURLObject aURL( IsDocShared() ? GetSharedFileURL() : GetMedium()->GetName() );
+    if ( nMaxLength > SFX_TITLE_CAPTION && nMaxLength <= SFX_TITLE_HISTORY )
+    {
+        sal_uInt16 nRemote;
+        if (aURL.GetProtocol() == INetProtocol::File)
+            nRemote = 0;
+        else
+            nRemote = 1;
+        nMaxLength = aTitleMap_Impl[nMaxLength-SFX_TITLE_CAPTION][nRemote];
+    }
+
+    // Local file?
+    if ( aURL.GetProtocol() == INetProtocol::File )
+    {
+        if ( nMaxLength == SFX_TITLE_FULLNAME )
+            return aURL.HasMark() ? INetURLObject( aURL.GetURLNoMark() ).PathToFileName() : aURL.PathToFileName();
+        if ( nMaxLength == SFX_TITLE_FILENAME )
+            return aURL.getName(INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset);
+        if ( pImpl->aTitle.isEmpty() )
+            pImpl->aTitle = aURL.getBase( INetURLObject::LAST_SEGMENT,
+                                         true, INetURLObject::DecodeMechanism::WithCharset );
+    }
+    else
+    {
+        if ( nMaxLength >= SFX_TITLE_MAXLEN )
+        {
+            const OUString aComplete( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
+            if( aComplete.getLength() > nMaxLength )
+                return OUString::Concat("...") + aComplete.subView( aComplete.getLength() - nMaxLength + 3, nMaxLength - 3 );
+            return aComplete;
+        }
+        if ( nMaxLength == SFX_TITLE_FILENAME )
+        {
+            const OUString aName = INetURLObject::decode( aURL.GetBase(), INetURLObject::DecodeMechanism::WithCharset );
+            return aName.isEmpty() ? aURL.GetURLNoPass() : aName;
+        }
+        if ( nMaxLength == SFX_TITLE_FULLNAME )
+            return aURL.GetMainURL( INetURLObject::DecodeMechanism::ToIUri );
+
+        // Generate Title from file name if possible
+        if ( pImpl->aTitle.isEmpty() )
+            pImpl->aTitle = aURL.GetBase();
+
+        // workaround for the case when the name can not be retrieved from URL by INetURLObject
+        if ( pImpl->aTitle.isEmpty() )
+            pImpl->aTitle = aURL.GetMainURL( INetURLObject::DecodeMechanism::WithCharset );
+    }
+
+    // Complete Title
+    return pImpl->aTitle;
+}
+
+
+void SfxObjectShell::InvalidateName()
+
+/*  [Description]
+
+    Returns the title of the new document, DocInfo-Title or
+    File name. Is required for loading from template or SaveAs.
+*/
+
+{
+    pImpl->aTitle.clear();
+    SetName( GetTitle( SFX_TITLE_APINAME ) );
+
+    Broadcast( SfxHint(SfxHintId::TitleChanged) );
+}
+
+
+void SfxObjectShell::SetNamedVisibility_Impl()
+{
+    if ( !pImpl->bIsNamedVisible )
+    {
+        pImpl->bIsNamedVisible = true;
+        if ( !HasName() && USHRT_MAX == pImpl->nVisualDocumentNumber && pImpl->aTitle.isEmpty() )
+        {
+            pImpl->nVisualDocumentNumber = SfxGetpApp()->GetFreeIndex();
+            Broadcast( SfxHint(SfxHintId::TitleChanged) );
+        }
+    }
+
+    SetName( GetTitle(SFX_TITLE_APINAME) );
+}
+
+void SfxObjectShell::SetNoName()
+{
+    bHasName = false;
+    GetModel()->attachResource( OUString(), GetModel()->getArgs() );
+}
+
+
+SfxProgress* SfxObjectShell::GetProgress() const
+{
+    return pImpl->pProgress;
+}
+
+
+void SfxObjectShell::SetProgress_Impl
+(
+    SfxProgress *pProgress      /* to started <SfxProgress> or 0,
+                                   if the progress is to be reset */
+)
+
+/*  [Description]
+
+    Internal method to set or reset the Progress modes for
+    SfxObjectShell.
+*/
+
+{
+    DBG_ASSERT( ( !pImpl->pProgress && pProgress ) ||
+                ( pImpl->pProgress && !pProgress ),
+                "Progress activation/deactivation mismatch" );
+    pImpl->pProgress = pProgress;
+}
+
+
+void SfxObjectShell::PostActivateEvent_Impl( SfxViewFrame const * pFrame )
+{
+    SfxApplication* pSfxApp = SfxGetpApp();
+    if ( pSfxApp->IsDowning() || IsLoading() || !pFrame || pFrame->GetFrame().IsClosing_Impl() )
+        return;
+
+    const SfxBoolItem* pHiddenItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_HIDDEN, false);
+    if ( !pHiddenItem || !pHiddenItem->GetValue() )
+    {
+        SfxEventHintId nId = pImpl->nEventId;
+        pImpl->nEventId = SfxEventHintId::NONE;
+        if ( nId == SfxEventHintId::OpenDoc )
+            pSfxApp->NotifyEvent(SfxViewEventHint( nId, GlobalEventConfig::GetEventName(GlobalEventId::OPENDOC), this, pFrame->GetFrame().GetController() ), false);
+        else if (nId == SfxEventHintId::CreateDoc )
+            pSfxApp->NotifyEvent(SfxViewEventHint( nId, GlobalEventConfig::GetEventName(GlobalEventId::CREATEDOC), this, pFrame->GetFrame().GetController() ), false);
+    }
+}
+
+
+void SfxObjectShell::SetActivateEvent_Impl(SfxEventHintId nId )
+{
+    pImpl->nEventId = nId;
+}
+
+bool SfxObjectShell::IsAutoLoadLocked() const
+
+/* Returns whether an Autoload is allowed to be executed. Before the
+   surrounding FrameSet of the AutoLoad is also taken into account as well.
+*/
+
+{
+    return !IsReadOnly();
+}
+
+
+void SfxObjectShell::BreakMacroSign_Impl( bool bBreakMacroSign )
+{
+    pImpl->m_bMacroSignBroken = bBreakMacroSign;
+}
+
+
+void SfxObjectShell::CheckSecurityOnLoading_Impl()
+{
+    // make sure LO evaluates the macro signatures, so it can be preserved
+    GetScriptingSignatureState();
+
+    uno::Reference< task::XInteractionHandler > xInteraction;
+    if ( GetMedium() )
+        xInteraction = GetMedium()->GetInteractionHandler();
+
+    // check if there is a broken signature...
+    CheckForBrokenDocSignatures_Impl();
+
+    CheckEncryption_Impl( xInteraction );
+
+    // check macro security
+    const bool bHasValidContentSignature = HasValidSignatures();
+    pImpl->aMacroMode.checkMacrosOnLoading( xInteraction, bHasValidContentSignature );
+}
+
+
+void SfxObjectShell::CheckEncryption_Impl( const uno::Reference< task::XInteractionHandler >& xHandler )
+{
+    OUString aVersion;
+    bool bIsEncrypted = false;
+    bool bHasNonEncrypted = false;
+
+    try
+    {
+        uno::Reference < beans::XPropertySet > xPropSet( GetStorage(), uno::UNO_QUERY_THROW );
+        xPropSet->getPropertyValue("Version") >>= aVersion;
+        xPropSet->getPropertyValue("HasEncryptedEntries") >>= bIsEncrypted;
+        xPropSet->getPropertyValue("HasNonEncryptedEntries") >>= bHasNonEncrypted;
+    }
+    catch( uno::Exception& )
+    {
+    }
+
+    if ( aVersion.compareTo( ODFVER_012_TEXT ) < 0 )
+        return;
+
+    // this is ODF1.2 or later
+    if ( !(bIsEncrypted && bHasNonEncrypted) )
+        return;
+
+    if ( !pImpl->m_bIncomplEncrWarnShown )
+    {
+        // this is an encrypted document with nonencrypted streams inside, show the warning
+        css::task::ErrorCodeRequest aErrorCode;
+        aErrorCode.ErrCode = sal_uInt32(ERRCODE_SFX_INCOMPLETE_ENCRYPTION);
+
+        SfxMedium::CallApproveHandler( xHandler, uno::Any( aErrorCode ), false );
+        pImpl->m_bIncomplEncrWarnShown = true;
+    }
+
+    // broken signatures imply no macro execution at all
+    pImpl->aMacroMode.disallowMacroExecution();
+}
+
+
+void SfxObjectShell::CheckForBrokenDocSignatures_Impl()
+{
+    SignatureState nSignatureState = GetDocumentSignatureState();
+    bool bSignatureBroken = ( nSignatureState == SignatureState::BROKEN );
+    if ( !bSignatureBroken )
+        return;
+
+    // broken signatures imply no macro execution at all
+    pImpl->aMacroMode.disallowMacroExecution();
+}
+
+
+void SfxObjectShell::SetAutoLoad(
+    const INetURLObject& rUrl, sal_uInt32 nTime, bool bReload )
+{
+    pImpl->pReloadTimer.reset();
+    if ( bReload )
+    {
+        pImpl->pReloadTimer.reset(new AutoReloadTimer_Impl(
+                                rUrl.GetMainURL( INetURLObject::DecodeMechanism::ToIUri ),
+                                nTime, this ));
+        pImpl->pReloadTimer->Start();
+    }
+}
+
+void SfxObjectShell::SetLoading(SfxLoadedFlags nFlags)
+{
+    pImpl->nLoadedFlags = nFlags;
+}
+
+bool SfxObjectShell::IsLoadingFinished() const
+{
+    return ( pImpl->nLoadedFlags == SfxLoadedFlags::ALL );
+}
+
+void SfxObjectShell::InitOwnModel_Impl()
+{
+    if ( pImpl->bModelInitialized )
+        return;
+
+    const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false);
+    if ( pSalvageItem )
+    {
+        pImpl->aTempName = pMedium->GetPhysicalName();
+        pMedium->GetItemSet()->ClearItem( SID_DOC_SALVAGE );
+        pMedium->GetItemSet()->ClearItem( SID_FILE_NAME );
+        pMedium->GetItemSet()->Put( SfxStringItem( SID_FILE_NAME, pMedium->GetOrigURL() ) );
+    }
+    else
+    {
+        pMedium->GetItemSet()->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL );
+        pMedium->GetItemSet()->ClearItem( SID_DOCUMENT );
+    }
+
+    pMedium->GetItemSet()->ClearItem( SID_REFERER );
+    uno::Reference< frame::XModel >  xModel = GetModel();
+    if ( xModel.is() )
+    {
+        SfxItemSet *pSet = GetMedium()->GetItemSet();
+        if ( !GetMedium()->IsReadOnly() )
+            pSet->ClearItem( SID_INPUTSTREAM );
+        uno::Sequence< beans::PropertyValue > aArgs;
+        TransformItems( SID_OPENDOC, *pSet, aArgs );
+        xModel->attachResource( GetMedium()->GetOrigURL(), aArgs );
+        impl_addToModelCollection(xModel);
+    }
+
+    pImpl->bModelInitialized = true;
+}
+
+void SfxObjectShell::FinishedLoading( SfxLoadedFlags nFlags )
+{
+    bool bSetModifiedTRUE = false;
+    const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false);
+    if( ( nFlags & SfxLoadedFlags::MAINDOCUMENT ) && !(pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT )
+        && !(pImpl->nFlagsInProgress & SfxLoadedFlags::MAINDOCUMENT ))
+    {
+        pImpl->nFlagsInProgress |= SfxLoadedFlags::MAINDOCUMENT;
+        static_cast<SfxHeaderAttributes_Impl*>(GetHeaderAttributes())->SetAttributes();
+
+        if ( ( GetModifyPasswordHash() || GetModifyPasswordInfo().hasElements() ) && !IsModifyPasswordEntered() )
+            SetReadOnly();
+
+        // Salvage
+        if ( pSalvageItem )
+            bSetModifiedTRUE = true;
+
+        if ( !IsEnableSetModified() )
+            EnableSetModified();
+
+        if( !bSetModifiedTRUE && IsEnableSetModified() )
+            SetModified( false );
+
+        CheckSecurityOnLoading_Impl();
+
+        bHasName = true; // the document is loaded, so the name should already available
+        GetTitle( SFX_TITLE_DETECT );
+        InitOwnModel_Impl();
+        pImpl->nFlagsInProgress &= ~SfxLoadedFlags::MAINDOCUMENT;
+    }
+
+    if( ( nFlags & SfxLoadedFlags::IMAGES ) && !(pImpl->nLoadedFlags & SfxLoadedFlags::IMAGES )
+        && !(pImpl->nFlagsInProgress & SfxLoadedFlags::IMAGES ))
+    {
+        pImpl->nFlagsInProgress |= SfxLoadedFlags::IMAGES;
+        uno::Reference<document::XDocumentProperties> xDocProps(
+            getDocProperties());
+        const OUString url(xDocProps->getAutoloadURL());
+        sal_Int32 delay(xDocProps->getAutoloadSecs());
+        SetAutoLoad( INetURLObject(url), delay * 1000,
+                     (delay > 0) || !url.isEmpty() );
+        if( !bSetModifiedTRUE && IsEnableSetModified() )
+            SetModified( false );
+        Invalidate( SID_SAVEASDOC );
+        pImpl->nFlagsInProgress &= ~SfxLoadedFlags::IMAGES;
+    }
+
+    pImpl->nLoadedFlags |= nFlags;
+
+    if ( pImpl->nFlagsInProgress != SfxLoadedFlags::NONE )
+        return;
+
+    // in case of reentrance calls the first called FinishedLoading() call on the stack
+    // should do the notification, in result the notification is done when all the FinishedLoading() calls are finished
+
+    if ( bSetModifiedTRUE )
+        SetModified();
+    else
+        SetModified( false );
+
+    if ( (pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT ) && (pImpl->nLoadedFlags & SfxLoadedFlags::IMAGES ) )
+    {
+        const SfxBoolItem* pTemplateItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_TEMPLATE, false);
+        bool bTemplate = pTemplateItem && pTemplateItem->GetValue();
+
+        // closing the streams on loading should be under control of SFX!
+        DBG_ASSERT( pMedium->IsOpen(), "Don't close the medium when loading documents!" );
+
+        if ( bTemplate )
+        {
+            TemplateDisconnectionAfterLoad();
+        }
+        else
+        {
+            // if a readonly medium has storage then it's stream is already based on temporary file
+            if( !(pMedium->GetOpenMode() & StreamMode::WRITE) && !pMedium->HasStorage_Impl() )
+                // don't lock file opened read only
+                pMedium->CloseInStream();
+        }
+    }
+
+    SetInitialized_Impl( false );
+
+    // Title is not available until loading has finished
+    Broadcast( SfxHint( SfxHintId::TitleChanged ) );
+    if ( pImpl->nEventId != SfxEventHintId::NONE )
+        PostActivateEvent_Impl(SfxViewFrame::GetFirst(this));
+}
+
+void SfxObjectShell::TemplateDisconnectionAfterLoad()
+{
+    // document is created from a template
+    //TODO/LATER: should the templates always be XML docs!
+
+    SfxMedium* pTmpMedium = pMedium;
+    if ( !pTmpMedium )
+        return;
+
+    const OUString aName( pTmpMedium->GetName() );
+    const SfxStringItem* pTemplNamItem = SfxItemSet::GetItem<SfxStringItem>(pTmpMedium->GetItemSet(), SID_TEMPLATE_NAME, false);
+    OUString aTemplateName;
+    if ( pTemplNamItem )
+        aTemplateName = pTemplNamItem->GetValue();
+    else
+    {
+        // !TODO/LATER: what's this?!
+        // Interactive ( DClick, Contextmenu ) no long name is included
+        aTemplateName = getDocProperties()->getTitle();
+        if ( aTemplateName.isEmpty() )
+        {
+            INetURLObject aURL( aName );
+            aURL.CutExtension();
+            aTemplateName = aURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset );
+        }
+    }
+
+    // set medium to noname
+    pTmpMedium->SetName( OUString(), true );
+    pTmpMedium->Init_Impl();
+
+    // drop resource
+    SetNoName();
+    InvalidateName();
+
+    if( IsPackageStorageFormat_Impl( *pTmpMedium ) )
+    {
+        // untitled document must be based on temporary storage
+        // the medium should not dispose the storage in this case
+        uno::Reference < embed::XStorage > xTmpStor = ::comphelper::OStorageHelper::GetTemporaryStorage();
+        GetStorage()->copyToStorage( xTmpStor );
+
+        // the medium should disconnect from the original location
+        // the storage should not be disposed since the document is still
+        // based on it, but in DoSaveCompleted it will be disposed
+        pTmpMedium->CanDisposeStorage_Impl( false );
+        pTmpMedium->Close();
+
+        // setting the new storage the medium will be based on
+        pTmpMedium->SetStorage_Impl( xTmpStor );
+
+        pMedium = nullptr;
+        bool ok = DoSaveCompleted( pTmpMedium );
+        assert(pMedium != nullptr);
+        if( ok )
+        {
+            const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false);
+            bool bSalvage = pSalvageItem != nullptr;
+
+            if ( !bSalvage )
+            {
+                // some further initializations for templates
+                SetTemplate_Impl( aName, aTemplateName, this );
+            }
+
+            // the medium should not dispose the storage, DoSaveCompleted() has let it to do so
+            pTmpMedium->CanDisposeStorage_Impl( false );
+        }
+        else
+        {
+            SetError(ERRCODE_IO_GENERAL);
+        }
+    }
+    else
+    {
+        // some further initializations for templates
+        SetTemplate_Impl( aName, aTemplateName, this );
+        pTmpMedium->CreateTempFile();
+    }
+
+    // templates are never readonly
+    pTmpMedium->GetItemSet()->ClearItem( SID_DOC_READONLY );
+    pTmpMedium->SetOpenMode( SFX_STREAM_READWRITE, true );
+
+    // notifications about possible changes in readonly state and document info
+    Broadcast( SfxHint(SfxHintId::ModeChanged) );
+
+    // created untitled document can't be modified
+    SetModified( false );
+}
+
+
+bool SfxObjectShell::IsLoading() const
+/*  [Description]
+
+    Has FinishedLoading been called?
+*/
+{
+    return !( pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT );
+}
+
+
+void SfxObjectShell::CancelTransfers()
+/*  [Description]
+
+    Here can Transfers get canceled, which were not registered
+    by RegisterTransfer.
+*/
+{
+    if( ( pImpl->nLoadedFlags & SfxLoadedFlags::ALL ) != SfxLoadedFlags::ALL )
+    {
+        pImpl->bIsAbortingImport = true;
+        if( IsLoading() )
+            FinishedLoading();
+    }
+}
+
+
+AutoReloadTimer_Impl::AutoReloadTimer_Impl(
+    const OUString& rURL, sal_uInt32 nTime, SfxObjectShell* pSh )
+    : Timer("sfx2 AutoReloadTimer_Impl"), aUrl( rURL ), pObjSh( pSh )
+{
+    SetTimeout( nTime );
+}
+
+
+void AutoReloadTimer_Impl::Invoke()
+{
+    SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pObjSh );
+
+    if ( pFrame )
+    {
+        // Not possible/meaningful at the moment?
+        if ( !pObjSh->CanReload_Impl() || pObjSh->IsAutoLoadLocked() || Application::IsUICaptured() )
+        {
+            // Allow a retry
+            Start();
+            return;
+        }
+
+        SfxAllItemSet aSet( SfxGetpApp()->GetPool() );
+        aSet.Put( SfxBoolItem( SID_AUTOLOAD, true ) );
+        if ( !aUrl.isEmpty() )
+            aSet.Put(  SfxStringItem( SID_FILE_NAME, aUrl ) );
+        if (pObjSh->HasName()) {
+            aSet.Put(
+                SfxStringItem(SID_REFERER, pObjSh->GetMedium()->GetName()));
+        }
+        SfxRequest aReq( SID_RELOAD, SfxCallMode::SLOT, aSet );
+        // this will delete this
+        pObjSh->Get_Impl()->pReloadTimer.reset();
+        pFrame->ExecReload_Impl( aReq );
+        return;
+    }
+
+    // this will delete this
+    pObjSh->Get_Impl()->pReloadTimer.reset();
+}
+
+SfxModule* SfxObjectShell::GetModule() const
+{
+    return GetFactory().GetModule();
+}
+
+ErrCode SfxObjectShell::CallBasic( std::u16string_view rMacro,
+    std::u16string_view rBasic, SbxArray* pArgs,
+    SbxValue* pRet )
+{
+    SfxApplication* pApp = SfxGetpApp();
+    if( pApp->GetName() != rBasic )
+    {
+        if ( !AdjustMacroMode() )
+            return ERRCODE_IO_ACCESSDENIED;
+    }
+
+    BasicManager *pMgr = GetBasicManager();
+    if( pApp->GetName() == rBasic )
+        pMgr = SfxApplication::GetBasicManager();
+    ErrCode nRet = SfxApplication::CallBasic( OUString(rMacro), pMgr, pArgs, pRet );
+    return nRet;
+}
+
+bool SfxObjectShell::isScriptAccessAllowed( const Reference< XInterface >& _rxScriptContext )
+{
+    try
+    {
+        Reference< XEmbeddedScripts > xScripts( _rxScriptContext, UNO_QUERY );
+        if ( !xScripts.is() )
+        {
+            Reference< XScriptInvocationContext > xContext( _rxScriptContext, UNO_QUERY_THROW );
+            xScripts.set( xContext->getScriptContainer(), UNO_SET_THROW );
+        }
+
+        return xScripts->getAllowMacroExecution();
+    }
+    catch( const Exception& )
+    {
+        DBG_UNHANDLED_EXCEPTION("sfx.doc");
+    }
+    return false;
+}
+
+// don't allow LibreLogo to be used with our mouseover/etc dom-alike events
+bool SfxObjectShell::UnTrustedScript(const OUString& rScriptURL)
+{
+    if (!rScriptURL.startsWith("vnd.sun.star.script:"))
+        return false;
+
+    // ensure URL Escape Codes are decoded
+    css::uno::Reference<css::uri::XUriReference> uri(
+        css::uri::UriReferenceFactory::create(comphelper::getProcessComponentContext())->parse(rScriptURL));
+    css::uno::Reference<css::uri::XVndSunStarScriptUrl> sfUri(uri, css::uno::UNO_QUERY);
+
+    if (!sfUri.is())
+        return false;
+
+    // pyuno encodes path separator as |
+    OUString sScript = sfUri->getName().replace('|', '/');
+
+    // check if any path portion matches LibreLogo and ban it if it does
+    sal_Int32 nIndex = 0;
+    do
+    {
+        OUString aToken = sScript.getToken(0, '/', nIndex);
+        if (aToken.startsWithIgnoreAsciiCase("LibreLogo") || aToken.indexOf('~') != -1)
+        {
+            return true;
+        }
+    }
+    while (nIndex >= 0);
+
+    return false;
+}
+
+ErrCode SfxObjectShell::CallXScript( const Reference< XInterface >& _rxScriptContext, const OUString& _rScriptURL,
+    const Sequence< Any >& aParams, Any& aRet, Sequence< sal_Int16 >& aOutParamIndex, Sequence< Any >& aOutParam, bool bRaiseError, const css::uno::Any* pCaller )
+{
+    SAL_INFO("sfx", "in CallXScript" );
+    ErrCode nErr = ERRCODE_NONE;
+
+    bool bCaughtException = false;
+    Any aException;
+    try
+    {
+        if (!isScriptAccessAllowed(_rxScriptContext))
+            return ERRCODE_IO_ACCESSDENIED;
+
+        if ( UnTrustedScript(_rScriptURL) )
+            return ERRCODE_IO_ACCESSDENIED;
+
+        // obtain/create a script provider
+        Reference< provider::XScriptProvider > xScriptProvider;
+        Reference< provider::XScriptProviderSupplier > xSPS( _rxScriptContext, UNO_QUERY );
+        if ( xSPS.is() )
+            xScriptProvider.set( xSPS->getScriptProvider() );
+
+        if ( !xScriptProvider.is() )
+        {
+            Reference< provider::XScriptProviderFactory > xScriptProviderFactory =
+                provider::theMasterScriptProviderFactory::get( ::comphelper::getProcessComponentContext() );
+            xScriptProvider.set( xScriptProviderFactory->createScriptProvider( Any( _rxScriptContext ) ), UNO_SET_THROW );
+        }
+
+        // ry to protect the invocation context's undo manager (if present), just in case the script tampers with it
+        ::framework::DocumentUndoGuard aUndoGuard( _rxScriptContext );
+
+        // obtain the script, and execute it
+        Reference< provider::XScript > xScript( xScriptProvider->getScript( _rScriptURL ), UNO_SET_THROW );
+        if ( pCaller && pCaller->hasValue() )
+        {
+            Reference< beans::XPropertySet > xProps( xScript, uno::UNO_QUERY );
+            if ( xProps.is() )
+            {
+                Sequence< uno::Any > aArgs{ *pCaller };
+                xProps->setPropertyValue("Caller", uno::Any( aArgs ) );
+            }
+        }
+        aRet = xScript->invoke( aParams, aOutParamIndex, aOutParam );
+    }
+    catch ( const uno::Exception& )
+    {
+        aException = ::cppu::getCaughtException();
+        bCaughtException = true;
+        nErr = ERRCODE_BASIC_INTERNAL_ERROR;
+    }
+
+    if ( bCaughtException && bRaiseError )
+    {
+        SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
+        pFact->ShowAsyncScriptErrorDialog( nullptr, aException );
+    }
+
+    SAL_INFO("sfx", "leaving CallXScript" );
+    return nErr;
+}
+
+// perhaps rename to CallScript once we get rid of the existing CallScript
+// and Call, CallBasic, CallStarBasic methods
+ErrCode SfxObjectShell::CallXScript( const OUString& rScriptURL,
+        const css::uno::Sequence< css::uno::Any >& aParams,
+        css::uno::Any& aRet,
+        css::uno::Sequence< sal_Int16 >& aOutParamIndex,
+        css::uno::Sequence< css::uno::Any >& aOutParam,
+        bool bRaiseError,
+        const css::uno::Any* pCaller )
+{
+    return CallXScript( GetModel(), rScriptURL, aParams, aRet, aOutParamIndex, aOutParam, bRaiseError, pCaller );
+}
+
+void SfxHeaderAttributes_Impl::SetAttributes()
+{
+    bAlert = true;
+    SvKeyValue aPair;
+    for( bool bCont = xIter->GetFirst( aPair ); bCont;
+         bCont = xIter->GetNext( aPair ) )
+        SetAttribute( aPair );
+}
+
+void SfxHeaderAttributes_Impl::SetAttribute( const SvKeyValue& rKV )
+{
+    const OUString& aValue = rKV.GetValue();
+    if( rKV.GetKey().equalsIgnoreAsciiCase("refresh") && !rKV.GetValue().isEmpty() )
+    {
+        sal_Int32 nIdx{ 0 };
+        const sal_Int32 nTime{ o3tl::toInt32(o3tl::getToken(aValue, 0, ';', nIdx )) };
+        const OUString aURL{ comphelper::string::strip(o3tl::getToken(aValue, 0, ';', nIdx ), ' ') };
+        uno::Reference<document::XDocumentProperties> xDocProps(
+            pDoc->getDocProperties());
+        if( aURL.startsWithIgnoreAsciiCase( "url=" ) )
+        {
+            try {
+                xDocProps->setAutoloadURL(
+                    rtl::Uri::convertRelToAbs(pDoc->GetMedium()->GetName(), aURL.copy( 4 )) );
+            } catch (rtl::MalformedUriException &) {
+                TOOLS_WARN_EXCEPTION("sfx", "");
+            }
+        }
+        try
+        {
+            xDocProps->setAutoloadSecs( nTime );
+        }
+        catch (lang::IllegalArgumentException &)
+        {
+            // ignore
+        }
+    }
+    else if( rKV.GetKey().equalsIgnoreAsciiCase( "expires" ) )
+    {
+        DateTime aDateTime( DateTime::EMPTY );
+        if( INetMIMEMessage::ParseDateField( rKV.GetValue(), aDateTime ) )
+        {
+            aDateTime.ConvertToLocalTime();
+            pDoc->GetMedium()->SetExpired_Impl( aDateTime );
+        }
+        else
+        {
+            pDoc->GetMedium()->SetExpired_Impl( Date( 1, 1, 1970 ) );
+        }
+    }
+}
+
+void SfxHeaderAttributes_Impl::Append( const SvKeyValue& rKV )
+{
+    xIter->Append( rKV );
+    if( bAlert ) SetAttribute( rKV );
+}
+
+SvKeyValueIterator* SfxObjectShell::GetHeaderAttributes()
+{
+    if( !pImpl->xHeaderAttributes.is() )
+    {
+        DBG_ASSERT( pMedium, "No Medium" );
+        pImpl->xHeaderAttributes = new SfxHeaderAttributes_Impl( this );
+    }
+    return static_cast<SvKeyValueIterator*>( pImpl->xHeaderAttributes.get() );
+}
+
+void SfxObjectShell::ClearHeaderAttributesForSourceViewHack()
+{
+    static_cast<SfxHeaderAttributes_Impl*>(GetHeaderAttributes())
+        ->ClearForSourceView();
+}
+
+
+void SfxObjectShell::SetHeaderAttributesForSourceViewHack()
+{
+    static_cast<SfxHeaderAttributes_Impl*>(GetHeaderAttributes())
+        ->SetAttributes();
+}
+
+bool SfxObjectShell::IsPreview() const
+{
+    if ( !pMedium )
+        return false;
+
+    bool bPreview = false;
+    const SfxStringItem* pFlags = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_OPTIONS, false);
+    if ( pFlags )
+    {
+        // Distributed values among individual items
+        const OUString aFileFlags = pFlags->GetValue().toAsciiUpperCase();
+        if ( -1 != aFileFlags.indexOf( 'B' ) )
+            bPreview = true;
+    }
+
+    if ( !bPreview )
+    {
+        const SfxBoolItem* pItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_PREVIEW, false);
+        if ( pItem )
+            bPreview = pItem->GetValue();
+    }
+
+    return bPreview;
+}
+
+void SfxObjectShell::SetWaitCursor( bool bSet ) const
+{
+    for( SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this ); pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, this ) )
+    {
+        if ( bSet )
+            pFrame->GetFrame().GetWindow().EnterWait();
+        else
+            pFrame->GetFrame().GetWindow().LeaveWait();
+    }
+}
+
+OUString SfxObjectShell::GetAPIName() const
+{
+    INetURLObject aURL( IsDocShared() ? GetSharedFileURL() : GetMedium()->GetName() );
+    OUString aName( aURL.GetBase() );
+    if( aName.isEmpty() )
+        aName = aURL.GetURLNoPass();
+    if ( aName.isEmpty() )
+        aName = GetTitle( SFX_TITLE_DETECT );
+    return aName;
+}
+
+void SfxObjectShell::Invalidate( sal_uInt16 nId )
+{
+    for( SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this ); pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, this ) )
+        Invalidate_Impl( pFrame->GetBindings(), nId );
+}
+
+bool SfxObjectShell::AdjustMacroMode()
+{
+    uno::Reference< task::XInteractionHandler > xInteraction;
+    if ( pMedium )
+        xInteraction = pMedium->GetInteractionHandler();
+
+    CheckForBrokenDocSignatures_Impl();
+
+    CheckEncryption_Impl( xInteraction );
+
+    return pImpl->aMacroMode.adjustMacroMode( xInteraction );
+}
+
+css::uno::Reference<css::awt::XWindow> SfxObjectShell::GetDialogParent( SfxMedium const * pLoadingMedium )
+{
+    css::uno::Reference<css::awt::XWindow> xWindow;
+    SfxItemSet* pSet = pLoadingMedium ? pLoadingMedium->GetItemSet() : GetMedium()->GetItemSet();
+    const SfxUnoFrameItem* pUnoItem = SfxItemSet::GetItem<SfxUnoFrameItem>(pSet, SID_FILLFRAME, false);
+    if ( pUnoItem )
+    {
+        const uno::Reference < frame::XFrame >& xFrame( pUnoItem->GetFrame() );
+        xWindow = xFrame->getContainerWindow();
+    }
+
+    if (!xWindow)
+    {
+        SfxFrame* pFrame = nullptr;
+        const SfxFrameItem* pFrameItem = SfxItemSet::GetItem<SfxFrameItem>(pSet, SID_DOCFRAME, false);
+        if( pFrameItem && pFrameItem->GetFrame() )
+            // get target frame from ItemSet
+            pFrame = pFrameItem->GetFrame();
+        else
+        {
+            // try the current frame
+            SfxViewFrame* pView = SfxViewFrame::Current();
+            if ( !pView || pView->GetObjectShell() != this )
+                // get any visible frame
+                pView = SfxViewFrame::GetFirst(this);
+            if ( pView )
+                pFrame = &pView->GetFrame();
+        }
+
+        if ( pFrame )
+        {
+            // get topmost window
+            xWindow = pFrame->GetFrameInterface()->getContainerWindow();
+        }
+    }
+
+    if (xWindow)
+    {
+        // this frame may be invisible, show it if it is allowed
+        const SfxBoolItem* pHiddenItem = SfxItemSet::GetItem<SfxBoolItem>(pSet, SID_HIDDEN, false);
+        if ( !pHiddenItem || !pHiddenItem->GetValue() )
+        {
+            xWindow->setVisible(true);
+            css::uno::Reference<css::awt::XTopWindow> xTopWindow(xWindow, uno::UNO_QUERY);
+            SAL_WARN_IF(!xTopWindow, "sfx.appl", "XTopWindow not available from XWindow");
+            if (xTopWindow)
+                xTopWindow->toFront();
+        }
+    }
+
+    return xWindow;
+}
+
+void SfxObjectShell::SetCreateMode_Impl( SfxObjectCreateMode nMode )
+{
+    eCreateMode = nMode;
+}
+
+bool SfxObjectShell::IsInPlaceActive() const
+{
+    if ( eCreateMode != SfxObjectCreateMode::EMBEDDED )
+        return false;
+
+    SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this );
+    return pFrame && pFrame->GetFrame().IsInPlace();
+}
+
+bool SfxObjectShell::IsUIActive() const
+{
+    if ( eCreateMode != SfxObjectCreateMode::EMBEDDED )
+        return false;
+
+    SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this );
+    return pFrame && pFrame->GetFrame().IsInPlace() && pFrame->GetFrame().GetWorkWindow_Impl()->IsVisible_Impl();
+}
+
+bool SfxObjectShell::UseInteractionToHandleError(
+                    const uno::Reference< task::XInteractionHandler >& xHandler,
+                    ErrCode nError )
+{
+    bool bResult = false;
+
+    if ( xHandler.is() )
+    {
+        try
+        {
+            uno::Any aInteraction;
+            rtl::Reference<::comphelper::OInteractionAbort> pAbort = new ::comphelper::OInteractionAbort();
+            rtl::Reference<::comphelper::OInteractionApprove> pApprove = new ::comphelper::OInteractionApprove();
+            uno::Sequence< uno::Reference< task::XInteractionContinuation > > lContinuations{
+                pAbort, pApprove
+            };
+
+            task::ErrorCodeRequest aErrorCode;
+            aErrorCode.ErrCode = sal_uInt32(nError);
+            aInteraction <<= aErrorCode;
+            xHandler->handle(::framework::InteractionRequest::CreateRequest (aInteraction,lContinuations));
+            bResult = pAbort->wasSelected();
+        }
+        catch( uno::Exception& )
+        {}
+    }
+
+    return bResult;
+}
+
+sal_Int16 SfxObjectShell_Impl::getCurrentMacroExecMode() const
+{
+    sal_Int16 nImposedExecMode( MacroExecMode::NEVER_EXECUTE );
+
+    const SfxMedium* pMedium( rDocShell.GetMedium() );
+    OSL_PRECOND( pMedium, "SfxObjectShell_Impl::getCurrentMacroExecMode: no medium!" );
+    if ( pMedium )
+    {
+        const SfxUInt16Item* pMacroModeItem = SfxItemSet::GetItem<SfxUInt16Item>(pMedium->GetItemSet(), SID_MACROEXECMODE, false);
+        if ( pMacroModeItem )
+            nImposedExecMode = pMacroModeItem->GetValue();
+    }
+    return nImposedExecMode;
+}
+
+void SfxObjectShell_Impl::setCurrentMacroExecMode( sal_uInt16 nMacroMode )
+{
+    const SfxMedium* pMedium( rDocShell.GetMedium() );
+    OSL_PRECOND( pMedium, "SfxObjectShell_Impl::getCurrentMacroExecMode: no medium!" );
+    if ( pMedium )
+    {
+        pMedium->GetItemSet()->Put( SfxUInt16Item( SID_MACROEXECMODE, nMacroMode ) );
+    }
+}
+
+OUString SfxObjectShell_Impl::getDocumentLocation() const
+{
+    OUString sLocation;
+
+    const SfxMedium* pMedium( rDocShell.GetMedium() );
+    OSL_PRECOND( pMedium, "SfxObjectShell_Impl::getDocumentLocation: no medium!" );
+    if ( pMedium )
+    {
+        sLocation = pMedium->GetName();
+        if ( sLocation.isEmpty() )
+        {
+            // for documents made from a template: get the name of the template
+            sLocation = rDocShell.getDocProperties()->getTemplateURL();
+        }
+
+        // tdf#128006 take document base url as location
+        if (sLocation.isEmpty())
+            sLocation = rDocShell.getDocumentBaseURL();
+    }
+
+    return sLocation;
+}
+
+bool SfxObjectShell_Impl::documentStorageHasMacros() const
+{
+    return ::sfx2::DocumentMacroMode::storageHasMacros( m_xDocStorage );
+}
+
+bool SfxObjectShell_Impl::macroCallsSeenWhileLoading() const
+{
+    return rDocShell.GetMacroCallsSeenWhileLoading();
+}
+
+Reference< XEmbeddedScripts > SfxObjectShell_Impl::getEmbeddedDocumentScripts() const
+{
+    return Reference< XEmbeddedScripts >( rDocShell.GetModel(), UNO_QUERY );
+}
+
+SignatureState SfxObjectShell_Impl::getScriptingSignatureState()
+{
+    SignatureState nSignatureState( rDocShell.GetScriptingSignatureState() );
+
+    if ( nSignatureState != SignatureState::NOSIGNATURES && m_bMacroSignBroken )
+    {
+        // if there is a macro signature it must be handled as broken
+        nSignatureState = SignatureState::BROKEN;
+    }
+
+    return nSignatureState;
+}
+
+bool SfxObjectShell_Impl::hasTrustedScriptingSignature( bool bAllowUIToAddAuthor )
+{
+    bool bResult = false;
+
+    try
+    {
+        OUString aVersion;
+        try
+        {
+            uno::Reference < beans::XPropertySet > xPropSet( rDocShell.GetStorage(), uno::UNO_QUERY_THROW );
+            xPropSet->getPropertyValue("Version") >>= aVersion;
+        }
+        catch( uno::Exception& )
+        {
+        }
+
+        uno::Reference< security::XDocumentDigitalSignatures > xSigner( security::DocumentDigitalSignatures::createWithVersion(comphelper::getProcessComponentContext(), aVersion) );
+
+        if ( nScriptingSignatureState == SignatureState::UNKNOWN
+          || nScriptingSignatureState == SignatureState::OK
+          || nScriptingSignatureState == SignatureState::NOTVALIDATED )
+        {
+            const uno::Sequence< security::DocumentSignatureInformation > aInfo = rDocShell.GetDocumentSignatureInformation( true, xSigner );
+
+            if ( aInfo.hasElements() )
+            {
+                if ( nScriptingSignatureState == SignatureState::UNKNOWN )
+                    nScriptingSignatureState = DocumentSignatures::getSignatureState(aInfo);
+
+                if ( nScriptingSignatureState == SignatureState::OK
+                  || nScriptingSignatureState == SignatureState::NOTVALIDATED )
+                {
+                    bResult = std::any_of(aInfo.begin(), aInfo.end(),
+                        [&xSigner](const security::DocumentSignatureInformation& rInfo) {
+                            return xSigner->isAuthorTrusted( rInfo.Signer ); });
+
+                    if ( !bResult && bAllowUIToAddAuthor )
+                    {
+                        uno::Reference< task::XInteractionHandler > xInteraction;
+                        if ( rDocShell.GetMedium() )
+                            xInteraction = rDocShell.GetMedium()->GetInteractionHandler();
+
+                        if ( xInteraction.is() )
+                        {
+                            task::DocumentMacroConfirmationRequest aRequest;
+                            aRequest.DocumentURL = getDocumentLocation();
+                            aRequest.DocumentStorage = rDocShell.GetMedium()->GetZipStorageToSign_Impl();
+                            aRequest.DocumentSignatureInformation = aInfo;
+                            aRequest.DocumentVersion = aVersion;
+                            aRequest.Classification = task::InteractionClassification_QUERY;
+                            bResult = SfxMedium::CallApproveHandler( xInteraction, uno::Any( aRequest ), true );
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch( uno::Exception& )
+    {}
+
+    return bResult;
+}
+
+bool SfxObjectShell::IsContinueImportOnFilterExceptions(std::u16string_view aErrMessage)
+{
+    if (mbContinueImportOnFilterExceptions == undefined)
+    {
+        if (Application::GetDialogCancelMode() == DialogCancelMode::Off)
+        {
+            // Ask the user to try to continue or abort loading
+            OUString aMessage = SfxResId(STR_QMSG_ERROR_OPENING_FILE);
+            if (!aErrMessage.empty())
+                aMessage += SfxResId(STR_QMSG_ERROR_OPENING_FILE_DETAILS) + aErrMessage;
+            aMessage += SfxResId(STR_QMSG_ERROR_OPENING_FILE_CONTINUE);
+            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(nullptr,
+                                                      VclMessageType::Question, VclButtonsType::YesNo, aMessage));
+            mbContinueImportOnFilterExceptions = (xBox->run() == RET_YES) ? yes : no;
+        }
+        else
+            mbContinueImportOnFilterExceptions = no;
+    }
+    return mbContinueImportOnFilterExceptions == yes;
+}
+
+bool SfxObjectShell::isEditDocLocked() const
+{
+    Reference<XModel3> xModel = GetModel();
+    if (!xModel.is())
+        return false;
+    if (!officecfg::Office::Common::Misc::AllowEditReadonlyDocs::get())
+        return true;
+    return comphelper::NamedValueCollection::getOrDefault(xModel->getArgs2( { "LockEditDoc" } ), u"LockEditDoc", false);
+}
+
+bool SfxObjectShell::isContentExtractionLocked() const
+{
+    Reference<XModel3> xModel = GetModel();
+    if (!xModel.is())
+        return false;
+    return comphelper::NamedValueCollection::getOrDefault(xModel->getArgs2( { "LockContentExtraction" } ), u"LockContentExtraction", false);
+}
+
+bool SfxObjectShell::isExportLocked() const
+{
+    Reference<XModel3> xModel = GetModel();
+    if (!xModel.is())
+        return false;
+    return comphelper::NamedValueCollection::getOrDefault(xModel->getArgs2( { "LockExport" } ), u"LockExport", false);
+}
+
+bool SfxObjectShell::isPrintLocked() const
+{
+    Reference<XModel3> xModel = GetModel();
+    if (!xModel.is())
+        return false;
+    return comphelper::NamedValueCollection::getOrDefault(xModel->getArgs2( { "LockPrint" } ), u"LockPrint", false);
+}
+
+bool SfxObjectShell::isSaveLocked() const
+{
+    Reference<XModel3> xModel = GetModel();
+    if (!xModel.is())
+        return false;
+    return comphelper::NamedValueCollection::getOrDefault(xModel->getArgs2( { "LockSave" } ), u"LockSave", false);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */