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

#include <hintids.hxx>

#include <comphelper/servicehelper.hxx>

#include <svl/languageoptions.hxx>

#include <sfx2/docfile.hxx>

#include <sfx2/linkmgr.hxx>

#include <sfx2/htmlmode.hxx>

#include <svx/imapdlg.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/viewfrm.hxx>

#include <sfx2/request.hxx>

#include <svl/whiter.hxx>

#include <svl/visitem.hxx>

#include <editeng/langitem.hxx>

#include <svx/clipfmtitem.hxx>

#include <svx/contdlg.hxx>

#include <vcl/graph.hxx>

#include <vcl/inputctx.hxx>

#include <svl/slstitm.hxx>

#include <svl/ptitem.hxx>

#include <svl/stritem.hxx>

#include <editeng/colritem.hxx>

#include <editeng/fhgtitem.hxx>

#include <editeng/fontitem.hxx>

#include <editeng/shaditem.hxx>

#include <editeng/boxitem.hxx>

#include <editeng/brushitem.hxx>

#include <editeng/opaqitem.hxx>

#include <editeng/sizeitem.hxx>

#include <editeng/protitem.hxx>

#include <svx/flagsdef.hxx>

#include <editeng/scriptsetitem.hxx>

#include <sfx2/objface.hxx>

#include <fmturl.hxx>

#include <fmthdft.hxx>

#include <fmtclds.hxx>

#include <docsh.hxx>

#include <wrtsh.hxx>

#include <view.hxx>

#include <swmodule.hxx>

#include <swundo.hxx>

#include <fldbas.hxx>

#include <uitool.hxx>

#include <basesh.hxx>

#include <viewopt.hxx>

#include <fontcfg.hxx>

#include <fmtsrnd.hxx>

#include <fldmgr.hxx>

#include <frmmgr.hxx>

#include <tablemgr.hxx>

#include <mdiexp.hxx>

#include <swdtflvr.hxx>

#include <pagedesc.hxx>

#include <fmtcol.hxx>

#include <edtwin.hxx>

#include <tblafmt.hxx>

#include <swwait.hxx>

#include <cmdid.h>

#include <strings.hrc>

#include <unotxdoc.hxx>

#include <doc.hxx>

#include <drawdoc.hxx>

#include <IDocumentSettingAccess.hxx>

#include <IDocumentDrawModelAccess.hxx>

#include <IDocumentUndoRedo.hxx>

#include <ThemeColorChanger.hxx>

#include <swabstdlg.hxx>

#include <modcfg.hxx>

#include <svx/fmshell.hxx>

#include <SwRewriter.hxx>

#include <GraphicSizeCheck.hxx>

#include <svx/galleryitem.hxx>

#include <sfx2/devtools/DevelopmentToolChildWindow.hxx>

#include <com/sun/star/gallery/GalleryItemType.hpp>

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

#include <memory>

#include <svx/unobrushitemhelper.hxx>

#include <svx/dialog/ThemeDialog.hxx>

#include <comphelper/scopeguard.hxx>

#include <comphelper/lok.hxx>

#include <LibreOfficeKit/LibreOfficeKitEnums.h>

#include <osl/diagnose.h>

#include <svx/svxdlg.hxx>

#include <comphelper/sequenceashashmap.hxx>

#include <shellres.hxx>

#include <UndoTable.hxx>

#include <ndtxt.hxx>

#include <UndoManager.hxx>

#include <fmtrfmrk.hxx>

#include <txtrfmrk.hxx>

#include <translatehelper.hxx>

#include <rootfrm.hxx>

FlyMode SwBaseShell::s_eFrameMode = FLY_DRAG_END;

// These variables keep the state of Gallery (slot SID_GALLERY_BG_BRUSH)

// detected by GetGalleryState() for the subsequent ExecuteGallery() call.

static sal_uInt8 nParagraphPos;

static sal_uInt8 nGraphicPos;

static sal_uInt8 nOlePos;

static sal_uInt8 nFramePos;

static sal_uInt8 nTablePos;

static sal_uInt8 nTableRowPos;

static sal_uInt8 nTableCellPos;

static sal_uInt8 nPagePos;

static sal_uInt8 nHeaderPos;

static sal_uInt8 nFooterPos;

#define ShellClass_SwBaseShell

#include <sfx2/msg.hxx>

#include <swslots.hxx>

#include <AccessibilityCheck.hxx>

namespace

{

    SvxContourDlg* GetContourDlg(SwView const &rView)

    {

        SfxChildWindow *pWnd = rView.GetViewFrame().GetChildWindow(SvxContourDlgChildWindow::GetChildWindowId());

        return pWnd ? static_cast<SvxContourDlg*>(pWnd->GetController().get()) : nullptr;

    }

    SvxIMapDlg* GetIMapDlg(SwView const &rView)

    {

        SfxChildWindow* pWnd = rView.GetViewFrame().GetChildWindow(SvxIMapDlgChildWindow::GetChildWindowId());

        return pWnd ? static_cast<SvxIMapDlg*>(pWnd->GetController().get()) : nullptr;

    }

}

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

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

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

SFX_IMPL_SUPERCLASS_INTERFACE(SwBaseShell, SfxShell)

void SwBaseShell::InitInterface_Impl()

{

    GetStaticInterface()->RegisterChildWindow(SvxIMapDlgChildWindow::GetChildWindowId());

    GetStaticInterface()->RegisterChildWindow(SvxContourDlgChildWindow::GetChildWindowId());

    GetStaticInterface()->RegisterChildWindow(DevelopmentToolChildWindow::GetChildWindowId());

}

static void lcl_UpdateIMapDlg( SwWrtShell& rSh )

{

    Graphic aGrf( rSh.GetIMapGraphic() );

    GraphicType nGrfType = aGrf.GetType();

    void* pEditObj = GraphicType::NONE != nGrfType && GraphicType::Default != nGrfType

                        ? rSh.GetIMapInventor() : nullptr;

    TargetList aList;

    SfxFrame::GetDefaultTargetList(aList);

    SfxItemSet aSet(SfxItemSet::makeFixedSfxItemSet<RES_URL, RES_URL>(rSh.GetAttrPool()));

    rSh.GetFlyFrameAttr( aSet );

    const SwFormatURL &rURL = aSet.Get( RES_URL );

    SvxIMapDlgChildWindow::UpdateIMapDlg(

            aGrf, rURL.GetMap(), &aList, pEditObj );

}

static bool lcl_UpdateContourDlg( SwWrtShell &rSh, SelectionType nSel )

{

    Graphic aGraf( rSh.GetIMapGraphic() );

    GraphicType nGrfType = aGraf.GetType();

    bool bRet = GraphicType::NONE != nGrfType && GraphicType::Default != nGrfType;

    if( bRet )

    {

        OUString aGrfName;

        if ( nSel & SelectionType::Graphic )

            rSh.GetGrfNms( &aGrfName, nullptr );

        SvxContourDlg *pDlg = GetContourDlg(rSh.GetView());

        if (pDlg)

        {

            pDlg->Update(aGraf, !aGrfName.isEmpty(),

                         rSh.GetGraphicPolygon(), rSh.GetIMapInventor());

        }

    }

    return bRet;

}

void SwBaseShell::ExecDelete(SfxRequest &rReq)

{

    SwWrtShell &rSh = GetShell();

    SwEditWin& rTmpEditWin = GetView().GetEditWin();

    switch(rReq.GetSlot())

    {

        case SID_DELETE:

            if (rSh.GetViewOptions()->IsShowOutlineContentVisibilityButton())

            {

                // Disallow if the cursor is at the end of a paragraph and the document model

                // node at this position is an outline node with folded content or the next node

                // is an outline node with folded content.

                if (rSh.IsEndPara())

                {

                    SwNodeIndex aIdx(rSh.GetCursor()->GetPointNode());

                    if (aIdx.GetNode().IsTextNode())

                    {

                        if (!aIdx.GetNode().GetTextNode()->GetAttrOutlineContentVisible())

                            break;

                        ++aIdx;

                        if (aIdx.GetNode().IsTextNode())

                        {

                            if (!aIdx.GetNode().GetTextNode()->GetAttrOutlineContentVisible())

                                break;

                        }

                    }

                }

            }

            rSh.DelRight();

            break;

        case FN_BACKSPACE:

            if (rSh.GetViewOptions()->IsShowOutlineContentVisibilityButton())

            {

                // Disallow if the cursor is at the start of a paragraph and the document model

                // node at this position is an outline node with folded content or the previous

                // node is a content node without a layout frame.

                if (rSh.IsSttPara())

                {

                    SwNodeIndex aIdx(rSh.GetCursor()->GetPointNode());

                    if (aIdx.GetNode().IsTextNode())

                    {

                        if (!aIdx.GetNode().GetTextNode()->GetAttrOutlineContentVisible())

                            break;

                        --aIdx;

                        if (aIdx.GetNode().IsContentNode() &&

                                !aIdx.GetNode().GetContentNode()->getLayoutFrame(rSh.GetLayout()))

                            break;

                    }

                }

            }

            if( rSh.IsNoNum() )

            {

                rSh.SttCursorMove();

                bool bLeft = rSh.Left( SwCursorSkipMode::Chars, true, 1, false  );

                if( bLeft )

                {

                    rSh.DelLeft();

                }

                else

                    // JP 15.07.96: If it no longer goes forward, cancel

                    //              the numbering. For example at the beginning

                    //              of a doc, frame, table or an area.

                    rSh.DelNumRules();

                rSh.EndCursorMove();

                break;

            }

            [[fallthrough]]; // otherwise call DelLeft

        case FN_SHIFT_BACKSPACE:

            rSh.DelLeft();

            break;

        default:

            OSL_FAIL("wrong Dispatcher");

            return;

    }

    rReq.Done();

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

    rTmpEditWin.SetUseInputLanguage( false );

    // Test Fieldmark when empty reset the Placeholders

    const IDocumentMarkAccess* pMarksAccess = rSh.GetDoc()->getIDocumentMarkAccess();

    for (SwPaM &rPaM : rSh.GetCursor()->GetRingContainer())

    {

        const SwPosition* sp = rPaM.Start();

        // Legacy text/combo/checkbox: never return read-only when inside these form fields.

        sw::mark::Fieldmark* pA = pMarksAccess->getInnerFieldmarkFor(*sp);

        if (pA != nullptr)

        {

            if ((IDocumentMarkAccess::GetType(*pA) == IDocumentMarkAccess::MarkType::TEXT_FIELDMARK) &&

                (pA->GetContent().getLength() == 0)

               )

            {

                pA->ReplaceContent(vEnSpaces);

                rSh.GotoFieldmark(pA);

            }

        }

    }

}

void SwBaseShell::ExecClpbrd(SfxRequest &rReq)

{

    // Attention: At risk of suicide!

    // After paste, paste special the shell can be destroy.

    SwWrtShell &rSh = GetShell();

    sal_uInt16 nId = rReq.GetSlot();

    bool bIgnore = false;

    PasteTableType ePasteTable = PasteTableType::PASTE_DEFAULT;

    switch( nId )

    {

        case SID_CUT:

        case SID_COPY:

            m_rView.GetEditWin().FlushInBuffer();

            if ( rSh.HasSelection() )

            {

                rtl::Reference<SwTransferable> pTransfer = new SwTransferable( rSh );

                if ( nId == SID_CUT && FlyProtectFlags::NONE == rSh.IsSelObjProtected(FlyProtectFlags::Content|FlyProtectFlags::Parent) )

                    pTransfer->Cut();

                else

                {

                    const bool bLockedView = rSh.IsViewLocked();

                    rSh.LockView( true );    //lock visible section

                    pTransfer->Copy();

                    rSh.LockView( bLockedView );

                }

                break;

            }

            return;

        case FN_PASTE_NESTED_TABLE:

        case FN_TABLE_PASTE_ROW_BEFORE:

        case FN_TABLE_PASTE_COL_BEFORE:

            switch ( nId )

            {

                case FN_PASTE_NESTED_TABLE:

                     ePasteTable = PasteTableType::PASTE_TABLE;

                     break;

                case FN_TABLE_PASTE_ROW_BEFORE:

                     ePasteTable = PasteTableType::PASTE_ROW;

                     break;

                case FN_TABLE_PASTE_COL_BEFORE:

                     ePasteTable = PasteTableType::PASTE_COLUMN;

                     break;

                default:

                    ;

            }

            [[fallthrough]];

        case SID_PASTE:

            {

                TransferableDataHelper aDataHelper(

                    TransferableDataHelper::CreateFromSystemClipboard( &rSh.GetView().GetEditWin() ) );

                if( aDataHelper.GetXTransferable().is()

                    && SwTransferable::IsPaste( rSh, aDataHelper ) )

                {

                    // Temporary variables, because the shell could already be

                    // destroyed after the paste.

                    SwView* pView = &m_rView;

                    RndStdIds nAnchorType = RndStdIds::FLY_AT_PARA;

                    const SfxUInt16Item* pAnchorType = rReq.GetArg<SfxUInt16Item>(FN_PARAM_1);

                    if (pAnchorType)

                        nAnchorType = static_cast<RndStdIds>(pAnchorType->GetValue());

                    bool bIgnoreComments = false;

                    const SfxBoolItem* pIgnoreComments = rReq.GetArg<SfxBoolItem>(FN_PARAM_2);

                    if (pIgnoreComments)

                        bIgnoreComments = pIgnoreComments->GetValue();

                    // See if detection should be used.

                    bool bSkipDetection = false;

                    const SfxBoolItem* pSkipDetection = rReq.GetArg<SfxBoolItem>(FN_PARAM_3);

                    if (pSkipDetection)

                        bSkipDetection = pSkipDetection->GetValue();

                    SwTransferable::Paste(rSh, aDataHelper, nAnchorType, bIgnoreComments, ePasteTable, !bSkipDetection);

                    if( rSh.IsFrameSelected() || rSh.GetSelectedObjCount() )

                        rSh.EnterSelFrameMode();

                    pView->AttrChangedNotify(nullptr);

                    // Fold pasted outlines that have outline content visible attribute false

                    MakeAllOutlineContentTemporarilyVisible a(rSh.GetDoc());

                }

                else

                    return;

            }

            break;

        case SID_CLIPBOARD_FORMAT_ITEMS:

            {

                const SfxItemSet* pArgs = rReq.GetArgs();

                const SfxPoolItem* pFormat;

                if( pArgs && SfxItemState::SET == pArgs->GetItemState( nId, false, &pFormat ) )

                {

                    TransferableDataHelper aDataHelper(

                        TransferableDataHelper::CreateFromSystemClipboard(

                                            &rSh.GetView().GetEditWin()) );

                    if( aDataHelper.GetXTransferable().is()

                        /*&& SwTransferable::IsPaste( rSh, aDataHelper )*/ )

                    {

                        // Temporary variables, because the shell could already be

                        // destroyed after the paste.

                        SwView* pView = &m_rView;

                        SwTransferable::PasteFormat( rSh, aDataHelper,

                                        static_cast<SotClipboardFormatId>(static_cast<const SfxUInt32Item*>(pFormat)->GetValue()) );

                        //Done() has to be called before the shell has been removed

                        rReq.Done();

                        bIgnore = true;

                        if( rSh.IsFrameSelected() || rSh.GetSelectedObjCount())

                            rSh.EnterSelFrameMode();

                        pView->AttrChangedNotify(nullptr);

                        // Fold pasted outlines that have outline content visible attribute false

                        MakeAllOutlineContentTemporarilyVisible a(rSh.GetDoc());

                    }

                }

            }

            break;

        case SID_PASTE_UNFORMATTED:

            {

                TransferableDataHelper aDataHelper(

                    TransferableDataHelper::CreateFromSystemClipboard( &rSh.GetView().GetEditWin()) );

                if( aDataHelper.GetXTransferable().is()

                    && SwTransferable::IsPaste( rSh, aDataHelper ) )

                {

                    // Temporary variables, because the shell could already be

                    // destroyed after the paste.

                    SwView* pView = &m_rView;

                    rReq.Ignore();

                    bIgnore = true;

                    if(SwTransferable::PasteUnformatted( rSh, aDataHelper ))

                    {

                        SfxViewFrame& rViewFrame = pView->GetViewFrame();

                        uno::Reference< frame::XDispatchRecorder > xRecorder =

                            rViewFrame.GetBindings().GetRecorder();

                        if(xRecorder.is()) {

                            SfxRequest aReq(rViewFrame, SID_CLIPBOARD_FORMAT_ITEMS);

                            aReq.AppendItem( SfxUInt32Item( SID_CLIPBOARD_FORMAT_ITEMS, static_cast<sal_uInt32>(SotClipboardFormatId::STRING) ) );

                            aReq.Done();

                        }

                    }

                    if (rSh.IsFrameSelected() || rSh.GetSelectedObjCount())

                        rSh.EnterSelFrameMode();

                    pView->AttrChangedNotify(nullptr);

                    // Fold pasted outlines that have outline content visible attribute false

                    MakeAllOutlineContentTemporarilyVisible a(rSh.GetDoc());

                }

                else

                    return;

            }

            break;

        case SID_PASTE_SPECIAL:

            {

                std::shared_ptr<const TransferableDataHelper> aDataHelper =

                    std::make_shared<TransferableDataHelper>(TransferableDataHelper::CreateFromSystemClipboard( &rSh.GetView().GetEditWin()));

                if( aDataHelper->GetXTransferable().is()

                    && SwTransferable::IsPaste( rSh, *aDataHelper )

                    && !rSh.CursorInsideInputField() )

                {

                    rReq.Ignore();

                    bIgnore = true;

                    SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();

                    VclPtr<SfxAbstractPasteDialog> pDlg(pFact->CreatePasteDialog( rReq.GetFrameWeld() ));

                    // Prepare the dialog

                    SwTransferable::PrePasteSpecial(rSh, *aDataHelper, pDlg);

                    pDlg->PreGetFormat(*aDataHelper);

                    pDlg->StartExecuteAsync(

                        [aDataHelper=std::move(aDataHelper), pDlg, &rSh, this](sal_Int32 nResult)

                        {

                            if (nResult == RET_OK)

                            {

                                // Temporary variables, because the shell could already be

                                // destroyed after the paste.

                                SwView* pView = &m_rView;

                                bool bRet = false;

                                SotClipboardFormatId nFormatId = pDlg->GetFormatOnly();

                                if( nFormatId != SotClipboardFormatId::NONE )

                                    bRet = SwTransferable::PasteFormat( rSh, *aDataHelper, nFormatId );

                                if (bRet)

                                {

                                    SfxViewFrame& rViewFrame = pView->GetViewFrame();

                                    uno::Reference< frame::XDispatchRecorder > xRecorder =

                                            rViewFrame.GetBindings().GetRecorder();

                                    if(xRecorder.is()) {

                                        SfxRequest aReq(rViewFrame, SID_CLIPBOARD_FORMAT_ITEMS);

                                        aReq.AppendItem( SfxUInt32Item( SID_CLIPBOARD_FORMAT_ITEMS, static_cast<sal_uInt32>(nFormatId) ) );

                                        aReq.Done();

                                    }

                                }

                                if (rSh.IsFrameSelected() || rSh.GetSelectedObjCount())

                                    rSh.EnterSelFrameMode();

                                pView->AttrChangedNotify(nullptr);

                                // Fold pasted outlines that have outline content visible attribute false

                                MakeAllOutlineContentTemporarilyVisible a(rSh.GetDoc());

                            }

                            pDlg->disposeOnce();

                        }

                    );

                }

                else

                    return;

            }

            break;

        default:

            OSL_FAIL("wrong Dispatcher");

            return;

    }

    if(!bIgnore)

        rReq.Done();

}

