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

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

1 files changed, 1768 insertions, 0 deletions

diff --git a/sw/source/core/undo/undobj.cxx b/sw/source/core/undo/undobj.cxx
new file mode 100644
index 0000000000..ce27962aa3
--- /dev/null
+++ b/sw/source/core/undo/undobj.cxx
@@ -0,0 +1,1768 @@
+/* -*- 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 <libxml/xmlwriter.h>
+
+#include <IShellCursorSupplier.hxx>
+#include <txtftn.hxx>
+#include <fmtanchr.hxx>
+#include <ftnidx.hxx>
+#include <frmfmt.hxx>
+#include <doc.hxx>
+#include <UndoManager.hxx>
+#include <IDocumentRedlineAccess.hxx>
+#include <docary.hxx>
+#include <swcrsr.hxx>
+#include <swundo.hxx>
+#include <pam.hxx>
+#include <ndtxt.hxx>
+#include <UndoCore.hxx>
+#include <rolbck.hxx>
+#include <ndnotxt.hxx>
+#include <IMark.hxx>
+#include <mvsave.hxx>
+#include <redline.hxx>
+#include <crossrefbookmark.hxx>
+#include <strings.hrc>
+#include <docsh.hxx>
+#include <view.hxx>
+#include <frameformats.hxx>
+#include <o3tl/deleter.hxx>
+#include <sal/log.hxx>
+
+// This class saves the Pam as integers and can recompose those into a PaM
+SwUndRng::SwUndRng()
+    : m_nSttNode( 0 ), m_nEndNode( 0 ), m_nSttContent( 0 ), m_nEndContent( 0 )
+{
+}
+
+SwUndRng::SwUndRng( const SwPaM& rPam )
+{
+    SetValues( rPam );
+}
+
+void SwUndRng::SetValues( const SwPaM& rPam )
+{
+    const SwPosition *pStt = rPam.Start();
+    if( rPam.HasMark() )
+    {
+        const SwPosition *pEnd = rPam.End();
+        m_nEndNode = pEnd->GetNodeIndex();
+        m_nEndContent = pEnd->GetContentIndex();
+    }
+    else
+    {
+        // no selection !!
+        m_nEndNode = SwNodeOffset(0);
+        m_nEndContent = COMPLETE_STRING;
+    }
+
+    m_nSttNode = pStt->GetNodeIndex();
+    m_nSttContent = pStt->GetContentIndex();
+}
+
+void SwUndRng::SetPaM( SwPaM & rPam, bool bCorrToContent ) const
+{
+    rPam.DeleteMark();
+    rPam.GetPoint()->Assign( m_nSttNode, m_nSttContent );
+    SwNode& rNd = rPam.GetPointNode();
+    if( !rNd.IsContentNode() && bCorrToContent )
+        rPam.Move( fnMoveForward, GoInContent );
+
+    if( !m_nEndNode && COMPLETE_STRING == m_nEndContent )       // no selection
+        return ;
+
+    rPam.SetMark();
+    if( m_nSttNode == m_nEndNode && m_nSttContent == m_nEndContent )
+        return;                             // nothing left to do
+
+    rPam.GetPoint()->Assign( m_nEndNode, m_nEndContent );
+    if( !rPam.GetPointNode().IsContentNode() && bCorrToContent )
+        rPam.Move( fnMoveBackward, GoInContent );
+}
+
+SwPaM & SwUndRng::AddUndoRedoPaM(
+        ::sw::UndoRedoContext & rContext, bool const bCorrToContent) const
+{
+    SwCursor & rPaM( rContext.GetCursorSupplier().CreateNewShellCursor() );
+    SetPaM( rPaM, bCorrToContent );
+    return rPaM;
+}
+
+void SwUndo::RemoveIdxFromSection( SwDoc& rDoc, SwNodeOffset nSttIdx,
+                                    const SwNodeOffset* pEndIdx )
+{
+    SwNodeIndex aIdx( rDoc.GetNodes(), nSttIdx );
+    SwNodeIndex aEndIdx( rDoc.GetNodes(), pEndIdx ? *pEndIdx
+                                    : aIdx.GetNode().EndOfSectionIndex() );
+    SwPosition aPos( rDoc.GetNodes().GetEndOfPostIts() );
+    SwDoc::CorrAbs( aIdx, aEndIdx, aPos, true );
+}
+
+void SwUndo::RemoveIdxFromRange( SwPaM& rPam, bool bMoveNext )
+{
+    const SwPosition* pEnd = rPam.End();
+    if( bMoveNext )
+    {
+        if( pEnd != rPam.GetPoint() )
+            rPam.Exchange();
+
+        SwNodeIndex aStt( rPam.GetMark()->GetNode() );
+        SwNodeIndex aEnd( rPam.GetPoint()->GetNode() );
+
+        if( !rPam.Move( fnMoveForward ) )
+        {
+            rPam.Exchange();
+            if( !rPam.Move( fnMoveBackward ) )
+            {
+                rPam.GetPoint()->Assign( rPam.GetDoc().GetNodes().GetEndOfPostIts() );
+            }
+        }
+
+        SwDoc::CorrAbs( aStt, aEnd, *rPam.GetPoint(), true );
+    }
+    else
+        SwDoc::CorrAbs( rPam, *pEnd, true );
+}
+
+void SwUndo::RemoveIdxRel( SwNodeOffset nIdx, const SwPosition& rPos )
+{
+    // Move only the Cursor. Bookmarks/TOXMarks/etc. are done by the corresponding
+    // JoinNext/JoinPrev
+    ::PaMCorrRel( *rPos.GetNode().GetNodes()[nIdx], rPos );
+}
+
+SwUndo::SwUndo(SwUndoId const nId, const SwDoc* pDoc)
+    : m_nId(nId), m_nOrigRedlineFlags(RedlineFlags::NONE)
+    , m_nViewShellId(CreateViewShellId(pDoc))
+    , m_isRepeatIgnored(false)
+    , m_bCacheComment(true)
+{
+}
+
+ViewShellId SwUndo::CreateViewShellId(const SwDoc* pDoc)
+{
+    ViewShellId nRet(-1);
+
+    if (const SwDocShell* pDocShell = pDoc->GetDocShell())
+    {
+        if (const SwView* pView = pDocShell->GetView())
+            nRet = pView->GetViewShellId();
+    }
+
+    return nRet;
+}
+
+bool SwUndo::IsDelBox() const
+{
+    return GetId() == SwUndoId::COL_DELETE || GetId() == SwUndoId::ROW_DELETE ||
+        GetId() == SwUndoId::TABLE_DELBOX;
+}
+
+SwUndo::~SwUndo()
+{
+}
+
+namespace {
+
+class UndoRedoRedlineGuard
+{
+public:
+    UndoRedoRedlineGuard(::sw::UndoRedoContext const & rContext, SwUndo const & rUndo)
+        : m_rRedlineAccess(rContext.GetDoc().getIDocumentRedlineAccess())
+        , m_eMode(m_rRedlineAccess.GetRedlineFlags())
+    {
+        RedlineFlags const eTmpMode = rUndo.GetRedlineFlags();
+        if ((RedlineFlags::ShowMask & eTmpMode) != (RedlineFlags::ShowMask & m_eMode))
+        {
+            m_rRedlineAccess.SetRedlineFlags( eTmpMode );
+        }
+        m_rRedlineAccess.SetRedlineFlags_intern( eTmpMode | RedlineFlags::Ignore );
+    }
+    ~UndoRedoRedlineGuard()
+    {
+        m_rRedlineAccess.SetRedlineFlags(m_eMode);
+    }
+private:
+    IDocumentRedlineAccess & m_rRedlineAccess;
+    RedlineFlags const m_eMode;
+};
+
+}
+
+void SwUndo::Undo()
+{
+    assert(false); // SwUndo::Undo(): ERROR: must call UndoWithContext instead
+}
+
+void SwUndo::Redo()
+{
+    assert(false); // SwUndo::Redo(): ERROR: must call RedoWithContext instead
+}
+
+void SwUndo::UndoWithContext(SfxUndoContext & rContext)
+{
+    ::sw::UndoRedoContext *const pContext(
+            dynamic_cast< ::sw::UndoRedoContext * >(& rContext));
+    assert(pContext);
+    const UndoRedoRedlineGuard aUndoRedoRedlineGuard(*pContext, *this);
+    UndoImpl(*pContext);
+}
+
+void SwUndo::RedoWithContext(SfxUndoContext & rContext)
+{
+    ::sw::UndoRedoContext *const pContext(
+            dynamic_cast< ::sw::UndoRedoContext * >(& rContext));
+    assert(pContext);
+    const UndoRedoRedlineGuard aUndoRedoRedlineGuard(*pContext, *this);
+    RedoImpl(*pContext);
+}
+
+void SwUndo::Repeat(SfxRepeatTarget & rContext)
+{
+    if (m_isRepeatIgnored)
+    {
+        return; // ignore Repeat for multi-selections
+    }
+    ::sw::RepeatContext *const pRepeatContext(
+            dynamic_cast< ::sw::RepeatContext * >(& rContext));
+    assert(pRepeatContext);
+    RepeatImpl(*pRepeatContext);
+}
+
+bool SwUndo::CanRepeat(SfxRepeatTarget & rContext) const
+{
+    assert(dynamic_cast< ::sw::RepeatContext * >(& rContext));
+    (void)rContext;
+    // a MultiSelection action that doesn't do anything must still return true
+    return (SwUndoId::REPEAT_START <= GetId()) && (GetId() < SwUndoId::REPEAT_END);
+}
+
+void SwUndo::RepeatImpl( ::sw::RepeatContext & )
+{
+}
+
+OUString GetUndoComment(SwUndoId eId)
+{
+    TranslateId pId;
+    switch (eId)
+    {
+        case SwUndoId::EMPTY:
+            pId = STR_CANT_UNDO;
+            break;
+        case SwUndoId::START:
+        case SwUndoId::END:
+            break;
+        case SwUndoId::DELETE:
+            pId = STR_DELETE_UNDO;
+            break;
+        case SwUndoId::INSERT:
+            pId = STR_INSERT_UNDO;
+            break;
+        case SwUndoId::OVERWRITE:
+            pId = STR_OVR_UNDO;
+            break;
+        case SwUndoId::SPLITNODE:
+            pId = STR_SPLITNODE_UNDO;
+            break;
+        case SwUndoId::INSATTR:
+            pId = STR_INSATTR_UNDO;
+            break;
+        case SwUndoId::SETFMTCOLL:
+            pId = STR_SETFMTCOLL_UNDO;
+            break;
+        case SwUndoId::RESETATTR:
+            pId = STR_RESET_ATTR_UNDO;
+            break;
+        case SwUndoId::INSFMTATTR:
+            pId = STR_INSFMT_ATTR_UNDO;
+            break;
+        case SwUndoId::INSDOKUMENT:
+            pId = STR_INSERT_DOC_UNDO;
+            break;
+        case SwUndoId::COPY:
+            pId = STR_COPY_UNDO;
+            break;
+        case SwUndoId::INSTABLE:
+            pId = STR_INSTABLE_UNDO;
+            break;
+        case SwUndoId::TABLETOTEXT:
+            pId = STR_TABLETOTEXT_UNDO;
+            break;
+        case SwUndoId::TEXTTOTABLE:
+            pId = STR_TEXTTOTABLE_UNDO;
+            break;
+        case SwUndoId::SORT_TXT:
+            pId = STR_SORT_TXT;
+            break;
+        case SwUndoId::INSLAYFMT:
+            pId = STR_INSERTFLY;
+            break;
+        case SwUndoId::TABLEHEADLINE:
+            pId = STR_TABLEHEADLINE;
+            break;
+        case SwUndoId::INSSECTION:
+            pId = STR_INSERTSECTION;
+            break;
+        case SwUndoId::OUTLINE_LR:
+            pId = STR_OUTLINE_LR;
+            break;
+        case SwUndoId::OUTLINE_UD:
+            pId = STR_OUTLINE_UD;
+            break;
+        case SwUndoId::OUTLINE_EDIT:
+            pId = STR_OUTLINE_EDIT;
+            break;
+        case SwUndoId::INSNUM:
+            pId = STR_INSNUM;
+            break;
+        case SwUndoId::NUMUP:
+            pId = STR_NUMUP;
+            break;
+        case SwUndoId::MOVENUM:
+            pId = STR_MOVENUM;
+            break;
+        case SwUndoId::INSDRAWFMT:
+            pId = STR_INSERTDRAW;
+            break;
+        case SwUndoId::NUMORNONUM:
+            pId = STR_NUMORNONUM;
+            break;
+        case SwUndoId::INC_LEFTMARGIN:
+            pId = STR_INC_LEFTMARGIN;
+            break;
+        case SwUndoId::DEC_LEFTMARGIN:
+            pId = STR_DEC_LEFTMARGIN;
+            break;
+        case SwUndoId::INSERTLABEL:
+            pId = STR_INSERTLABEL;
+            break;
+        case SwUndoId::SETNUMRULESTART:
+            pId = STR_SETNUMRULESTART;
+            break;
+        case SwUndoId::CHGFTN:
+            pId = STR_CHANGEFTN;
+            break;
+        case SwUndoId::REDLINE:
+            SAL_INFO("sw.core", "Should NEVER be used/translated");
+            return "$1";
+        case SwUndoId::ACCEPT_REDLINE:
+            pId = STR_ACCEPT_REDLINE;
+            break;
+        case SwUndoId::REJECT_REDLINE:
+            pId = STR_REJECT_REDLINE;
+            break;
+        case SwUndoId::SPLIT_TABLE:
+            pId = STR_SPLIT_TABLE;
+            break;
+        case SwUndoId::DONTEXPAND:
+            pId = STR_DONTEXPAND;
+            break;
+        case SwUndoId::AUTOCORRECT:
+            pId = STR_AUTOCORRECT;
+            break;
+        case SwUndoId::MERGE_TABLE:
+            pId = STR_MERGE_TABLE;
+            break;
+        case SwUndoId::TRANSLITERATE:
+            pId = STR_TRANSLITERATE;
+            break;
+        case SwUndoId::PASTE_CLIPBOARD:
+            pId = STR_PASTE_CLIPBOARD_UNDO;
+            break;
+        case SwUndoId::TYPING:
+            pId = STR_TYPING_UNDO;
+            break;
+        case SwUndoId::MOVE:
+            pId = STR_MOVE_UNDO;
+            break;
+        case SwUndoId::INSGLOSSARY:
+            pId = STR_INSERT_GLOSSARY;
+            break;
+        case SwUndoId::DELBOOKMARK:
+            pId = STR_DELBOOKMARK;
+            break;
+        case SwUndoId::INSBOOKMARK:
+            pId = STR_INSBOOKMARK;
+            break;
+        case SwUndoId::SORT_TBL:
+            pId = STR_SORT_TBL;
+            break;
+        case SwUndoId::DELLAYFMT:
+            pId = STR_DELETEFLY;
+            break;
+        case SwUndoId::AUTOFORMAT:
+            pId = STR_AUTOFORMAT;
+            break;
+        case SwUndoId::REPLACE:
+            pId = STR_REPLACE;
+            break;
+        case SwUndoId::DELSECTION:
+            pId = STR_DELETESECTION;
+            break;
+        case SwUndoId::CHGSECTION:
+            pId = STR_CHANGESECTION;
+            break;
+        case SwUndoId::SETDEFTATTR:
+            pId = STR_CHANGEDEFATTR;
+            break;
+        case SwUndoId::DELNUM:
+            pId = STR_DELNUM;
+            break;
+        case SwUndoId::DRAWUNDO:
+            pId = STR_DRAWUNDO;
+            break;
+        case SwUndoId::DRAWGROUP:
+            pId = STR_DRAWGROUP;
+            break;
+        case SwUndoId::DRAWUNGROUP:
+            pId = STR_DRAWUNGROUP;
+            break;
+        case SwUndoId::DRAWDELETE:
+            pId = STR_DRAWDELETE;
+            break;
+        case SwUndoId::REREAD:
+            pId = STR_REREAD;
+            break;
+        case SwUndoId::DELGRF:
+            pId = STR_DELGRF;
+            break;
+        case SwUndoId::TABLE_ATTR:
+            pId = STR_TABLE_ATTR;
+            break;
+        case SwUndoId::TABLE_AUTOFMT:
+            pId = STR_UNDO_TABLE_AUTOFMT;
+            break;
+        case SwUndoId::TABLE_INSCOL:
+            pId = STR_UNDO_TABLE_INSCOL;
+            break;
+        case SwUndoId::TABLE_INSROW:
+            pId = STR_UNDO_TABLE_INSROW;
+            break;
+        case SwUndoId::TABLE_DELBOX:
+            pId = STR_UNDO_TABLE_DELBOX;
+            break;
+        case SwUndoId::TABLE_SPLIT:
+            pId = STR_UNDO_TABLE_SPLIT;
+            break;
+        case SwUndoId::TABLE_MERGE:
+            pId = STR_UNDO_TABLE_MERGE;
+            break;
+        case SwUndoId::TBLNUMFMT:
+            pId = STR_TABLE_NUMFORMAT;
+            break;
+        case SwUndoId::INSTOX:
+            pId = STR_INSERT_TOX;
+            break;
+        case SwUndoId::CLEARTOXRANGE:
+            pId = STR_CLEAR_TOX_RANGE;
+            break;
+        case SwUndoId::TBLCPYTBL:
+            pId = STR_TABLE_TBLCPYTBL;
+            break;
+        case SwUndoId::CPYTBL:
+            pId = STR_TABLE_CPYTBL;
+            break;
+        case SwUndoId::INS_FROM_SHADOWCRSR:
+            pId = STR_INS_FROM_SHADOWCRSR;
+            break;
+        case SwUndoId::CHAINE:
+            pId = STR_UNDO_CHAIN;
+            break;
+        case SwUndoId::UNCHAIN:
+            pId = STR_UNDO_UNCHAIN;
+            break;
+        case SwUndoId::FTNINFO:
+            pId = STR_UNDO_FTNINFO;
+            break;
+        case SwUndoId::COMPAREDOC:
+            pId = STR_UNDO_COMPAREDOC;
+            break;
+        case SwUndoId::SETFLYFRMFMT:
+            pId = STR_UNDO_SETFLYFRMFMT;
+            break;
+        case SwUndoId::SETRUBYATTR:
+            pId = STR_UNDO_SETRUBYATTR;
+            break;
+        case SwUndoId::TOXCHANGE:
+            pId = STR_TOXCHANGE;
+            break;
+        case SwUndoId::CREATE_PAGEDESC:
+            pId = STR_UNDO_PAGEDESC_CREATE;
+            break;
+        case SwUndoId::CHANGE_PAGEDESC:
+            pId = STR_UNDO_PAGEDESC;
+            break;
+        case SwUndoId::DELETE_PAGEDESC:
+            pId = STR_UNDO_PAGEDESC_DELETE;
+            break;
+        case SwUndoId::HEADER_FOOTER:
+            pId = STR_UNDO_HEADER_FOOTER;
+            break;
+        case SwUndoId::FIELD:
+            pId = STR_UNDO_FIELD;
+            break;
+        case SwUndoId::TXTFMTCOL_CREATE:
+            pId = STR_UNDO_TXTFMTCOL_CREATE;
+            break;
+        case SwUndoId::TXTFMTCOL_DELETE:
+            pId = STR_UNDO_TXTFMTCOL_DELETE;
+            break;
+        case SwUndoId::TXTFMTCOL_RENAME:
+            pId = STR_UNDO_TXTFMTCOL_RENAME;
+            break;
+        case SwUndoId::CHARFMT_CREATE:
+            pId = STR_UNDO_CHARFMT_CREATE;
+            break;
+        case SwUndoId::CHARFMT_DELETE:
+            pId = STR_UNDO_CHARFMT_DELETE;
+            break;
+        case SwUndoId::CHARFMT_RENAME:
+            pId = STR_UNDO_CHARFMT_RENAME;
+            break;
+        case SwUndoId::FRMFMT_CREATE:
+            pId = STR_UNDO_FRMFMT_CREATE;
+            break;
+        case SwUndoId::FRMFMT_DELETE:
+            pId = STR_UNDO_FRMFMT_DELETE;
+            break;
+        case SwUndoId::FRMFMT_RENAME:
+            pId = STR_UNDO_FRMFMT_RENAME;
+            break;
+        case SwUndoId::NUMRULE_CREATE:
+            pId = STR_UNDO_NUMRULE_CREATE;
+            break;
+        case SwUndoId::NUMRULE_DELETE:
+            pId = STR_UNDO_NUMRULE_DELETE;
+            break;
+        case SwUndoId::NUMRULE_RENAME:
+            pId = STR_UNDO_NUMRULE_RENAME;
+            break;
+        case SwUndoId::BOOKMARK_RENAME:
+            pId = STR_UNDO_BOOKMARK_RENAME;
+            break;
+        case SwUndoId::INDEX_ENTRY_INSERT:
+            pId = STR_UNDO_INDEX_ENTRY_INSERT;
+            break;
+        case SwUndoId::INDEX_ENTRY_DELETE:
+            pId = STR_UNDO_INDEX_ENTRY_DELETE;
+            break;
+        case SwUndoId::COL_DELETE:
+            pId = STR_UNDO_COL_DELETE;
+            break;
+        case SwUndoId::ROW_DELETE:
+            pId = STR_UNDO_ROW_DELETE;
+            break;
+        case SwUndoId::RENAME_PAGEDESC:
+            pId = STR_UNDO_PAGEDESC_RENAME;
+            break;
+        case SwUndoId::NUMDOWN:
+            pId = STR_NUMDOWN;
+            break;
+        case SwUndoId::FLYFRMFMT_TITLE:
+            pId = STR_UNDO_FLYFRMFMT_TITLE;
+            break;
+        case SwUndoId::FLYFRMFMT_DESCRIPTION:
+            pId = STR_UNDO_FLYFRMFMT_DESCRIPTION;
+            break;
+        case SwUndoId::TBLSTYLE_CREATE:
+            pId = STR_UNDO_TBLSTYLE_CREATE;
+            break;
+        case SwUndoId::TBLSTYLE_DELETE:
+            pId = STR_UNDO_TBLSTYLE_DELETE;
+            break;
+        case SwUndoId::TBLSTYLE_UPDATE:
+            pId = STR_UNDO_TBLSTYLE_UPDATE;
+            break;
+        case SwUndoId::UI_REPLACE:
+            pId = STR_REPLACE_UNDO;
+            break;
+        case SwUndoId::UI_INSERT_PAGE_BREAK:
+            pId = STR_INSERT_PAGE_BREAK_UNDO;
+            break;
+        case SwUndoId::UI_INSERT_COLUMN_BREAK:
+            pId = STR_INSERT_COLUMN_BREAK_UNDO;
+            break;
+        case SwUndoId::UI_INSERT_ENVELOPE:
+            pId = STR_INSERT_ENV_UNDO;
+            break;
+        case SwUndoId::UI_DRAG_AND_COPY:
+            pId = STR_DRAG_AND_COPY;
+            break;
+        case SwUndoId::UI_DRAG_AND_MOVE:
+            pId = STR_DRAG_AND_MOVE;
+            break;
+        case SwUndoId::UI_INSERT_CHART:
+            pId = STR_INSERT_CHART;
+            break;
+        case SwUndoId::UI_INSERT_FOOTNOTE:
+            pId = STR_INSERT_FOOTNOTE;
+            break;
+        case SwUndoId::UI_INSERT_URLBTN:
+            pId = STR_INSERT_URLBTN;
+            break;
+        case SwUndoId::UI_INSERT_URLTXT:
+            pId = STR_INSERT_URLTXT;
+            break;
+        case SwUndoId::UI_DELETE_INVISIBLECNTNT:
+            pId = STR_DELETE_INVISIBLECNTNT;
+            break;
+        case SwUndoId::UI_REPLACE_STYLE:
+            pId = STR_REPLACE_STYLE;
+            break;
+        case SwUndoId::UI_DELETE_PAGE_BREAK:
+            pId = STR_DELETE_PAGE_BREAK;
+            break;
+        case SwUndoId::UI_TEXT_CORRECTION:
+            pId = STR_TEXT_CORRECTION;
+            break;
+        case SwUndoId::UI_TABLE_DELETE:
+            pId = STR_UNDO_TABLE_DELETE;
+            break;
+        case SwUndoId::CONFLICT:
+            break;
+        case SwUndoId::PARA_SIGN_ADD:
+            pId = STR_PARAGRAPH_SIGN_UNDO;
+            break;
+        case SwUndoId::INSERT_FORM_FIELD:
+            pId = STR_UNDO_INSERT_FORM_FIELD;
+            break;
+        case SwUndoId::INSERT_PAGE_NUMBER:
+            pId = STR_UNDO_INSERT_PAGE_NUMBER;
+            break;
+        case SwUndoId::UPDATE_FORM_FIELD:
+            pId = STR_UNDO_UPDATE_FORM_FIELD;
+            break;
+        case SwUndoId::UPDATE_FORM_FIELDS:
+            pId = STR_UNDO_UPDATE_FORM_FIELDS;
+            break;
+        case SwUndoId::DELETE_FORM_FIELDS:
+            pId = STR_UNDO_DELETE_FORM_FIELDS;
+            break;
+        case SwUndoId::UPDATE_BOOKMARK:
+            pId = STR_UPDATE_BOOKMARK;
+            break;
+        case SwUndoId::UPDATE_BOOKMARKS:
+            pId = STR_UPDATE_BOOKMARKS;
+            break;
+        case SwUndoId::DELETE_BOOKMARKS:
+            pId = STR_DELETE_BOOKMARKS;
+            break;
+        case SwUndoId::UPDATE_FIELD:
+            pId = STR_UPDATE_FIELD;
+            break;
+        case SwUndoId::UPDATE_FIELDS:
+            pId = STR_UPDATE_FIELDS;
+            break;
+        case SwUndoId::DELETE_FIELDS:
+            pId = STR_DELETE_FIELDS;
+            break;
+        case SwUndoId::UPDATE_SECTIONS:
+            pId = STR_UPDATE_SECTIONS;
+            break;
+        case SwUndoId::CHANGE_THEME:
+            pId = STR_UNDO_CHANGE_THEME_COLORS;
+            break;
+        case SwUndoId::DELETE_SECTIONS:
+            pId = STR_DELETE_SECTIONS;
+            break;
+        case SwUndoId::FLYFRMFMT_DECORATIVE:
+            pId = STR_UNDO_FLYFRMFMT_DECORATIVE;
+            break;
+    }
+
+    assert(pId);
+    return SwResId(pId);
+}
+
+OUString SwUndo::GetComment() const
+{
+    OUString aResult;
+
+    if (m_bCacheComment)
+    {
+        if (! maComment)
+        {
+            maComment = GetUndoComment(GetId());
+
+            SwRewriter aRewriter = GetRewriter();
+
+            maComment = aRewriter.Apply(*maComment);
+        }
+
+        aResult = *maComment;
+    }
+    else
+    {
+        aResult = GetUndoComment(GetId());
+
+        SwRewriter aRewriter = GetRewriter();
+
+        aResult = aRewriter.Apply(aResult);
+    }
+
+    return aResult;
+}
+
+ViewShellId SwUndo::GetViewShellId() const
+{
+    return m_nViewShellId;
+}
+
+SwRewriter SwUndo::GetRewriter() const
+{
+    SwRewriter aResult;
+
+    return aResult;
+}
+
+SwUndoSaveContent::SwUndoSaveContent()
+{}
+
+SwUndoSaveContent::~SwUndoSaveContent() COVERITY_NOEXCEPT_FALSE
+{
+}
+
+void SwUndoSaveContent::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwUndoSaveContent"));
+    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
+
+    if (m_pHistory)
+    {
+        m_pHistory->dumpAsXml(pWriter);
+    }
+
+    (void)xmlTextWriterEndElement(pWriter);
+}
+
+// This is needed when deleting content. For REDO all contents will be moved
+// into the UndoNodesArray. These methods always create a new node to insert
+// content. As a result, the attributes will not be expanded.
+// - MoveTo   moves from NodesArray into UndoNodesArray
+// - MoveFrom moves from UndoNodesArray into NodesArray
+
+// If pEndNdIdx is given, Undo/Redo calls -Ins/DelFly. In that case the whole
+// section should be moved.
+void SwUndoSaveContent::MoveToUndoNds( SwPaM& rPaM, SwNodeIndex* pNodeIdx,
+                    SwNodeOffset* pEndNdIdx )
+{
+    SwDoc& rDoc = rPaM.GetDoc();
+    ::sw::UndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
+
+    SwNoTextNode* pCpyNd = rPaM.GetPointNode().GetNoTextNode();
+
+    // here comes the actual delete (move)
+    SwNodes & rNds = rDoc.GetUndoManager().GetUndoNodes();
+    SwPosition aPos( pEndNdIdx ? rNds.GetEndOfPostIts()
+                               : rNds.GetEndOfExtras() );
+
+    const SwPosition* pStt = rPaM.Start(), *pEnd = rPaM.End();
+
+    SwNodeOffset nTmpMvNode = aPos.GetNodeIndex();
+
+    if( pCpyNd || pEndNdIdx )
+    {
+        SwNodeRange aRg( pStt->GetNode(), SwNodeOffset(0), pEnd->GetNode(), SwNodeOffset(1) );
+        rDoc.GetNodes().MoveNodes( aRg, rNds, aPos.GetNode(), true );
+        aPos.Adjust(SwNodeOffset(-1));
+    }
+    else
+    {
+        rDoc.GetNodes().MoveRange( rPaM, aPos, rNds );
+    }
+    if( pEndNdIdx )
+        *pEndNdIdx = aPos.GetNodeIndex();
+
+    // old position
+    aPos.Assign(nTmpMvNode);
+    if( pNodeIdx )
+        *pNodeIdx = aPos.GetNode();
+}
+
+void SwUndoSaveContent::MoveFromUndoNds( SwDoc& rDoc, SwNodeOffset nNodeIdx,
+                            SwPosition& rInsPos,
+            const SwNodeOffset* pEndNdIdx, bool const bForceCreateFrames)
+{
+    // here comes the recovery
+    SwNodes & rNds = rDoc.GetUndoManager().GetUndoNodes();
+    if( nNodeIdx == rNds.GetEndOfPostIts().GetIndex() )
+        return;     // nothing saved
+
+    ::sw::UndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
+
+    SwPaM aPaM( rInsPos );
+    if( pEndNdIdx )         // than get the section from it
+        aPaM.GetPoint()->Assign( *rNds[SwNodeOffset(0)], *pEndNdIdx );
+    else
+    {
+        aPaM.GetPoint()->Assign( rNds.GetEndOfExtras() );
+        GoInContent( aPaM, fnMoveBackward );
+    }
+
+    SwTextNode* pTextNd = aPaM.GetPointNode().GetTextNode();
+    if (!pEndNdIdx && pTextNd)
+    {
+        aPaM.SetMark();
+        aPaM.GetPoint()->Assign(nNodeIdx, 0);
+
+        SaveRedlEndPosForRestore aRedlRest( rInsPos.GetNode(), rInsPos.GetContentIndex() );
+
+        rNds.MoveRange( aPaM, rInsPos, rDoc.GetNodes() );
+
+        // delete the last Node as well
+        bool bDeleteLastNode = false;
+        if( !aPaM.GetPoint()->GetContentIndex() )
+            bDeleteLastNode = true;
+        else
+        {
+            // still empty Nodes at the end?
+            aPaM.GetPoint()->Adjust(SwNodeOffset(1));
+            if ( &rNds.GetEndOfExtras() != &aPaM.GetPoint()->GetNode() )
+                bDeleteLastNode = true;
+        }
+        if( bDeleteLastNode )
+        {
+            SwNode& rDelNode = aPaM.GetPoint()->GetNode();
+            SwNodeOffset nDelOffset = rNds.GetEndOfExtras().GetIndex() -
+                        aPaM.GetPoint()->GetNodeIndex();
+            //move it so we don't have SwContentIndex pointing at a node when it is deleted.
+            aPaM.GetPoint()->Adjust(SwNodeOffset(-1));
+            aPaM.SetMark();
+            rNds.Delete( rDelNode, nDelOffset );
+        }
+
+        aRedlRest.Restore();
+    }
+    else
+    {
+        SwNodeRange aRg( rNds, nNodeIdx, (pEndNdIdx
+                        ? ((*pEndNdIdx) + 1)
+                        : rNds.GetEndOfExtras().GetIndex() ) );
+        rNds.MoveNodes(aRg, rDoc.GetNodes(), rInsPos.GetNode(), nullptr == pEndNdIdx || bForceCreateFrames);
+
+    }
+}
+
+// These two methods save and restore the Point of PaM.
+// If the point cannot be moved, a "backup" is created on the previous node.
+// Either way, returned, inserting at its original position will not move it.
+::std::optional<SwNodeIndex> SwUndoSaveContent::MovePtBackward(SwPaM & rPam)
+{
+    rPam.SetMark();
+    if( rPam.Move( fnMoveBackward ))
+        return {};
+
+    return { SwNodeIndex(rPam.GetPoint()->GetNode(), -1) };
+}
+
+void SwUndoSaveContent::MovePtForward(SwPaM& rPam, ::std::optional<SwNodeIndex> && oMvBkwrd)
+{
+    // Was there content before this position?
+    if (!oMvBkwrd)
+        rPam.Move( fnMoveForward );
+    else
+    {
+        *rPam.GetPoint() = SwPosition(*oMvBkwrd);
+        rPam.GetPoint()->Adjust(SwNodeOffset(1));
+        SwContentNode* pCNd = rPam.GetPointContentNode();
+        if( !pCNd )
+            rPam.Move( fnMoveForward );
+    }
+}
+
+// Delete all objects that have ContentIndices to the given area.
+// Currently (1994) these exist:
+//                  - Footnotes
+//                  - Flys
+//                  - Bookmarks
+
+// #i81002# - extending method
+// delete certain (not all) cross-reference bookmarks at text node of <rMark>
+// and at text node of <rPoint>, if these text nodes aren't the same.
+void SwUndoSaveContent::DelContentIndex( const SwPosition& rMark,
+                                     const SwPosition& rPoint,
+                                     DelContentType nDelContentType )
+{
+    const SwPosition *pStt = rMark < rPoint ? &rMark : &rPoint,
+                    *pEnd = &rMark == pStt ? &rPoint : &rMark;
+
+    SwDoc& rDoc = rMark.GetNode().GetDoc();
+
+    // if it's not in the doc array, probably missing some invalidation somewhere
+    assert(&rPoint.GetNodes() == &rDoc.GetNodes());
+    assert(&rMark.GetNodes() == &rDoc.GetNodes());
+
+    ::sw::UndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
+
+    // 1. Footnotes
+    if( DelContentType::Ftn & nDelContentType )
+    {
+        SwFootnoteIdxs& rFootnoteArr = rDoc.GetFootnoteIdxs();
+        if( !rFootnoteArr.empty() )
+        {
+            const SwNode* pFootnoteNd;
+            size_t nPos = 0;
+            rFootnoteArr.SeekEntry( pStt->GetNode(), &nPos );
+            SwTextFootnote* pSrch;
+
+            // for now delete all that come afterwards
+            while( nPos < rFootnoteArr.size() && ( pFootnoteNd =
+                &( pSrch = rFootnoteArr[ nPos ] )->GetTextNode())->GetIndex()
+                        <= pEnd->GetNodeIndex() )
+            {
+                const sal_Int32 nFootnoteSttIdx = pSrch->GetStart();
+                if( (DelContentType::CheckNoCntnt & nDelContentType )
+                    ? (&pEnd->GetNode() == pFootnoteNd )
+                    : (( &pStt->GetNode() == pFootnoteNd &&
+                    pStt->GetContentIndex() > nFootnoteSttIdx) ||
+                    ( &pEnd->GetNode() == pFootnoteNd &&
+                    nFootnoteSttIdx >= pEnd->GetContentIndex() )) )
+                {
+                    ++nPos;     // continue searching
+                    continue;
+                }
+
+// FIXME: duplicated code here and below -> refactor?
+                // Unfortunately an index needs to be created. Otherwise there
+                // will be problems with TextNode because the index will be
+                // deleted in the DTOR of SwFootnote!
+                SwTextNode* pTextNd = const_cast<SwTextNode*>(static_cast<const SwTextNode*>(pFootnoteNd));
+                if( !m_pHistory )
+                    m_pHistory.reset( new SwHistory );
+                SwTextAttr* const pFootnoteHint =
+                    pTextNd->GetTextAttrForCharAt( nFootnoteSttIdx );
+                assert(pFootnoteHint);
+                SwContentIndex aIdx( pTextNd, nFootnoteSttIdx );
+                m_pHistory->AddTextAttr(pFootnoteHint, pTextNd->GetIndex(), false);
+                pTextNd->EraseText( aIdx, 1 );
+            }
+
+            while( nPos-- && ( pFootnoteNd = &( pSrch = rFootnoteArr[ nPos ] )->
+                    GetTextNode())->GetIndex() >= pStt->GetNodeIndex() )
+            {
+                const sal_Int32 nFootnoteSttIdx = pSrch->GetStart();
+                if( !(DelContentType::CheckNoCntnt & nDelContentType) && (
+                    ( &pStt->GetNode() == pFootnoteNd &&
+                    pStt->GetContentIndex() > nFootnoteSttIdx ) ||
+                    ( &pEnd->GetNode() == pFootnoteNd &&
+                    nFootnoteSttIdx >= pEnd->GetContentIndex() )))
+                    continue;               // continue searching
+
+                // Unfortunately an index needs to be created. Otherwise there
+                // will be problems with TextNode because the index will be
+                // deleted in the DTOR of SwFootnote!
+                SwTextNode* pTextNd = const_cast<SwTextNode*>(static_cast<const SwTextNode*>(pFootnoteNd));
+                if( !m_pHistory )
+                    m_pHistory.reset( new SwHistory );
+                SwTextAttr* const pFootnoteHint =
+                    pTextNd->GetTextAttrForCharAt( nFootnoteSttIdx );
+                assert(pFootnoteHint);
+                SwContentIndex aIdx( pTextNd, nFootnoteSttIdx );
+                m_pHistory->AddTextAttr(pFootnoteHint, pTextNd->GetIndex(), false);
+                pTextNd->EraseText( aIdx, 1 );
+            }
+        }
+    }
+
+    // 2. Flys
+    if( DelContentType::Fly & nDelContentType )
+    {
+        sal_uInt16 nChainInsPos = m_pHistory ? m_pHistory->Count() : 0;
+        const sw::SpzFrameFormats& rSpzArr = *rDoc.GetSpzFrameFormats();
+        if( !rSpzArr.empty() )
+        {
+            sw::SpzFrameFormat* pFormat;
+            const SwFormatAnchor* pAnchor;
+            size_t n = rSpzArr.size();
+            const SwPosition* pAPos;
+
+            while( n && !rSpzArr.empty() )
+            {
+                pFormat = rSpzArr[--n];
+                pAnchor = &pFormat->GetAnchor();
+                switch( pAnchor->GetAnchorId() )
+                {
+                case RndStdIds::FLY_AS_CHAR:
+                    if( nullptr != (pAPos = pAnchor->GetContentAnchor() ) &&
+                        (( DelContentType::CheckNoCntnt & nDelContentType )
+                        ? ( pStt->GetNode() <= pAPos->GetNode() &&
+                            pAPos->GetNode() < pEnd->GetNode() )
+                        : ( *pStt <= *pAPos && *pAPos < *pEnd )) )
+                    {
+                        if( !m_pHistory )
+                            m_pHistory.reset( new SwHistory );
+                        SwTextNode *const pTextNd =
+                            pAPos->GetNode().GetTextNode();
+                        SwTextAttr* const pFlyHint = pTextNd->GetTextAttrForCharAt(
+                            pAPos->GetContentIndex());
+                        assert(pFlyHint);
+                        m_pHistory->AddTextAttr(pFlyHint, SwNodeOffset(0), false);
+                        // reset n so that no Format is skipped
+                        n = n >= rSpzArr.size() ? rSpzArr.size() : n+1;
+                    }
+                    break;
+                case RndStdIds::FLY_AT_PARA:
+                    {
+                        pAPos =  pAnchor->GetContentAnchor();
+                        if (pAPos &&
+                            pStt->GetNode() <= pAPos->GetNode() && pAPos->GetNode() <= pEnd->GetNode())
+                        {
+                            if (!m_pHistory)
+                                m_pHistory.reset( new SwHistory );
+
+                            if (!(DelContentType::Replace & nDelContentType)
+                                && IsSelectFrameAnchoredAtPara(*pAPos, *pStt, *pEnd, nDelContentType))
+                            {
+                                m_pHistory->AddDeleteFly(*pFormat, nChainInsPos);
+                                // reset n so that no Format is skipped
+                                n = n >= rSpzArr.size() ? rSpzArr.size() : n+1;
+                            }
+                            // Moving the anchor?
+                            else if (!((DelContentType::CheckNoCntnt|DelContentType::ExcludeFlyAtStartEnd)
+                                    & nDelContentType) &&
+                                // for SwUndoDelete: rPoint is the node that
+                                // will be Joined - so anchor should be moved
+                                // off it - but UndoImpl() split will insert
+                                // new node *before* existing one so a no-op
+                                // may need to be done here to add it to
+                                // history for Undo.
+                                (rPoint.GetNodeIndex() == pAPos->GetNodeIndex()
+                                 || pStt->GetNodeIndex() == pAPos->GetNodeIndex())
+                                // Do not try to move the anchor to a table!
+                                && rMark.GetNode().IsTextNode())
+                            {
+                                m_pHistory->AddChangeFlyAnchor(*pFormat);
+                                SwFormatAnchor aAnch( *pAnchor );
+                                SwPosition aPos( rMark.GetNode() );
+                                aAnch.SetAnchor( &aPos );
+                                pFormat->SetFormatAttr( aAnch );
+                            }
+                        }
+                    }
+                    break;
+                case RndStdIds::FLY_AT_CHAR:
+                    if( nullptr != (pAPos = pAnchor->GetContentAnchor() ) &&
+                        ( pStt->GetNode() <= pAPos->GetNode() && pAPos->GetNode() <= pEnd->GetNode() ) )
+                    {
+                        if( !m_pHistory )
+                            m_pHistory.reset( new SwHistory );
+                        if (!(DelContentType::Replace & nDelContentType)
+                            && IsDestroyFrameAnchoredAtChar(
+                                *pAPos, *pStt, *pEnd, nDelContentType))
+                        {
+                            m_pHistory->AddDeleteFly(*pFormat, nChainInsPos);
+                            n = n >= rSpzArr.size() ? rSpzArr.size() : n+1;
+                        }
+                        else if (!((DelContentType::CheckNoCntnt |
+                                    DelContentType::ExcludeFlyAtStartEnd)
+                                    & nDelContentType))
+                        {
+                            if( *pStt <= *pAPos && *pAPos < *pEnd )
+                            {
+                                // These are the objects anchored
+                                // between section start and end position
+                                // Do not try to move the anchor to a table!
+                                if( rMark.GetNode().GetTextNode() )
+                                {
+                                    m_pHistory->AddChangeFlyAnchor(*pFormat);
+                                    SwFormatAnchor aAnch( *pAnchor );
+                                    aAnch.SetAnchor( &rMark );
+                                    pFormat->SetFormatAttr( aAnch );
+                                }
+                            }
+                        }
+                    }
+                    break;
+                case RndStdIds::FLY_AT_FLY:
+
+                    if( nullptr != (pAPos = pAnchor->GetContentAnchor() ) &&
+                        pStt->GetNode() == pAPos->GetNode() )
+                    {
+                        if( !m_pHistory )
+                            m_pHistory.reset( new SwHistory );
+
+                        m_pHistory->AddDeleteFly(*pFormat, nChainInsPos);
+
+                        // reset n so that no Format is skipped
+                        n = n >= rSpzArr.size() ? rSpzArr.size() : n+1;
+                    }
+                    break;
+                default: break;
+                }
+            }
+        }
+    }
+
+    // 3. Bookmarks
+    if( !(DelContentType::Bkm & nDelContentType) )
+        return;
+
+    IDocumentMarkAccess* const pMarkAccess = rDoc.getIDocumentMarkAccess();
+    if( !pMarkAccess->getAllMarksCount() )
+        return;
+
+    for( sal_Int32 n = 0; n < pMarkAccess->getAllMarksCount(); ++n )
+    {
+        // #i81002#
+        bool bSavePos = false;
+        bool bSaveOtherPos = false;
+        bool bDelete = false;
+        const ::sw::mark::IMark *const pBkmk = pMarkAccess->getAllMarksBegin()[n];
+        auto const type(IDocumentMarkAccess::GetType(*pBkmk));
+
+        if( DelContentType::CheckNoCntnt & nDelContentType )
+        {
+            if ( pStt->GetNode() <= pBkmk->GetMarkPos().GetNode()
+                 && pBkmk->GetMarkPos().GetNode() < pEnd->GetNode() )
+            {
+                bSavePos = true;
+            }
+            if ( pBkmk->IsExpanded()
+                 && pStt->GetNode() <= pBkmk->GetOtherMarkPos().GetNode()
+                 && pBkmk->GetOtherMarkPos().GetNode() < pEnd->GetNode() )
+            {
+                bSaveOtherPos = true;
+            }
+            bDelete = bSavePos && bSaveOtherPos;
+        }
+        else
+        {
+            // #i92125#
+            // keep cross-reference bookmarks, if content inside one paragraph is deleted.
+            if ( rMark.GetNode() == rPoint.GetNode()
+                && (   type == IDocumentMarkAccess::MarkType::CROSSREF_HEADING_BOOKMARK
+                    || type == IDocumentMarkAccess::MarkType::CROSSREF_NUMITEM_BOOKMARK))
+            {
+                continue;
+            }
+
+            bool bMaybe = false;
+            if ( *pStt <= pBkmk->GetMarkPos() && pBkmk->GetMarkPos() <= *pEnd )
+            {
+                if ( pBkmk->GetMarkPos() == *pEnd
+                     || ( *pStt == pBkmk->GetMarkPos() && pBkmk->IsExpanded() ) )
+                    bMaybe = true;
+                else
+                    bSavePos = true;
+            }
+            if( pBkmk->IsExpanded() &&
+                *pStt <= pBkmk->GetOtherMarkPos() && pBkmk->GetOtherMarkPos() <= *pEnd )
+            {
+                assert(!bSaveOtherPos);
+                if (   bSavePos
+                    || (*pStt < pBkmk->GetOtherMarkPos() && pBkmk->GetOtherMarkPos() < *pEnd)
+                    || (bMaybe
+                        && (   type == IDocumentMarkAccess::MarkType::TEXT_FIELDMARK
+                            || type == IDocumentMarkAccess::MarkType::CHECKBOX_FIELDMARK
+                            || type == IDocumentMarkAccess::MarkType::DROPDOWN_FIELDMARK
+                            || type == IDocumentMarkAccess::MarkType::DATE_FIELDMARK))
+                    || (bMaybe
+                        && !(nDelContentType & DelContentType::Replace)
+                        && type == IDocumentMarkAccess::MarkType::BOOKMARK
+                        && pStt->GetContentIndex() == 0 // entire paragraph deleted?
+                        && pEnd->GetContentIndex() == pEnd->GetNode().GetTextNode()->Len()))
+                {
+                    if( bMaybe )
+                        bSavePos = true;
+                    bDelete = true;
+                }
+                if (bDelete || pBkmk->GetOtherMarkPos() == *pEnd)
+                {
+                    bSaveOtherPos = true; // tdf#148389 always undo if at end
+                }
+            }
+            if (!bSavePos && bMaybe && pBkmk->IsExpanded() && *pStt == pBkmk->GetMarkPos())
+            {
+                bSavePos = true; // tdf#148389 always undo if at start
+            }
+
+            if ( !bSavePos && !bSaveOtherPos
+                 && dynamic_cast< const ::sw::mark::CrossRefBookmark* >(pBkmk) )
+            {
+                // certain special handling for cross-reference bookmarks
+                const bool bDifferentTextNodesAtMarkAndPoint =
+                    rMark.GetNode() != rPoint.GetNode()
+                    && rMark.GetNode().GetTextNode()
+                    && rPoint.GetNode().GetTextNode();
+                if ( bDifferentTextNodesAtMarkAndPoint )
+                {
+                    // delete cross-reference bookmark at <pStt>, if only part of
+                    // <pEnd> text node content is deleted.
+                    if( pStt->GetNode() == pBkmk->GetMarkPos().GetNode()
+                        && pEnd->GetContentIndex() != pEnd->GetNode().GetTextNode()->Len() )
+                    {
+                        bSavePos = true;
+                        bSaveOtherPos = false; // cross-reference bookmarks are not expanded
+                    }
+                    // delete cross-reference bookmark at <pEnd>, if only part of
+                    // <pStt> text node content is deleted.
+                    else if( pEnd->GetNode() == pBkmk->GetMarkPos().GetNode() &&
+                        pStt->GetContentIndex() != 0 )
+                    {
+                        bSavePos = true;
+                        bSaveOtherPos = false; // cross-reference bookmarks are not expanded
+                    }
+                }
+            }
+            else if (type == IDocumentMarkAccess::MarkType::ANNOTATIONMARK)
+            {
+                // delete annotation marks, if its end position is covered by the deletion
+                const SwPosition& rAnnotationEndPos = pBkmk->GetMarkEnd();
+                if ( *pStt < rAnnotationEndPos && rAnnotationEndPos <= *pEnd )
+                {
+                    bSavePos = true;
+                    bSaveOtherPos = pBkmk->IsExpanded(); //tdf#90138, only save the other pos if there is one
+                    bDelete = true;
+                }
+            }
+        }
+
+        if ( bSavePos || bSaveOtherPos )
+        {
+            if (type != IDocumentMarkAccess::MarkType::UNO_BOOKMARK)
+            {
+                if( !m_pHistory )
+                    m_pHistory.reset( new SwHistory );
+                m_pHistory->AddIMark(*pBkmk, bSavePos, bSaveOtherPos);
+            }
+            if ( bSavePos
+                 && (bDelete || !pBkmk->IsExpanded()))
+            {
+                pMarkAccess->deleteMark(pMarkAccess->getAllMarksBegin()+n, false);
+                n--;
+            }
+        }
+    }
+}
+
+// save a complete section into UndoNodes array
+SwUndoSaveSection::SwUndoSaveSection()
+    : m_nMoveLen( 0 ), m_nStartPos( NODE_OFFSET_MAX )
+{
+}
+
+SwUndoSaveSection::~SwUndoSaveSection()
+{
+    if (m_oMovedStart) // delete also the section from UndoNodes array
+    {
+        // SaveSection saves the content in the PostIt section.
+        SwNodes& rUNds = m_oMovedStart->GetNode().GetNodes();
+        // cid#1486004 Uncaught exception
+        suppress_fun_call_w_exception(rUNds.Delete(*m_oMovedStart, m_nMoveLen));
+
+        m_oMovedStart.reset();
+    }
+    m_pRedlineSaveData.reset();
+}
+
+void SwUndoSaveSection::SaveSection( const SwNodeIndex& rSttIdx )
+{
+    SwNodeRange aRg( rSttIdx.GetNode(), *rSttIdx.GetNode().EndOfSectionNode() );
+    SaveSection( aRg );
+}
+
+void SwUndoSaveSection::SaveSection(
+    const SwNodeRange& rRange, bool const bExpandNodes)
+{
+    SwPaM aPam( rRange.aStart, rRange.aEnd );
+
+    // delete all footnotes, fly frames, bookmarks
+    DelContentIndex( *aPam.GetMark(), *aPam.GetPoint() );
+
+    // redlines *before* CorrAbs, because DelBookmarks will make them 0-length
+    // but *after* DelContentIndex because that also may use FillSaveData (in
+    // flys) and that will be restored *after* this one...
+    m_pRedlineSaveData.reset( new SwRedlineSaveDatas );
+    if (!SwUndo::FillSaveData( aPam, *m_pRedlineSaveData ))
+    {
+        m_pRedlineSaveData.reset();
+    }
+
+    {
+        // move certain indexes out of deleted range
+        SwNodeIndex aSttIdx( aPam.Start()->GetNode() );
+        SwNodeIndex aEndIdx( aPam.End()->GetNode() );
+        SwNodeIndex aMvStt( aEndIdx, 1 );
+        SwDoc::CorrAbs( aSttIdx, aEndIdx, SwPosition( aMvStt ), true );
+    }
+
+    m_nStartPos = rRange.aStart.GetIndex();
+
+    if (bExpandNodes)
+    {
+        aPam.GetPoint()->Adjust(SwNodeOffset(-1));
+        aPam.GetMark()->Adjust(SwNodeOffset(+1));
+    }
+
+    SwContentNode* pCNd = aPam.GetMarkContentNode();
+    if( pCNd )
+        aPam.GetMark()->SetContent( 0 );
+    pCNd = aPam.GetPointContentNode();
+    if( nullptr != pCNd )
+        aPam.GetPoint()->SetContent( pCNd->Len() );
+
+    // Keep positions as SwContentIndex so that this section can be deleted in DTOR
+    SwNodeOffset nEnd;
+    m_oMovedStart = rRange.aStart;
+    MoveToUndoNds(aPam, &*m_oMovedStart, &nEnd);
+    m_nMoveLen = nEnd - m_oMovedStart->GetIndex() + 1;
+}
+
+void SwUndoSaveSection::RestoreSection( SwDoc* pDoc, SwNodeIndex* pIdx,
+                                        sal_uInt16 nSectType )
+{
+    if( NODE_OFFSET_MAX == m_nStartPos )        // was there any content?
+        return;
+
+    // check if the content is at the old position
+    SwNodeIndex aSttIdx( pDoc->GetNodes(), m_nStartPos );
+
+    // move the content from UndoNodes array into Fly
+    SwStartNode* pSttNd = SwNodes::MakeEmptySection( aSttIdx.GetNode(),
+                                            static_cast<SwStartNodeType>(nSectType) );
+
+    RestoreSection( pDoc, *pSttNd->EndOfSectionNode() );
+
+    if( pIdx )
+        *pIdx = *pSttNd;
+}
+
+void SwUndoSaveSection::RestoreSection(
+        SwDoc *const pDoc, const SwNode& rInsPos, bool bForceCreateFrames)
+{
+    if( NODE_OFFSET_MAX == m_nStartPos )        // was there any content?
+        return;
+
+    SwPosition aInsPos( rInsPos );
+    SwNodeOffset nEnd = m_oMovedStart->GetIndex() + m_nMoveLen - 1;
+    MoveFromUndoNds(*pDoc, m_oMovedStart->GetIndex(), aInsPos, &nEnd, bForceCreateFrames);
+
+    // destroy indices again, content was deleted from UndoNodes array
+    m_oMovedStart.reset();
+    m_nMoveLen = SwNodeOffset(0);
+
+    if( m_pRedlineSaveData )
+    {
+        SwUndo::SetSaveData( *pDoc, *m_pRedlineSaveData );
+        m_pRedlineSaveData.reset();
+    }
+}
+
+void SwUndoSaveSection::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+    SwUndoSaveContent::dumpAsXml(pWriter);
+}
+
+// save and set the RedlineData
+SwRedlineSaveData::SwRedlineSaveData(
+    SwComparePosition eCmpPos,
+    const SwPosition& rSttPos,
+    const SwPosition& rEndPos,
+    SwRangeRedline& rRedl,
+    bool bCopyNext )
+    : SwUndRng( rRedl )
+    , SwRedlineData( rRedl.GetRedlineData(), bCopyNext )
+{
+    assert( SwComparePosition::Outside == eCmpPos ||
+            !rRedl.GetContentIdx() ); // "Redline with Content"
+
+    switch (eCmpPos)
+    {
+    case SwComparePosition::OverlapBefore:        // Pos1 overlaps Pos2 at the beginning
+        m_nEndNode = rEndPos.GetNodeIndex();
+        m_nEndContent = rEndPos.GetContentIndex();
+        break;
+
+    case SwComparePosition::OverlapBehind:        // Pos1 overlaps Pos2 at the end
+        m_nSttNode = rSttPos.GetNodeIndex();
+        m_nSttContent = rSttPos.GetContentIndex();
+        break;
+
+    case SwComparePosition::Inside:                // Pos1 lays completely in Pos2
+        m_nSttNode = rSttPos.GetNodeIndex();
+        m_nSttContent = rSttPos.GetContentIndex();
+        m_nEndNode = rEndPos.GetNodeIndex();
+        m_nEndContent = rEndPos.GetContentIndex();
+        break;
+
+    case SwComparePosition::Outside:               // Pos2 lays completely in Pos1
+        if ( rRedl.GetContentIdx() )
+        {
+            // than move section into UndoArray and memorize it
+            SaveSection( *rRedl.GetContentIdx() );
+            rRedl.ClearContentIdx();
+        }
+        break;
+
+    case SwComparePosition::Equal:                 // Pos1 is exactly as big as Pos2
+        break;
+
+    default:
+        assert(false);
+    }
+
+#if OSL_DEBUG_LEVEL > 0
+    m_nRedlineCount = rSttPos.GetNode().GetDoc().getIDocumentRedlineAccess().GetRedlineTable().size();
+    m_bRedlineCountDontCheck = false;
+    m_bRedlineMoved = rRedl.IsMoved();
+#endif
+}
+
+SwRedlineSaveData::~SwRedlineSaveData()
+{
+}
+
+void SwRedlineSaveData::RedlineToDoc( SwPaM const & rPam )
+{
+    SwDoc& rDoc = rPam.GetDoc();
+    SwRangeRedline* pRedl = new SwRangeRedline( *this, rPam );
+
+    if( GetMvSttIdx() )
+    {
+        SwNodeIndex aIdx( rDoc.GetNodes() );
+        RestoreSection( &rDoc, &aIdx, SwNormalStartNode );
+        if( GetHistory() )
+            GetHistory()->Rollback( &rDoc );
+        pRedl->SetContentIdx( aIdx );
+    }
+    SetPaM( *pRedl );
+    // First, delete the "old" so that in an Append no unexpected things will
+    // happen, e.g. a delete in an insert. In the latter case the just restored
+    // content will be deleted and not the one you originally wanted.
+    rDoc.getIDocumentRedlineAccess().DeleteRedline( *pRedl, false, RedlineType::Any );
+
+    RedlineFlags eOld = rDoc.getIDocumentRedlineAccess().GetRedlineFlags();
+    rDoc.getIDocumentRedlineAccess().SetRedlineFlags_intern( eOld | RedlineFlags::DontCombineRedlines );
+    //#i92154# let UI know about a new redline with comment
+    if (rDoc.GetDocShell() && (!pRedl->GetComment().isEmpty()) )
+        rDoc.GetDocShell()->Broadcast(SwRedlineHint());
+
+    auto const result(rDoc.getIDocumentRedlineAccess().AppendRedline(pRedl, true));
+    assert(result != IDocumentRedlineAccess::AppendResult::IGNORED); // SwRedlineSaveData::RedlineToDoc: insert redline failed
+    (void) result; // unused in non-debug
+    rDoc.getIDocumentRedlineAccess().SetRedlineFlags_intern( eOld );
+}
+
+bool SwUndo::FillSaveData(
+    const SwPaM& rRange,
+    SwRedlineSaveDatas& rSData,
+    bool bDelRange,
+    bool bCopyNext )
+{
+    rSData.clear();
+
+    auto [pStt, pEnd] = rRange.StartEnd(); // SwPosition*
+    const SwRedlineTable& rTable = rRange.GetDoc().getIDocumentRedlineAccess().GetRedlineTable();
+    SwRedlineTable::size_type n = 0;
+    rRange.GetDoc().getIDocumentRedlineAccess().GetRedline( *pStt, &n );
+    for ( ; n < rTable.size(); ++n )
+    {
+        SwRangeRedline* pRedl = rTable[n];
+
+        const SwComparePosition eCmpPos =
+            ComparePosition( *pStt, *pEnd, *pRedl->Start(), *pRedl->End() );
+        if ( eCmpPos != SwComparePosition::Before
+             && eCmpPos != SwComparePosition::Behind
+             && eCmpPos != SwComparePosition::CollideEnd
+             && eCmpPos != SwComparePosition::CollideStart )
+        {
+
+            rSData.push_back(std::unique_ptr<SwRedlineSaveData>(new SwRedlineSaveData(eCmpPos, *pStt, *pEnd, *pRedl, bCopyNext)));
+        }
+    }
+    if( !rSData.empty() && bDelRange )
+    {
+        rRange.GetDoc().getIDocumentRedlineAccess().DeleteRedline( rRange, false, RedlineType::Any );
+    }
+    return !rSData.empty();
+}
+
+bool SwUndo::FillSaveDataForFormat(
+    const SwPaM& rRange,
+    SwRedlineSaveDatas& rSData )
+{
+    rSData.clear();
+
+    const SwPosition *pStt = rRange.Start(), *pEnd = rRange.End();
+    const SwRedlineTable& rTable = rRange.GetDoc().getIDocumentRedlineAccess().GetRedlineTable();
+    SwRedlineTable::size_type n = 0;
+    rRange.GetDoc().getIDocumentRedlineAccess().GetRedline( *pStt, &n );
+    for ( ; n < rTable.size(); ++n )
+    {
+        SwRangeRedline* pRedl = rTable[n];
+        if ( RedlineType::Format == pRedl->GetType() )
+        {
+            const SwComparePosition eCmpPos = ComparePosition( *pStt, *pEnd, *pRedl->Start(), *pRedl->End() );
+            if ( eCmpPos != SwComparePosition::Before
+                 && eCmpPos != SwComparePosition::Behind
+                 && eCmpPos != SwComparePosition::CollideEnd
+                 && eCmpPos != SwComparePosition::CollideStart )
+            {
+                rSData.push_back(std::unique_ptr<SwRedlineSaveData>(new SwRedlineSaveData(eCmpPos, *pStt, *pEnd, *pRedl, true)));
+            }
+
+        }
+    }
+    return !rSData.empty();
+}
+
+
+void SwUndo::SetSaveData( SwDoc& rDoc, SwRedlineSaveDatas& rSData )
+{
+    RedlineFlags eOld = rDoc.getIDocumentRedlineAccess().GetRedlineFlags();
+    rDoc.getIDocumentRedlineAccess().SetRedlineFlags_intern( ( eOld & ~RedlineFlags::Ignore) | RedlineFlags::On );
+    SwPaM aPam( rDoc.GetNodes().GetEndOfContent() );
+
+    for( size_t n = rSData.size(); n; )
+        rSData[ --n ].RedlineToDoc( aPam );
+
+#if OSL_DEBUG_LEVEL > 0
+    // check redline count against count saved in RedlineSaveData object
+    // except in the case of moved redlines
+    assert(
+        rSData.empty() || rSData[0].m_bRedlineMoved || rSData[0].m_bRedlineCountDontCheck ||
+           (rSData[0].m_nRedlineCount == rDoc.getIDocumentRedlineAccess().GetRedlineTable().size()));
+            // "redline count not restored properly"
+#endif
+
+    rDoc.getIDocumentRedlineAccess().SetRedlineFlags_intern( eOld );
+}
+
+bool SwUndo::HasHiddenRedlines( const SwRedlineSaveDatas& rSData )
+{
+    for( size_t n = rSData.size(); n; )
+        if( rSData[ --n ].GetMvSttIdx() )
+            return true;
+    return false;
+}
+
+bool SwUndo::CanRedlineGroup( SwRedlineSaveDatas& rCurr,
+                        const SwRedlineSaveDatas& rCheck, bool bCurrIsEnd )
+{
+    if( rCurr.size() != rCheck.size() )
+        return false;
+
+    for( size_t n = 0; n < rCurr.size(); ++n )
+    {
+        const SwRedlineSaveData& rSet = rCurr[ n ];
+        const SwRedlineSaveData& rGet = rCheck[ n ];
+        if( rSet.m_nSttNode != rGet.m_nSttNode ||
+            rSet.GetMvSttIdx() || rGet.GetMvSttIdx() ||
+            ( bCurrIsEnd ? rSet.m_nSttContent != rGet.m_nEndContent
+                            : rSet.m_nEndContent != rGet.m_nSttContent ) ||
+            !rGet.CanCombine( rSet ) )
+        {
+            return false;
+        }
+    }
+
+    for( size_t n = 0; n < rCurr.size(); ++n )
+    {
+        SwRedlineSaveData& rSet = rCurr[ n ];
+        const SwRedlineSaveData& rGet = rCheck[ n ];
+        if( bCurrIsEnd )
+            rSet.m_nSttContent = rGet.m_nSttContent;
+        else
+            rSet.m_nEndContent = rGet.m_nEndContent;
+    }
+    return true;
+}
+
+OUString ShortenString(const OUString & rStr, sal_Int32 nLength, std::u16string_view aFillStr)
+{
+    assert(nLength - aFillStr.size() >= 2);
+
+    if (rStr.getLength() <= nLength)
+        return rStr;
+
+    nLength -= aFillStr.size();
+    if ( nLength < 2 )
+        nLength = 2;
+
+    const sal_Int32 nFrontLen = nLength - nLength / 2;
+    const sal_Int32 nBackLen = nLength - nFrontLen;
+
+    return OUString::Concat(rStr.subView(0, nFrontLen))
+           + aFillStr
+           + rStr.subView(rStr.getLength() - nBackLen);
+}
+
+static bool IsAtEndOfSection(SwPosition const& rAnchorPos)
+{
+    SwNodeIndex node(*rAnchorPos.GetNode().EndOfSectionNode());
+    SwContentNode *const pNode(SwNodes::GoPrevious(&node));
+    assert(pNode);
+    assert(rAnchorPos.GetNode() <= node.GetNode()); // last valid anchor pos is last content
+    return node == rAnchorPos.GetNode()
+        // at-para fly has no SwContentIndex!
+        && (rAnchorPos.GetContentIndex() == pNode->Len() || rAnchorPos.GetContentNode() == nullptr);
+}
+
+static bool IsAtStartOfSection(SwPosition const& rAnchorPos)
+{
+    SwNodes const& rNodes(rAnchorPos.GetNodes());
+    SwNodeIndex node(*rAnchorPos.GetNode().StartOfSectionNode());
+    SwContentNode *const pNode(rNodes.GoNext(&node));
+    assert(pNode);
+    (void) pNode;
+    assert(node <= rAnchorPos.GetNode());
+    return node == rAnchorPos.GetNode() && rAnchorPos.GetContentIndex() == 0;
+}
+
+/// passed start / end position could be on section start / end node
+static bool IsAtEndOfSection2(SwPosition const& rPos)
+{
+    return rPos.GetNode().IsEndNode()
+        || IsAtEndOfSection(rPos);
+}
+
+static bool IsAtStartOfSection2(SwPosition const& rPos)
+{
+    return rPos.GetNode().IsStartNode()
+        || IsAtStartOfSection(rPos);
+}
+
+static bool IsNotBackspaceHeuristic(
+        SwPosition const& rStart, SwPosition const& rEnd)
+{
+    // check if the selection is backspace/delete created by DelLeft/DelRight
+    if (rStart.GetNodeIndex() + 1 != rEnd.GetNodeIndex())
+        return true;
+    if (rEnd.GetContentIndex() != 0)
+        return true;
+    const SwTextNode* pTextNode = rStart.GetNode().GetTextNode();
+    if (!pTextNode || rStart.GetContentIndex() != pTextNode->Len())
+        return true;
+    return false;
+}
+
+bool IsDestroyFrameAnchoredAtChar(SwPosition const & rAnchorPos,
+        SwPosition const & rStart, SwPosition const & rEnd,
+        DelContentType const nDelContentType)
+{
+    assert(rStart <= rEnd);
+
+    // CheckNoCntnt means DelFullPara which is obvious to handle
+    if (DelContentType::CheckNoCntnt & nDelContentType)
+    {   // exclude selection end node because it won't be deleted
+        return (rAnchorPos.GetNode() < rEnd.GetNode())
+            && (rStart.GetNode() <= rAnchorPos.GetNode());
+    }
+
+    if ((nDelContentType & DelContentType::WriterfilterHack)
+        && rAnchorPos.GetDoc().IsInWriterfilterImport())
+    {   // FIXME hack for writerfilter RemoveLastParagraph() and MakeFlyAndMove(); can't test file format more specific?
+        return (rStart < rAnchorPos) && (rAnchorPos < rEnd);
+    }
+
+    if (nDelContentType & DelContentType::ExcludeFlyAtStartEnd)
+    {   // exclude selection start and end node
+        return (rAnchorPos.GetNode() < rEnd.GetNode())
+            && (rStart.GetNode() < rAnchorPos.GetNode());
+    }
+
+    // in general, exclude the start and end position
+    return ((rStart < rAnchorPos)
+            || (rStart == rAnchorPos
+                // special case: fully deleted node
+                && ((rStart.GetNode() != rEnd.GetNode() && rStart.GetContentIndex() == 0
+                        // but not if the selection is backspace/delete!
+                        && IsNotBackspaceHeuristic(rStart, rEnd))
+                    || (IsAtStartOfSection(rAnchorPos) && IsAtEndOfSection2(rEnd)))))
+        && ((rAnchorPos < rEnd)
+            || (rAnchorPos == rEnd
+                // special case: fully deleted node
+                && ((rEnd.GetNode() != rStart.GetNode() && rEnd.GetContentIndex() == rEnd.GetNode().GetTextNode()->Len()
+                        && IsNotBackspaceHeuristic(rStart, rEnd))
+                    || (IsAtEndOfSection(rAnchorPos) && IsAtStartOfSection2(rStart)))));
+}
+
+bool IsSelectFrameAnchoredAtPara(SwPosition const & rAnchorPos,
+        SwPosition const & rStart, SwPosition const & rEnd,
+        DelContentType const nDelContentType)
+{
+    assert(rStart <= rEnd);
+
+    // CheckNoCntnt means DelFullPara which is obvious to handle
+    if (DelContentType::CheckNoCntnt & nDelContentType)
+    {   // exclude selection end node because it won't be deleted
+        return (rAnchorPos.GetNode() < rEnd.GetNode())
+            && (rStart.GetNode() <= rAnchorPos.GetNode());
+    }
+
+    if ((nDelContentType & DelContentType::WriterfilterHack)
+        && rAnchorPos.GetDoc().IsInWriterfilterImport())
+    {   // FIXME hack for writerfilter RemoveLastParagraph() and MakeFlyAndMove(); can't test file format more specific?
+        // but it MUST NOT be done during the SetRedlineFlags at the end of ODF
+        // import, where the IsInXMLImport() cannot be checked because the
+        // stupid code temp. overrides it - instead rely on setting the ALLFLYS
+        // flag in MoveFromSection() and converting that to CheckNoCntnt with
+        // adjusted cursor!
+        return (rStart.GetNode() < rAnchorPos.GetNode()) && (rAnchorPos.GetNode() < rEnd.GetNode());
+    }
+
+    // in general, exclude the start and end position
+    return ((rStart.GetNode() < rAnchorPos.GetNode())
+            || (rStart.GetNode() == rAnchorPos.GetNode()
+                && !(nDelContentType & DelContentType::ExcludeFlyAtStartEnd)
+                // special case: fully deleted node
+                && ((rStart.GetNode() != rEnd.GetNode() && rStart.GetContentIndex() == 0
+                        // but not if the selection is backspace/delete!
+                        && IsNotBackspaceHeuristic(rStart, rEnd))
+                    || (IsAtStartOfSection2(rStart) && IsAtEndOfSection2(rEnd)))))
+        && ((rAnchorPos.GetNode() < rEnd.GetNode())
+            || (rAnchorPos.GetNode() == rEnd.GetNode()
+                && !(nDelContentType & DelContentType::ExcludeFlyAtStartEnd)
+                // special case: fully deleted node
+                && ((rEnd.GetNode() != rStart.GetNode() && rEnd.GetContentIndex() == rEnd.GetNode().GetTextNode()->Len()
+                        && IsNotBackspaceHeuristic(rStart, rEnd))
+                    || (IsAtEndOfSection2(rEnd) && IsAtStartOfSection2(rStart)))));
+}
+
+bool IsFlySelectedByCursor(SwDoc const & rDoc,
+        SwPosition const & rStart, SwPosition const & rEnd)
+{
+    for (SwFrameFormat const*const pFly : *rDoc.GetSpzFrameFormats())
+    {
+        SwFormatAnchor const& rAnchor(pFly->GetAnchor());
+        switch (rAnchor.GetAnchorId())
+        {
+            case RndStdIds::FLY_AT_CHAR:
+            case RndStdIds::FLY_AT_PARA:
+            {
+                SwPosition const*const pAnchorPos(rAnchor.GetContentAnchor());
+                // can this really be null?
+                if (pAnchorPos != nullptr
+                    && ((rAnchor.GetAnchorId() == RndStdIds::FLY_AT_CHAR)
+                        ? IsDestroyFrameAnchoredAtChar(*pAnchorPos, rStart, rEnd)
+                        : IsSelectFrameAnchoredAtPara(*pAnchorPos, rStart, rEnd)))
+                {
+                    return true;
+                }
+            }
+            break;
+            default: // other types not relevant
+            break;
+        }
+    }
+    return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */