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

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

#include <o3tl/any.hxx>

#include <vcl/graphicfilter.hxx>

#include <com/sun/star/sdb/DatabaseContext.hpp>

#include <com/sun/star/ui/dialogs/XFilePicker3.hpp>

#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>

#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>

#include <com/sun/star/ui/dialogs/ListboxControlActions.hpp>

#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>

#include <com/sun/star/linguistic2/XProofreadingIterator.hpp>

#include <com/sun/star/linguistic2/XDictionary.hpp>

#include <comphelper/propertyvalue.hxx>

#include <officecfg/Office/Common.hxx>

#include <SwCapObjType.hxx>

#include <SwStyleNameMapper.hxx>

#include <docary.hxx>

#include <hintids.hxx>

#include <SwRewriter.hxx>

#include <numrule.hxx>

#include <swundo.hxx>

#include <svl/PasswordHelper.hxx>

#include <svl/urihelper.hxx>

#include <sfx2/passwd.hxx>

#include <sfx2/sfxdlg.hxx>

#include <sfx2/filedlghelper.hxx>

#include <editeng/langitem.hxx>

#include <svx/linkwarn.hxx>

#include <svx/statusitem.hxx>

#include <svx/viewlayoutitem.hxx>

#include <svx/zoomslideritem.hxx>

#include <sfx2/lokhelper.hxx>

#include <sfx2/htmlmode.hxx>

#include <vcl/svapp.hxx>

#include <sfx2/app.hxx>

#include <sfx2/request.hxx>

#include <sfx2/bindings.hxx>

#include <editeng/lrspitem.hxx>

#include <unotools/localedatawrapper.hxx>

#include <unotools/syslocale.hxx>

#include <editeng/unolingu.hxx>

#include <vcl/weld.hxx>

#include <editeng/tstpitem.hxx>

#include <sfx2/event.hxx>

#include <sfx2/docfile.hxx>

#include <sfx2/docfilt.hxx>

#include <sfx2/fcontnr.hxx>

#include <editeng/sizeitem.hxx>

#include <sfx2/dispatch.hxx>

#include <svl/whiter.hxx>

#include <svl/ptitem.hxx>

#include <sfx2/viewfrm.hxx>

#include <vcl/errinf.hxx>

#include <tools/hostfilter.hxx>

#include <tools/urlobj.hxx>

#include <svx/svdview.hxx>

#include <swtypes.hxx>

#include <swwait.hxx>

#include <redlndlg.hxx>

#include <view.hxx>

#include <uivwimp.hxx>

#include <docsh.hxx>

#include <doc.hxx>

#include <printdata.hxx>

#include <IDocumentDeviceAccess.hxx>

#include <IDocumentRedlineAccess.hxx>

#include <DocumentRedlineManager.hxx>

#include <IDocumentUndoRedo.hxx>

#include <IDocumentSettingAccess.hxx>

#include <IDocumentDrawModelAccess.hxx>

#include <IDocumentStatistics.hxx>

#include <IDocumentOutlineNodes.hxx>

#include <wrtsh.hxx>

#include <viewopt.hxx>

#include <basesh.hxx>

#include <swmodule.hxx>

#include <uitool.hxx>

#include <shellio.hxx>

#include <fmtinfmt.hxx>

#include <mdiexp.hxx>

#include <drawbase.hxx>

#include <frmatr.hxx>

#include <frmmgr.hxx>

#include <pagedesc.hxx>

#include <section.hxx>

#include <tox.hxx>

#include <edtwin.hxx>

#include <wview.hxx>

#include <cmdid.h>

#include <sfx2/strings.hrc>

#include <sfx2/sfxresid.hxx>

#include <strings.hrc>

#include <swerror.h>

#include <globals.hrc>

#include <fmtclds.hxx>

#include <sfx2/templatedlg.hxx>

#include <dbconfig.hxx>

#include <dbmgr.hxx>

#include <reffld.hxx>

#include <comphelper/lok.hxx>

#include <comphelper/string.hxx>

#include <comphelper/docpasswordhelper.hxx>

#include <svtools/strings.hrc>

#include <svtools/svtresid.hxx>

#include <PostItMgr.hxx>

#include <comphelper/processfactory.hxx>

#include <LibreOfficeKit/LibreOfficeKitEnums.h>

#include <svx/svxdlg.hxx>

#include <swabstdlg.hxx>

#include <fmthdft.hxx>

#include <unotextrange.hxx>

#include <docstat.hxx>

#include <wordcountdialog.hxx>

#include <OnlineAccessibilityCheck.hxx>

#include <sfx2/sidebar/Sidebar.hxx>

#include <vcl/GraphicNativeTransform.hxx>

#include <vcl/GraphicNativeMetadata.hxx>

#include <vcl/settings.hxx>