// ClipBoard state

void SwBaseShell::StateClpbrd(SfxItemSet &rSet)

{

    SwWrtShell &rSh = GetShell();

    SfxWhichIter aIter(rSet);

    const bool bCopy = rSh.HasSelection();

    sal_uInt16 nWhich = aIter.FirstWhich();

    while(nWhich)

    {

        switch(nWhich)

        {

        case SID_CUT:

            if( FlyProtectFlags::NONE != rSh.IsSelObjProtected(FlyProtectFlags::Content|FlyProtectFlags::Parent ) )

            {

                rSet.DisableItem( nWhich );

                break;

            }

            [[fallthrough]];

        case SID_COPY:

            if( !bCopy || GetObjectShell()->isContentExtractionLocked())

                rSet.DisableItem( nWhich );

            break;

        case FN_PASTE_NESTED_TABLE:

        case FN_TABLE_PASTE_ROW_BEFORE:

        case FN_TABLE_PASTE_COL_BEFORE:

            if( !rSh.IsCursorInTable()

                || !GetView().IsPasteSpecialAllowed()

                || rSh.CursorInsideInputField()

                // disable if not a native Writer table and not a spreadsheet format

                || !GetView().IsPasteSpreadsheet(rSh.GetTableCopied()) )

            {

                rSet.DisableItem( nWhich );

            }

            break;

        case SID_PASTE:

            if( !GetView().IsPasteAllowed() )

            {

                rSet.DisableItem( nWhich );

            }

            break;

        case SID_PASTE_SPECIAL:

            if( !GetView().IsPasteSpecialAllowed()

                || rSh.CursorInsideInputField() )

            {

                rSet.DisableItem( nWhich );

            }

            break;

        case SID_PASTE_UNFORMATTED:

            if( !GetView().IsPasteSpecialAllowed() )

            {

                rSet.DisableItem( nWhich );

            }

            break;

        case SID_CLIPBOARD_FORMAT_ITEMS:

            {

                TransferableDataHelper aDataHelper(

                    TransferableDataHelper::CreateFromSystemClipboard(

                                            &rSh.GetView().GetEditWin()) );

                SvxClipboardFormatItem aFormatItem( SID_CLIPBOARD_FORMAT_ITEMS );

                SwTransferable::FillClipFormatItem( rSh, aDataHelper, aFormatItem );

                rSet.Put( aFormatItem );

            }

            break;

        }

        nWhich = aIter.NextWhich();

    }

}

