/* -*- 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 <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 <swundo.hxx>
#include <pam.hxx>
#include <pamtyp.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 <o3tl/make_unique.hxx>
#include <sal/log.hxx>
// This class saves the Pam as integers and can recompose those into a PaM
SwUndRng::SwUndRng()
: nSttNode( 0 ), nEndNode( 0 ), nSttContent( 0 ), 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.GetPoint() == pStt
? rPam.GetMark()
: rPam.GetPoint();
nEndNode = pEnd->nNode.GetIndex();
nEndContent = pEnd->nContent.GetIndex();
}
else
{
// no selection !!
nEndNode = 0;
nEndContent = COMPLETE_STRING;
}
nSttNode = pStt->nNode.GetIndex();
nSttContent = pStt->nContent.GetIndex();
}
void SwUndRng::SetPaM( SwPaM & rPam, bool bCorrToContent ) const
{
rPam.DeleteMark();
rPam.GetPoint()->nNode = nSttNode;
SwNode& rNd = rPam.GetNode();
if( rNd.IsContentNode() )
rPam.GetPoint()->nContent.Assign( rNd.GetContentNode(), nSttContent );
else if( bCorrToContent )
rPam.Move( fnMoveForward, GoInContent );
else
rPam.GetPoint()->nContent.Assign( nullptr, 0 );
if( !nEndNode && COMPLETE_STRING == nEndContent ) // no selection
return ;
rPam.SetMark();
if( nSttNode == nEndNode && nSttContent == nEndContent )
return; // nothing left to do
rPam.GetPoint()->nNode = nEndNode;
if( rPam.GetNode().IsContentNode() )
rPam.GetPoint()->nContent.Assign( rPam.GetNode().GetContentNode(), nEndContent );
else if( bCorrToContent )
rPam.Move( fnMoveBackward, GoInContent );
else
rPam.GetPoint()->nContent.Assign( nullptr, 0 );
}
SwPaM & SwUndRng::AddUndoRedoPaM(
::sw::UndoRedoContext & rContext, bool const bCorrToContent) const
{
SwPaM & rPaM( rContext.GetCursorSupplier().CreateNewShellCursor() );
SetPaM( rPaM, bCorrToContent );
return rPaM;
}
void SwUndo::RemoveIdxFromSection( SwDoc& rDoc, sal_uLong nSttIdx,
const sal_uLong* 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()->nNode );
SwNodeIndex aEnd( rPam.GetPoint()->nNode );
if( !rPam.Move( fnMoveForward ) )
{
rPam.Exchange();
if( !rPam.Move( fnMoveBackward ) )
{
rPam.GetPoint()->nNode = rPam.GetDoc()->GetNodes().GetEndOfPostIts();
rPam.GetPoint()->nContent.Assign( nullptr, 0 );
}
}
SwDoc::CorrAbs( aStt, aEnd, *rPam.GetPoint(), true );
}
else
SwDoc::CorrAbs( rPam, *pEnd, true );
}
void SwUndo::RemoveIdxRel( sal_uLong nIdx, const SwPosition& rPos )
{
// Move only the Cursor. Bookmarks/TOXMarks/etc. are done by the corresponding
// JoinNext/JoinPrev
SwNodeIndex aIdx( rPos.nNode.GetNode().GetNodes(), nIdx );
::PaMCorrRel( aIdx, rPos );
}
SwUndo::SwUndo(SwUndoId const nId, const SwDoc* pDoc)
: m_nId(nId), nOrigRedlineFlags(RedlineFlags::NONE)
, m_nViewShellId(CreateViewShellId(pDoc))
, m_isRepeatIgnored(false)
, 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()
{
}
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)
{
const char *pId = nullptr;
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::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_WARN("sw.core", "Should NEVER be used/translated");
return OUString();
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_DESCRITPTION;
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;
};
assert(pId);
return SwResId(pId);
}
OUString SwUndo::GetComment() const
{
OUString aResult;
if (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
{
}
// 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,
sal_uLong* pEndNdIdx )
{
SwDoc& rDoc = *rPaM.GetDoc();
::sw::UndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
SwNoTextNode* pCpyNd = rPaM.GetNode().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();
sal_uLong nTmpMvNode = aPos.nNode.GetIndex();
if( pCpyNd || pEndNdIdx )
{
SwNodeRange aRg( pStt->nNode, 0, pEnd->nNode, 1 );
rDoc.GetNodes().MoveNodes( aRg, rNds, aPos.nNode, false );
aPos.nContent = 0;
--aPos.nNode;
}
else
{
rDoc.GetNodes().MoveRange( rPaM, aPos, rNds );
}
if( pEndNdIdx )
*pEndNdIdx = aPos.nNode.GetIndex();
// old position
aPos.nNode = nTmpMvNode;
if( pNodeIdx )
*pNodeIdx = aPos.nNode;
}
void SwUndoSaveContent::MoveFromUndoNds( SwDoc& rDoc, sal_uLong nNodeIdx,
SwPosition& rInsPos,
const sal_uLong* pEndNdIdx )
{
// 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()->nNode.Assign( rNds, *pEndNdIdx );
else
{
aPaM.GetPoint()->nNode = rNds.GetEndOfExtras();
GoInContent( aPaM, fnMoveBackward );
}
SwTextNode* pTextNd = aPaM.GetNode().GetTextNode();
if (!pEndNdIdx && pTextNd)
{
aPaM.SetMark();
aPaM.GetPoint()->nNode = nNodeIdx;
aPaM.GetPoint()->nContent.Assign(aPaM.GetContentNode(), 0);
SaveRedlEndPosForRestore aRedlRest( rInsPos.nNode, rInsPos.nContent.GetIndex() );
rNds.MoveRange( aPaM, rInsPos, rDoc.GetNodes() );
// delete the last Node as well
if( !aPaM.GetPoint()->nContent.GetIndex() ||
( aPaM.GetPoint()->nNode++ && // still empty Nodes at the end?
&rNds.GetEndOfExtras() != &aPaM.GetPoint()->nNode.GetNode() ))
{
aPaM.GetPoint()->nContent.Assign( nullptr, 0 );
aPaM.SetMark();
rNds.Delete( aPaM.GetPoint()->nNode,
rNds.GetEndOfExtras().GetIndex() -
aPaM.GetPoint()->nNode.GetIndex() );
}
aRedlRest.Restore();
}
else if( pEndNdIdx || !pTextNd )
{
SwNodeRange aRg( rNds, nNodeIdx, rNds, (pEndNdIdx
? ((*pEndNdIdx) + 1)
: rNds.GetEndOfExtras().GetIndex() ) );
rNds.MoveNodes( aRg, rDoc.GetNodes(), rInsPos.nNode, nullptr == pEndNdIdx );
}
else {
assert(false); // wtf?
}
}
// These two methods move the Point of Pam backwards/forwards. With that, one
// can span an area for a Undo/Redo. (The Point is then positioned in front of
// the area to manipulate!)
// The flag indicates if there is still content in front of Point.
bool SwUndoSaveContent::MovePtBackward( SwPaM& rPam )
{
rPam.SetMark();
if( rPam.Move( fnMoveBackward ))
return true;
// If there is no content onwards, set Point simply to the previous position
// (Node and Content, so that Content will be detached!)
--rPam.GetPoint()->nNode;
rPam.GetPoint()->nContent.Assign( nullptr, 0 );
return false;
}
void SwUndoSaveContent::MovePtForward( SwPaM& rPam, bool bMvBkwrd )
{
// Was there content before this position?
if( bMvBkwrd )
rPam.Move( fnMoveForward );
else
{
++rPam.GetPoint()->nNode;
SwContentNode* pCNd = rPam.GetContentNode();
if( pCNd )
pCNd->MakeStartIndex( &rPam.GetPoint()->nContent );
else
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* pDoc = rMark.nNode.GetNode().GetDoc();
::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
// 1. Footnotes
if( DelContentType::Ftn & nDelContentType )
{
SwFootnoteIdxs& rFootnoteArr = pDoc->GetFootnoteIdxs();
if( !rFootnoteArr.empty() )
{
const SwNode* pFootnoteNd;
size_t nPos = 0;
rFootnoteArr.SeekEntry( pStt->nNode, &nPos );
SwTextFootnote* pSrch;
// for now delete all that come afterwards
while( nPos < rFootnoteArr.size() && ( pFootnoteNd =
&( pSrch = rFootnoteArr[ nPos ] )->GetTextNode())->GetIndex()
<= pEnd->nNode.GetIndex() )
{
const sal_Int32 nFootnoteSttIdx = pSrch->GetStart();
if( (DelContentType::CheckNoCntnt & nDelContentType )
? (&pEnd->nNode.GetNode() == pFootnoteNd )
: (( &pStt->nNode.GetNode() == pFootnoteNd &&
pStt->nContent.GetIndex() > nFootnoteSttIdx) ||
( &pEnd->nNode.GetNode() == pFootnoteNd &&
nFootnoteSttIdx >= pEnd->nContent.GetIndex() )) )
{
++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( !pHistory )
pHistory.reset( new SwHistory );
SwTextAttr* const pFootnoteHint =
pTextNd->GetTextAttrForCharAt( nFootnoteSttIdx );
assert(pFootnoteHint);
SwIndex aIdx( pTextNd, nFootnoteSttIdx );
pHistory->Add( pFootnoteHint, pTextNd->GetIndex(), false );
pTextNd->EraseText( aIdx, 1 );
}
while( nPos-- && ( pFootnoteNd = &( pSrch = rFootnoteArr[ nPos ] )->
GetTextNode())->GetIndex() >= pStt->nNode.GetIndex() )
{
const sal_Int32 nFootnoteSttIdx = pSrch->GetStart();
if( !(DelContentType::CheckNoCntnt & nDelContentType) && (
( &pStt->nNode.GetNode() == pFootnoteNd &&
pStt->nContent.GetIndex() > nFootnoteSttIdx ) ||
( &pEnd->nNode.GetNode() == pFootnoteNd &&
nFootnoteSttIdx >= pEnd->nContent.GetIndex() )))
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( !pHistory )
pHistory.reset( new SwHistory );
SwTextAttr* const pFootnoteHint =
pTextNd->GetTextAttrForCharAt( nFootnoteSttIdx );
assert(pFootnoteHint);
SwIndex aIdx( pTextNd, nFootnoteSttIdx );
pHistory->Add( pFootnoteHint, pTextNd->GetIndex(), false );
pTextNd->EraseText( aIdx, 1 );
}
}
}
// 2. Flys
if( DelContentType::Fly & nDelContentType )
{
sal_uInt16 nChainInsPos = pHistory ? pHistory->Count() : 0;
const SwFrameFormats& rSpzArr = *pDoc->GetSpzFrameFormats();
if( !rSpzArr.empty() )
{
const bool bDelFwrd = rMark.nNode.GetIndex() <= rPoint.nNode.GetIndex();
SwFrameFormat* 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->nNode <= pAPos->nNode &&
pAPos->nNode < pEnd->nNode )
: ( *pStt <= *pAPos && *pAPos < *pEnd )) )
{
if( !pHistory )
pHistory.reset( new SwHistory );
SwTextNode *const pTextNd =
pAPos->nNode.GetNode().GetTextNode();
SwTextAttr* const pFlyHint = pTextNd->GetTextAttrForCharAt(
pAPos->nContent.GetIndex());
assert(pFlyHint);
pHistory->Add( pFlyHint, 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 )
{
bool bTmp;
if( DelContentType::CheckNoCntnt & nDelContentType )
bTmp = pStt->nNode <= pAPos->nNode && pAPos->nNode < pEnd->nNode;
else
{
if (bDelFwrd)
bTmp = rMark.nNode < pAPos->nNode &&
pAPos->nNode <= rPoint.nNode;
else
bTmp = rPoint.nNode <= pAPos->nNode &&
pAPos->nNode < rMark.nNode;
}
if (bTmp)
{
if( !pHistory )
pHistory.reset( new SwHistory );
// Moving the anchor?
if( !( DelContentType::CheckNoCntnt & nDelContentType ) &&
( rPoint.nNode.GetIndex() == pAPos->nNode.GetIndex() ) )
{
// Do not try to move the anchor to a table!
if( rMark.nNode.GetNode().GetTextNode() )
{
pHistory->Add( *pFormat );
SwFormatAnchor aAnch( *pAnchor );
SwPosition aPos( rMark.nNode );
aAnch.SetAnchor( &aPos );
pFormat->SetFormatAttr( aAnch );
}
}
else
{
pHistory->Add( *static_cast<SwFlyFrameFormat *>(pFormat), nChainInsPos );
// reset n so that no Format is skipped
n = n >= rSpzArr.size() ?
rSpzArr.size() : n+1;
}
}
}
}
break;
case RndStdIds::FLY_AT_CHAR:
if( nullptr != (pAPos = pAnchor->GetContentAnchor() ) &&
( pStt->nNode <= pAPos->nNode && pAPos->nNode <= pEnd->nNode ) )
{
if( !pHistory )
pHistory.reset( new SwHistory );
if (IsDestroyFrameAnchoredAtChar(
*pAPos, *pStt, *pEnd, nDelContentType))
{
pHistory->Add( *static_cast<SwFlyFrameFormat *>(pFormat), nChainInsPos );
n = n >= rSpzArr.size() ? rSpzArr.size() : n+1;
}
else if( !( DelContentType::CheckNoCntnt & 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.nNode.GetNode().GetTextNode() )
{
pHistory->Add( *pFormat );
SwFormatAnchor aAnch( *pAnchor );
aAnch.SetAnchor( &rMark );
pFormat->SetFormatAttr( aAnch );
}
}
}
}
break;
case RndStdIds::FLY_AT_FLY:
if( nullptr != (pAPos = pAnchor->GetContentAnchor() ) &&
pStt->nNode == pAPos->nNode )
{
if( !pHistory )
pHistory.reset( new SwHistory );
pHistory->Add( *static_cast<SwFlyFrameFormat *>(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 )
{
IDocumentMarkAccess* const pMarkAccess = pDoc->getIDocumentMarkAccess();
if( pMarkAccess->getAllMarksCount() )
{
for( sal_Int32 n = 0; n < pMarkAccess->getAllMarksCount(); ++n )
{
// #i81002#
bool bSavePos = false;
bool bSaveOtherPos = false;
const ::sw::mark::IMark* pBkmk = (pMarkAccess->getAllMarksBegin() + n)->get();
if( DelContentType::CheckNoCntnt & nDelContentType )
{
if ( pStt->nNode <= pBkmk->GetMarkPos().nNode
&& pBkmk->GetMarkPos().nNode < pEnd->nNode )
{
bSavePos = true;
}
if ( pBkmk->IsExpanded()
&& pStt->nNode <= pBkmk->GetOtherMarkPos().nNode
&& pBkmk->GetOtherMarkPos().nNode < pEnd->nNode )
{
bSaveOtherPos = true;
}
}
else
{
// #i92125#
// keep cross-reference bookmarks, if content inside one paragraph is deleted.
if ( rMark.nNode == rPoint.nNode
&& ( IDocumentMarkAccess::GetType(*pBkmk) == IDocumentMarkAccess::MarkType::CROSSREF_HEADING_BOOKMARK
|| IDocumentMarkAccess::GetType(*pBkmk) == 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 )
{
if ( bSavePos || bSaveOtherPos
|| ( pBkmk->GetOtherMarkPos() < *pEnd && pBkmk->GetOtherMarkPos() > *pStt ) )
{
if( bMaybe )
bSavePos = true;
bSaveOtherPos = true;
}
}
if ( !bSavePos && !bSaveOtherPos
&& dynamic_cast< const ::sw::mark::CrossRefBookmark* >(pBkmk) )
{
// certain special handling for cross-reference bookmarks
const bool bDifferentTextNodesAtMarkAndPoint =
rMark.nNode != rPoint.nNode
&& rMark.nNode.GetNode().GetTextNode()
&& rPoint.nNode.GetNode().GetTextNode();
if ( bDifferentTextNodesAtMarkAndPoint )
{
// delete cross-reference bookmark at <pStt>, if only part of
// <pEnd> text node content is deleted.
if( pStt->nNode == pBkmk->GetMarkPos().nNode
&& pEnd->nContent.GetIndex() != pEnd->nNode.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->nNode == pBkmk->GetMarkPos().nNode &&
pStt->nContent.GetIndex() != 0 )
{
bSavePos = true;
bSaveOtherPos = false; // cross-reference bookmarks are not expanded
}
}
}
else if ( IDocumentMarkAccess::GetType(*pBkmk) == 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
}
}
}
if ( bSavePos || bSaveOtherPos )
{
if( IDocumentMarkAccess::GetType(*pBkmk) != IDocumentMarkAccess::MarkType::UNO_BOOKMARK )
{
if( !pHistory )
pHistory.reset( new SwHistory );
pHistory->Add( *pBkmk, bSavePos, bSaveOtherPos );
}
if ( bSavePos
&& ( bSaveOtherPos
|| !pBkmk->IsExpanded() ) )
{
pMarkAccess->deleteMark(pMarkAccess->getAllMarksBegin()+n);
n--;
}
}
}
}
}
}
// save a complete section into UndoNodes array
SwUndoSaveSection::SwUndoSaveSection()
: nMvLen( 0 ), nStartPos( ULONG_MAX )
{
}
SwUndoSaveSection::~SwUndoSaveSection()
{
if (m_pMovedStart) // delete also the section from UndoNodes array
{
// SaveSection saves the content in the PostIt section.
SwNodes& rUNds = m_pMovedStart->GetNode().GetNodes();
rUNds.Delete( *m_pMovedStart, nMvLen );
m_pMovedStart.reset();
}
pRedlSaveData.reset();
}
void SwUndoSaveSection::SaveSection( const SwNodeIndex& rSttIdx )
{
SwNodeRange aRg( rSttIdx.GetNode(), *rSttIdx.GetNode().EndOfSectionNode() );
SaveSection( aRg );
}
void SwUndoSaveSection::SaveSection(
const SwNodeRange& rRange )
{
SwPaM aPam( rRange.aStart, rRange.aEnd );
// delete all footnotes, fly frames, bookmarks
DelContentIndex( *aPam.GetMark(), *aPam.GetPoint() );
{
// move certain indexes out of deleted range
SwNodeIndex aSttIdx( aPam.Start()->nNode.GetNode() );
SwNodeIndex aEndIdx( aPam.End()->nNode.GetNode() );
SwNodeIndex aMvStt( aEndIdx, 1 );
SwDoc::CorrAbs( aSttIdx, aEndIdx, SwPosition( aMvStt ), true );
}
pRedlSaveData.reset( new SwRedlineSaveDatas );
if( !SwUndo::FillSaveData( aPam, *pRedlSaveData ))
{
pRedlSaveData.reset();
}
nStartPos = rRange.aStart.GetIndex();
--aPam.GetPoint()->nNode;
++aPam.GetMark()->nNode;
SwContentNode* pCNd = aPam.GetContentNode( false );
if( pCNd )
aPam.GetMark()->nContent.Assign( pCNd, 0 );
if( nullptr != ( pCNd = aPam.GetContentNode()) )
aPam.GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
// Keep positions as SwIndex so that this section can be deleted in DTOR
sal_uLong nEnd;
m_pMovedStart.reset(new SwNodeIndex(rRange.aStart));
MoveToUndoNds(aPam, m_pMovedStart.get(), &nEnd);
nMvLen = nEnd - m_pMovedStart->GetIndex() + 1;
}
void SwUndoSaveSection::RestoreSection( SwDoc* pDoc, SwNodeIndex* pIdx,
sal_uInt16 nSectType )
{
if( ULONG_MAX != nStartPos ) // was there any content?
{
// check if the content is at the old position
SwNodeIndex aSttIdx( pDoc->GetNodes(), nStartPos );
// move the content from UndoNodes array into Fly
SwStartNode* pSttNd = SwNodes::MakeEmptySection( aSttIdx,
static_cast<SwStartNodeType>(nSectType) );
RestoreSection( pDoc, SwNodeIndex( *pSttNd->EndOfSectionNode() ));
if( pIdx )
*pIdx = *pSttNd;
}
}
void SwUndoSaveSection::RestoreSection( SwDoc* pDoc, const SwNodeIndex& rInsPos )
{
if( ULONG_MAX != nStartPos ) // was there any content?
{
SwPosition aInsPos( rInsPos );
sal_uLong nEnd = m_pMovedStart->GetIndex() + nMvLen - 1;
MoveFromUndoNds(*pDoc, m_pMovedStart->GetIndex(), aInsPos, &nEnd);
// destroy indices again, content was deleted from UndoNodes array
m_pMovedStart.reset();
nMvLen = 0;
if( pRedlSaveData )
{
SwUndo::SetSaveData( *pDoc, *pRedlSaveData );
pRedlSaveData.reset();
}
}
}
// 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
nEndNode = rEndPos.nNode.GetIndex();
nEndContent = rEndPos.nContent.GetIndex();
break;
case SwComparePosition::OverlapBehind: // Pos1 overlaps Pos2 at the end
nSttNode = rSttPos.nNode.GetIndex();
nSttContent = rSttPos.nContent.GetIndex();
break;
case SwComparePosition::Inside: // Pos1 lays completely in Pos2
nSttNode = rSttPos.nNode.GetIndex();
nSttContent = rSttPos.nContent.GetIndex();
nEndNode = rEndPos.nNode.GetIndex();
nEndContent = rEndPos.nContent.GetIndex();
break;
case SwComparePosition::Outside: // Pos2 lays completely in Pos1
if ( rRedl.GetContentIdx() )
{
// than move section into UndoArray and memorize it
SaveSection( *rRedl.GetContentIdx() );
rRedl.SetContentIdx( nullptr );
}
break;
case SwComparePosition::Equal: // Pos1 is exactly as big as Pos2
break;
default:
assert(false);
}
#if OSL_DEBUG_LEVEL > 0
nRedlineCount = rSttPos.nNode.GetNode().GetDoc()->getIDocumentRedlineAccess().GetRedlineTable().size();
#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, USHRT_MAX );
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();
const SwPosition* pStt = rRange.Start();
const SwPosition* 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];
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, o3tl::default_delete<SwRedlineSaveData>>(new SwRedlineSaveData(eCmpPos, *pStt, *pEnd, *pRedl, bCopyNext)));
}
}
if( !rSData.empty() && bDelRange )
{
rRange.GetDoc()->getIDocumentRedlineAccess().DeleteRedline( rRange, false, USHRT_MAX );
}
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 ( nsRedlineType_t::REDLINE_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, o3tl::default_delete<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
assert(rSData.empty() ||
(rSData[0].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.nSttNode != rGet.nSttNode ||
rSet.GetMvSttIdx() || rGet.GetMvSttIdx() ||
( bCurrIsEnd ? rSet.nSttContent != rGet.nEndContent
: rSet.nEndContent != rGet.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.nSttContent = rGet.nSttContent;
else
rSet.nEndContent = rGet.nEndContent;
}
return true;
}
OUString ShortenString(const OUString & rStr, sal_Int32 nLength, const OUString & rFillStr)
{
assert(nLength - rFillStr.getLength() >= 2);
if (rStr.getLength() <= nLength)
return rStr;
nLength -= rFillStr.getLength();
if ( nLength < 2 )
nLength = 2;
const sal_Int32 nFrontLen = nLength - nLength / 2;
const sal_Int32 nBackLen = nLength - nFrontLen;
return rStr.copy(0, nFrontLen)
+ rFillStr
+ rStr.copy(rStr.getLength() - nBackLen);
}
bool IsDestroyFrameAnchoredAtChar(SwPosition const & rAnchorPos,
SwPosition const & rStart, SwPosition const & rEnd,
DelContentType const nDelContentType)
{
// Here we identified the objects to destroy:
// - anchored between start and end of the selection
// - anchored in start of the selection with "CheckNoContent"
// - anchored in start of sel. and the selection start at pos 0
return (rAnchorPos.nNode < rEnd.nNode)
&& ( (DelContentType::CheckNoCntnt & nDelContentType)
|| (rStart.nNode < rAnchorPos.nNode)
|| !rStart.nContent.GetIndex()
);
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V522 There might be dereferencing of a potential null pointer 'pContext'.
↑ V522 There might be dereferencing of a potential null pointer 'pContext'.
↑ V522 There might be dereferencing of a potential null pointer 'pRepeatContext'.