#include <i18nutil/searchopt.hxx>

#include <osl/diagnose.h>

#include <paratr.hxx>

#include <rootfrm.hxx>

#include <frameformats.hxx>

#include <viewimp.hxx>

#include <pagefrm.hxx>

#include <memory>

#include <string_view>

#include <svl/slstitm.hxx>

#include <basegfx/utils/zoomtools.hxx>

#include <ndtxt.hxx>

#include <grfatr.hxx>

#include <svx/srchdlg.hxx>

#include <o3tl/string_view.hxx>

#include <svx/dialog/gotodlg.hxx>

const char sStatusDelim[] = " : ";

using namespace sfx2;

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

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

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

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

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

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

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

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

using namespace ::com::sun::star::ui::dialogs;

namespace {

class SwNumberInputDlg : public SfxDialogController

{

private:

    std::unique_ptr<weld::Label> m_xLabel1;

    std::unique_ptr<weld::SpinButton> m_xSpinButton;

    std::unique_ptr<weld::Label> m_xLabel2;

    std::unique_ptr<weld::Button> m_xOKButton;

    DECL_LINK(InputModifiedHdl, weld::Entry&, void);

public:

    SwNumberInputDlg(weld::Window* pParent, const OUString& rTitle,

        const OUString& rLabel1, const sal_Int64 nValue, const sal_Int64 min, const sal_Int64 max,

        const OUString& rLabel2 = OUString())

        : SfxDialogController(pParent, u"modules/swriter/ui/numberinput.ui"_ustr, u"NumberInputDialog"_ustr)

        , m_xLabel1(m_xBuilder->weld_label(u"label1"_ustr))

        , m_xSpinButton(m_xBuilder->weld_spin_button(u"spinbutton"_ustr))

        , m_xLabel2(m_xBuilder->weld_label(u"label2"_ustr))

        , m_xOKButton(m_xBuilder->weld_button(u"ok"_ustr))

    {

        m_xDialog->set_title(rTitle);

        m_xLabel1->set_label(rLabel1);

        m_xSpinButton->set_value(nValue);

        m_xSpinButton->set_range(min, max);

        m_xSpinButton->set_position(-1);

        m_xSpinButton->select_region(0, -1);

        m_xSpinButton->connect_changed(LINK(this, SwNumberInputDlg, InputModifiedHdl));

        if (!rLabel2.isEmpty())

        {

            m_xLabel2->set_label(rLabel2);

            m_xLabel2->show();

        }

    }

    auto GetNumber()

    {

        return m_xSpinButton->get_text().toInt32();

    }

};

IMPL_LINK_NOARG(SwNumberInputDlg, InputModifiedHdl, weld::Entry&, void)

{

    m_xOKButton->set_sensitive(!m_xSpinButton->get_text().isEmpty());

    if (!m_xOKButton->get_sensitive())

        return;

    auto nValue = m_xSpinButton->get_text().toInt32();

    if (nValue <= m_xSpinButton->get_min())

        m_xSpinButton->set_value(m_xSpinButton->get_min());

    else if (nValue > m_xSpinButton->get_max())

        m_xSpinButton->set_value(m_xSpinButton->get_max());

    else

        m_xSpinButton->set_value(nValue);

    m_xSpinButton->set_position(-1);

}

}

static void lcl_SetAllTextToDefaultLanguage( SwWrtShell &rWrtSh, TypedWhichId<SvxLanguageItem> nWhichId )

{

    if (!(nWhichId == RES_CHRATR_LANGUAGE ||

          nWhichId == RES_CHRATR_CJK_LANGUAGE ||

          nWhichId == RES_CHRATR_CTL_LANGUAGE))

        return;

    rWrtSh.StartAction();

    rWrtSh.LockView( true );

    rWrtSh.Push();

    // prepare to apply new language to all text in document

    rWrtSh.SelAll();

    rWrtSh.ExtendedSelectAll();

    // set language attribute to default for all text

    rWrtSh.ResetAttr({ nWhichId });

    rWrtSh.Pop(SwCursorShell::PopMode::DeleteCurrent);

    rWrtSh.LockView( false );

    rWrtSh.EndAction();

}

/**

 * Create string for showing the page number in the statusbar

 *

 * @param nPhyNum  The physical page number

 * @param nVirtNum The logical page number (user-assigned)

 * @param rPgStr   User-defined page name (will be shown if different from logical page number)

 *

 * @return OUString Formatted string: Page 1 of 10 (Page 1 of 8 to print OR Page nVirtNumv/rPgStr)

 **/

OUString SwView::GetPageStr(sal_uInt16 nPhyNum, sal_uInt16 nVirtNum, const OUString& rPgStr)

{

    // Show user-defined page number in brackets if any.

    OUString extra;

    if (!rPgStr.isEmpty() && std::u16string_view(OUString::number(nPhyNum)) != rPgStr)

        extra = rPgStr;

    else if (nPhyNum != nVirtNum)

        extra = OUString::number(nVirtNum);

    sal_uInt16 nPageCount = GetWrtShell().GetPageCnt();

    sal_uInt16 nPrintedPhyNum = nPhyNum;

    sal_uInt16 nPrintedPageCount = nPageCount;

    if (!GetWrtShell().getIDocumentDeviceAccess().getPrintData().IsPrintEmptyPages())

        SwDoc::CalculateNonBlankPages(*m_pWrtShell->GetLayout(), nPrintedPageCount, nPrintedPhyNum);

    // Show printed page numbers only, when they are different

    OUString aStr( nPageCount != nPrintedPageCount

                    ? SwResId(STR_PAGE_COUNT_PRINTED)

                    : (extra.isEmpty() ? SwResId(STR_PAGE_COUNT) : SwResId(STR_PAGE_COUNT_CUSTOM)));

    aStr = aStr.replaceFirst("%1", OUString::number(nPhyNum));

    if (nPageCount != nPrintedPageCount)

    {

        aStr = aStr.replaceFirst("%2", OUString::number(nPageCount));

        aStr = aStr.replaceFirst("%3", OUString::number(nPrintedPhyNum));

        aStr = aStr.replaceFirst("%4", OUString::number(nPrintedPageCount));

    }

    else {

        if (extra.isEmpty())

            aStr = aStr.replaceFirst("%2", OUString::number(nPageCount));

        else

        {

            aStr = aStr.replaceFirst("%2", extra);

            aStr = aStr.replaceFirst("%3", OUString::number(nPageCount));

        }

    }

    return aStr;

}

ErrCode SwView::InsertGraphic( const OUString &rPath, const OUString &rFilter,

                                bool bLink, GraphicFilter *pFilter )

{

    SwWait aWait( *GetDocShell(), true );

    Graphic aGraphic;

    ErrCode aResult = ERRCODE_NONE;

    if( !pFilter )

    {

        pFilter = &GraphicFilter::GetGraphicFilter();

    }

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

    {

        INetURLObject aURL(rPath);

        if (INetProtocol::File != aURL.GetProtocol() && HostFilter::isForbidden(aURL.GetHost()))

            SfxLokHelper::sendNetworkAccessError("insert");

    }

    auto xHandler(GetDocShell()->GetMedium()->GetInteractionHandler());

    aResult = GraphicFilter::LoadGraphic(rPath, rFilter, aGraphic, pFilter, nullptr, xHandler);

    if( ERRCODE_NONE == aResult )

    {

        Degree10 aRotation;

        GraphicNativeMetadata aMetadata;

        if ( aMetadata.read(aGraphic) )

            aRotation = aMetadata.getRotation();

        SwWrtShell& rShell = GetWrtShell();

        SwFlyFrameAttrMgr aFrameManager( true, &rShell, Frmmgr_Type::GRF, nullptr );

        // #i123922# determine if we really want to insert or replace the graphic at a selected object

        const bool bReplaceMode(rShell.HasSelection() && SelectionType::Frame == rShell.GetSelectionType());

        if(bReplaceMode)

        {

            // #i123922# Do same as in D&D, ReRead graphic and all is done

            rShell.ReRead(

                bLink ? rPath : OUString(),

                bLink ? rFilter : OUString(),

                &aGraphic);

        }

        else

        {

            rShell.StartAction();

            if( bLink )

            {

                SwDocShell* pDocSh = GetDocShell();

                INetURLObject aTemp(

                    pDocSh->HasName() ?

                        pDocSh->GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ) :

                        OUString());

                OUString sURL = URIHelper::SmartRel2Abs(

                    aTemp, rPath, URIHelper::GetMaybeFileHdl() );

                aGraphic.setOriginURL(sURL);

                rShell.InsertGraphic( sURL, rFilter, aGraphic, &aFrameManager );

            }

            else

            {

                rShell.InsertGraphic( OUString(), OUString(), aGraphic, &aFrameManager );

            }

            if (aRotation)

            {

                SfxItemSetFixed<RES_GRFATR_ROTATION, RES_GRFATR_ROTATION> aSet( rShell.GetAttrPool() );

                rShell.GetCurAttr( aSet );

                const SwRotationGrf& rRotation = aSet.Get(RES_GRFATR_ROTATION);

                aFrameManager.SetRotation(rRotation.GetValue(), aRotation, rRotation.GetUnrotatedSize());

            }

            // it is too late after "EndAction" because the Shell can already be destroyed.

            rShell.EndAction();

        }

    }

    return aResult;

}

bool SwView::InsertGraphicDlg( SfxRequest& rReq )