// Perform undo

void SwBaseShell::ExecUndo(SfxRequest &rReq)

{

    MakeAllOutlineContentTemporarilyVisible a(GetShell().GetDoc(), true);

    SwWrtShell &rWrtShell = GetShell();

    SwUndoId nUndoId(SwUndoId::EMPTY);

    sal_uInt16 nId = rReq.GetSlot(), nCnt = 1;

    const SfxItemSet* pArgs = rReq.GetArgs();

    const SfxPoolItem* pItem;

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

        nCnt = static_cast<const SfxUInt16Item*>(pItem)->GetValue();

    // Repair mode: allow undo/redo of all undo actions, even if access would

    // be limited based on the view shell ID.

    bool bRepair = false;

    const SfxBoolItem* pRepairItem;

    if (pArgs && (pRepairItem = pArgs->GetItemIfSet(SID_REPAIRPACKAGE, false)))

        bRepair = pRepairItem->GetValue();

    // #i106349#: save pointer: undo/redo may delete the shell, i.e., this!

    SfxViewFrame& rViewFrame( GetView().GetViewFrame() );

    IDocumentUndoRedo& rUndoRedo = rWrtShell.GetIDocumentUndoRedo();

    bool bWasRepair = rUndoRedo.DoesRepair();

    rUndoRedo.DoRepair(bRepair);

    comphelper::ScopeGuard aGuard([&rUndoRedo, bWasRepair]()

    {

        rUndoRedo.DoRepair(bWasRepair);

    });

    switch( nId )

    {

        case SID_UNDO:

            if (rUndoRedo.GetLastUndoInfo(nullptr, &nUndoId, &rWrtShell.GetView()))

            {

                for (SwViewShell& rShell : rWrtShell.GetRingContainer())

                    rShell.LockPaint(LockPaintReason::Undo);

                sal_uInt16 nUndoOffset = 0;

                if (comphelper::LibreOfficeKit::isActive() && !bRepair && nCnt == 1)

                {

                    sw::UndoManager& rManager = rWrtShell.GetDoc()->GetUndoManager();

                    const SfxUndoAction* pAction = rManager.GetUndoAction();

                    SwView& rView = rWrtShell.GetView();

                    ViewShellId nViewShellId = rView.GetViewShellId();

                    sal_uInt16 nOffset = 0;

                    if (pAction->GetViewShellId() != nViewShellId

                        && rManager.IsViewUndoActionIndependent(&rView, nOffset))

                    {

                        // Execute the undo with an offset: don't undo the top action, but an

                        // earlier one, since it's independent and that belongs to our view.

                        nUndoOffset += nOffset;

                    }

                }

                rWrtShell.Do(SwWrtShell::UNDO, nCnt, nUndoOffset);

                for (SwViewShell& rShell : rWrtShell.GetRingContainer())

                    rShell.UnlockPaint();

            }

            break;

        case SID_REDO:

            if (rUndoRedo.GetFirstRedoInfo(nullptr, &nUndoId, &rWrtShell.GetView()))

            {

                for (SwViewShell& rShell : rWrtShell.GetRingContainer())

                    rShell.LockPaint(LockPaintReason::Redo);

                rWrtShell.Do( SwWrtShell::REDO, nCnt );

                for (SwViewShell& rShell : rWrtShell.GetRingContainer())

                    rShell.UnlockPaint();

            }

            break;

        case SID_REPEAT:

            rWrtShell.Do( SwWrtShell::REPEAT );

            break;

        default:

            OSL_FAIL("wrong Dispatcher");

    }

    if (nUndoId == SwUndoId::CONFLICT)

    {

        rReq.SetReturnValue( SfxUInt32Item(nId, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)) );

    }

    rViewFrame.GetBindings().InvalidateAll(false);

}

