[Libreoffice-commits] core.git: sw/inc sw/source
Miklos Vajna (via logerrit)
logerrit at kemper.freedesktop.org
Mon Aug 5 08:05:23 UTC 2019
sw/inc/undobj.hxx | 4 -
sw/source/core/inc/UndoRedline.hxx | 4 -
sw/source/core/inc/UndoSplitMove.hxx | 2
sw/source/core/undo/unattr.cxx | 16 +++---
sw/source/core/undo/undel.cxx | 88 +++++++++++++++++------------------
sw/source/core/undo/undobj.cxx | 52 ++++++++++----------
sw/source/core/undo/unmove.cxx | 26 +++++-----
sw/source/core/undo/unnum.cxx | 30 +++++------
sw/source/core/undo/unredln.cxx | 40 +++++++--------
sw/source/core/undo/unsect.cxx | 8 +--
sw/source/core/undo/unsort.cxx | 14 ++---
sw/source/core/undo/untbl.cxx | 14 ++---
sw/source/core/undo/untblk.cxx | 36 +++++++-------
13 files changed, 167 insertions(+), 167 deletions(-)
New commits:
commit 837ee0de927a6ab6ac75b1044a3363c3484710a3
Author: Miklos Vajna <vmiklos at collabora.com>
AuthorDate: Mon Aug 5 09:13:07 2019 +0200
Commit: Miklos Vajna <vmiklos at collabora.com>
CommitDate: Mon Aug 5 10:04:44 2019 +0200
sw: prefix members of SwUndRng
See tdf#94879 for motivation.
Change-Id: Ie028e421b44f66e8db3941c6dcd142f830e6e343
Reviewed-on: https://gerrit.libreoffice.org/76963
Reviewed-by: Miklos Vajna <vmiklos at collabora.com>
Tested-by: Jenkins
diff --git a/sw/inc/undobj.hxx b/sw/inc/undobj.hxx
index 3128ffc788d5..8d7afa1bc046 100644
--- a/sw/inc/undobj.hxx
+++ b/sw/inc/undobj.hxx
@@ -215,8 +215,8 @@ public:
class SwUndRng
{
public:
- sal_uLong nSttNode, nEndNode;
- sal_Int32 nSttContent, nEndContent;
+ sal_uLong m_nSttNode, m_nEndNode;
+ sal_Int32 m_nSttContent, m_nEndContent;
SwUndRng();
SwUndRng( const SwPaM& );
diff --git a/sw/source/core/inc/UndoRedline.hxx b/sw/source/core/inc/UndoRedline.hxx
index e2c75db6aa1b..38ecd86314cb 100644
--- a/sw/source/core/inc/UndoRedline.hxx
+++ b/sw/source/core/inc/UndoRedline.hxx
@@ -68,8 +68,8 @@ public:
bool CanGrouping( const SwUndoRedlineDelete& rPrev );
// SwUndoTableCpyTable needs this information:
- long NodeDiff() const { return nSttNode - nEndNode; }
- sal_Int32 ContentStart() const { return nSttContent; }
+ long NodeDiff() const { return m_nSttNode - m_nEndNode; }
+ sal_Int32 ContentStart() const { return m_nSttContent; }
void SetRedlineText(const OUString & rText);
};
diff --git a/sw/source/core/inc/UndoSplitMove.hxx b/sw/source/core/inc/UndoSplitMove.hxx
index 6641611da7f5..a21b249b2509 100644
--- a/sw/source/core/inc/UndoSplitMove.hxx
+++ b/sw/source/core/inc/UndoSplitMove.hxx
@@ -75,7 +75,7 @@ public:
const SwNodeIndex& rInsPos );
bool IsMoveRange() const { return m_bMoveRange; }
- sal_uLong GetEndNode() const { return nEndNode; }
+ sal_uLong GetEndNode() const { return m_nEndNode; }
sal_uLong GetDestSttNode() const { return m_nDestStartNode; }
sal_Int32 GetDestSttContent() const { return m_nDestStartContent; }
diff --git a/sw/source/core/undo/unattr.cxx b/sw/source/core/undo/unattr.cxx
index e389d4341dab..ca1c30ddaebd 100644
--- a/sw/source/core/undo/unattr.cxx
+++ b/sw/source/core/undo/unattr.cxx
@@ -567,8 +567,8 @@ SwUndoResetAttr::SwUndoResetAttr( const SwPosition& rPos, sal_uInt16 nFormatId )
, m_pHistory( new SwHistory )
, m_nFormatId( nFormatId )
{
- nSttNode = nEndNode = rPos.nNode.GetIndex();
- nSttContent = nEndContent = rPos.nContent.GetIndex();
+ m_nSttNode = m_nEndNode = rPos.nNode.GetIndex();
+ m_nSttContent = m_nEndContent = rPos.nContent.GetIndex();
}
SwUndoResetAttr::~SwUndoResetAttr()
@@ -583,10 +583,10 @@ void SwUndoResetAttr::UndoImpl(::sw::UndoRedoContext & rContext)
m_pHistory->SetTmpEnd( m_pHistory->Count() );
if ((RES_CONDTXTFMTCOLL == m_nFormatId) &&
- (nSttNode == nEndNode) && (nSttContent == nEndContent)) {
- SwTextNode* pTNd = rDoc.GetNodes()[ nSttNode ]->GetTextNode();
+ (m_nSttNode == m_nEndNode) && (m_nSttContent == m_nEndContent)) {
+ SwTextNode* pTNd = rDoc.GetNodes()[ m_nSttNode ]->GetTextNode();
if( pTNd ) {
- SwIndex aIdx( pTNd, nSttContent );
+ SwIndex aIdx( pTNd, m_nSttContent );
pTNd->DontExpandFormat( aIdx, false );
}
}
@@ -614,9 +614,9 @@ void SwUndoResetAttr::RedoImpl(::sw::UndoRedoContext & rContext)
// special treatment for TOXMarks
{
SwTOXMarks aArr;
- SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode );
+ SwNodeIndex aIdx( rDoc.GetNodes(), m_nSttNode );
SwPosition aPos( aIdx, SwIndex( aIdx.GetNode().GetContentNode(),
- nSttContent ));
+ m_nSttContent ));
sal_uInt16 nCnt = SwDoc::GetCurTOXMark( aPos, aArr );
if( nCnt ) {
@@ -725,7 +725,7 @@ void SwUndoAttr::UndoImpl(::sw::UndoRedoContext & rContext)
if ( ULONG_MAX != m_nNodeIndex ) {
aPam.DeleteMark();
aPam.GetPoint()->nNode = m_nNodeIndex;
- aPam.GetPoint()->nContent.Assign( aPam.GetContentNode(), nSttContent );
+ aPam.GetPoint()->nContent.Assign( aPam.GetContentNode(), m_nSttContent );
aPam.SetMark();
++aPam.GetPoint()->nContent;
pDoc->getIDocumentRedlineAccess().DeleteRedline(aPam, false, RedlineType::Any);
diff --git a/sw/source/core/undo/undel.cxx b/sw/source/core/undo/undel.cxx
index a53458952594..83536dba8f31 100644
--- a/sw/source/core/undo/undel.cxx
+++ b/sw/source/core/undo/undel.cxx
@@ -72,19 +72,19 @@ static SwTextNode * FindFirstAndNextNode(SwDoc & rDoc, SwUndRng const& rRange,
SwTextNode *& o_rpFirstMergedDeletedTextNode)
{
// redlines are corrected now to exclude the deleted node
- assert(rRange.nEndContent == 0);
+ assert(rRange.m_nEndContent == 0);
sal_uLong nEndOfRedline = 0;
for (size_t i = 0; i < rRedlineSaveData.size(); ++i)
{
auto const& rRedline(rRedlineSaveData[i]);
- if (rRedline.nSttNode <= rRange.nSttNode
- && rRedline.nSttNode < rRange.nEndNode
- && rRange.nEndNode <= rRedline.nEndNode
+ if (rRedline.m_nSttNode <= rRange.m_nSttNode
+ && rRedline.m_nSttNode < rRange.m_nEndNode
+ && rRange.m_nEndNode <= rRedline.m_nEndNode
&& rRedline.GetType() == RedlineType::Delete)
{
- nEndOfRedline = rRedline.nEndNode;
- o_rpFirstMergedDeletedTextNode = rDoc.GetNodes()[rRedline.nSttNode]->GetTextNode();
- assert(rRange.nSttNode == rRange.nEndNode - 1); // otherwise this needs to iterate more RL to find the first node?
+ nEndOfRedline = rRedline.m_nEndNode;
+ o_rpFirstMergedDeletedTextNode = rDoc.GetNodes()[rRedline.m_nSttNode]->GetTextNode();
+ assert(rRange.m_nSttNode == rRange.m_nEndNode - 1); // otherwise this needs to iterate more RL to find the first node?
break;
}
}
@@ -92,7 +92,7 @@ static SwTextNode * FindFirstAndNextNode(SwDoc & rDoc, SwUndRng const& rRange,
{
assert(o_rpFirstMergedDeletedTextNode);
SwTextNode * pNextNode(nullptr);
- for (sal_uLong i = rRange.nEndNode; /* i <= nEndOfRedline */; ++i)
+ for (sal_uLong i = rRange.m_nEndNode; /* i <= nEndOfRedline */; ++i)
{
SwNode *const pNode(rDoc.GetNodes()[i]);
assert(!pNode->IsEndNode()); // cannot be both leaving section here *and* overlapping redline
@@ -228,7 +228,7 @@ SwUndoDelete::SwUndoDelete(
{
DelContentIndex( *rPam.GetMark(), *rPam.GetPoint() );
::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
- if (nEndNode - nSttNode > 1) // check for fully selected nodes
+ if (m_nEndNode - m_nSttNode > 1) // check for fully selected nodes
{
SwNodeIndex const start(pStt->nNode, +1);
DelBookmarks(start, pEnd->nNode);
@@ -238,7 +238,7 @@ SwUndoDelete::SwUndoDelete(
m_nSetPos = pHistory ? pHistory->Count() : 0;
// Is already anything deleted?
- m_nNdDiff = nSttNode - pStt->nNode.GetIndex();
+ m_nNdDiff = m_nSttNode - pStt->nNode.GetIndex();
m_bJoinNext = !bFullPara && pEnd == rPam.GetPoint();
m_bBackSp = !bFullPara && !m_bJoinNext;
@@ -247,7 +247,7 @@ SwUndoDelete::SwUndoDelete(
if( !bFullPara )
{
pSttTextNd = pStt->nNode.GetNode().GetTextNode();
- pEndTextNd = nSttNode == nEndNode
+ pEndTextNd = m_nSttNode == m_nEndNode
? pSttTextNd
: pEnd->nNode.GetNode().GetTextNode();
}
@@ -293,21 +293,21 @@ SwUndoDelete::SwUndoDelete(
rPam.DeleteMark(); // the SPoint is in the selection
if( !pEndTextNd )
- nEndContent = 0;
+ m_nEndContent = 0;
if( !pSttTextNd )
- nSttContent = 0;
+ m_nSttContent = 0;
if( bMoveNds ) // Do Nodes exist that need to be moved?
{
SwNodes& rNds = pDoc->GetUndoManager().GetUndoNodes();
SwNodes& rDocNds = pDoc->GetNodes();
- SwNodeRange aRg( rDocNds, nSttNode - m_nNdDiff,
- rDocNds, nEndNode - m_nNdDiff );
+ SwNodeRange aRg( rDocNds, m_nSttNode - m_nNdDiff,
+ rDocNds, m_nEndNode - m_nNdDiff );
if( !bFullPara && !pEndTextNd &&
&aRg.aEnd.GetNode() != &pDoc->GetNodes().GetEndOfContent() )
{
SwNode* pNode = aRg.aEnd.GetNode().StartOfSectionNode();
- if( pNode->GetIndex() >= nSttNode - m_nNdDiff )
+ if( pNode->GetIndex() >= m_nSttNode - m_nNdDiff )
++aRg.aEnd; // Deletion of a complete table
}
SwNode* pTmpNd;
@@ -321,7 +321,7 @@ SwUndoDelete::SwUndoDelete(
pTmpNd->StartOfSectionNode()->IsSectionNode() &&
pTmpNd->StartOfSectionNode()->GetIndex() >= aRg.aStart.GetIndex() ) )
++aRg.aEnd;
- m_nReplaceDummy = aRg.aEnd.GetIndex() + m_nNdDiff - nEndNode;
+ m_nReplaceDummy = aRg.aEnd.GetIndex() + m_nNdDiff - m_nEndNode;
if( m_nReplaceDummy )
{ // The selection has been expanded, because
++aRg.aEnd;
@@ -352,7 +352,7 @@ SwUndoDelete::SwUndoDelete(
--aRg.aStart;
if( pSttTextNd )
{
- m_nReplaceDummy = nSttNode - m_nNdDiff - aRg.aStart.GetIndex();
+ m_nReplaceDummy = m_nSttNode - m_nNdDiff - aRg.aStart.GetIndex();
if( m_nReplaceDummy )
{
SwNodeRange aMvRg( *pSttTextNd, 0, *pSttTextNd, 1 );
@@ -417,12 +417,12 @@ SwUndoDelete::SwUndoDelete(
// have ContentNodes)?
if( !pSttTextNd && !pEndTextNd )
{
- m_nNdDiff = nSttNode - rPam.GetPoint()->nNode.GetIndex() - (bFullPara ? 0 : 1);
+ m_nNdDiff = m_nSttNode - rPam.GetPoint()->nNode.GetIndex() - (bFullPara ? 0 : 1);
rPam.Move( fnMoveForward, GoInNode );
}
else
{
- m_nNdDiff = nSttNode;
+ m_nNdDiff = m_nSttNode;
if( m_nSectDiff && m_bBackSp )
m_nNdDiff += m_nSectDiff;
m_nNdDiff -= rPam.GetPoint()->nNode.GetIndex();
@@ -443,7 +443,7 @@ bool SwUndoDelete::SaveContent( const SwPosition* pStt, const SwPosition* pEnd,
// 1 - copy start in Start-String
if( pSttTextNd )
{
- bool bOneNode = nSttNode == nEndNode;
+ bool bOneNode = m_nSttNode == m_nEndNode;
SwRegHistory aRHst( *pSttTextNd, pHistory.get() );
// always save all text atttibutes because of possibly overlapping
// areas of on/off
@@ -460,7 +460,7 @@ bool SwUndoDelete::SaveContent( const SwPosition* pStt, const SwPosition* pEnd,
// delete now also the text (all attribute changes are added to
// UNDO history)
- m_aSttStr = pSttTextNd->GetText().copy(nSttContent, nLen);
+ m_aSttStr = pSttTextNd->GetText().copy(m_nSttContent, nLen);
pSttTextNd->EraseText( pStt->nContent, nLen );
if( pSttTextNd->GetpSwpHints() )
pSttTextNd->GetpSwpHints()->DeRegister();
@@ -509,7 +509,7 @@ bool SwUndoDelete::SaveContent( const SwPosition* pStt, const SwPosition* pEnd,
}
// if there are only two Nodes then we're done
- if( ( pSttTextNd || pEndTextNd ) && nSttNode + 1 == nEndNode )
+ if( ( pSttTextNd || pEndTextNd ) && m_nSttNode + 1 == m_nEndNode )
return false; // do not move any Node
return true; // move Nodes lying in between
@@ -522,7 +522,7 @@ bool SwUndoDelete::CanGrouping( SwDoc* pDoc, const SwPaM& rDelPam )
return false;
// only the deletion of single char's can be condensed
- if( nSttNode != nEndNode || ( !m_bGroup && nSttContent+1 != nEndContent ))
+ if( m_nSttNode != m_nEndNode || ( !m_bGroup && m_nSttContent+1 != m_nEndContent ))
return false;
const SwPosition *pStt = rDelPam.Start(),
@@ -532,17 +532,17 @@ bool SwUndoDelete::CanGrouping( SwDoc* pDoc, const SwPaM& rDelPam )
if( pStt->nNode != pEnd->nNode ||
pStt->nContent.GetIndex()+1 != pEnd->nContent.GetIndex() ||
- pEnd->nNode != nSttNode )
+ pEnd->nNode != m_nSttNode )
return false;
// Distinguish between BackSpace and Delete because the Undo array needs to
// be constructed differently!
- if( pEnd->nContent == nSttContent )
+ if( pEnd->nContent == m_nSttContent )
{
if( m_bGroup && !m_bBackSp ) return false;
m_bBackSp = true;
}
- else if( pStt->nContent == nSttContent )
+ else if( pStt->nContent == m_nSttContent )
{
if( m_bGroup && m_bBackSp ) return false;
m_bBackSp = false;
@@ -578,10 +578,10 @@ bool SwUndoDelete::CanGrouping( SwDoc* pDoc, const SwPaM& rDelPam )
// Both 'deletes' can be consolidated, so 'move' the related character
if( m_bBackSp )
- nSttContent--; // BackSpace: add char to array!
+ m_nSttContent--; // BackSpace: add char to array!
else
{
- nEndContent++; // Delete: attach char at the end
+ m_nEndContent++; // Delete: attach char at the end
nUChrPos++;
}
m_aSttStr = m_aSttStr->replaceAt( nUChrPos, 0, OUString(cDelChar) );
@@ -836,7 +836,7 @@ void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc& rDoc = rContext.GetDoc();
- sal_uLong nCalcStt = nSttNode - m_nNdDiff;
+ sal_uLong nCalcStt = m_nSttNode - m_nNdDiff;
if( m_nSectDiff && m_bBackSp )
nCalcStt += m_nSectDiff;
@@ -855,12 +855,12 @@ void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
rDoc.GetDfltTextFormatColl() );
--aIdx;
aPos.nNode = aIdx;
- aPos.nContent.Assign( pInsNd->GetContentNode(), nSttContent );
+ aPos.nContent.Assign( pInsNd->GetContentNode(), m_nSttContent );
}
else
{
if( pInsNd->IsContentNode() )
- aPos.nContent.Assign( static_cast<SwContentNode*>(pInsNd), nSttContent );
+ aPos.nContent.Assign( static_cast<SwContentNode*>(pInsNd), m_nSttContent );
if( !m_bTableDelLastNd )
pInsNd = nullptr; // do not delete Node!
}
@@ -908,7 +908,7 @@ void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
SwTextNode * pNd = aPos.nNode.GetNode().GetTextNode();
if( pNd )
{
- if (nSttContent < pNd->GetText().getLength())
+ if (m_nSttContent < pNd->GetText().getLength())
{
sal_uLong nOldIdx = aPos.nNode.GetIndex();
rDoc.getIDocumentContentOperations().SplitNode( aPos, false );
@@ -957,7 +957,7 @@ void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
sal_uLong nMoveIndex;
if( m_bJoinNext )
{
- nMoveIndex = nEndNode - m_nNdDiff;
+ nMoveIndex = m_nEndNode - m_nNdDiff;
aPos.nNode = nMoveIndex + m_nReplaceDummy;
}
else
@@ -975,7 +975,7 @@ void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
if( m_aSttStr )
{
- aPos.nNode = nSttNode - m_nNdDiff + ( m_bJoinNext ? 0 : m_nReplaceDummy );
+ aPos.nNode = m_nSttNode - m_nNdDiff + ( m_bJoinNext ? 0 : m_nReplaceDummy );
SwTextNode * pTextNd = aPos.nNode.GetNode().GetTextNode();
// If more than a single Node got deleted, also all "Node"
// attributes were saved
@@ -989,7 +989,7 @@ void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
// SectionNode mode and selection from top to bottom:
// -> in StartNode is still the rest of the Join => delete
- aPos.nContent.Assign( pTextNd, nSttContent );
+ aPos.nContent.Assign( pTextNd, m_nSttContent );
OUString const ins( pTextNd->InsertText(*m_aSttStr, aPos.nContent,
SwInsertFlags::NOHINTEXPAND) );
assert(ins.getLength() == m_aSttStr->getLength()); // must succeed
@@ -1026,7 +1026,7 @@ void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
sal_uInt16 nStt = m_bResetPgDesc ? sal_uInt16(RES_PAGEDESC) : sal_uInt16(RES_BREAK);
sal_uInt16 nEnd = m_bResetPgBrk ? sal_uInt16(RES_BREAK) : sal_uInt16(RES_PAGEDESC);
- SwNode* pNode = rDoc.GetNodes()[ nEndNode + 1 ];
+ SwNode* pNode = rDoc.GetNodes()[ m_nEndNode + 1 ];
if( pNode->IsContentNode() )
static_cast<SwContentNode*>(pNode)->ResetAttr( nStt, nEnd );
else if( pNode->IsTableNode() )
@@ -1039,7 +1039,7 @@ void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
if( m_pRedlSaveData )
SetSaveData(rDoc, *m_pRedlSaveData);
- sal_uLong delFullParaEndNode(nEndNode);
+ sal_uLong delFullParaEndNode(m_nEndNode);
if (m_bDelFullPara && m_pRedlSaveData)
{
SwTextNode * pFirstMergedDeletedTextNode(nullptr);
@@ -1081,7 +1081,7 @@ void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
{
// only now do we have redlines in the document again; fix up the split
// frames
- SwTextNode *const pStartNode(aIdx.GetNodes()[nSttNode]->GetTextNode());
+ SwTextNode *const pStartNode(aIdx.GetNodes()[m_nSttNode]->GetTextNode());
assert(pStartNode);
std::vector<SwTextFrame*> frames;
SwIterator<SwTextFrame, SwTextNode, sw::IteratorMode::UnwrapMulti> aIter(*pStartNode);
@@ -1115,13 +1115,13 @@ void SwUndoDelete::UndoImpl(::sw::UndoRedoContext & rContext)
// tdf#121031 if the start node is a text node, it already has a frame;
// if it's a table, it does not
// tdf#109376 exception: end on non-text-node -> start node was inserted
- SwNodeIndex const start(rDoc.GetNodes(), nSttNode +
- ((m_bDelFullPara || !rDoc.GetNodes()[nSttNode]->IsTextNode() || pInsNd)
+ SwNodeIndex const start(rDoc.GetNodes(), m_nSttNode +
+ ((m_bDelFullPara || !rDoc.GetNodes()[m_nSttNode]->IsTextNode() || pInsNd)
? 0 : 1));
// don't include end node in the range: it may have been merged already
// by the start node, or it may be merged by one of the moved nodes,
// but if it isn't merged, its current frame(s) should be good...
- SwNodeIndex const end(rDoc.GetNodes(), m_bDelFullPara ? delFullParaEndNode : nEndNode);
+ SwNodeIndex const end(rDoc.GetNodes(), m_bDelFullPara ? delFullParaEndNode : m_nEndNode);
::MakeFrames(&rDoc, start, end);
}
@@ -1235,7 +1235,7 @@ void SwUndoDelete::RedoImpl(::sw::UndoRedoContext & rContext)
else if (*rPam.GetMark() == *rPam.GetPoint())
{ // paragraph with only footnote or as-char fly, delete that
// => DelContentIndex has already deleted it! nothing to do here
- assert(nEndNode == nSttNode);
+ assert(m_nEndNode == m_nSttNode);
return;
}
@@ -1252,7 +1252,7 @@ void SwUndoDelete::RedoImpl(::sw::UndoRedoContext & rContext)
rPam.DeleteMark();
- rDoc.GetNodes().Delete( aSttIdx, nEndNode - nSttNode );
+ rDoc.GetNodes().Delete( aSttIdx, m_nEndNode - m_nSttNode );
}
else if( m_bDelFullPara )
{
diff --git a/sw/source/core/undo/undobj.cxx b/sw/source/core/undo/undobj.cxx
index fccab47e8f27..a07b873c5922 100644
--- a/sw/source/core/undo/undobj.cxx
+++ b/sw/source/core/undo/undobj.cxx
@@ -44,7 +44,7 @@
// This class saves the Pam as integers and can recompose those into a PaM
SwUndRng::SwUndRng()
- : nSttNode( 0 ), nEndNode( 0 ), nSttContent( 0 ), nEndContent( 0 )
+ : m_nSttNode( 0 ), m_nEndNode( 0 ), m_nSttContent( 0 ), m_nEndContent( 0 )
{
}
@@ -61,42 +61,42 @@ void SwUndRng::SetValues( const SwPaM& rPam )
const SwPosition *pEnd = rPam.GetPoint() == pStt
? rPam.GetMark()
: rPam.GetPoint();
- nEndNode = pEnd->nNode.GetIndex();
- nEndContent = pEnd->nContent.GetIndex();
+ m_nEndNode = pEnd->nNode.GetIndex();
+ m_nEndContent = pEnd->nContent.GetIndex();
}
else
{
// no selection !!
- nEndNode = 0;
- nEndContent = COMPLETE_STRING;
+ m_nEndNode = 0;
+ m_nEndContent = COMPLETE_STRING;
}
- nSttNode = pStt->nNode.GetIndex();
- nSttContent = pStt->nContent.GetIndex();
+ m_nSttNode = pStt->nNode.GetIndex();
+ m_nSttContent = pStt->nContent.GetIndex();
}
void SwUndRng::SetPaM( SwPaM & rPam, bool bCorrToContent ) const
{
rPam.DeleteMark();
- rPam.GetPoint()->nNode = nSttNode;
+ rPam.GetPoint()->nNode = m_nSttNode;
SwNode& rNd = rPam.GetNode();
if( rNd.IsContentNode() )
- rPam.GetPoint()->nContent.Assign( rNd.GetContentNode(), nSttContent );
+ rPam.GetPoint()->nContent.Assign( rNd.GetContentNode(), m_nSttContent );
else if( bCorrToContent )
rPam.Move( fnMoveForward, GoInContent );
else
rPam.GetPoint()->nContent.Assign( nullptr, 0 );
- if( !nEndNode && COMPLETE_STRING == nEndContent ) // no selection
+ if( !m_nEndNode && COMPLETE_STRING == m_nEndContent ) // no selection
return ;
rPam.SetMark();
- if( nSttNode == nEndNode && nSttContent == nEndContent )
+ if( m_nSttNode == m_nEndNode && m_nSttContent == m_nEndContent )
return; // nothing left to do
- rPam.GetPoint()->nNode = nEndNode;
+ rPam.GetPoint()->nNode = m_nEndNode;
if( rPam.GetNode().IsContentNode() )
- rPam.GetPoint()->nContent.Assign( rPam.GetNode().GetContentNode(), nEndContent );
+ rPam.GetPoint()->nContent.Assign( rPam.GetNode().GetContentNode(), m_nEndContent );
else if( bCorrToContent )
rPam.Move( fnMoveBackward, GoInContent );
else
@@ -1308,20 +1308,20 @@ SwRedlineSaveData::SwRedlineSaveData(
switch (eCmpPos)
{
case SwComparePosition::OverlapBefore: // Pos1 overlaps Pos2 at the beginning
- nEndNode = rEndPos.nNode.GetIndex();
- nEndContent = rEndPos.nContent.GetIndex();
+ m_nEndNode = rEndPos.nNode.GetIndex();
+ m_nEndContent = rEndPos.nContent.GetIndex();
break;
case SwComparePosition::OverlapBehind: // Pos1 overlaps Pos2 at the end
- nSttNode = rSttPos.nNode.GetIndex();
- nSttContent = rSttPos.nContent.GetIndex();
+ m_nSttNode = rSttPos.nNode.GetIndex();
+ m_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();
+ m_nSttNode = rSttPos.nNode.GetIndex();
+ m_nSttContent = rSttPos.nContent.GetIndex();
+ m_nEndNode = rEndPos.nNode.GetIndex();
+ m_nEndContent = rEndPos.nContent.GetIndex();
break;
case SwComparePosition::Outside: // Pos2 lays completely in Pos1
@@ -1482,10 +1482,10 @@ bool SwUndo::CanRedlineGroup( SwRedlineSaveDatas& rCurr,
{
const SwRedlineSaveData& rSet = rCurr[ n ];
const SwRedlineSaveData& rGet = rCheck[ n ];
- if( rSet.nSttNode != rGet.nSttNode ||
+ if( rSet.m_nSttNode != rGet.m_nSttNode ||
rSet.GetMvSttIdx() || rGet.GetMvSttIdx() ||
- ( bCurrIsEnd ? rSet.nSttContent != rGet.nEndContent
- : rSet.nEndContent != rGet.nSttContent ) ||
+ ( bCurrIsEnd ? rSet.m_nSttContent != rGet.m_nEndContent
+ : rSet.m_nEndContent != rGet.m_nSttContent ) ||
!rGet.CanCombine( rSet ) )
{
return false;
@@ -1497,9 +1497,9 @@ bool SwUndo::CanRedlineGroup( SwRedlineSaveDatas& rCurr,
SwRedlineSaveData& rSet = rCurr[ n ];
const SwRedlineSaveData& rGet = rCheck[ n ];
if( bCurrIsEnd )
- rSet.nSttContent = rGet.nSttContent;
+ rSet.m_nSttContent = rGet.m_nSttContent;
else
- rSet.nEndContent = rGet.nEndContent;
+ rSet.m_nEndContent = rGet.m_nEndContent;
}
return true;
}
diff --git a/sw/source/core/undo/unmove.cxx b/sw/source/core/undo/unmove.cxx
index a8f99653961a..0ff383652e62 100644
--- a/sw/source/core/undo/unmove.cxx
+++ b/sw/source/core/undo/unmove.cxx
@@ -45,32 +45,32 @@ SwUndoMove::SwUndoMove( const SwPaM& rRange, const SwPosition& rMvPos )
{
// get StartNode from footnotes before delete!
SwDoc* pDoc = rRange.GetDoc();
- SwTextNode* pTextNd = pDoc->GetNodes()[ nSttNode ]->GetTextNode();
- SwTextNode* pEndTextNd = pDoc->GetNodes()[ nEndNode ]->GetTextNode();
+ SwTextNode* pTextNd = pDoc->GetNodes()[ m_nSttNode ]->GetTextNode();
+ SwTextNode* pEndTextNd = pDoc->GetNodes()[ m_nEndNode ]->GetTextNode();
pHistory.reset( new SwHistory );
if( pTextNd )
{
- pHistory->Add( pTextNd->GetTextColl(), nSttNode, SwNodeType::Text );
+ pHistory->Add( pTextNd->GetTextColl(), m_nSttNode, SwNodeType::Text );
if ( pTextNd->GetpSwpHints() )
{
- pHistory->CopyAttr( pTextNd->GetpSwpHints(), nSttNode,
+ pHistory->CopyAttr( pTextNd->GetpSwpHints(), m_nSttNode,
0, pTextNd->GetText().getLength(), false );
}
if( pTextNd->HasSwAttrSet() )
- pHistory->CopyFormatAttr( *pTextNd->GetpSwAttrSet(), nSttNode );
+ pHistory->CopyFormatAttr( *pTextNd->GetpSwAttrSet(), m_nSttNode );
}
if( pEndTextNd && pEndTextNd != pTextNd )
{
- pHistory->Add( pEndTextNd->GetTextColl(), nEndNode, SwNodeType::Text );
+ pHistory->Add( pEndTextNd->GetTextColl(), m_nEndNode, SwNodeType::Text );
if ( pEndTextNd->GetpSwpHints() )
{
- pHistory->CopyAttr( pEndTextNd->GetpSwpHints(), nEndNode,
+ pHistory->CopyAttr( pEndTextNd->GetpSwpHints(), m_nEndNode,
0, pEndTextNd->GetText().getLength(), false );
}
if( pEndTextNd->HasSwAttrSet() )
- pHistory->CopyFormatAttr( *pEndTextNd->GetpSwAttrSet(), nEndNode );
+ pHistory->CopyFormatAttr( *pEndTextNd->GetpSwAttrSet(), m_nEndNode );
}
pTextNd = rMvPos.nNode.GetNode().GetTextNode();
@@ -108,10 +108,10 @@ SwUndoMove::SwUndoMove( SwDoc* pDoc, const SwNodeRange& rRg,
m_bMoveRange = true;
m_bJoinNext = m_bJoinPrev = false;
- nSttContent = nEndContent = m_nMoveDestContent = COMPLETE_STRING;
+ m_nSttContent = m_nEndContent = m_nMoveDestContent = COMPLETE_STRING;
- nSttNode = rRg.aStart.GetIndex();
- nEndNode = rRg.aEnd.GetIndex();
+ m_nSttNode = rRg.aStart.GetIndex();
+ m_nEndNode = rRg.aEnd.GetIndex();
// DelFootnote( rRange );
// FIXME: duplication of the method body of DelFootnote below
@@ -287,7 +287,7 @@ void SwUndoMove::RedoImpl(::sw::UndoRedoContext & rContext)
if( m_bMoveRange )
{
// only a move with SwRange
- SwNodeRange aRg( rNds, nSttNode, rNds, nEndNode );
+ SwNodeRange aRg( rNds, m_nSttNode, rNds, m_nEndNode );
rDoc.getIDocumentContentOperations().MoveNodeRange( aRg, aIdx, m_bMoveRedlines
? SwMoveFlags::REDLINES
: SwMoveFlags::DEFAULT );
@@ -309,7 +309,7 @@ void SwUndoMove::RedoImpl(::sw::UndoRedoContext & rContext)
rDoc.getIDocumentContentOperations().MoveRange( aPam, aMvPos,
SwMoveFlags::DEFAULT );
- if( nSttNode != nEndNode && bJoinText )
+ if( m_nSttNode != m_nEndNode && bJoinText )
{
++aIdx;
SwTextNode * pTextNd = aIdx.GetNode().GetTextNode();
diff --git a/sw/source/core/undo/unnum.cxx b/sw/source/core/undo/unnum.cxx
index 958f55139f16..a9595f643327 100644
--- a/sw/source/core/undo/unnum.cxx
+++ b/sw/source/core/undo/unnum.cxx
@@ -53,10 +53,10 @@ SwUndoInsNum::SwUndoInsNum( const SwPosition& rPos, const SwNumRule& rRule,
sReplaceRule( rReplaceRule ), nLRSavePos( 0 )
{
// No selection!
- nEndNode = 0;
- nEndContent = COMPLETE_STRING;
- nSttNode = rPos.nNode.GetIndex();
- nSttContent = rPos.nContent.GetIndex();
+ m_nEndNode = 0;
+ m_nEndContent = COMPLETE_STRING;
+ m_nSttNode = rPos.nNode.GetIndex();
+ m_nSttContent = rPos.nContent.GetIndex();
}
SwUndoInsNum::~SwUndoInsNum()
@@ -92,7 +92,7 @@ void SwUndoInsNum::UndoImpl(::sw::UndoRedoContext & rContext)
pHistory->SetTmpEnd( pHistory->Count() );
}
- if (nSttNode)
+ if (m_nSttNode)
{
AddUndoRedoPaM(rContext);
}
@@ -128,7 +128,7 @@ void SwUndoInsNum::SetLRSpaceEndPos()
void SwUndoInsNum::RepeatImpl(::sw::RepeatContext & rContext)
{
SwDoc & rDoc( rContext.GetDoc() );
- if ( nSttNode )
+ if ( m_nSttNode )
{
if( sReplaceRule.isEmpty() )
{
@@ -158,7 +158,7 @@ void SwUndoInsNum::SaveOldNumRule( const SwNumRule& rOld )
SwUndoDelNum::SwUndoDelNum( const SwPaM& rPam )
: SwUndo( SwUndoId::DELNUM, rPam.GetDoc() ), SwUndRng( rPam )
{
- aNodes.reserve( std::min<sal_uLong>(nEndNode - nSttNode, 255) );
+ aNodes.reserve( std::min<sal_uLong>(m_nEndNode - m_nSttNode, 255) );
pHistory.reset( new SwHistory );
}
@@ -216,22 +216,22 @@ SwUndoMoveNum::SwUndoMoveNum( const SwPaM& rPam, long nOff, bool bIsOutlMv )
void SwUndoMoveNum::UndoImpl(::sw::UndoRedoContext & rContext)
{
- sal_uLong nTmpStt = nSttNode, nTmpEnd = nEndNode;
+ sal_uLong nTmpStt = m_nSttNode, nTmpEnd = m_nEndNode;
- if (nEndNode || nEndContent != COMPLETE_STRING) // section?
+ if (m_nEndNode || m_nEndContent != COMPLETE_STRING) // section?
{
- if( nNewStt < nSttNode ) // moved forwards
- nEndNode = nEndNode - ( nSttNode - nNewStt );
+ if( nNewStt < m_nSttNode ) // moved forwards
+ m_nEndNode = m_nEndNode - ( m_nSttNode - nNewStt );
else
- nEndNode = nEndNode + ( nNewStt - nSttNode );
+ m_nEndNode = m_nEndNode + ( nNewStt - m_nSttNode );
}
- nSttNode = nNewStt;
+ m_nSttNode = nNewStt;
SwPaM & rPam( AddUndoRedoPaM(rContext) );
rContext.GetDoc().MoveParagraph( rPam, -nOffset,
SwUndoId::OUTLINE_UD == GetId() );
- nSttNode = nTmpStt;
- nEndNode = nTmpEnd;
+ m_nSttNode = nTmpStt;
+ m_nEndNode = nTmpEnd;
}
void SwUndoMoveNum::RedoImpl(::sw::UndoRedoContext & rContext)
diff --git a/sw/source/core/undo/unredln.cxx b/sw/source/core/undo/unredln.cxx
index 59be96d9d2dd..725922e26157 100644
--- a/sw/source/core/undo/unredln.cxx
+++ b/sw/source/core/undo/unredln.cxx
@@ -69,8 +69,8 @@ SwUndoRedline::SwUndoRedline( SwUndoId nUsrId, const SwPaM& rRange )
if( mbHiddenRedlines ) // then the NodeIndices of SwUndRng need to be corrected
{
nEndExtra -= rDoc.GetNodes().GetEndOfExtras().GetIndex();
- nSttNode -= nEndExtra;
- nEndNode -= nEndExtra;
+ m_nSttNode -= nEndExtra;
+ m_nEndNode -= nEndExtra;
}
}
}
@@ -102,8 +102,8 @@ void SwUndoRedline::UndoImpl(::sw::UndoRedoContext & rContext)
mpRedlSaveData->clear();
nEndExtra = rDoc.GetNodes().GetEndOfExtras().GetIndex() - nEndExtra;
- nSttNode += nEndExtra;
- nEndNode += nEndExtra;
+ m_nSttNode += nEndExtra;
+ m_nEndNode += nEndExtra;
}
SetPaM(rPam, true);
}
@@ -133,8 +133,8 @@ void SwUndoRedline::RedoImpl(::sw::UndoRedoContext & rContext)
FillSaveData(rPam, *mpRedlSaveData, false, SwUndoId::REJECT_REDLINE != mnUserId );
nEndExtra -= rDoc.GetNodes().GetEndOfExtras().GetIndex();
- nSttNode -= nEndExtra;
- nEndNode -= nEndExtra;
+ m_nSttNode -= nEndExtra;
+ m_nEndNode -= nEndExtra;
}
RedoRedlineImpl(rDoc, rPam);
@@ -160,16 +160,16 @@ SwUndoRedlineDelete::SwUndoRedlineDelete( const SwPaM& rRange, SwUndoId nUsrId )
const SwTextNode* pTNd;
SetRedlineText(rRange.GetText());
if( SwUndoId::DELETE == mnUserId &&
- nSttNode == nEndNode && nSttContent + 1 == nEndContent &&
+ m_nSttNode == m_nEndNode && m_nSttContent + 1 == m_nEndContent &&
nullptr != (pTNd = rRange.GetNode().GetTextNode()) )
{
- sal_Unicode const cCh = pTNd->GetText()[nSttContent];
+ sal_Unicode const cCh = pTNd->GetText()[m_nSttContent];
if( CH_TXTATR_BREAKWORD != cCh && CH_TXTATR_INWORD != cCh )
{
bCanGroup = true;
bIsDelim = !GetAppCharClass().isLetterNumeric( pTNd->GetText(),
- nSttContent );
- bIsBackspace = nSttContent == rRange.GetPoint()->nContent.GetIndex();
+ m_nSttContent );
+ bIsBackspace = m_nSttContent == rRange.GetPoint()->nContent.GetIndex();
}
}
@@ -215,14 +215,14 @@ bool SwUndoRedlineDelete::CanGrouping( const SwUndoRedlineDelete& rNext )
bCanGroup == rNext.bCanGroup &&
bIsDelim == rNext.bIsDelim &&
bIsBackspace == rNext.bIsBackspace &&
- nSttNode == nEndNode &&
- rNext.nSttNode == nSttNode &&
- rNext.nEndNode == nEndNode )
+ m_nSttNode == m_nEndNode &&
+ rNext.m_nSttNode == m_nSttNode &&
+ rNext.m_nEndNode == m_nEndNode )
{
int bIsEnd = 0;
- if( rNext.nSttContent == nEndContent )
+ if( rNext.m_nSttContent == m_nEndContent )
bIsEnd = 1;
- else if( rNext.nEndContent == nSttContent )
+ else if( rNext.m_nEndContent == m_nSttContent )
bIsEnd = -1;
if( bIsEnd &&
@@ -233,9 +233,9 @@ bool SwUndoRedlineDelete::CanGrouping( const SwUndoRedlineDelete& rNext )
)))
{
if( 1 == bIsEnd )
- nEndContent = rNext.nEndContent;
+ m_nEndContent = rNext.m_nEndContent;
else
- nSttContent = rNext.nSttContent;
+ m_nSttContent = rNext.m_nSttContent;
bRet = true;
}
}
@@ -246,7 +246,7 @@ SwUndoRedlineSort::SwUndoRedlineSort( const SwPaM& rRange,
const SwSortOptions& rOpt )
: SwUndoRedline( SwUndoId::SORT_TXT, rRange ),
pOpt( new SwSortOptions( rOpt ) ),
- nSaveEndNode( nEndNode ), nSaveEndContent( nEndContent )
+ nSaveEndNode( m_nEndNode ), nSaveEndContent( m_nEndContent )
{
}
@@ -271,7 +271,7 @@ void SwUndoRedlineSort::UndoRedlineImpl(SwDoc & rDoc, SwPaM & rPam)
// consistent again. The 'delete' one is hidden, thus search for the
// 'insert' Redline object. The former is located directly after the latter.
SwRedlineTable::size_type nFnd = rDoc.getIDocumentRedlineAccess().GetRedlinePos(
- *rDoc.GetNodes()[ nSttNode + 1 ],
+ *rDoc.GetNodes()[ m_nSttNode + 1 ],
RedlineType::Insert );
OSL_ENSURE( SwRedlineTable::npos != nFnd && nFnd+1 < rDoc.getIDocumentRedlineAccess().GetRedlineTable().size(),
"could not find an Insert object" );
@@ -443,7 +443,7 @@ void SwUndoCompDoc::UndoImpl(::sw::UndoRedoContext & rContext)
// complete nodes into the current doc. And then the selection
// must be from end to start, so the delete join into the right
// direction.
- if( !nSttContent && !nEndContent )
+ if( !m_nSttContent && !m_nEndContent )
rPam.Exchange();
bool bJoinText, bJoinPrev;
diff --git a/sw/source/core/undo/unsect.cxx b/sw/source/core/undo/unsect.cxx
index f6bd82bb959f..127ba5a410eb 100644
--- a/sw/source/core/undo/unsect.cxx
+++ b/sw/source/core/undo/unsect.cxx
@@ -137,8 +137,8 @@ void SwUndoInsSection::UndoImpl(::sw::UndoRedoContext & rContext)
// no selection?
SwNodeIndex aIdx( *pNd );
- if( ( !nEndNode && COMPLETE_STRING == nEndContent ) ||
- ( nSttNode == nEndNode && nSttContent == nEndContent ))
+ if( ( !m_nEndNode && COMPLETE_STRING == m_nEndContent ) ||
+ ( m_nSttNode == m_nEndNode && m_nSttContent == m_nEndContent ))
// delete simply all nodes
rDoc.GetNodes().Delete( aIdx, pNd->EndOfSectionIndex() -
aIdx.GetIndex() );
@@ -149,12 +149,12 @@ void SwUndoInsSection::UndoImpl(::sw::UndoRedoContext & rContext)
// do we need to consolidate?
if (m_bSplitAtStart)
{
- Join( rDoc, nSttNode );
+ Join( rDoc, m_nSttNode );
}
if (m_bSplitAtEnd)
{
- Join( rDoc, nEndNode );
+ Join( rDoc, m_nEndNode );
}
if (m_pHistory)
diff --git a/sw/source/core/undo/unsort.cxx b/sw/source/core/undo/unsort.cxx
index 3765c71bd384..f0ffbaeb454e 100644
--- a/sw/source/core/undo/unsort.cxx
+++ b/sw/source/core/undo/unsort.cxx
@@ -54,8 +54,8 @@ SwUndoSort::SwUndoSort( sal_uLong nStt, sal_uLong nEnd, const SwTableNode& rTabl
const SwSortOptions& rOpt, bool bSaveTable )
: SwUndo(SwUndoId::SORT_TBL, rTableNd.GetDoc())
{
- nSttNode = nStt;
- nEndNode = nEnd;
+ m_nSttNode = nStt;
+ m_nEndNode = nEnd;
nTableNd = rTableNd.GetIndex();
pSortOpt.reset( new SwSortOptions(rOpt) );
@@ -75,7 +75,7 @@ void SwUndoSort::UndoImpl(::sw::UndoRedoContext & rContext)
if(pSortOpt->bTable)
{
// Undo for Table
- RemoveIdxFromSection( rDoc, nSttNode, &nEndNode );
+ RemoveIdxFromSection( rDoc, m_nSttNode, &m_nEndNode );
if( pUndoTableAttr )
{
@@ -128,7 +128,7 @@ void SwUndoSort::UndoImpl(::sw::UndoRedoContext & rContext)
{
for (std::unique_ptr<SwSortUndoElement> & j : m_SortList)
{
- if (j->SORT_TXT_TBL.TXT.nSource == nSttNode + i)
+ if (j->SORT_TXT_TBL.TXT.nSource == m_nSttNode + i)
{
aIdxList.push_back( SwNodeIndex( rDoc.GetNodes(),
j->SORT_TXT_TBL.TXT.nTarget ) );
@@ -139,7 +139,7 @@ void SwUndoSort::UndoImpl(::sw::UndoRedoContext & rContext)
for (size_t i = 0; i < m_SortList.size(); ++i)
{
- SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode + i );
+ SwNodeIndex aIdx( rDoc.GetNodes(), m_nSttNode + i );
SwNodeRange aRg( aIdxList[i], 0, aIdxList[i], 1 );
rDoc.getIDocumentContentOperations().MoveNodeRange(aRg, aIdx,
SwMoveFlags::DEFAULT);
@@ -157,7 +157,7 @@ void SwUndoSort::RedoImpl(::sw::UndoRedoContext & rContext)
if(pSortOpt->bTable)
{
// Redo for Table
- RemoveIdxFromSection( rDoc, nSttNode, &nEndNode );
+ RemoveIdxFromSection( rDoc, m_nSttNode, &m_nEndNode );
SwTableNode* pTableNd = rDoc.GetNodes()[ nTableNd ]->GetTableNode();
@@ -212,7 +212,7 @@ void SwUndoSort::RedoImpl(::sw::UndoRedoContext & rContext)
for (size_t i = 0; i < m_SortList.size(); ++i)
{
- SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode + i);
+ SwNodeIndex aIdx( rDoc.GetNodes(), m_nSttNode + i);
SwNodeRange aRg( aIdxList[i], 0, aIdxList[i], 1 );
rDoc.getIDocumentContentOperations().MoveNodeRange(aRg, aIdx,
SwMoveFlags::DEFAULT);
diff --git a/sw/source/core/undo/untbl.cxx b/sw/source/core/undo/untbl.cxx
index 7e0775f92fff..ef3f14d189ff 100644
--- a/sw/source/core/undo/untbl.cxx
+++ b/sw/source/core/undo/untbl.cxx
@@ -713,8 +713,8 @@ void SwUndoTextToTable::UndoImpl(::sw::UndoRedoContext & rContext)
{
SwDoc & rDoc = rContext.GetDoc();
- sal_uLong nTableNd = nSttNode;
- if( nSttContent )
+ sal_uLong nTableNd = m_nSttNode;
+ if( m_nSttContent )
++nTableNd; // Node was splitted previously
SwNodeIndex aIdx( rDoc.GetNodes(), nTableNd );
SwTableNode *const pTNd = aIdx.GetNode().GetTableNode();
@@ -751,7 +751,7 @@ void SwUndoTextToTable::UndoImpl(::sw::UndoRedoContext & rContext)
// join again at start?
SwPaM aPam(rDoc.GetNodes().GetEndOfContent());
SwPosition *const pPos = aPam.GetPoint();
- if( nSttContent )
+ if( m_nSttContent )
{
pPos->nNode = nTableNd;
pPos->nContent.Assign(pPos->nNode.GetNode().GetContentNode(), 0);
@@ -770,7 +770,7 @@ void SwUndoTextToTable::UndoImpl(::sw::UndoRedoContext & rContext)
if( bSplitEnd )
{
SwNodeIndex& rIdx = pPos->nNode;
- rIdx = nEndNode;
+ rIdx = m_nEndNode;
SwTextNode* pTextNd = rIdx.GetNode().GetTextNode();
if( pTextNd && pTextNd->CanJoinNext() )
{
@@ -779,7 +779,7 @@ void SwUndoTextToTable::UndoImpl(::sw::UndoRedoContext & rContext)
// than move, relatively, the Cursor/etc. again
pPos->nContent.Assign(pTextNd, pTextNd->GetText().getLength());
- RemoveIdxRel( nEndNode + 1, *pPos );
+ RemoveIdxRel( m_nEndNode + 1, *pPos );
pTextNd->JoinNext();
}
@@ -1984,8 +1984,8 @@ void SwUndoTableMerge::UndoImpl(::sw::UndoRedoContext & rContext)
}
SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
pPam->DeleteMark();
- pPam->GetPoint()->nNode = nSttNode;
- pPam->GetPoint()->nContent.Assign( pPam->GetContentNode(), nSttContent );
+ pPam->GetPoint()->nNode = m_nSttNode;
+ pPam->GetPoint()->nContent.Assign( pPam->GetContentNode(), m_nSttContent );
pPam->SetMark();
pPam->DeleteMark();
diff --git a/sw/source/core/undo/untblk.cxx b/sw/source/core/undo/untblk.cxx
index 8b206e064873..595810b6bef6 100644
--- a/sw/source/core/undo/untblk.cxx
+++ b/sw/source/core/undo/untblk.cxx
@@ -72,16 +72,16 @@ SwUndoInserts::SwUndoInserts( SwUndoId nUndoId, const SwPaM& rPam )
if( pTextNd )
{
pTextFormatColl = pTextNd->GetTextColl();
- pHistory->CopyAttr( pTextNd->GetpSwpHints(), nSttNode,
+ pHistory->CopyAttr( pTextNd->GetpSwpHints(), m_nSttNode,
0, pTextNd->GetText().getLength(), false );
if( pTextNd->HasSwAttrSet() )
- pHistory->CopyFormatAttr( *pTextNd->GetpSwAttrSet(), nSttNode );
+ pHistory->CopyFormatAttr( *pTextNd->GetpSwAttrSet(), m_nSttNode );
// We may have some flys anchored to paragraph where we inserting.
// These flys will be saved in pFrameFormats array (only flys which exist BEFORE insertion!)
// Then in SwUndoInserts::SetInsertRange the flys saved in pFrameFormats will NOT create Undos.
// m_FlyUndos will only be filled with newly inserted flys.
- pFrameFormats = sw::GetFlysAnchoredAt(*pDoc, nSttNode);
+ pFrameFormats = sw::GetFlysAnchoredAt(*pDoc, m_nSttNode);
}
// consider Redline
if( pDoc->getIDocumentRedlineAccess().IsRedlineOn() )
@@ -107,8 +107,8 @@ void SwUndoInserts::SetInsertRange( const SwPaM& rPam, bool bScanFlys,
bool bSttIsTextNd )
{
const SwPosition* pTmpPos = rPam.End();
- nEndNode = pTmpPos->nNode.GetIndex();
- nEndContent = pTmpPos->nContent.GetIndex();
+ m_nEndNode = pTmpPos->nNode.GetIndex();
+ m_nEndContent = pTmpPos->nContent.GetIndex();
if( rPam.HasMark() )
{
if( pTmpPos == rPam.GetPoint() )
@@ -116,12 +116,12 @@ void SwUndoInserts::SetInsertRange( const SwPaM& rPam, bool bScanFlys,
else
pTmpPos = rPam.GetPoint();
- nSttNode = pTmpPos->nNode.GetIndex();
- nSttContent = pTmpPos->nContent.GetIndex();
+ m_nSttNode = pTmpPos->nNode.GetIndex();
+ m_nSttContent = pTmpPos->nContent.GetIndex();
if( !bSttIsTextNd ) // if a table selection is added...
{
- ++nSttNode; // ... then the CopyPam is not fully correct
+ ++m_nSttNode; // ... then the CopyPam is not fully correct
bSttWasTextNd = false;
}
}
@@ -137,7 +137,7 @@ void SwUndoInserts::SetInsertRange( const SwPaM& rPam, bool bScanFlys,
{
SwFrameFormat* pFormat = (*pDoc->GetSpzFrameFormats())[n];
SwFormatAnchor const*const pAnchor = &pFormat->GetAnchor();
- if (IsCreateUndoForNewFly(*pAnchor, nSttNode, nEndNode))
+ if (IsCreateUndoForNewFly(*pAnchor, m_nSttNode, m_nEndNode))
{
std::vector<SwFrameFormat*>::iterator it;
if( !pFrameFormats ||
@@ -224,17 +224,17 @@ void SwUndoInserts::UndoImpl(::sw::UndoRedoContext & rContext)
rDoc.getIDocumentRedlineAccess().DeleteRedline(rPam, true, RedlineType::Any);
// if Point and Mark are different text nodes so a JoinNext has to be done
- bool bJoinNext = nSttNode != nEndNode &&
+ bool bJoinNext = m_nSttNode != m_nEndNode &&
rPam.GetMark()->nNode.GetNode().GetTextNode() &&
rPam.GetPoint()->nNode.GetNode().GetTextNode();
// Is there any content? (loading from template does not have content)
- if( nSttNode != nEndNode || nSttContent != nEndContent )
+ if( m_nSttNode != m_nEndNode || m_nSttContent != m_nEndContent )
{
- if( nSttNode != nEndNode )
+ if( m_nSttNode != m_nEndNode )
{
- SwTextNode* pTextNd = rDoc.GetNodes()[ nEndNode ]->GetTextNode();
- if (pTextNd && pTextNd->GetText().getLength() == nEndContent)
+ SwTextNode* pTextNd = rDoc.GetNodes()[ m_nEndNode ]->GetTextNode();
+ if (pTextNd && pTextNd->GetText().getLength() == m_nEndContent)
pLastNdColl = pTextNd->GetTextColl();
}
@@ -260,7 +260,7 @@ void SwUndoInserts::UndoImpl(::sw::UndoRedoContext & rContext)
nNdDiff += nTmp - rPam.GetPoint()->nNode.GetIndex();
}
- if (nSttNode != nEndNode || nSttContent != nEndContent)
+ if (m_nSttNode != m_nEndNode || m_nSttContent != m_nEndContent)
{
// are there Footnotes or ContentFlyFrames in text?
nSetPos = pHistory->Count();
@@ -329,9 +329,9 @@ void SwUndoInserts::RedoImpl(::sw::UndoRedoContext & rContext)
SwPaM& rPam(rContext.GetCursorSupplier().CreateNewShellCursor());
SwDoc* pDoc = rPam.GetDoc();
rPam.DeleteMark();
- rPam.GetPoint()->nNode = nSttNode - nNdDiff;
+ rPam.GetPoint()->nNode = m_nSttNode - nNdDiff;
SwContentNode* pCNd = rPam.GetContentNode();
- rPam.GetPoint()->nContent.Assign( pCNd, nSttContent );
+ rPam.GetPoint()->nContent.Assign( pCNd, m_nSttContent );
SwTextFormatColl* pSavTextFormatColl = pTextFormatColl;
if( pTextFormatColl && pCNd && pCNd->IsTextNode() )
@@ -340,7 +340,7 @@ void SwUndoInserts::RedoImpl(::sw::UndoRedoContext & rContext)
pHistory->SetTmpEnd( nSetPos );
// retrieve start position for rollback
- if( ( nSttNode != nEndNode || nSttContent != nEndContent ) && m_pUndoNodeIndex)
+ if( ( m_nSttNode != m_nEndNode || m_nSttContent != m_nEndContent ) && m_pUndoNodeIndex)
{
auto const pFlysAtInsPos(sw::GetFlysAnchoredAt(*pDoc,
rPam.GetPoint()->nNode.GetIndex()));
More information about the Libreoffice-commits
mailing list