{

    bool bReturn = false;

    SwDocShell* pDocShell = GetDocShell();

    SwDoc* pDoc = pDocShell->GetDoc();

    UIName sGraphicFormat( SwResId(STR_POOLFRM_GRAPHIC) );

    const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(SID_INSERT_GRAPHIC);

    bool bShowError = !pName;

    // No file pickers in a non-desktop (mobile app) build.

#if HAVE_FEATURE_DESKTOP

    // when in HTML mode insert only as a link

    const sal_uInt16 nHtmlMode = ::GetHtmlMode(pDocShell);

    if (!pName && !Application::IsHeadlessModeEnabled())

    {

        std::unique_ptr<FileDialogHelper> pFileDlg(new FileDialogHelper(

            ui::dialogs::TemplateDescription::FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE,

            FileDialogFlags::Graphic, GetFrameWeld()));

        pFileDlg->SetTitle(SwResId(STR_INSERT_GRAPHIC ));

        pFileDlg->SetContext( FileDialogHelper::WriterInsertImage );

        uno::Reference < XFilePicker3 > xFP = pFileDlg->GetFilePicker();

        uno::Reference < XFilePickerControlAccess > xCtrlAcc(xFP, UNO_QUERY);

        if(nHtmlMode & HTMLMODE_ON)

        {

            xCtrlAcc->setValue( ExtendedFilePickerElementIds::CHECKBOX_LINK, 0, Any(true));

            xCtrlAcc->enableControl( ExtendedFilePickerElementIds::CHECKBOX_LINK, false);

        }

        std::vector<OUString> aFormats;

        for( const auto& pSwFrameFormat : (*pDoc->GetFrameFormats()) )

        {

            const SwFrameFormat* pFormat = pSwFrameFormat;

            if(pFormat->IsDefault() || pFormat->IsAuto())

                continue;

            aFormats.push_back(pFormat->GetName().toString());

        }

        // pool formats

        const std::vector<OUString>& rFramePoolArr(

                SwStyleNameMapper::GetFrameFormatUINameArray());

        for(const auto & i : rFramePoolArr)

        {

            aFormats.push_back(i);

        }

        std::sort(aFormats.begin(), aFormats.end());

        aFormats.erase(std::unique(aFormats.begin(), aFormats.end()), aFormats.end());

        Sequence<OUString> aListBoxEntries(aFormats.size());

        OUString* pEntries = aListBoxEntries.getArray();

        sal_Int16 nSelect = 0;

        sal_Int16 i = 0;

        for( const auto& a : aFormats )

        {

            pEntries[i] = a;

            if(pEntries[i] == sGraphicFormat)

                nSelect = i;

            ++i;

        }

        try

        {

            Any aTemplates(&aListBoxEntries, cppu::UnoType<decltype(aListBoxEntries)>::get());

            xCtrlAcc->setValue( ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE,

                ListboxControlActions::ADD_ITEMS , aTemplates );

            Any aSelectPos(&nSelect, cppu::UnoType<decltype(nSelect)>::get());

            xCtrlAcc->setValue( ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE,

                ListboxControlActions::SET_SELECT_ITEM, aSelectPos );

        }

        catch (const Exception&)

        {

            OSL_FAIL("control access failed");

        }

        // execute file dialog, without capturing mouse (tdf#156033)

        vcl::Window* pWin = GetWindow();

        const bool bMouseCaptured = pWin && pWin->IsMouseCaptured();

        if (bMouseCaptured)

            pWin->ReleaseMouse();

        bool bHaveName =  ERRCODE_NONE == pFileDlg->Execute();

        if (bMouseCaptured)

            pWin->CaptureMouse();

        if (bHaveName)

        {

            rReq.AppendItem(SfxStringItem(SID_INSERT_GRAPHIC, pFileDlg->GetPath()));

            rReq.AppendItem(SfxStringItem(FN_PARAM_FILTER, pFileDlg->GetCurrentFilter()));

            pName = rReq.GetArg<SfxStringItem>(SID_INSERT_GRAPHIC);

            bool bAsLink = false;

            if(nHtmlMode & HTMLMODE_ON)

                bAsLink = true;

            else

            {

                try

                {

                    Any aVal = xCtrlAcc->getValue( ExtendedFilePickerElementIds::CHECKBOX_LINK, 0);

                    OSL_ENSURE(aVal.hasValue(), "Value CBX_INSERT_AS_LINK not found");

                    bAsLink = !aVal.hasValue() || *o3tl::doAccess<bool>(aVal);

                    Any aTemplateValue = xCtrlAcc->getValue(

                        ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE,

                        ListboxControlActions::GET_SELECTED_ITEM );

                    OUString sTmpl;

                    aTemplateValue >>= sTmpl;

                    rReq.AppendItem( SfxStringItem( FN_PARAM_2, sTmpl) );

                }

                catch (const Exception&)

                {

                    OSL_FAIL("control access failed");

                }

            }

            rReq.AppendItem( SfxBoolItem( FN_PARAM_1, bAsLink ) );

        }

    }

#endif

    if (pName)

    {

        OUString aFileName = pName->GetValue();

        OUString aFilterName;

        if (const SfxStringItem* pFilter = rReq.GetArg<SfxStringItem>(FN_PARAM_FILTER))

            aFilterName = pFilter->GetValue();

        bool bAsLink = false;

        if (const SfxBoolItem* pAsLink = rReq.GetArg<SfxBoolItem>(FN_PARAM_1))

            bAsLink = pAsLink->GetValue();

        if (const SfxStringItem* pStyle = rReq.GetArg<SfxStringItem>(FN_PARAM_2);

            pStyle && !pStyle->GetValue().isEmpty())

            sGraphicFormat = UIName(pStyle->GetValue());

#if HAVE_FEATURE_DESKTOP

        if( nHtmlMode & HTMLMODE_ON )

            bAsLink = true;

        else

        {

            // really store as link only?

            if (bAsLink && bShowError

                && officecfg::Office::Common::Misc::ShowLinkWarningDialog::get())

            {

                SvxLinkWarningDialog aWarnDlg(GetFrameWeld(), aFileName);

                if (aWarnDlg.run() != RET_OK)

                    bAsLink=false; // don't store as link

            }

        }

#endif

        SwWrtShell& rSh = GetWrtShell();

        rSh.LockPaint(LockPaintReason::InsertGraphic);

        rSh.StartAction();

        SwRewriter aRewriter;

        aRewriter.AddRule(UndoArg1, SwResId(STR_GRAPHIC_DEFNAME));

        // #i123922# determine if we really want to insert or replace the graphic at a selected object

        const bool bReplaceMode(rSh.HasSelection() && SelectionType::Frame == rSh.GetSelectionType());

        rSh.StartUndo(SwUndoId::INSERT, &aRewriter);

        ErrCode nError = InsertGraphic( aFileName, aFilterName, bAsLink, &GraphicFilter::GetGraphicFilter() );

        // format not equal to current filter (with autodetection)

        if( nError == ERRCODE_GRFILTER_FORMATERROR )

            nError = InsertGraphic( aFileName, OUString(), bAsLink, &GraphicFilter::GetGraphicFilter() );

        // #i123922# no new FrameFormat for replace mode, only when new object was created,

        // else this would reset the current setting for the frame holding the graphic

        if ( !bReplaceMode && rSh.IsFrameSelected() )

        {

            SwFrameFormat* pFormat = pDoc->FindFrameFormatByName( sGraphicFormat );

            if(!pFormat)

                pFormat = pDoc->MakeFrameFormat(sGraphicFormat,

                                        pDocShell->GetDoc()->GetDfltFrameFormat(),

                                        false);

            rSh.SetFrameFormat( pFormat );

        }

        TranslateId pResId;

        if( nError == ERRCODE_GRFILTER_OPENERROR )

            pResId = STR_GRFILTER_OPENERROR;

        else if( nError == ERRCODE_GRFILTER_IOERROR )

            pResId = STR_GRFILTER_IOERROR;

        else if( nError ==ERRCODE_GRFILTER_FORMATERROR )

            pResId = STR_GRFILTER_FORMATERROR;

        else if( nError ==ERRCODE_GRFILTER_VERSIONERROR )

            pResId = STR_GRFILTER_VERSIONERROR;

        else if( nError ==ERRCODE_GRFILTER_FILTERERROR )

            pResId = STR_GRFILTER_FILTERERROR;

        else if( nError ==ERRCODE_GRFILTER_TOOBIG )

            pResId = STR_GRFILTER_TOOBIG;

        rSh.EndAction();

        rSh.UnlockPaint();

        if (pResId)

        {

            if( bShowError )

            {

                std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),

                                                              VclMessageType::Info, VclButtonsType::Ok,

                                                              SwResId(pResId)));

                xInfoBox->run();

            }

            rReq.Ignore();

        }

        else

        {

            // set the specific graphic attributes to the graphic

            bReturn = true;

            AutoCaption( GRAPHIC_CAP );

            rReq.Done();

        }

        rSh.EndUndo(); // due to possible change of Shell

    }

    return bReturn;

}