// State of undo

void SwBaseShell::StateUndo(SfxItemSet &rSet)

{

    SwUndoId nUndoId(SwUndoId::EMPTY);

    SwWrtShell &rSh = GetShell();

    SfxWhichIter aIter(rSet);

    sal_uInt16 nWhich = aIter.FirstWhich();

    while(nWhich)

    {

        switch(nWhich)

        {

            case SID_UNDO:

            {

                if (rSh.GetLastUndoInfo(nullptr, &nUndoId, &rSh.GetView()))

                {

                    rSet.Put( SfxStringItem(nWhich,

                        rSh.GetDoString(SwWrtShell::UNDO)));

                }

                else if (nUndoId == SwUndoId::CONFLICT)

                {

                    rSet.Put( SfxUInt32Item(nWhich, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)) );

                }

                else

                    rSet.DisableItem(nWhich);

                break;

            }

            case SID_REDO:

            {

                if (rSh.GetFirstRedoInfo(nullptr, &nUndoId, &rSh.GetView()))

                {

                    rSet.Put(SfxStringItem(nWhich,

                        rSh.GetDoString(SwWrtShell::REDO)));

                }

                else if (nUndoId == SwUndoId::CONFLICT)

                {

                     rSet.Put( SfxInt32Item(nWhich, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)) );

                }

                else

                    rSet.DisableItem(nWhich);

                break;

            }

            case SID_REPEAT:

            {   // Repeat is only possible if no REDO is possible - UI-Restriction

                if ((!rSh.GetFirstRedoInfo(nullptr, nullptr)) &&

                    !rSh.IsSelFrameMode() &&

                    (SwUndoId::EMPTY != rSh.GetRepeatInfo(nullptr)))

                {

                    rSet.Put(SfxStringItem(nWhich, rSh.GetRepeatString()));

                }

                else

                    rSet.DisableItem(nWhich);

                break;

            }

            case SID_GETUNDOSTRINGS:

                if (rSh.GetLastUndoInfo(nullptr, nullptr))

                {

                    SfxStringListItem aStrLst( nWhich );

                    rSh.GetDoStrings( SwWrtShell::UNDO, aStrLst );

                    rSet.Put( aStrLst );

                }

                else

                    rSet.DisableItem( nWhich );

                break;

            case SID_GETREDOSTRINGS:

                if (rSh.GetFirstRedoInfo(nullptr, nullptr))

                {

                    SfxStringListItem aStrLst( nWhich );

                    rSh.GetDoStrings( SwWrtShell::REDO, aStrLst );

                    rSet.Put( aStrLst );

                }

                else

                    rSet.DisableItem( nWhich );

                break;

        }

        nWhich = aIter.NextWhich();

    }

}

