/* -*- 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_feature_desktop.h>

#include <config_wasm_strip.h>

#include <o3tl/test_info.hxx>

#include <osl/file.hxx>

#include <sfx2/docfilt.hxx>

#include <sfx2/infobar.hxx>

#include <sfx2/sfxdlg.hxx>

#include <sfx2/sfxsids.hrc>

#include <sfx2/viewfrm.hxx>

#include <sfx2/classificationhelper.hxx>

#include <sfx2/notebookbar/SfxNotebookBar.hxx>

#include <sfx2/pageids.hxx>

#include <com/sun/star/document/MacroExecMode.hpp>

#include <com/sun/star/frame/Desktop.hpp>

#include <com/sun/star/frame/DispatchRecorder.hpp>

#include <com/sun/star/frame/DispatchRecorderSupplier.hpp>

#include <com/sun/star/frame/XLoadable.hpp>

#include <com/sun/star/frame/XLayoutManager.hpp>

#include <com/sun/star/frame/XComponentLoader.hpp>

#include <com/sun/star/frame/XModel3.hpp>

#include <com/sun/star/task/PasswordContainer.hpp>

#include <com/sun/star/task/PasswordRequestMode.hpp>

#include <com/sun/star/security/DocumentDigitalSignatures.hpp>

#include <officecfg/Office/Common.hxx>

#include <officecfg/Office/UI/Infobar.hxx>

#include <officecfg/Setup.hxx>

#include <toolkit/helper/vclunohelper.hxx>

#include <vcl/wrkwin.hxx>

#include <unotools/moduleoptions.hxx>

#include <svl/intitem.hxx>

#include <svl/visitem.hxx>

#include <svl/stritem.hxx>

#include <svl/eitem.hxx>

#include <svl/whiter.hxx>

#include <svl/undo.hxx>

#include <tools/urlobj.hxx>

#include <vcl/help.hxx>

#include <vcl/stdtext.hxx>

#include <vcl/weld/Button.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <vcl/weld/weldutils.hxx>

#if !ENABLE_WASM_STRIP_PINGUSER

#include <unotools/VersionConfig.hxx>

#endif

#include <unotools/securityoptions.hxx>

#include <svtools/miscopt.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <com/sun/star/container/XIndexAccess.hpp>

#include <com/sun/star/frame/XFramesSupplier.hpp>

#include <com/sun/star/frame/FrameSearchFlag.hpp>

#include <com/sun/star/frame/XFrame.hpp>

#include <com/sun/star/awt/XWindow.hpp>

#include <com/sun/star/frame/XController.hpp>

#include <com/sun/star/util/URLTransformer.hpp>

#include <com/sun/star/util/XURLTransformer.hpp>

#include <com/sun/star/util/XCloseable.hpp>

#include <com/sun/star/frame/XDispatchRecorderSupplier.hpp>

#include <com/sun/star/document/UpdateDocMode.hpp>

#include <com/sun/star/beans/XPropertySet.hpp>

#include <com/sun/star/uri/UriReferenceFactory.hpp>

#include <com/sun/star/uri/XVndSunStarScriptUrl.hpp>

#include <com/sun/star/document/XViewDataSupplier.hpp>

#include <com/sun/star/container/XIndexContainer.hpp>

#include <com/sun/star/task/InteractionHandler.hpp>

#include <com/sun/star/drawing/XDrawView.hpp>

#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>

#include <rtl/ustrbuf.hxx>

#include <sal/log.hxx>

#include <com/sun/star/frame/ModuleManager.hpp>

#include <unotools/ucbhelper.hxx>

#include <comphelper/lok.hxx>

#include <comphelper/processfactory.hxx>

#include <comphelper/namedvaluecollection.hxx>

#include <comphelper/docpasswordrequest.hxx>

#include <comphelper/docpasswordhelper.hxx>

#include <com/sun/star/uno/Reference.h>

#include <basic/basmgr.hxx>

#include <basic/sbmod.hxx>

#include <basic/sbmeth.hxx>

#include <svtools/strings.hrc>

#include <svtools/svtresid.hxx>

#include <framework/framelistanalyzer.hxx>

#include <optional>

#include <comphelper/sequenceashashmap.hxx>

#include <commandpopup/CommandPopup.hxx>

// Due to ViewFrame::Current

#include <appdata.hxx>

#include <sfx2/app.hxx>

#include <sfx2/objface.hxx>

#include <openflag.hxx>

#include <objshimp.hxx>

#include <sfx2/viewsh.hxx>

#include <sfx2/objsh.hxx>

#include <sfx2/bindings.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/request.hxx>

#include <sfx2/docfac.hxx>

#include <sfx2/ipclient.hxx>

#include <sfx2/sfxresid.hxx>

#include <sfx2/viewfac.hxx>

#include <sfx2/event.hxx>

#include <sfx2/fcontnr.hxx>

#include <sfx2/docfile.hxx>

#include <sfx2/module.hxx>

#include <sfx2/sfxuno.hxx>

#include <sfx2/progress.hxx>

#include <sfx2/sidebar/Sidebar.hxx>

#include <workwin.hxx>

#include <sfx2/minfitem.hxx>

#include <sfx2/strings.hrc>

#include "impviewframe.hxx"

#include <vcl/commandinfoprovider.hxx>

#include <vcl/svapp.hxx>

#include <svl/cryptosign.hxx>

#include <tools/debug.hxx>

#define ShellClass_SfxViewFrame

#include <sfxslots.hxx>

using namespace ::com::sun::star;

using namespace ::com::sun::star::uno;

using namespace ::com::sun::star::ucb;

using namespace ::com::sun::star::frame;

using namespace ::com::sun::star::lang;

using ::com::sun::star::awt::XWindow;

using ::com::sun::star::beans::PropertyValue;

using ::com::sun::star::document::XViewDataSupplier;

using ::com::sun::star::container::XIndexContainer;

constexpr OUString CHANGES_STR = u"private:resource/toolbar/changes"_ustr;

SFX_IMPL_SUPERCLASS_INTERFACE(SfxViewFrame,SfxShell)

void SfxViewFrame::InitInterface_Impl()

{

    GetStaticInterface()->RegisterChildWindow(SID_BROWSER);

    GetStaticInterface()->RegisterChildWindow(SID_RECORDING_FLOATWINDOW);

#if HAVE_FEATURE_DESKTOP

    GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_FULLSCREEN, SfxVisibilityFlags::FullScreen, ToolbarId::FullScreenToolbox);

    GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_APPLICATION, SfxVisibilityFlags::Standard, ToolbarId::EnvToolbox);

#endif

}

namespace {

/// Asks the user if editing a read-only document is really wanted.

class SfxEditDocumentDialog : public weld::MessageDialogController

{

public:

    SfxEditDocumentDialog(weld::Widget* pParent);

};

SfxEditDocumentDialog::SfxEditDocumentDialog(weld::Widget* pParent)

    : MessageDialogController(pParent, u"sfx/ui/editdocumentdialog.ui"_ustr,

            u"EditDocumentDialog"_ustr)

{

}

class SfxQueryOpenAsTemplate

{

private:

    std::unique_ptr<weld::MessageDialog> m_xQueryBox;

public:

    SfxQueryOpenAsTemplate(weld::Window* pParent, bool bAllowIgnoreLock, LockFileEntry& rLockData)

        : m_xQueryBox(Application::CreateMessageDialog(pParent, VclMessageType::Question,

                                                       VclButtonsType::NONE, u""_ustr))

    {

        m_xQueryBox->add_button(SfxResId(STR_QUERY_OPENASTEMPLATE_OPENCOPY_BTN), RET_YES);

        bAllowIgnoreLock

            = bAllowIgnoreLock && officecfg::Office::Common::Misc::AllowOverrideLocking::get();

        if (bAllowIgnoreLock)

            m_xQueryBox->add_button(SfxResId(STR_QUERY_OPENASTEMPLATE_OPEN_BTN), RET_IGNORE);

        m_xQueryBox->add_button(GetStandardText( StandardButtonType::Cancel ), RET_CANCEL);

        m_xQueryBox->set_primary_text(QueryString(bAllowIgnoreLock, rLockData));

        m_xQueryBox->set_default_response(RET_YES);

    }

    short run() { return m_xQueryBox->run(); }

private:

    static OUString QueryString(bool bAllowIgnoreLock, LockFileEntry& rLockData)

    {

        OUString sLockUserData;

        if (!rLockData[LockFileComponent::OOOUSERNAME].isEmpty())

            sLockUserData = rLockData[LockFileComponent::OOOUSERNAME];

        else

            sLockUserData = rLockData[LockFileComponent::SYSUSERNAME];

        if (!sLockUserData.isEmpty() && !rLockData[LockFileComponent::EDITTIME].isEmpty())

            sLockUserData += " ( " + svt::LockFileCommon::FormatDateTime(rLockData[LockFileComponent::EDITTIME]) + " )";

        if (!sLockUserData.isEmpty())

            sLockUserData = "\n\n" + sLockUserData + "\n";

        const bool bUseLockStr = bAllowIgnoreLock || !sLockUserData.isEmpty();

        OUString sMsg(

            SfxResId(bUseLockStr ? STR_QUERY_OPENASTEMPLATE_LOCKED : STR_QUERY_OPENASTEMPLATE));

        if (bAllowIgnoreLock)

            sMsg += "\n\n" + SfxResId(STR_QUERY_OPENASTEMPLATE_ALLOW_IGNORE);

        return sMsg.replaceFirst("%LOCKINFO", sLockUserData);

    }

};

bool AskPasswordToModify_Impl( const uno::Reference< task::XInteractionHandler >& xHandler, const OUString& aPath, const std::shared_ptr<const SfxFilter>& pFilter, sal_uInt32 nPasswordHash, const uno::Sequence< beans::PropertyValue >& aInfo )

{

    // TODO/LATER: In future the info should replace the direct hash completely

    bool bResult = ( !nPasswordHash && !aInfo.hasElements() );

    SAL_WARN_IF( !(pFilter && ( pFilter->GetFilterFlags() & SfxFilterFlags::PASSWORDTOMODIFY )), "sfx.view",

                       "PasswordToModify feature is active for a filter that does not support it!");

    if ( pFilter && xHandler.is() )

    {

        bool bCancel = false;

        bool bFirstTime = true;

        while ( !bResult && !bCancel )

        {

            bool bMSType = !pFilter->IsOwnFormat();

            ::rtl::Reference< ::comphelper::DocPasswordRequest > pPasswordRequest(

                 new ::comphelper::DocPasswordRequest(

                 bMSType ? ::comphelper::DocPasswordRequestType::MS : ::comphelper::DocPasswordRequestType::Standard,

                 bFirstTime ? css::task::PasswordRequestMode_PASSWORD_ENTER : css::task::PasswordRequestMode_PASSWORD_REENTER,

                 aPath,

                 true ) );

            xHandler->handle( pPasswordRequest );

            if ( pPasswordRequest->isPassword() )

            {

                if ( aInfo.hasElements() )

                {

                    bResult = ::comphelper::DocPasswordHelper::IsModifyPasswordCorrect( pPasswordRequest->getPasswordToModify(), aInfo );

                }

                else

                {

                    // the binary format

                    bResult = ( SfxMedium::CreatePasswordToModifyHash( pPasswordRequest->getPasswordToModify(), pFilter->GetServiceName()=="com.sun.star.text.TextDocument" ) == nPasswordHash );

                }

            }

            else

                bCancel = true;

            bFirstTime = false;

        }

    }

    return bResult;

}

bool physObjIsOlder(INetURLObject const & aMedObj, INetURLObject const & aPhysObj) {

    return ::utl::UCBContentHelper::IsYounger(aMedObj.GetMainURL( INetURLObject::DecodeMechanism::NONE),

                                           aPhysObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );

}

}

void SfxViewFrame::ExecReload_Impl( SfxRequest& rReq )

{

    // Open as editable?

    std::optional<bool> oForEdit;

    SfxObjectShell* pSh = GetObjectShell();

    switch ( rReq.GetSlot() )

    {

        case SID_EDITDOC:

        case SID_READONLYDOC:

        {

            // Due to Double occupancy in toolboxes (with or without Ctrl),

            // it is also possible that the slot is enabled, but Ctrl-click

            // despite this is not!

            if( !pSh || !pSh->HasName() || !(pSh->Get_Impl()->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT ))

                break;

            if (pSh->isEditDocLocked())

                break;

            // Only change read-only UI and remove info bar when we succeed

            struct ReadOnlyUIGuard

            {

                SfxViewFrame* m_pFrame;

                SfxObjectShell* m_pSh;

                SfxMedium* m_pMed = nullptr;

                bool m_bSetRO;

                ReadOnlyUIGuard(SfxViewFrame* pFrame, SfxObjectShell* p_Sh)

                    : m_pFrame(pFrame), m_pSh(p_Sh), m_bSetRO(p_Sh->IsReadOnlyUI())

                {}

                void ImplDestroy()

                {

                    if (m_bSetRO != m_pSh->IsReadOnlyUI())

                    {

                        m_pSh->SetReadOnlyUI(m_bSetRO);

                        if (!m_bSetRO)

                            m_pFrame->RemoveInfoBar(u"readonly");

                        if (m_pMed)

                        {

                            bool const isEnableSetModified(m_pSh->IsEnableSetModified());

                            m_pSh->EnableSetModified(false);

                            // tdf#116066: DoSaveCompleted should be called after SetReadOnlyUI

                            m_pSh->DoSaveCompleted(m_pMed);

                            m_pSh->Broadcast(SfxHint(SfxHintId::ModeChanged));

                            m_pSh->EnableSetModified(isEnableSetModified);

                        }

                    }

                }

                ~ReadOnlyUIGuard()

                {

                    suppress_fun_call_w_exception(ImplDestroy());

                }

            } aReadOnlyUIGuard(this, pSh);

            SfxMedium* pMed = pSh->GetMedium();

            std::shared_ptr<std::recursive_mutex> pChkEditMutex = pMed->GetCheckEditableMutex();

            std::unique_lock<std::recursive_mutex> chkEditLock;

            if (pChkEditMutex != nullptr)

                chkEditLock = std::unique_lock<std::recursive_mutex>(*pChkEditMutex);

            pMed->CancelCheckEditableEntry();

            const SfxBoolItem* pItem = pMed->GetItemSet().GetItem(SID_VIEWONLY, false);

            if ( pItem && pItem->GetValue() )

            {

                SfxApplication* pApp = SfxGetpApp();

                SfxAllItemSet aSet( pApp->GetPool() );

                aSet.Put( SfxStringItem( SID_FILE_NAME, pMed->GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::NONE) ) );

                aSet.Put( SfxBoolItem( SID_TEMPLATE, true ) );

                aSet.Put( SfxStringItem( SID_TARGETNAME, u"_blank"_ustr ) );

                const SfxStringItem* pReferer = pMed->GetItemSet().GetItem(SID_REFERER, false);

                if ( pReferer )

                    aSet.Put( *pReferer );

                const SfxInt16Item* pVersionItem = pMed->GetItemSet().GetItem(SID_VERSION, false);

                if ( pVersionItem )

                    aSet.Put( *pVersionItem );

                if( pMed->GetFilter() )

                {

                    aSet.Put( SfxStringItem( SID_FILTER_NAME, pMed->GetFilter()->GetFilterName() ) );

                    const SfxStringItem* pOptions = pMed->GetItemSet().GetItem(SID_FILE_FILTEROPTIONS, false);

                    if ( pOptions )

                        aSet.Put( *pOptions );

                }

                GetDispatcher()->Execute( SID_OPENDOC, SfxCallMode::ASYNCHRON, aSet );

                return;

            }

            StreamMode nOpenMode;

            bool bNeedsReload = false;

            bool bPasswordEntered = false;

            if ( !pSh->IsReadOnly() )

            {

                // Save and reload Readonly

                if( pSh->IsModified() )

                {

                    if ( pSh->PrepareClose() )

                    {

                        // the storing could let the medium be changed

                        pMed = pSh->GetMedium();

                        bNeedsReload = true;

                    }

                    else

                    {

                        rReq.SetReturnValue( SfxBoolItem( rReq.GetSlot(), false ) );

                        return;

                    }

                }

                nOpenMode = SFX_STREAM_READONLY;

                aReadOnlyUIGuard.m_bSetRO = true;

            }

            else

            {

                if ( pSh->IsReadOnlyMedium()

                  && ( pSh->GetModifyPasswordHash() || pSh->GetModifyPasswordInfo().hasElements() )

                  && !pSh->IsModifyPasswordEntered() )

                {

                    const OUString aDocumentName = INetURLObject( pMed->GetOrigURL() ).GetMainURL( INetURLObject::DecodeMechanism::WithCharset );

                    if( !AskPasswordToModify_Impl( pMed->GetInteractionHandler(), aDocumentName, pMed->GetFilter(), pSh->GetModifyPasswordHash(), pSh->GetModifyPasswordInfo() ) )

                    {

                        // this is a read-only document, if it has "Password to modify"

                        // the user should enter password before he can edit the document

                        rReq.SetReturnValue( SfxBoolItem( rReq.GetSlot(), false ) );

                        return;

                    }

                    pSh->SetModifyPasswordEntered();

                    bPasswordEntered = true;

                }

                nOpenMode = pSh->IsOriginallyReadOnlyMedium() ? SFX_STREAM_READONLY : SFX_STREAM_READWRITE;

                aReadOnlyUIGuard.m_bSetRO = false;

                if (pMed->HasRestrictedFonts())

                    bNeedsReload = true; // Let it ask user, reload fonts, etc.

                // if only the view was in the readonly mode then there is no need to do the reload

                if ( !pSh->IsReadOnlyMedium() )

                {

                    // SetReadOnlyUI causes recomputation of window title, using

                    // open mode among other things, so call SetOpenMode before

                    // SetReadOnlyUI:

                    pMed->SetOpenMode( nOpenMode );

                    return;

                }

            }

            if ( rReq.IsAPI() )

            {

                // Control through API if r/w or r/o

                const SfxBoolItem* pEditItem = rReq.GetArg(SID_EDITDOC);

                if ( pEditItem )

                    nOpenMode = pEditItem->GetValue() ? SFX_STREAM_READWRITE : SFX_STREAM_READONLY;

            }

            // doing

            OUString sTemp;

            osl::FileBase::getFileURLFromSystemPath( pMed->GetPhysicalName(), sTemp );

            INetURLObject aPhysObj( sTemp );

            const SfxInt16Item* pVersionItem = pMed->GetItemSet().GetItem(SID_VERSION, false);

            INetURLObject aMedObj( pMed->GetName() );

            // -> tdf#82744

            // the logic below is following:

            // if the document seems not to need to be reloaded

            //     and the physical name is different to the logical one,

            // then on file system it can be checked that the copy is still newer than the original and no document reload is required.

            // Did some simplification to enhance readability of the 'if' expression

            //

            // when the 'http/https' protocol is active, the bool bPhysObjIsYounger relies upon the getlastmodified Property of a WebDAV resource.

            // Said property should be implemented, but sometimes it's not.

            // In this case the reload activated here will not work properly.

            // TODO: change the check age method for WebDAV to etag (entity-tag) property value, need some rethinking, since the

            // etag tells that the cache representation (e.g. in LO) is different from the one on the server,

            // but tells nothing about the age

            // Details at this link: http://tools.ietf.org/html/rfc4918#section-15, section 15.7

            bool bIsWebDAV = aMedObj.isAnyKnownWebDAVScheme();

            // tdf#118938 Reload the document when the user enters the editing password,

            //            even if the physical name isn't different to the logical name.

            if ( ( !bNeedsReload && ( ( aMedObj.GetProtocol() == INetProtocol::File &&

                                        ( aMedObj.getFSysPath( FSysStyle::Detect ) != aPhysObj.getFSysPath( FSysStyle::Detect )

                                          || bPasswordEntered ) &&

                                        !physObjIsOlder(aMedObj, aPhysObj))

                                      || (bIsWebDAV && !physObjIsOlder(aMedObj, aPhysObj))

                                      || ( pMed->IsRemote() && !bIsWebDAV ) ) )

                 || pVersionItem )

            // <- tdf#82744

            {

                bool bOK = false;

                bool bRetryIgnoringLock = false;

                bool bOpenTemplate = false;

                std::optional<bool> aOrigROVal;

                if (!pVersionItem)

                {

                    auto pRO = pMed->GetItemSet().GetItem<SfxBoolItem>(SID_DOC_READONLY, false);

                    if (pRO)

                        aOrigROVal = pRO->GetValue();

                }

                do {

                    LockFileEntry aLockData;

                    if ( !pVersionItem )

                    {

                        if (bRetryIgnoringLock)

                            pMed->ResetError();

                        bool bHasStorage = pMed->HasStorage_Impl();

                        // switching edit mode could be possible without reload

                        if ( bHasStorage && pMed->GetStorage() == pSh->GetStorage() )

                        {

                            // TODO/LATER: faster creation of copy

                            if ( !pSh->ConnectTmpStorage_Impl( pMed->GetStorage(), pMed ) )

                                return;

                        }

                        pMed->CloseAndRelease();

                        pMed->SetOpenMode( nOpenMode );

                        // We need to clear the SID_DOC_READONLY item from the set, to allow

                        // MediaDescriptor::impl_openStreamWithURL (called indirectly by

                        // SfxMedium::CompleteReOpen) to properly fill input stream of the

                        // descriptor, even when the file can't be open in read-write mode.

                        // Only then can following call to SfxMedium::LockOrigFileOnDemand

                        // return proper information about who has locked the file, to show

                        // in the SfxQueryOpenAsTemplate box below; otherwise it exits right

                        // after call to SfxMedium::GetMedium_Impl. This mimics what happens

                        // when the file is opened initially, when filter detection code also

                        // calls MediaDescriptor::impl_openStreamWithURL without the item set.

                        pMed->GetItemSet().ClearItem(SID_DOC_READONLY);

                        pMed->CompleteReOpen();

                        pMed->GetItemSet().Put(

                            SfxBoolItem(SID_DOC_READONLY, !(nOpenMode & StreamMode::WRITE)));

                        if ( nOpenMode & StreamMode::WRITE )

                        {

                            auto eResult = pMed->LockOrigFileOnDemand(

                                true, true, bRetryIgnoringLock, &aLockData);

                            bRetryIgnoringLock

                                = eResult == SfxMedium::LockFileResult::FailedLockFile;

                        }

                        // LockOrigFileOnDemand might set the readonly flag itself, it should be set back

                        pMed->GetItemSet().Put( SfxBoolItem( SID_DOC_READONLY, !( nOpenMode & StreamMode::WRITE ) ) );

                        if ( !pMed->GetErrorCode() )

                            bOK = true;

                    }

                    if( !bOK )

                    {

                        if (nOpenMode == SFX_STREAM_READWRITE && !rReq.IsAPI())

                        {

                            // css::sdbcx::User offering to open it as a template

                            SfxQueryOpenAsTemplate aBox(GetWindow().GetFrameWeld(),

                                                        bRetryIgnoringLock, aLockData);

                            short nUserAnswer = aBox.run();

                            bOpenTemplate = RET_YES == nUserAnswer;

                            // Always reset this here to avoid infinite loop

                            bRetryIgnoringLock = RET_IGNORE == nUserAnswer;

                            if (RET_CANCEL == nUserAnswer)

                                pMed->AddToCheckEditableWorkerList();

                        }

                        else

                            bRetryIgnoringLock = false;

                    }

                }

                while ( !bOK && bRetryIgnoringLock );

                if( !bOK )

                {

                    ErrCodeMsg nErr = pMed->GetErrorCode();

                    if ( pVersionItem )

                        nErr = ERRCODE_IO_ACCESSDENIED;

                    else

                    {

                        pMed->ResetError();

                        pMed->SetOpenMode( SFX_STREAM_READONLY );

                        if (aOrigROVal)

                            pMed->GetItemSet().Put(SfxBoolItem(SID_DOC_READONLY, *aOrigROVal));

                        else

                            pMed->GetItemSet().ClearItem(SID_DOC_READONLY);

                        pMed->ReOpen();

                        pSh->DoSaveCompleted( pMed );

                    }

                    // Readonly document can not be switched to edit mode?

                    rReq.Done();

                    if ( nOpenMode == SFX_STREAM_READWRITE && !rReq.IsAPI() )

                    {

                        if ( bOpenTemplate )

                        {

                            SfxApplication* pApp = SfxGetpApp();

                            SfxAllItemSet aSet( pApp->GetPool() );

                            aSet.Put( SfxStringItem( SID_FILE_NAME, pMed->GetName() ) );

                            const SfxStringItem* pReferer = pMed->GetItemSet().GetItem(SID_REFERER, false);

                            if ( pReferer )

                                aSet.Put( *pReferer );

                            aSet.Put( SfxBoolItem( SID_TEMPLATE, true ) );

                            if ( pVersionItem )

                                aSet.Put( *pVersionItem );

                            if( pMed->GetFilter() )

                            {

                                aSet.Put( SfxStringItem( SID_FILTER_NAME, pMed->GetFilter()->GetFilterName() ) );

                                const SfxStringItem* pOptions = pMed->GetItemSet().GetItem(SID_FILE_FILTEROPTIONS, false);

                                if ( pOptions )

                                    aSet.Put( *pOptions );

                            }

                            GetDispatcher()->Execute( SID_OPENDOC, SfxCallMode::ASYNCHRON, aSet );

                            return;

                        }

                        nErr = ERRCODE_NONE;

                    }

                    // Keep the read-only UI

                    aReadOnlyUIGuard.m_bSetRO = true;

                    ErrorHandler::HandleError( nErr );

                    rReq.SetReturnValue(

                        SfxBoolItem( rReq.GetSlot(), false ) );

                    return;

                }

                else

                {

                    aReadOnlyUIGuard.m_pMed = pMed;

                    rReq.SetReturnValue( SfxBoolItem( rReq.GetSlot(), true ) );

                    rReq.Done( true );

                    return;

                }

            }

            rReq.AppendItem( SfxBoolItem(SID_FORCERELOAD,

                    (rReq.GetSlot() == SID_EDITDOC

                     // tdf#151715 exclude files loaded from /tmp to avoid Notebookbar bugs

                     && (!pSh->IsOriginallyReadOnlyMedium() || pSh->IsOriginallyLoadedReadOnlyMedium()))

                    || bNeedsReload) );

            rReq.AppendItem( SfxBoolItem( SID_SILENT, true ));

            oForEdit = !aReadOnlyUIGuard.m_bSetRO;

            [[fallthrough]]; //TODO ???

        }

        case SID_RELOAD:

        {

            // Due to Double occupancy in toolboxes (with or without Ctrl),

            // it is also possible that the slot is enabled, but Ctrl-click

            // despite this is not!

            if ( !pSh || !pSh->CanReload_Impl() )

                break;

            SfxApplication* pApp = SfxGetpApp();

            const SfxBoolItem* pForceReloadItem = rReq.GetArg(SID_FORCERELOAD);

            if(  pForceReloadItem && !pForceReloadItem->GetValue() &&

                !pSh->GetMedium()->IsExpired() )

                return;

            if( m_pImpl->bReloading || pSh->IsInModalMode() )

                return;

            // AutoLoad is prohibited if possible

            const SfxBoolItem* pAutoLoadItem = rReq.GetArg(SID_AUTOLOAD);

            if ( pAutoLoadItem && pAutoLoadItem->GetValue() &&

                 GetFrame().IsAutoLoadLocked_Impl() )

                return;

            SfxObjectShellLock xOldObj( pSh );

            m_pImpl->bReloading = true;

            const SfxStringItem* pURLItem = rReq.GetArg(SID_FILE_NAME);

            // Open as editable?

            if (!oForEdit.has_value())

                oForEdit = !pSh->IsReadOnly();

            // If possible ask the User

            bool bDo = GetViewShell()->PrepareClose();

            const SfxBoolItem* pSilentItem = rReq.GetArg(SID_SILENT);

            if (getenv("SAL_NO_QUERYSAVE"))

                bDo = true;

            else if (bDo && GetFrame().DocIsModified_Impl() && !rReq.IsAPI()

                     && (!pSilentItem || !pSilentItem->GetValue()))

            {

                std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(

                    GetWindow().GetFrameWeld(), VclMessageType::Question, VclButtonsType::YesNo,

                    SfxResId(STR_QUERY_LASTVERSION)));

                bDo = RET_YES == xBox->run();

            }

            if ( bDo )

            {

                SfxMedium *pMedium = xOldObj->GetMedium();

                std::shared_ptr<std::recursive_mutex> pChkEditMutex

                    = pMedium->GetCheckEditableMutex();

                std::unique_lock<std::recursive_mutex> chkEditLock;

                if (pChkEditMutex != nullptr)

                    chkEditLock = std::unique_lock<std::recursive_mutex>(*pChkEditMutex);

                pMedium->CancelCheckEditableEntry();

                bool bHandsOff =

                    ( pMedium->GetURLObject().GetProtocol() == INetProtocol::File && !xOldObj->IsDocShared() );

                // Empty existing SfxMDIFrames for this Document

                // in native format or R/O, open it now for editing?

                SfxObjectShellLock xNewObj;

                // collect the views of the document

                // TODO: when UNO ViewFactories are available for SFX-based documents, the below code should

                // be UNOized, too

                typedef ::std::pair< Reference< XFrame >, SfxInterfaceId >  ViewDescriptor;

                ::std::vector< ViewDescriptor > aViewFrames;

                SfxViewFrame *pView = GetFirst( xOldObj );

                while ( pView )

                {

                    Reference< XFrame > xFrame( pView->GetFrame().GetFrameInterface() );

                    SAL_WARN_IF( !xFrame.is(), "sfx.view", "SfxViewFrame::ExecReload_Impl: no XFrame?!");

                    aViewFrames.emplace_back( xFrame, pView->GetCurViewId() );

                    pView = GetNext( *pView, xOldObj );

                }

                xOldObj->Get_Impl()->pReloadTimer.reset();

                std::optional<SfxAllItemSet> pNewSet;

                std::shared_ptr<const SfxFilter> pFilter = pMedium->GetFilter();

                if( pURLItem )

                {

                    pNewSet.emplace( pApp->GetPool() );

                    pNewSet->Put( *pURLItem );

                    // Filter Detection

                    OUString referer;

                    const SfxStringItem* refererItem = rReq.GetArg(SID_REFERER);

                    if (refererItem != nullptr) {

                        referer = refererItem->GetValue();

                    }

                    SfxMedium aMedium( pURLItem->GetValue(), referer, SFX_STREAM_READWRITE );

                    SfxFilterMatcher().GuessFilter( aMedium, pFilter );

                    if ( pFilter )

                        pNewSet->Put( SfxStringItem( SID_FILTER_NAME, pFilter->GetName() ) );

                    pNewSet->Put( aMedium.GetItemSet() );

                }

                else

                {

                    pNewSet.emplace( pMedium->GetItemSet() );

                    pNewSet->ClearItem( SID_VIEW_ID );

                    pNewSet->ClearItem( SID_STREAM );

                    pNewSet->ClearItem( SID_INPUTSTREAM );

                    pNewSet->Put( SfxStringItem( SID_FILTER_NAME, pMedium->GetFilter()->GetName() ) );

                    // let the current security settings be checked again

                    pNewSet->Put( SfxUInt16Item( SID_MACROEXECMODE, document::MacroExecMode::USE_CONFIG ) );

                    if ( pSh->IsOriginallyReadOnlyMedium()

                         || pSh->IsOriginallyLoadedReadOnlyMedium() )

                        // edit mode is switched or reload of readonly document

                        pNewSet->Put( SfxBoolItem( SID_DOC_READONLY, true ) );

                    else

                        // Reload of file opened for writing

                        pNewSet->ClearItem( SID_DOC_READONLY );

                }

                // If a salvaged file is present, do not enclose the OrigURL

                // again, since the Template is invalid after reload.

                const SfxStringItem* pSalvageItem = pNewSet->GetItem(SID_DOC_SALVAGE, false);

                if( pSalvageItem )

                {

                    pNewSet->ClearItem( SID_DOC_SALVAGE );

                }

#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT

                // TODO/LATER: Temporary solution, the SfxMedium must know the original URL as aLogicName

                //             SfxMedium::Transfer_Impl() will be forbidden then.

                if ( xOldObj->IsDocShared() )

                    pNewSet->Put( SfxStringItem( SID_FILE_NAME, xOldObj->GetSharedFileURL() ) );

#endif

                if ( pURLItem )

                    pNewSet->Put( SfxStringItem( SID_REFERER, pMedium->GetName() ) );

                else

                    pNewSet->Put( SfxStringItem( SID_REFERER, OUString() ) );

                xOldObj->CancelTransfers();

                if ( pSilentItem && pSilentItem->GetValue() )

                    pNewSet->Put( SfxBoolItem( SID_SILENT, true ) );

                const SfxUnoAnyItem* pInteractionItem = pNewSet->GetItem(SID_INTERACTIONHANDLER, false);

                const SfxUInt16Item* pMacroExecItem = pNewSet->GetItem(SID_MACROEXECMODE, false);

                const SfxUInt16Item* pDocTemplateItem = pNewSet->GetItem(SID_UPDATEDOCMODE, false);

                if (!pInteractionItem)

                {

                    Reference < task::XInteractionHandler2 > xHdl = task::InteractionHandler::createWithParent( ::comphelper::getProcessComponentContext(), nullptr );

                    if (xHdl.is())

                        pNewSet->Put( SfxUnoAnyItem(SID_INTERACTIONHANDLER,css::uno::Any(xHdl)) );

                }

                if (!pMacroExecItem)

                    pNewSet->Put( SfxUInt16Item(SID_MACROEXECMODE,css::document::MacroExecMode::USE_CONFIG) );

                if (!pDocTemplateItem)

                    pNewSet->Put( SfxUInt16Item(SID_UPDATEDOCMODE,css::document::UpdateDocMode::ACCORDING_TO_CONFIG) );

                xOldObj->SetModified( false );

                // Do not cache the old Document! Is invalid when loading

                // another document.

                bool bHasStorage = pMedium->HasStorage_Impl();

                if( bHandsOff )

                {

                    if ( bHasStorage && pMedium->GetStorage() == xOldObj->GetStorage() )

                    {

                        // TODO/LATER: faster creation of copy

                        if ( !xOldObj->ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium ) )

                            return;

                    }

                    pMedium->CloseAndRelease();

                }

                xNewObj = SfxObjectShell::CreateObject( pFilter->GetServiceName() );

                if ( xOldObj->IsModifyPasswordEntered() )

                    xNewObj->SetModifyPasswordEntered();

                comphelper::SequenceAsHashMap aLoadArgs = TransformItems(SID_OPENDOC, *pNewSet);

                try

                {

                    uno::Reference < frame::XLoadable > xLoad( xNewObj->GetModel(), uno::UNO_QUERY );

                    xLoad->load(aLoadArgs.getAsConstPropertyValueList());

                }

                catch ( uno::Exception& )

                {

                    xNewObj->DoClose();

                    xNewObj = nullptr;

                    pMedium->AddToCheckEditableWorkerList();

                }

                pNewSet.reset();

                if( !xNewObj.Is() )

                {

                    if( bHandsOff )

                    {

                        // back to old medium

                        pMedium->ReOpen();

                        pMedium->LockOrigFileOnDemand( false, true );

                        xOldObj->DoSaveCompleted( pMedium );

                    }

                }

                else

                {

                    if ( xNewObj->GetModifyPasswordHash() && xNewObj->GetModifyPasswordHash() != xOldObj->GetModifyPasswordHash() )

                    {

                        xNewObj->SetModifyPasswordEntered( false );

                        xNewObj->SetReadOnly();

                    }

                    else if ( rReq.GetSlot() == SID_EDITDOC || rReq.GetSlot() == SID_READONLYDOC )

                    {

                        xNewObj->SetReadOnlyUI(!*oForEdit);

                    }

#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT

                    if ( xNewObj->IsDocShared() )

                    {

                        // the file is shared but the closing can change the sharing control file

                        xOldObj->DoNotCleanShareControlFile();

                    }

#endif

                    // the Reload and Silent items were only temporary, remove them

                    xNewObj->GetMedium()->GetItemSet().ClearItem( SID_RELOAD );

                    xNewObj->GetMedium()->GetItemSet().ClearItem( SID_SILENT );

                    aLoadArgs = TransformItems(SID_OPENDOC, xNewObj->GetMedium()->GetItemSet());

                    UpdateDocument_Impl();

                    auto sModule = vcl::CommandInfoProvider::GetModuleIdentifier(GetFrame().GetFrameInterface());

                    OUString sReloadNotebookBar;

                    if (sModule == "com.sun.star.text.TextDocument")

                        sReloadNotebookBar = u"modules/swriter/ui/"_ustr;

                    else if (sModule == "com.sun.star.sheet.SpreadsheetDocument")

                        sReloadNotebookBar = u"modules/scalc/ui/"_ustr;

                    else if (sfx2::SfxNotebookBar::IsActive()

                             && sModule != "presentation.PresentationDocument"

                             && sModule != "com.sun.star.drawing.DrawingDocument")

                    {

                        assert(false && "SID_RELOAD Notebookbar active, but not refreshed here");

                    }

                    try

                    {

                        const auto aArgs = aLoadArgs.getAsConstPropertyValueList();

                        for (auto const& viewFrame : aViewFrames)

                        {

                            LoadViewIntoFrame_Impl(*xNewObj, viewFrame.first, aArgs, viewFrame.second, false);

                        }

                        aViewFrames.clear();

                    }

                    catch( const Exception& )

                    {

                        // close the remaining frames

                        // Don't catch exceptions herein, if this fails, then we're left in an indetermined state, and

                        // crashing is better than trying to proceed

                        for (auto const& viewFrame : aViewFrames)

                        {

                            Reference< util::XCloseable > xClose( viewFrame.first, UNO_QUERY_THROW );