void SwView::Execute(SfxRequest &rReq)

{

    const sal_uInt16 nSlot = rReq.GetSlot();

    const SfxItemSet* pArgs = rReq.GetArgs();

    const SfxPoolItem* pItem;

    bool bIgnore = false;

    switch( nSlot )

    {

        case SID_CREATE_SW_DRAWVIEW:

            m_pWrtShell->getIDocumentDrawModelAccess().GetOrCreateDrawModel();

            break;

        case FN_LINE_NUMBERING_DLG:

        {

            SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();

            ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateVclSwViewDialog(*this));

            VclAbstractDialog::AsyncContext aContext;

            aContext.maEndDialogFn = [](sal_Int32){};

            pDlg->StartExecuteAsync(aContext);

            break;

        }

        case FN_EDIT_LINK_DLG:

            EditLinkDlg();

            break;

        case SID_REFRESH_VIEW:

            GetEditWin().Invalidate();

            m_pWrtShell->Reformat();

            break;

        case FN_PAGEUP:

        case FN_PAGEUP_SEL:

        case FN_PAGEDOWN:

        case FN_PAGEDOWN_SEL:

        {

            tools::Rectangle aVis( GetVisArea() );

            SwEditWin& rTmpWin = GetEditWin();

            if ( FN_PAGEUP == nSlot || FN_PAGEUP_SEL == nSlot )

                PageUpCursor(FN_PAGEUP_SEL == nSlot);

            else

                PageDownCursor(FN_PAGEDOWN_SEL == nSlot);

            rReq.SetReturnValue(SfxBoolItem(nSlot,

                                                aVis != GetVisArea()));

            //#i42732# - notify the edit window that from now on we do not use the input language

            rTmpWin.SetUseInputLanguage( false );

        }

        break;

        case SID_ZOOM_IN:

        case SID_ZOOM_OUT:

        {

            sal_uInt16 nFact = m_pWrtShell->GetViewOptions()->GetZoom();

            if (SID_ZOOM_IN == nSlot)

                nFact = basegfx::zoomtools::zoomIn(nFact);

            else

                nFact = basegfx::zoomtools::zoomOut(nFact);

            SetZoom(SvxZoomType::PERCENT, nFact);

        }

        break;

        case FN_TO_PREV_PAGE:

        case FN_TO_NEXT_PAGE:

        {

            sal_uInt16 nPage = 0;

            if (m_pWrtShell->IsCursorVisible())

                nPage = m_pWrtShell->GetCursor()->GetPageNum();

            else

            {

                SwFrame* pPageFrame = m_pWrtShell->Imp()->GetFirstVisPage(m_pWrtShell->GetOut());

                if (pPageFrame)

                    nPage = pPageFrame->GetPhyPageNum();

            }

            if (nPage != 0)

            {

                sal_uInt16 nOldPage(nPage);

                if (FN_TO_PREV_PAGE == nSlot && nPage > 1)

                    nPage--;

                else if (FN_TO_NEXT_PAGE == nSlot && nPage < m_pWrtShell->GetPageCount())

                    nPage++;

                if (nPage != nOldPage)

                {

                    m_pWrtShell->LockPaint(LockPaintReason::GotoPage);

                    if (IsDrawMode())

                        LeaveDrawCreate();

                    m_pWrtShell->EnterStdMode();

                    m_pWrtShell->GotoPage(nPage, true);

                    // set visible area (borrowed from SwView::PhyPageUp/Down)

                    const Point aPt(m_aVisArea.Left(), m_pWrtShell->GetPagePos(nPage).Y());

                    Point aAlPt(AlignToPixel(aPt));

                    if(aPt.Y() != aAlPt.Y())

                        aAlPt.AdjustY(3 * GetEditWin().PixelToLogic(Size(0, 1)).Height());

                    SetVisArea(aAlPt);

                    m_pWrtShell->UnlockPaint();

                }

            }

        }

        break;

        case FN_SELECTION_CYCLE:

        {

            if (m_pWrtShell->IsSelFrameMode())

                break;

            if (!m_pWrtShell->IsStdMode())

                m_pWrtShell->EnterStdMode();

            SwShellCursor *pCursor = m_pWrtShell->SwCursorShell::GetCursor_();

            Point CurrMarkPt = pCursor->GetMkPos();

            Point CurrPointPt = pCursor->GetPtPos();

            sal_uInt16 nStep = m_aSelectCycle.nStep;

            if (nStep && (CurrMarkPt != m_aSelectCycle.m_MarkPt || CurrPointPt != m_aSelectCycle.m_PointPt))

                nStep = 0;

            switch(nStep)

            {

                case 0:

                    m_aSelectCycle.m_pInitialCursor = CurrPointPt;

                    m_pWrtShell->SwCursorShell::ClearMark();

                    m_pWrtShell->SelWrd(&CurrPointPt);

                    break;

                case 1:

                    m_pWrtShell->SelSentence(&CurrPointPt);

                    break;

                case 2:

                    m_pWrtShell->SelPara(&CurrPointPt);

                    break;

                case 3:

                    m_pWrtShell->SwCursorShell::ClearMark();

                    m_pWrtShell->SwCursorShell::SetCursor(m_aSelectCycle.m_pInitialCursor);

                    break;

            }

            nStep++;

            nStep %= 4;

            pCursor = m_pWrtShell->SwCursorShell::GetCursor_();

            m_aSelectCycle.m_MarkPt = pCursor->GetMkPos();

            m_aSelectCycle.m_PointPt = pCursor->GetPtPos();

            m_aSelectCycle.nStep = nStep;

        }

        break;

        case FN_REDLINE_ON:

        case FN_TRACK_CHANGES_IN_THIS_VIEW:

        case FN_TRACK_CHANGES_IN_ALL_VIEWS:

        {

            std::optional<bool> oOn;

            if( pArgs &&

                SfxItemState::SET == pArgs->GetItemState(nSlot, false, &pItem ))

            {

                oOn = static_cast<const SfxBoolItem*>(pItem)->GetValue();

            }

            else if (nSlot == FN_TRACK_CHANGES_IN_THIS_VIEW || nSlot == FN_TRACK_CHANGES_IN_ALL_VIEWS)

            {

                oOn = true;

            }

            if (oOn.has_value())

            {

                IDocumentRedlineAccess& rIDRA = m_pWrtShell->getIDocumentRedlineAccess();

                Sequence <sal_Int8> aPasswd = rIDRA.GetRedlinePassword();

                if( aPasswd.hasElements() )

                {

                    OSL_ENSURE( !oOn.value(), "SwView::Execute(): password set and redlining off doesn't match!" );

                    // xmlsec05:    new password dialog

                    SfxPasswordDialog aPasswdDlg(GetFrameWeld());

                    aPasswdDlg.SetMinLen(1);

                    //#i69751# the result of Execute() can be ignored

                    (void)aPasswdDlg.run();

                    OUString sNewPasswd(aPasswdDlg.GetPassword());

                    // password verification

                    bool bPasswordOk = false;

                    if (aPasswd.getLength() == 1 && aPasswd[0] == 1)

                    {

                        // dummy RedlinePassword from OOXML import: get real password info

                        // from the grab-bag to verify the password

                        const css::uno::Sequence< css::beans::PropertyValue > aDocumentProtection =

                            static_cast<SfxObjectShell*>(GetDocShell())->

                                                   GetDocumentProtectionFromGrabBag();

                        bPasswordOk =

                            // password is ok, if there is no DocumentProtection in the GrabBag,

                            // i.e. the dummy RedlinePassword imported from an OpenDocument file

                            !aDocumentProtection.hasElements() ||

                            // verify password with the password info imported from OOXML

                            ::comphelper::DocPasswordHelper::IsModifyPasswordCorrect(sNewPasswd,

                                ::comphelper::DocPasswordHelper::ConvertPasswordInfo ( aDocumentProtection ) );

                    }

                    else

                    {

                        // the simplified RedlinePassword

                        Sequence <sal_Int8> aNewPasswd = rIDRA.GetRedlinePassword();

                        SvPasswordHelper::GetHashPassword( aNewPasswd, sNewPasswd );

                        bPasswordOk = SvPasswordHelper::CompareHashPassword(aPasswd, sNewPasswd);

                    }

                    if (bPasswordOk)

                        rIDRA.SetRedlinePassword(Sequence <sal_Int8> ());

                    else

                    {   // xmlsec05: message box for wrong password

                        std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(nullptr,

                                                      VclMessageType::Info, VclButtonsType::Ok,

                                                      SfxResId(RID_SVXSTR_INCORRECT_PASSWORD)));

                        xInfoBox->run();

                        break;

                    }

                }

                SwDocShell* pDocShell = GetDocShell();

                SfxRedlineRecordingMode eRedlineRecordingMode = SfxRedlineRecordingMode::AllViews;

                if (nSlot == FN_TRACK_CHANGES_IN_THIS_VIEW)

                {

                    eRedlineRecordingMode = SfxRedlineRecordingMode::ThisView;

                }

                pDocShell->SetChangeRecording( oOn.value(), /*bLockAllViews=*/true, eRedlineRecordingMode );

                // Notify all view shells of this document, as the track changes mode is document-global.

                for (SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst(pDocShell); pViewFrame; pViewFrame = SfxViewFrame::GetNext(*pViewFrame, pDocShell))

                {

                    pViewFrame->GetBindings().Invalidate(FN_REDLINE_ON);

                    pViewFrame->GetBindings().Update(FN_REDLINE_ON);

                    pViewFrame->GetBindings().Invalidate(FN_TRACK_CHANGES_IN_THIS_VIEW);

                    pViewFrame->GetBindings().Update(FN_TRACK_CHANGES_IN_THIS_VIEW);

                    pViewFrame->GetBindings().Invalidate(FN_TRACK_CHANGES_IN_ALL_VIEWS);

                    pViewFrame->GetBindings().Update(FN_TRACK_CHANGES_IN_ALL_VIEWS);

                }

            }

        }

        break;

        case FN_REDLINE_PROTECT :

        {

            IDocumentRedlineAccess& rIDRA = m_pWrtShell->getIDocumentRedlineAccess();

            Sequence <sal_Int8> aPasswd = rIDRA.GetRedlinePassword();

            if( pArgs && SfxItemState::SET == pArgs->GetItemState(nSlot, false, &pItem )

                && static_cast<const SfxBoolItem*>(pItem)->GetValue() == aPasswd.hasElements() )

                break;

            // xmlsec05:    new password dialog

            //              message box for wrong password

            SfxPasswordDialog aPasswdDlg(GetFrameWeld());

            aPasswdDlg.SetMinLen(1);

            if (!aPasswd.hasElements())

                aPasswdDlg.ShowExtras(SfxShowExtras::CONFIRM);

            if (aPasswdDlg.run())

            {

                RedlineFlags nOn = RedlineFlags::On;

                OUString sNewPasswd(aPasswdDlg.GetPassword());

                Sequence <sal_Int8> aNewPasswd =

                        rIDRA.GetRedlinePassword();

                SvPasswordHelper::GetHashPassword( aNewPasswd, sNewPasswd );

                if(!aPasswd.hasElements())

                {

                    rIDRA.SetRedlinePassword(aNewPasswd);

                }

                else if(SvPasswordHelper::CompareHashPassword(aPasswd, sNewPasswd))

                {

                    rIDRA.SetRedlinePassword(Sequence <sal_Int8> ());

                    nOn = RedlineFlags::NONE;

                }

                const RedlineFlags nMode = rIDRA.GetRedlineFlags();

                m_pWrtShell->SetRedlineFlagsAndCheckInsMode( (nMode & ~RedlineFlags::On) | nOn);

                rReq.AppendItem( SfxBoolItem( FN_REDLINE_PROTECT, !(nMode&RedlineFlags::On) ) );

            }

            else

                bIgnore = true;

        }

        break;

        case FN_REDLINE_SHOW:

            if( pArgs &&

                SfxItemState::SET == pArgs->GetItemState(nSlot, false, &pItem))

            {

                // tdf#125754 avoid recursive layout

                // because all views share the layout, have to use AllAction

                const bool bShow = static_cast<const SfxBoolItem*>(pItem)->GetValue();

                m_pWrtShell->StartAllAction();

                // always show redline insertions in Hide Changes mode

                if ( m_pWrtShell->GetViewOptions()->IsShowChangesInMargin() &&

                     m_pWrtShell->GetViewOptions()->IsShowChangesInMargin2() )

                {

                    GetDocShell()->GetDoc()->GetDocumentRedlineManager().HideAll(/*bDeletion=*/!bShow);

                }

                m_pWrtShell->GetLayout()->SetHideRedlines( !bShow );

                m_pWrtShell->EndAllAction();

                if (m_pWrtShell->IsRedlineOn())

                    m_pWrtShell->SetInsMode();

                GetDocShell()->Broadcast(SfxHint(SfxHintId::SwRedlineShowChanged));

            }

            break;

        case FN_MAILMERGE_SENDMAIL_CHILDWINDOW:

        case FN_REDLINE_ACCEPT:

            GetViewFrame().ToggleChildWindow(nSlot);

        break;

        case FN_REDLINE_ACCEPT_DIRECT:

        case FN_REDLINE_REJECT_DIRECT:

        case FN_REDLINE_ACCEPT_TONEXT:

        case FN_REDLINE_REJECT_TONEXT:

        case FN_REDLINE_REINSTATE_DIRECT:

        case FN_REDLINE_REINSTATE_TONEXT:

        {

            SwDoc *pDoc = m_pWrtShell->GetDoc();

            SwPaM *pCursor = m_pWrtShell->GetCursor();

            const SwRedlineTable& rRedlineTable = pDoc->getIDocumentRedlineAccess().GetRedlineTable();

            SwRedlineTable::size_type nRedline = SwRedlineTable::npos;

            if (pArgs && pArgs->GetItemState(nSlot, false, &pItem) == SfxItemState::SET)

            {

                const sal_Int64 nChangeId = static_cast<const SfxUInt32Item*>(pItem)->GetValue();

                for (SwRedlineTable::size_type i = 0; i < rRedlineTable.size(); ++i)

                {

                    if (nChangeId == rRedlineTable[i]->GetId())

                        nRedline = i;

                }

            }

            if( pCursor->HasMark() && nRedline == SwRedlineTable::npos)

            {

                bool bAccept = FN_REDLINE_ACCEPT_DIRECT == nSlot || FN_REDLINE_ACCEPT_TONEXT == nSlot;