namespace

{

/// Searches for the specified field type and field name prefix and update the matching fields to

/// have the provided new name and content.

bool UpdateFieldContents(const SfxRequest& rReq, SwWrtShell& rWrtSh)

{

    const SfxStringItem* pTypeName = rReq.GetArg<SfxStringItem>(FN_PARAM_1);

    if (!pTypeName || pTypeName->GetValue() != "SetRef")

    {

        // This is implemented so far only for reference marks.

        return false;

    }

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

    if (!pNamePrefix)

    {

        return false;

    }

    const OUString& rNamePrefix = pNamePrefix->GetValue();

    const SfxUnoAnyItem* pFields = rReq.GetArg<SfxUnoAnyItem>(FN_PARAM_3);

    if (!pFields)

    {

        return false;

    }

    bool bNeverExpand = false;

    const SfxBoolItem* pNeverExpand = rReq.GetArg<SfxBoolItem>(FN_PARAM_6);

    if (pNeverExpand)

    {

        bNeverExpand = pNeverExpand->GetValue();

    }

    uno::Sequence<beans::PropertyValues> aFields;

    pFields->GetValue() >>= aFields;

    SwDoc* pDoc = rWrtSh.GetDoc();

    pDoc->GetIDocumentUndoRedo().StartUndo(SwUndoId::UPDATE_FIELDS, nullptr);

    rWrtSh.StartAction();

    std::vector<const SwFormatRefMark*> aRefMarks;

    pDoc->GetRefMarks(aRefMarks);

    std::sort(aRefMarks.begin(), aRefMarks.end(),

              [](const SwFormatRefMark* pMark1, const SwFormatRefMark* pMark2) -> bool {

                  const SwTextRefMark* pTextRefMark1 = pMark1->GetTextRefMark();

                  const SwTextRefMark* pTextRefMark2 = pMark2->GetTextRefMark();

                  SwPosition aPos1(pTextRefMark1->GetTextNode(), pTextRefMark1->GetStart());

                  SwPosition aPos2(pTextRefMark2->GetTextNode(), pTextRefMark2->GetStart());

                  return aPos1 < aPos2;

              });

    sal_uInt16 nFieldIndex = 0;

    for (auto& pIntermediateRefMark : aRefMarks)

    {

        auto pRefMark = const_cast<SwFormatRefMark*>(pIntermediateRefMark);

        if (!pRefMark->GetRefName().toString().startsWith(rNamePrefix))

        {

            continue;

        }

        auto pTextRefMark = const_cast<SwTextRefMark*>(pRefMark->GetTextRefMark());

        if (bNeverExpand)

        {

            pTextRefMark->SetDontExpand(true);

            pTextRefMark->SetLockExpandFlag(true);

            pTextRefMark->SetDontExpandStartAttr(true);

        }

        if (nFieldIndex >= aFields.getLength())

        {

            // earlier we used to break here

            // but now we need to set expand flags for each refmark

            continue;

        }

        comphelper::SequenceAsHashMap aMap(aFields[nFieldIndex++]);

        pRefMark->GetRefName() = SwMarkName(aMap[u"Name"_ustr].get<OUString>());

        pTextRefMark->UpdateFieldContent(pDoc, rWrtSh, aMap[u"Content"_ustr].get<OUString>());

    }

    rWrtSh.EndAction();

    pDoc->GetIDocumentUndoRedo().EndUndo(SwUndoId::UPDATE_FIELDS, nullptr);

    return true;

}

/// Searches for the specified field type and field name prefix under cursor and update the matching

/// field to have the provided new name and content.

void UpdateFieldContent(const SfxRequest& rReq, SwWrtShell& rWrtSh)

{

    const SfxStringItem* pTypeName = rReq.GetArg<SfxStringItem>(FN_PARAM_1);

    if (!pTypeName || pTypeName->GetValue() != "SetRef")

    {

        // This is implemented so far only for reference marks.

        return;

    }

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

    if (!pNamePrefix)

    {

        return;

    }