/* -*- 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/debug.hxx>

#include <tools/inetmsg.hxx>

#include <comphelper/diagnose_ex.hxx>

#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/ErrorCodeRequest2.hpp>

#include <comphelper/lok.hxx>

#include <LibreOfficeKit/LibreOfficeKitEnums.h>

#include <comphelper/processfactory.hxx>

#include <comphelper/sequenceashashmap.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 <utility>

#include <vcl/weld/MessageDialog.hxx>

#include <vcl/weld/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 <ucbhelper/simpleinteractionrequest.hxx>

#include <officecfg/Office/Common.hxx>

#include <sfx2/brokenpackageint.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/lokhelper.hxx>

#include <sfx2/sfxbasemodel.hxx>

#include <openflag.hxx>

#include "objstor.hxx"

#include <appopen.hxx>

#include <sfx2/viewsh.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;

// 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(const ErrCodeMsg& lErr)

{

    if (pImpl->lErr == ERRCODE_NONE || (pImpl->lErr.IsWarning() && lErr.IsError()))

    {

        pImpl->lErr=lErr;

    }

}

ErrCodeMsg SfxObjectShell::GetErrorIgnoreWarning() const

{

    return GetErrorCode().IgnoreWarning();

}

ErrCodeMsg SfxObjectShell::GetErrorCode() const

{

    ErrCodeMsg 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

{

    // tdf#146547 read-only does not prevent modified, instead try to prevent

    // setting "internal" documents that may be displayed in some dialog but

    // which the user didn't load or activate to modified.

    return pImpl->m_bEnableSetModified && !IsPreview()

        && eCreateMode != SfxObjectCreateMode::ORGANIZER

        && eCreateMode != SfxObjectCreateMode::INTERNAL

        // tdf#157931 form documents only in design mode

        && ((pImpl->pBaseModel

                && !pImpl->pBaseModel->impl_isDisposed()

                && pImpl->pBaseModel->IsInitialized()

                && pImpl->pBaseModel->getIdentifier() != "com.sun.star.sdb.FormDesign")

            || !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 ) );

    // Don't wait to get this important state via binding notification timeout.

    if ( comphelper::LibreOfficeKit::isActive() )

    {

        OString aStatus = ".uno:ModifiedStatus="_ostr;

        aStatus += IsModified() ? "true" : "false";

        SfxLokHelper::notifyAllViews(LOK_CALLBACK_STATE_CHANGED, aStatus);

    }

}

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 || SfxViewShell::IsCurrentLokViewReadOnly();

}

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 || pMedium->HasRestrictedFonts();

}

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 SfxPoolItemHolder aItem(pViewFrame->GetBindings().ExecuteSynchron( HasName() ? SID_SAVEDOC : SID_SAVEASDOC ));

                const SfxBoolItem* pResult(dynamic_cast<const SfxBoolItem*>(aItem.getItem()));

                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( u""_ustr );

    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 u"-not available-"_ustr;

        bRecur = true;

        OUString aTitle;

        if ( pMed )

        {

            const SfxStringItem* pNameItem = pMed->GetItemSet().GetItem(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 = pMed->GetItemSet().GetItem(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();

    OUString sOldName = GetName();

    OUString sNewName = GetTitle(SFX_TITLE_APINAME);

    if (sOldName != sNewName)

    {

        SetName(sNewName);

        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 = pMedium ? pMedium->GetItemSet().GetItem(SID_HIDDEN, false) : nullptr;

    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()

{

    if (GetErrorCode() == ERRCODE_IO_BROKENPACKAGE)

    {   // safety first: don't run any macros from broken package.

        pImpl->aMacroMode.disallowMacroExecution();

        return; // do not get signature status - needs to be done after RepairPackage

    }

    // 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();

    const bool bHasMacros = pImpl->aMacroMode.hasMacros();

    pImpl->aMacroMode.checkMacrosOnLoading( xInteraction, bHasValidContentSignature, bHasMacros );

    pImpl->m_bHadCheckedMacrosOnLoad = bHasMacros;

}

bool SfxObjectShell::GetHadCheckedMacrosOnLoad() const

{

    return pImpl->m_bHadCheckedMacrosOnLoad;

}

bool SfxObjectShell::AllowedLinkProtocolFromDocument(const OUString& rUrl, SfxObjectShell* pObjShell, weld::Window* pDialogParent)

{

    if (!INetURLObject(rUrl).IsExoticProtocol())

        return true;

    // Default to ignoring exotic protocols

    bool bAllow = false;

    if (pObjShell)

    {

        // If the document had macros when loaded then follow the allowed macro-mode

        if (pObjShell->GetHadCheckedMacrosOnLoad())

            bAllow = pObjShell->AdjustMacroMode();

        else // otherwise ask the user, defaulting to cancel

        {

            //Reuse URITools::onOpenURI warning string

            std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(pDialogParent,

                                                           VclMessageType::Warning, VclButtonsType::YesNo,

                                                           SfxResId(STR_DANGEROUS_TO_OPEN)));

            xQueryBox->set_primary_text(xQueryBox->get_primary_text().replaceFirst("$(ARG1)",

                INetURLObject::decode(rUrl, INetURLObject::DecodeMechanism::Unambiguous)));

            xQueryBox->set_default_response(RET_NO);

            bAllow = xQueryBox->run() == RET_YES;