LibreOffice Module sw (master)  1
nodes.cxx
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of the LibreOffice project.
4  *
5  * This Source Code Form is subject to the terms of the Mozilla Public
6  * License, v. 2.0. If a copy of the MPL was not distributed with this
7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8  *
9  * This file incorporates work covered by the following license notice:
10  *
11  * Licensed to the Apache Software Foundation (ASF) under one or more
12  * contributor license agreements. See the NOTICE file distributed
13  * with this work for additional information regarding copyright
14  * ownership. The ASF licenses this file to you under the Apache
15  * License, Version 2.0 (the "License"); you may not use this file
16  * except in compliance with the License. You may obtain a copy of
17  * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18  */
19 
20 #include <stdlib.h>
21 
22 #include <libxml/xmlwriter.h>
23 #include <osl/diagnose.h>
24 
25 #include <node.hxx>
26 #include <doc.hxx>
27 #include <IDocumentUndoRedo.hxx>
28 #include <IDocumentFieldsAccess.hxx>
29 #include <IDocumentLayoutAccess.hxx>
30 #include <pam.hxx>
31 #include <txtfld.hxx>
32 #include <fmtfld.hxx>
33 #include <numrule.hxx>
34 #include <ndtxt.hxx>
35 #include <ndnotxt.hxx>
36 #include <swtable.hxx>
37 #include <section.hxx>
38 #include <ddefld.hxx>
39 #include <swddetbl.hxx>
40 #include <txtatr.hxx>
41 #include <tox.hxx>
42 #include <fmtrfmrk.hxx>
43 #include <fmtftn.hxx>
44 
45 #include <docsh.hxx>
46 
47 typedef std::vector<SwStartNode*> SwStartNodePointers;
48 
49 // function to determine the highest level in the given range
50 static sal_uInt16 HighestLevel( SwNodes & rNodes, const SwNodeRange & rRange );
51 
58 SwNodes::SwNodes( SwDoc& rDocument )
59  : m_vIndices(nullptr), m_rMyDoc( rDocument )
60 {
61  m_bInNodesDel = m_bInDelUpdOutline = false;
62 
63  sal_uLong nPos = 0;
64  SwStartNode* pSttNd = new SwStartNode( *this, nPos++ );
65  m_pEndOfPostIts = new SwEndNode( *this, nPos++, *pSttNd );
66 
67  SwStartNode* pTmp = new SwStartNode( *this, nPos++ );
68  m_pEndOfInserts = new SwEndNode( *this, nPos++, *pTmp );
69 
70  pTmp = new SwStartNode( *this, nPos++ );
71  pTmp->m_pStartOfSection = pSttNd;
72  m_pEndOfAutotext = new SwEndNode( *this, nPos++, *pTmp );
73 
74  pTmp = new SwStartNode( *this, nPos++ );
75  pTmp->m_pStartOfSection = pSttNd;
76  m_pEndOfRedlines = new SwEndNode( *this, nPos++, *pTmp );
77 
78  pTmp = new SwStartNode( *this, nPos++ );
79  pTmp->m_pStartOfSection = pSttNd;
80  m_pEndOfContent.reset(new SwEndNode( *this, nPos++, *pTmp ));
81 
82  m_pOutlineNodes.reset(new SwOutlineNodes);
83 }
84 
91 SwNodes::~SwNodes()
92 {
93  m_pOutlineNodes.reset();
94 
95  {
96  SwNodeIndex aNdIdx( *this );
97  while( true )
98  {
99  SwNode *pNode = &aNdIdx.GetNode();
100  if( pNode == m_pEndOfContent.get() )
101  break;
102 
103  ++aNdIdx;
104  delete pNode;
105  }
106  }
107 
108  // here, all SwNodeIndices must be unregistered
109  m_pEndOfContent.reset();
110 }
111 
112 void SwNodes::ChgNode( SwNodeIndex const & rDelPos, sal_uLong nSz,
113  SwNodeIndex& rInsPos, bool bNewFrames )
114 {
115  // no need for frames in the UndoArea
116  SwNodes& rNds = rInsPos.GetNodes();
117  const SwNode* pPrevInsNd = rNds[ rInsPos.GetIndex() -1 ];
118 
119  // declare all fields as invalid, updating will happen
120  // in the idle-handler of the doc
121  if( GetDoc().getIDocumentFieldsAccess().SetFieldsDirty( true, &rDelPos.GetNode(), nSz ) &&
122  &rNds.GetDoc() != &GetDoc() )
123  rNds.GetDoc().getIDocumentFieldsAccess().SetFieldsDirty( true, nullptr, 0 );
124 
125  // NEVER include nodes from the RedLineArea
126  sal_uLong nNd = rInsPos.GetIndex();
127  bool bInsOutlineIdx = (
128  rNds.GetEndOfRedlines().StartOfSectionNode()->GetIndex() >= nNd ||
129  nNd >= rNds.GetEndOfRedlines().GetIndex() );
130 
131  if( &rNds == this ) // if in the same node array -> move
132  {
133  // Move order: from front to back, so that new entries are added at
134  // first position, thus, deletion position stays the same
135  const sal_uLong nDiff = rDelPos.GetIndex() < rInsPos.GetIndex() ? 0 : 1;
136 
137  for( sal_uLong n = rDelPos.GetIndex(); nSz; n += nDiff, --nSz )
138  {
139  SwNodeIndex aDelIdx( *this, n );
140  SwNode& rNd = aDelIdx.GetNode();
141 
142  // #i57920# - correction of refactoring done by cws swnumtree:
143  // - <SwTextNode::SetLevel( NO_NUMBERING ) is deprecated and
144  // set <IsCounted> state of the text node to <false>, which
145  // isn't correct here.
146  if ( rNd.IsTextNode() )
147  {
148  SwTextNode* pTextNode = rNd.GetTextNode();
149 
150  pTextNode->RemoveFromList();
151 
152  if (pTextNode->IsOutline())
153  {
154  const SwNodePtr pSrch = &rNd;
155  m_pOutlineNodes->erase( pSrch );
156  }
157  }
158 
159  BigPtrArray::Move( aDelIdx.GetIndex(), rInsPos.GetIndex() );
160 
161  if( rNd.IsTextNode() )
162  {
163  SwTextNode& rTextNd = static_cast<SwTextNode&>(rNd);
164 
165  rTextNd.AddToList();
166 
167  if (bInsOutlineIdx && rTextNd.IsOutline())
168  {
169  const SwNodePtr pSrch = &rNd;
170  m_pOutlineNodes->insert( pSrch );
171  }
172  rTextNd.InvalidateNumRule();
173 
174 //FEATURE::CONDCOLL
175  if( RES_CONDTXTFMTCOLL == rTextNd.GetTextColl()->Which() )
176  rTextNd.ChkCondColl();
177 //FEATURE::CONDCOLL
178  }
179  else if( rNd.IsContentNode() )
180  static_cast<SwContentNode&>(rNd).InvalidateNumRule();
181  }
182  }
183  else
184  {
185  bool bSavePersData(GetDoc().GetIDocumentUndoRedo().IsUndoNodes(rNds));
186  bool bRestPersData(GetDoc().GetIDocumentUndoRedo().IsUndoNodes(*this));
187  SwDoc* pDestDoc = &rNds.GetDoc() != &GetDoc() ? &rNds.GetDoc() : nullptr;
188  OSL_ENSURE(!pDestDoc, "SwNodes::ChgNode(): "
189  "the code to handle text fields here looks broken\n"
190  "if the target is in a different document.");
191  if( !bRestPersData && !bSavePersData && pDestDoc )
192  bSavePersData = bRestPersData = true;
193 
194  OUString sNumRule;
195  for( sal_uLong n = 0; n < nSz; n++ )
196  {
197  SwNode* pNd = &rDelPos.GetNode();
198 
199  // NoTextNode keep their persistent data
200  if( pNd->IsNoTextNode() )
201  {
202  if( bSavePersData )
203  static_cast<SwNoTextNode*>(pNd)->SavePersistentData();
204  }
205  else if( pNd->IsTextNode() )
206  {
207  SwTextNode* pTextNd = static_cast<SwTextNode*>(pNd);
208 
209  // remove outline index from old nodes array
210  if (pTextNd->IsOutline())
211  {
212  m_pOutlineNodes->erase( pNd );
213  }
214 
215  // copy rules if needed
216  if( pDestDoc )
217  {
218  const SwNumRule* pNumRule = pTextNd->GetNumRule();
219  if( pNumRule && sNumRule != pNumRule->GetName() )
220  {
221  sNumRule = pNumRule->GetName();
222  SwNumRule* pDestRule = pDestDoc->FindNumRulePtr( sNumRule );
223  if( pDestRule )
224  pDestRule->SetInvalidRule( true );
225  else
226  pDestDoc->MakeNumRule( sNumRule, pNumRule );
227  }
228  }
229  else
230  // if movement into the UndoNodes-array, update numbering
231  pTextNd->InvalidateNumRule();
232 
233  pTextNd->RemoveFromList();
234  }
235 
236  RemoveNode( rDelPos.GetIndex(), 1, false ); // move indices
237  SwContentNode * pCNd = pNd->GetContentNode();
238  rNds.InsertNode( pNd, rInsPos );
239 
240  if( pCNd )
241  {
242  SwTextNode* pTextNd = pCNd->GetTextNode();
243  if( pTextNd )
244  {
245  SwpHints * const pHts = pTextNd->GetpSwpHints();
246  // OutlineNodes set the new nodes in the array
247  if (bInsOutlineIdx && pTextNd->IsOutline())
248  {
249  rNds.m_pOutlineNodes->insert( pTextNd );
250  }
251 
252  pTextNd->AddToList();
253 
254  // special treatment for fields
255  if( pHts && pHts->Count() )
256  {
257  bool const bToUndo = !pDestDoc &&
258  GetDoc().GetIDocumentUndoRedo().IsUndoNodes(rNds);
259  for( size_t i = pHts->Count(); i; )
260  {
261  SwTextAttr * const pAttr = pHts->Get( --i );
262  switch ( pAttr->Which() )
263  {
264  case RES_TXTATR_FIELD:
265  case RES_TXTATR_ANNOTATION:
266  case RES_TXTATR_INPUTFIELD:
267  {
268  SwTextField* pTextField = static_txtattr_cast<SwTextField*>(pAttr);
269  rNds.GetDoc().getIDocumentFieldsAccess().InsDelFieldInFieldLst( !bToUndo, *pTextField );
270 
271  const SwFieldType* pTyp = pTextField->GetFormatField().GetField()->GetTyp();
272  if ( SwFieldIds::Postit == pTyp->Which() )
273  {
274  rNds.GetDoc().GetDocShell()->Broadcast(
275  SwFormatFieldHint(
276  &pTextField->GetFormatField(),
277  ( pTextField->GetFormatField().IsFieldInDoc()
278  ? SwFormatFieldHintWhich::INSERTED
279  : SwFormatFieldHintWhich::REMOVED ) ) );
280  }
281  else if( SwFieldIds::Dde == pTyp->Which() )
282  {
283  if( bToUndo )
284  const_cast<SwDDEFieldType*>(static_cast<const SwDDEFieldType*>(pTyp))->DecRefCnt();
285  else
286  const_cast<SwDDEFieldType*>(static_cast<const SwDDEFieldType*>(pTyp))->IncRefCnt();
287  }
288  static_cast<SwFormatField&>(pAttr->GetAttr())
289  .InvalidateField();
290  }
291  break;
292 
293  case RES_TXTATR_FTN:
294  static_cast<SwFormatFootnote&>(pAttr->GetAttr())
295  .InvalidateFootnote();
296  break;
297 
298  case RES_TXTATR_TOXMARK:
299  static_cast<SwTOXMark&>(pAttr->GetAttr())
300  .InvalidateTOXMark();
301  break;
302 
303  case RES_TXTATR_REFMARK:
304  static_cast<SwFormatRefMark&>(pAttr->GetAttr())
305  .InvalidateRefMark();
306  break;
307 
308  case RES_TXTATR_META:
309  case RES_TXTATR_METAFIELD:
310  {
311  SwTextMeta *const pTextMeta(
312  static_txtattr_cast<SwTextMeta*>(pAttr));
313  // force removal of UNO object
314  pTextMeta->ChgTextNode(nullptr);
315  pTextMeta->ChgTextNode(pTextNd);
316  }
317  break;
318 
319  default:
320  break;
321  }
322  }
323  }
324  //FEATURE::CONDCOLL
325  if( RES_CONDTXTFMTCOLL == pTextNd->GetTextColl()->Which() )
326  pTextNd->ChkCondColl();
327  //FEATURE::CONDCOLL
328  }
329  else
330  {
331  // Moved into different Docs? Persist data again!
332  if( pCNd->IsNoTextNode() && bRestPersData )
333  static_cast<SwNoTextNode*>(pCNd)->RestorePersistentData();
334  }
335  }
336  }
337  }
338 
339  // declare all fields as invalid, updating will happen
340  // in the idle-handler of the doc
341  GetDoc().getIDocumentFieldsAccess().SetFieldsDirty( true, nullptr, 0 );
342  if( &rNds.GetDoc() != &GetDoc() )
343  rNds.GetDoc().getIDocumentFieldsAccess().SetFieldsDirty( true, nullptr, 0 );
344 
345  if( bNewFrames )
346  bNewFrames = &GetDoc().GetNodes() == &rNds &&
347  GetDoc().getIDocumentLayoutAccess().GetCurrentViewShell();
348 
349  if( !bNewFrames )
350  return;
351 
352  // get the frames:
353  SwNodeIndex aIdx( *pPrevInsNd, 1 );
354  SwNodeIndex aFrameNdIdx( aIdx );
355  SwNode* pFrameNd = rNds.FindPrvNxtFrameNode( aFrameNdIdx,
356  rNds[ rInsPos.GetIndex() - 1 ] );
357 
358  if( !pFrameNd )
359  return;
360 
361  while( aIdx != rInsPos )
362  {
363  SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
364  if( pCNd )
365  {
366  if( pFrameNd->IsTableNode() )
367  static_cast<SwTableNode*>(pFrameNd)->MakeFramesForAdjacentContentNode(aIdx);
368  else if( pFrameNd->IsSectionNode() )
369  static_cast<SwSectionNode*>(pFrameNd)->MakeFramesForAdjacentContentNode(aIdx);
370  else
371  static_cast<SwContentNode*>(pFrameNd)->MakeFramesForAdjacentContentNode(*pCNd);
372  pFrameNd = pCNd;
373  }
374  ++aIdx;
375  }
376 }
377 
378 // TODO: provide documentation
394 bool SwNodes::MoveNodes( const SwNodeRange& aRange, SwNodes & rNodes,
395  const SwNodeIndex& aIndex, bool bNewFrames )
396 {
397  SwNode * pCurrentNode;
398  if( aIndex == 0 ||
399  ( (pCurrentNode = &aIndex.GetNode())->GetStartNode() &&
400  !pCurrentNode->StartOfSectionIndex() ))
401  return false;
402 
403  SwNodeRange aRg( aRange );
404 
405  // skip "simple" start or end nodes
406  while( SwNodeType::Start == (pCurrentNode = &aRg.aStart.GetNode())->GetNodeType()
407  || ( pCurrentNode->IsEndNode() &&
408  !pCurrentNode->m_pStartOfSection->IsSectionNode() ) )
409  ++aRg.aStart;
410  --aRg.aStart;
411 
412  // if aEnd-1 points to no ContentNode, search previous one
413  --aRg.aEnd;
414  while( ( (( pCurrentNode = &aRg.aEnd.GetNode())->GetStartNode() &&
415  !pCurrentNode->IsSectionNode() ) ||
416  ( pCurrentNode->IsEndNode() &&
417  SwNodeType::Start == pCurrentNode->m_pStartOfSection->GetNodeType()) ) &&
418  aRg.aEnd > aRg.aStart )
419  --aRg.aEnd;
420 
421  // if in same array, check insertion position
422  if( aRg.aStart >= aRg.aEnd )
423  return false;
424 
425  if( this == &rNodes )
426  {
427  if( ( aIndex.GetIndex()-1 >= aRg.aStart.GetIndex() &&
428  aIndex.GetIndex()-1 < aRg.aEnd.GetIndex()) ||
429  ( aIndex.GetIndex()-1 == aRg.aEnd.GetIndex() ) )
430  return false;
431  }
432 
433  sal_uLong nInsPos = 0; // counter for tmp array
434 
435  // array as a stack, storing all StartOfSelections
436  SwStartNodePointers aSttNdStack;
437  SwStartNodePointers::size_type nLevel = 0; // level counter
438 
439  // set start index
440  SwNodeIndex aIdx( aIndex );
441 
442  SwStartNode* pStartNode = aIdx.GetNode().m_pStartOfSection;
443  aSttNdStack.insert( aSttNdStack.begin(), pStartNode );
444 
445  SwNodeRange aOrigInsPos( aIdx, -1, aIdx ); // original insertion position
446 
447  // call DelFrames/MakeFrames for the upmost SectionNode
448  int nSectNdCnt = 0;
449  bool bSaveNewFrames = bNewFrames;
450 
451  // continue until everything has been moved
452  while( aRg.aStart < aRg.aEnd )
453  {
454  pCurrentNode = &aRg.aEnd.GetNode();
455  switch( pCurrentNode->GetNodeType() )
456  {
457  case SwNodeType::End:
458  {
459  if( nInsPos ) // move everything until here
460  {
461  // delete and copy. CAUTION: all indices after
462  // "aRg.aEnd+1" will be moved as well!
463  SwNodeIndex aSwIndex( aRg.aEnd, 1 );
464  ChgNode( aSwIndex, nInsPos, aIdx, bNewFrames );
465  aIdx -= nInsPos;
466  nInsPos = 0;
467  }
468 
469  SwStartNode* pSttNd = pCurrentNode->m_pStartOfSection;
470  if( pSttNd->IsTableNode() )
471  {
472  SwTableNode* pTableNd = static_cast<SwTableNode*>(pSttNd);
473 
474  // move the whole table/range
475  nInsPos = (aRg.aEnd.GetIndex() -
476  pSttNd->GetIndex() )+1;
477  aRg.aEnd -= nInsPos;
478 
479  // NEVER include nodes from the RedLineArea
480  sal_uLong nNd = aIdx.GetIndex();
481  bool bInsOutlineIdx = ( rNodes.GetEndOfRedlines().
482  StartOfSectionNode()->GetIndex() >= nNd ||
483  nNd >= rNodes.GetEndOfRedlines().GetIndex() );
484 
485  if( bNewFrames )
486  // delete all frames
487  pTableNd->DelFrames(nullptr);
488  if( &rNodes == this ) // move into self?
489  {
490  // move all Start/End/ContentNodes
491  // ContentNodes: delete also the frames!
492  pTableNd->m_pStartOfSection = aIdx.GetNode().m_pStartOfSection;
493  for( sal_uLong n = 0; n < nInsPos; ++n )
494  {
495  SwNodeIndex aMvIdx( aRg.aEnd, 1 );
496  SwContentNode* pCNd = nullptr;
497  SwNode* pTmpNd = &aMvIdx.GetNode();
498  if( pTmpNd->IsContentNode() )
499  {
500  pCNd = static_cast<SwContentNode*>(pTmpNd);
501  if( pTmpNd->IsTextNode() )
502  static_cast<SwTextNode*>(pTmpNd)->RemoveFromList();
503 
504  // remove outline index from old nodes array
505  if (pCNd->IsTextNode() && pCNd->GetTextNode()->IsOutline())
506  {
507  m_pOutlineNodes->erase( pCNd );
508  }
509  else
510  pCNd = nullptr;
511  }
512 
513  BigPtrArray::Move( aMvIdx.GetIndex(), aIdx.GetIndex() );
514 
515  if( bInsOutlineIdx && pCNd )
516  m_pOutlineNodes->insert( pCNd );
517  if( pTmpNd->IsTextNode() )
518  static_cast<SwTextNode*>(pTmpNd)->AddToList();
519  }
520  }
521  else
522  {
523  // get StartNode
524  // Even aIdx points to a startnode, we need the startnode
525  // of the environment of aIdx (#i80941)
526  SwStartNode* pSttNode = aIdx.GetNode().m_pStartOfSection;
527 
528  // get all boxes with content because their indices
529  // pointing to the StartNodes need to be reset
530  // (copying the array and deleting all found ones eases
531  // searching)
532  SwNodeIndex aMvIdx( aRg.aEnd, 1 );
533  for( sal_uLong n = 0; n < nInsPos; ++n )
534  {
535  SwNode* pNd = &aMvIdx.GetNode();
536 
537  const bool bOutlNd = pNd->IsTextNode() && pNd->GetTextNode()->IsOutline();
538  // delete outline indices from old node array
539  if( bOutlNd )
540  m_pOutlineNodes->erase( pNd );
541 
542  RemoveNode( aMvIdx.GetIndex(), 1, false );
543  pNd->m_pStartOfSection = pSttNode;
544  rNodes.InsertNode( pNd, aIdx );
545 
546  // set correct indices in Start/EndNodes
547  if( bInsOutlineIdx && bOutlNd )
548  // and put them into the new node array
549  rNodes.m_pOutlineNodes->insert( pNd );
550  else if( pNd->IsStartNode() )
551  pSttNode = static_cast<SwStartNode*>(pNd);
552  else if( pNd->IsEndNode() )
553  {
554  pSttNode->m_pEndOfSection = static_cast<SwEndNode*>(pNd);
555  if( pSttNode->IsSectionNode() )
556  static_cast<SwSectionNode*>(pSttNode)->NodesArrChgd();
557  pSttNode = pSttNode->m_pStartOfSection;
558  }
559  }
560 
561  if( auto pDDETable = dynamic_cast<SwDDETable*>(&pTableNd->GetTable()) )
562  {
563  SwDDEFieldType* pTyp = pDDETable->GetDDEFieldType();
564  if( pTyp )
565  {
566  if( rNodes.IsDocNodes() )
567  pTyp->IncRefCnt();
568  else
569  pTyp->DecRefCnt();
570  }
571  }
572 
573  if (GetDoc().GetIDocumentUndoRedo().IsUndoNodes(rNodes))
574  {
575  SwFrameFormat* pTableFormat = pTableNd->GetTable().GetFrameFormat();
576  pTableFormat->GetNotifier().Broadcast(SfxHint(SfxHintId::Dying));
577  }
578  }
579  if( bNewFrames )
580  {
581  SwNodeIndex aTmp( aIdx );
582  pTableNd->MakeOwnFrames(&aTmp);
583  }
584  aIdx -= nInsPos;
585  nInsPos = 0;
586  }
587  else if( pSttNd->GetIndex() < aRg.aStart.GetIndex() )
588  {
589  // SectionNode: not the whole section will be moved, thus,
590  // move only the ContentNodes
591  // StartNode: create a new section at the given position
592  do { // middle check loop
593  if( !pSttNd->IsSectionNode() )
594  {
595  // create StartNode and EndNode at InsertPos
596  SwStartNode* pTmp = new SwStartNode( aIdx,
597  SwNodeType::Start,
598 /*?? NodeType ??*/ SwNormalStartNode );
599 
600  nLevel++; // put the index to StartNode on the stack
601  aSttNdStack.insert( aSttNdStack.begin() + nLevel, pTmp );
602 
603  // create EndNode
604  new SwEndNode( aIdx, *pTmp );
605  }
606  else if (GetDoc().GetIDocumentUndoRedo().IsUndoNodes(
607  rNodes))
608  {
609  // use placeholder in UndoNodes array
610  new SwPlaceholderNode(aIdx);
611  }
612  else
613  {
614  // JP 18.5.2001 (Bug 70454) creating new section?
615  --aRg.aEnd;
616  break;
617 
618  }
619 
620  --aRg.aEnd;
621  --aIdx;
622  } while( false );
623  }
624  else
625  {
626  // move StartNode and EndNode in total
627 
628  // if Start is exactly the Start of the area,
629  // then the Node needs to be re-visited
630  if( &aRg.aStart.GetNode() == pSttNd )
631  --aRg.aStart;
632 
633  SwSectionNode* pSctNd = pSttNd->GetSectionNode();
634  if( bNewFrames && pSctNd )
635  { // tdf#135056 skip over code in DelFrames() that moves
636  // SwNodeIndex around because in case of nested
637  // sections, m_pStartOfSection will point between
638  // undo nodes-array and doc nodes-array
639  pSctNd->DelFrames(nullptr, true);
640  }
641 
642  RemoveNode( aRg.aEnd.GetIndex(), 1, false ); // delete EndNode
643  sal_uLong nSttPos = pSttNd->GetIndex();
644 
645  // this StartNode will be removed later
646  SwStartNode* pTmpSttNd = new SwStartNode( *this, nSttPos+1 );
647  pTmpSttNd->m_pStartOfSection = pSttNd->m_pStartOfSection;
648 
649  RemoveNode( nSttPos, 1, false ); // delete SttNode
650 
651  pSttNd->m_pStartOfSection = aIdx.GetNode().m_pStartOfSection;
652  rNodes.InsertNode( pSttNd, aIdx );
653  rNodes.InsertNode( pCurrentNode, aIdx );
654  --aIdx;
655  pSttNd->m_pEndOfSection = static_cast<SwEndNode*>(pCurrentNode);
656 
657  --aRg.aEnd;
658 
659  nLevel++; // put the index pointing to the StartNode onto the stack
660  aSttNdStack.insert( aSttNdStack.begin() + nLevel, pSttNd );
661 
662  // reset remaining indices if SectionNode
663  if( pSctNd )
664  {
665  pSctNd->NodesArrChgd();
666  ++nSectNdCnt;
667  // tdf#132326 do not let frames survive in undo nodes
668  if (!GetDoc().GetIDocumentUndoRedo().IsUndoNodes(rNodes))
669  {
670  bNewFrames = false;
671  }
672  }
673  }
674  }
675  break;
676 
677  case SwNodeType::Section:
678  if( !nLevel &&
679  GetDoc().GetIDocumentUndoRedo().IsUndoNodes(rNodes))
680  {
681  // here, a SectionDummyNode needs to be inserted at the current position
682  if( nInsPos ) // move everything until here
683  {
684  // delete and copy. CAUTION: all indices after
685  // "aRg.aEnd+1" will be moved as well!
686  SwNodeIndex aSwIndex( aRg.aEnd, 1 );
687  ChgNode( aSwIndex, nInsPos, aIdx, bNewFrames );
688  aIdx -= nInsPos;
689  nInsPos = 0;
690  }
691  new SwPlaceholderNode(aIdx);
692  --aRg.aEnd;
693  --aIdx;
694  break;
695  }
696  [[fallthrough]];
697  case SwNodeType::Table:
698  case SwNodeType::Start:
699  {
700  // empty section -> nothing to do
701  // and only if it's a top level section
702  if( !nInsPos && !nLevel )
703  {
704  --aRg.aEnd;
705  break;
706  }
707 
708  if( !nLevel ) // level is decreasing
709  {
710  // create decrease
711  SwNodeIndex aTmpSIdx( aOrigInsPos.aStart, 1 );
712  SwStartNode* pTmpStt = new SwStartNode( aTmpSIdx,
713  SwNodeType::Start,
714  static_cast<SwStartNode*>(pCurrentNode)->GetStartNodeType() );
715 
716  --aTmpSIdx;
717 
718  SwNodeIndex aTmpEIdx( aOrigInsPos.aEnd );
719  new SwEndNode( aTmpEIdx, *pTmpStt );
720  --aTmpEIdx;
721  ++aTmpSIdx;
722 
723  // set correct StartOfSection
724  ++aRg.aEnd;
725  {
726  SwNodeIndex aCntIdx( aRg.aEnd );
727  for( sal_uLong n = 0; n < nInsPos; n++, ++aCntIdx)
728  aCntIdx.GetNode().m_pStartOfSection = pTmpStt;
729  }
730 
731  // also set correct StartNode for all decreased nodes
732  while( aTmpSIdx < aTmpEIdx )
733  if( nullptr != (( pCurrentNode = &aTmpEIdx.GetNode())->GetEndNode()) )
734  aTmpEIdx = pCurrentNode->StartOfSectionIndex();
735  else
736  {
737  pCurrentNode->m_pStartOfSection = pTmpStt;
738  --aTmpEIdx;
739  }
740 
741  --aIdx; // after the inserted StartNode
742  --aRg.aEnd; // before StartNode
743  // copy array. CAUTION: all indices after
744  // "aRg.aEnd+1" will be moved as well!
745  SwNodeIndex aSwIndex( aRg.aEnd, 1 );
746  ChgNode( aSwIndex, nInsPos, aIdx, bNewFrames );
747  aIdx -= nInsPos+1;
748  nInsPos = 0;
749  }
750  else // all nodes between StartNode and EndNode were moved
751  {
752  OSL_ENSURE( pCurrentNode == aSttNdStack[nLevel] ||
753  ( pCurrentNode->IsStartNode() &&
754  aSttNdStack[nLevel]->IsSectionNode()),
755  "wrong StartNode" );
756 
757  SwNodeIndex aSwIndex( aRg.aEnd, 1 );
758  ChgNode( aSwIndex, nInsPos, aIdx, bNewFrames );
759  aIdx -= nInsPos+1; // before inserted StartNode
760  nInsPos = 0;
761 
762  // remove pointer from node array
763  RemoveNode( aRg.aEnd.GetIndex(), 1, true );
764  --aRg.aEnd;
765 
766  SwSectionNode* pSectNd = aSttNdStack[ nLevel ]->GetSectionNode();
767  if( pSectNd && !--nSectNdCnt )
768  {
769  SwNodeIndex aTmp( *pSectNd );
770  pSectNd->MakeOwnFrames(&aTmp);
771  bNewFrames = bSaveNewFrames;
772  }
773  aSttNdStack.erase( aSttNdStack.begin() + nLevel ); // remove from stack
774  nLevel--;
775  }
776 
777  // delete all resulting empty start/end node pairs
778  SwNode* pTmpNode = (*this)[ aRg.aEnd.GetIndex()+1 ]->GetEndNode();
779  if( pTmpNode && SwNodeType::Start == (pCurrentNode = &aRg.aEnd.GetNode())
780  ->GetNodeType() && pCurrentNode->StartOfSectionIndex() &&
781  pTmpNode->StartOfSectionNode() == pCurrentNode )
782  {
783  DelNodes( aRg.aEnd, 2 );
784  --aRg.aEnd;
785  }
786  }
787  break;
788 
789  case SwNodeType::Text:
790  //Add special function to text node.
791  {
792  if( bNewFrames && pCurrentNode->GetContentNode() )
793  static_cast<SwContentNode*>(pCurrentNode)->DelFrames(nullptr);
794  pCurrentNode->m_pStartOfSection = aSttNdStack[ nLevel ];
795  nInsPos++;
796  --aRg.aEnd;
797  }
798  break;
799  case SwNodeType::Grf:
800  case SwNodeType::Ole:
801  {
802  if( bNewFrames && pCurrentNode->GetContentNode() )
803  static_cast<SwContentNode*>(pCurrentNode)->DelFrames(nullptr);
804 
805  pCurrentNode->m_pStartOfSection = aSttNdStack[ nLevel ];
806  nInsPos++;
807  --aRg.aEnd;
808  }
809  break;
810 
811  case SwNodeType::PlaceHolder:
812  if (GetDoc().GetIDocumentUndoRedo().IsUndoNodes(*this))
813  {
814  if( &rNodes == this ) // inside UndoNodesArray
815  {
816  // move everything
817  pCurrentNode->m_pStartOfSection = aSttNdStack[ nLevel ];
818  nInsPos++;
819  }
820  else // move into "normal" node array
821  {
822  // than a SectionNode (start/end) is needed at the current
823  // InsPos; if so skip it, otherwise ignore current node
824  if( nInsPos ) // move everything until here
825  {
826  // delete and copy. CAUTION: all indices after
827  // "aRg.aEnd+1" will be moved as well!
828  SwNodeIndex aSwIndex( aRg.aEnd, 1 );
829  ChgNode( aSwIndex, nInsPos, aIdx, bNewFrames );
830  aIdx -= nInsPos;
831  nInsPos = 0;
832  }
833  SwNode* pTmpNd = &aIdx.GetNode();
834  if( pTmpNd->IsSectionNode() ||
835  pTmpNd->StartOfSectionNode()->IsSectionNode() )
836  --aIdx; // skip
837  }
838  }
839  else {
840  assert(!"How can this node be in the node array?");
841  }
842  --aRg.aEnd;
843  break;
844 
845  default:
846  assert(!"Unknown node type");
847  break;
848  }
849  }
850 
851  if( nInsPos ) // copy remaining rest
852  {
853  // rest should be ok
854  SwNodeIndex aSwIndex( aRg.aEnd, 1 );
855  ChgNode( aSwIndex, nInsPos, aIdx, bNewFrames );
856  }
857  ++aRg.aEnd; // again, exclusive end
858 
859  // delete all resulting empty start/end node pairs
860  if( ( pCurrentNode = &aRg.aStart.GetNode())->GetStartNode() &&
861  pCurrentNode->StartOfSectionIndex() &&
862  aRg.aEnd.GetNode().GetEndNode() )
863  DelNodes( aRg.aStart, 2 );
864 
865  // initialize numbering update
866  ++aOrigInsPos.aStart;
867  // Moved in same node array? Then call update top down!
868  if( this == &rNodes &&
869  aRg.aEnd.GetIndex() >= aOrigInsPos.aStart.GetIndex() )
870  {
871  UpdateOutlineIdx( aOrigInsPos.aStart.GetNode() );
872  UpdateOutlineIdx( aRg.aEnd.GetNode() );
873  }
874  else
875  {
876  UpdateOutlineIdx( aRg.aEnd.GetNode() );
877  rNodes.UpdateOutlineIdx( aOrigInsPos.aStart.GetNode() );
878  }
879 
880  return true;
881 }
882 
899 void SwNodes::SectionDown(SwNodeRange *pRange, SwStartNodeType eSttNdTyp )
900 {
901  if( pRange->aStart >= pRange->aEnd ||
902  pRange->aEnd >= Count() ||
903  !::CheckNodesRange(pRange->aStart, pRange->aEnd, false))
904  {
905  return;
906  }
907 
908  // If the beginning of a range is before or at a start node position, so
909  // delete it, otherwise empty S/E or E/S nodes would be created.
910  // For other nodes, create a new start node.
911  SwNode * pCurrentNode = &pRange->aStart.GetNode();
912  SwNodeIndex aTmpIdx( *pCurrentNode->StartOfSectionNode() );
913 
914  if( pCurrentNode->GetEndNode() )
915  DelNodes( pRange->aStart ); // prevent empty section
916  else
917  {
918  // insert a new StartNode
919  SwNode* pSttNd = new SwStartNode( pRange->aStart, SwNodeType::Start, eSttNdTyp );
920  pRange->aStart = *pSttNd;
921  aTmpIdx = pRange->aStart;
922  }
923 
924  // If the end of a range is before or at a StartNode, so delete it,
925  // otherwise empty S/E or E/S nodes would be created.
926  // For other nodes, insert a new end node.
927  --pRange->aEnd;
928  if( pRange->aEnd.GetNode().GetStartNode() )
929  DelNodes( pRange->aEnd );
930  else
931  {
932  ++pRange->aEnd;
933  // insert a new EndNode
934  new SwEndNode( pRange->aEnd, *pRange->aStart.GetNode().GetStartNode() );
935  }
936  --pRange->aEnd;
937 
938  SectionUpDown( aTmpIdx, pRange->aEnd );
939 }
940 
953 void SwNodes::SectionUp(SwNodeRange *pRange)
954 {
955  if( pRange->aStart >= pRange->aEnd ||
956  pRange->aEnd >= Count() ||
957  !::CheckNodesRange(pRange->aStart, pRange->aEnd, false) ||
958  ( HighestLevel( *this, *pRange ) <= 1 ))
959  {
960  return;
961  }
962 
963  // If the beginning of a range is before or at a start node position, so
964  // delete it, otherwise empty S/E or E/S nodes would be created.
965  // For other nodes, create a new start node.
966  SwNode * pCurrentNode = &pRange->aStart.GetNode();
967  SwNodeIndex aIdx( *pCurrentNode->StartOfSectionNode() );
968  if( pCurrentNode->IsStartNode() ) // is StartNode itself
969  {
970  SwEndNode* pEndNd = pRange->aEnd.GetNode().GetEndNode();
971  if (pEndNd && pCurrentNode == pEndNd->m_pStartOfSection)
972  {
973  // there was a pairwise reset, adjust only those in the range
974  SwStartNode* pTmpSttNd = pCurrentNode->m_pStartOfSection;
975  RemoveNode( pRange->aStart.GetIndex(), 1, true );
976  RemoveNode( pRange->aEnd.GetIndex(), 1, true );
977 
978  SwNodeIndex aTmpIdx( pRange->aStart );
979  while( aTmpIdx < pRange->aEnd )
980  {
981  pCurrentNode = &aTmpIdx.GetNode();
982  pCurrentNode->m_pStartOfSection = pTmpSttNd;
983  if( pCurrentNode->IsStartNode() )
984  aTmpIdx = pCurrentNode->EndOfSectionIndex() + 1;
985  else
986  ++aTmpIdx;
987  }
988  return ;
989  }
990  DelNodes( pRange->aStart );
991  }
992  else if( aIdx == pRange->aStart.GetIndex()-1 ) // before StartNode
993  DelNodes( aIdx );
994  else
995  new SwEndNode( pRange->aStart, *aIdx.GetNode().GetStartNode() );
996 
997  // If the end of a range is before or at a StartNode, so delete it,
998  // otherwise empty S/E or E/S nodes would be created.
999  // For other nodes, insert a new end node.
1000  SwNodeIndex aTmpIdx( pRange->aEnd );
1001  if( pRange->aEnd.GetNode().IsEndNode() )
1002  DelNodes( pRange->aEnd );
1003  else
1004  {
1005  new SwStartNode( pRange->aEnd );
1006 /*?? which NodeType ??*/
1007  aTmpIdx = *pRange->aEnd.GetNode().EndOfSectionNode();
1008  --pRange->aEnd;
1009  }
1010 
1011  SectionUpDown( aIdx, aTmpIdx );
1012 }
1013 
1024 void SwNodes::SectionUpDown( const SwNodeIndex & aStart, const SwNodeIndex & aEnd )
1025 {
1026  SwNodeIndex aTmpIdx( aStart, +1 );
1027  // array forms a stack, holding all StartOfSelections
1028  SwStartNodePointers aSttNdStack;
1029  SwStartNode* pTmp = aStart.GetNode().GetStartNode();
1030  aSttNdStack.push_back( pTmp );
1031 
1032  // loop until the first start node that needs to be change was found
1033  // (the indices are updated from the end node backwards to the start)
1034  for( ;; ++aTmpIdx )
1035  {
1036  SwNode * pCurrentNode = &aTmpIdx.GetNode();
1037  pCurrentNode->m_pStartOfSection = aSttNdStack[ aSttNdStack.size()-1 ];
1038 
1039  if( pCurrentNode->GetStartNode() )
1040  {
1041  pTmp = static_cast<SwStartNode*>(pCurrentNode);
1042  aSttNdStack.push_back( pTmp );
1043  }
1044  else if( pCurrentNode->GetEndNode() )
1045  {
1046  SwStartNode* pSttNd = aSttNdStack[ aSttNdStack.size() - 1 ];
1047  pSttNd->m_pEndOfSection = static_cast<SwEndNode*>(pCurrentNode);
1048  aSttNdStack.pop_back();
1049  if( !aSttNdStack.empty() )
1050  continue; // still enough EndNodes on the stack
1051 
1052  else if( aTmpIdx < aEnd ) // too many StartNodes
1053  // if the end is not reached, yet, get the start of the section above
1054  {
1055  aSttNdStack.insert( aSttNdStack.begin(), pSttNd->m_pStartOfSection );
1056  }
1057  else // finished, as soon as out of the range
1058  break;
1059  }
1060  }
1061 }
1062 
1072 void SwNodes::Delete(const SwNodeIndex &rIndex, sal_uLong nNodes)
1073 {
1074  int nLevel = 0; // level counter
1075  SwNode * pCurrentNode;
1076 
1077  sal_uLong nCnt = Count() - rIndex.GetIndex() - 1;
1078  if( nCnt > nNodes ) nCnt = nNodes;
1079 
1080  if( nCnt == 0 ) // no count -> return
1081  return;
1082 
1083  SwNodeRange aRg( rIndex, 0, rIndex, nCnt-1 );
1084  // check if [rIndex..rIndex + nCnt] is larger than the range
1085  if( ( !aRg.aStart.GetNode().StartOfSectionIndex() &&
1086  !aRg.aStart.GetIndex() ) ||
1087  !::CheckNodesRange(aRg.aStart, aRg.aEnd, false))
1088  {
1089  return;
1090  }
1091 
1092  // if aEnd is not on a ContentNode, search the previous one
1093  while( ( pCurrentNode = &aRg.aEnd.GetNode())->GetStartNode() ||
1094  ( pCurrentNode->GetEndNode() &&
1095  !pCurrentNode->m_pStartOfSection->IsTableNode() ))
1096  --aRg.aEnd;
1097 
1098  nCnt = 0;
1099 //TODO: check/improve comment
1100  // increase start so that we are able to use "<" (using "<=" might cause
1101  // problems if aEnd == aStart and aEnd is deleted, so aEnd <= aStart)
1102  --aRg.aStart;
1103 
1104  bool bSaveInNodesDel = m_bInNodesDel;
1105  m_bInNodesDel = true;
1106  bool bUpdateOutline = false;
1107 
1108  // loop until everything is deleted
1109  while( aRg.aStart < aRg.aEnd )
1110  {
1111  pCurrentNode = &aRg.aEnd.GetNode();
1112 
1113  if( pCurrentNode->GetEndNode() )
1114  {
1115  // delete the whole section?
1116  if( pCurrentNode->StartOfSectionIndex() > aRg.aStart.GetIndex() )
1117  {
1118  SwTableNode* pTableNd = pCurrentNode->m_pStartOfSection->GetTableNode();
1119  if( pTableNd )
1120  pTableNd->DelFrames();
1121 
1122  SwNode *pNd, *pChkNd = pCurrentNode->m_pStartOfSection;
1123  SwOutlineNodes::size_type nIdxPos;
1124  do {
1125  pNd = &aRg.aEnd.GetNode();
1126 
1127  if( pNd->IsTextNode() )
1128  {
1129  SwTextNode *const pTextNode(pNd->GetTextNode());
1130  if (pTextNode->IsOutline() &&
1131  m_pOutlineNodes->Seek_Entry( pNd, &nIdxPos ))
1132  {
1133  // remove outline indices
1134  m_pOutlineNodes->erase(nIdxPos);
1135  bUpdateOutline = true;
1136  }
1137  pTextNode->InvalidateNumRule();
1138  }
1139  else if( pNd->IsEndNode() &&
1140  pNd->m_pStartOfSection->IsTableNode() )
1141  static_cast<SwTableNode*>(pNd->m_pStartOfSection)->DelFrames();
1142 
1143  --aRg.aEnd;
1144  nCnt++;
1145 
1146  } while( pNd != pChkNd );
1147  }
1148  else
1149  {
1150  RemoveNode( aRg.aEnd.GetIndex()+1, nCnt, true ); // delete
1151  nCnt = 0;
1152  --aRg.aEnd; // before the EndNode
1153  nLevel++;
1154  }
1155  }
1156  else if( pCurrentNode->GetStartNode() ) // found StartNode
1157  {
1158  if( nLevel == 0 ) // decrease one level
1159  {
1160  if( nCnt )
1161  {
1162  // now delete array
1163  ++aRg.aEnd;
1164  RemoveNode( aRg.aEnd.GetIndex(), nCnt, true );
1165  nCnt = 0;
1166  }
1167  }
1168  else // remove all nodes between start and end node (incl. both)
1169  {
1170  RemoveNode( aRg.aEnd.GetIndex(), nCnt + 2, true ); // delete array
1171  nCnt = 0;
1172  nLevel--;
1173  }
1174 
1175  // after deletion, aEnd might point to an EndNode...
1176  // delete all empty start/end node pairs
1177  SwNode* pTmpNode = aRg.aEnd.GetNode().GetEndNode();
1178  --aRg.aEnd;
1179  while( pTmpNode &&
1180  ( pCurrentNode = &aRg.aEnd.GetNode())->GetStartNode() &&
1181  pCurrentNode->StartOfSectionIndex() )
1182  {
1183  // remove end and start node
1184  DelNodes( aRg.aEnd, 2 );
1185  pTmpNode = aRg.aEnd.GetNode().GetEndNode();
1186  --aRg.aEnd;
1187  }
1188  }
1189  else // "normal" node, so insert into TmpArray
1190  {
1191  SwTextNode* pTextNd = pCurrentNode->GetTextNode();
1192  if( pTextNd )
1193  {
1194  if( pTextNd->IsOutline())
1195  {
1196  // delete outline indices
1197  m_pOutlineNodes->erase( pTextNd );
1198  bUpdateOutline = true;
1199  }
1200  pTextNd->InvalidateNumRule();
1201  }
1202  else if( pCurrentNode->IsContentNode() )
1203  static_cast<SwContentNode*>(pCurrentNode)->InvalidateNumRule();
1204 
1205  --aRg.aEnd;
1206  nCnt++;
1207  }
1208  }
1209 
1210  ++aRg.aEnd;
1211  if( nCnt != 0 )
1212  RemoveNode( aRg.aEnd.GetIndex(), nCnt, true ); // delete the rest
1213 
1214  // delete all empty start/end node pairs
1215  while( aRg.aEnd.GetNode().GetEndNode() &&
1216  ( pCurrentNode = &aRg.aStart.GetNode())->GetStartNode() &&
1217  pCurrentNode->StartOfSectionIndex() )
1218  // but none of the holy 5. (???)
1219  {
1220  DelNodes( aRg.aStart, 2 ); // delete start and end node
1221  --aRg.aStart;
1222  }
1223 
1224  m_bInNodesDel = bSaveInNodesDel;
1225 
1226  if( !m_bInNodesDel )
1227  {
1228  // update numbering
1229  if( bUpdateOutline || m_bInDelUpdOutline )
1230  {
1231  UpdateOutlineIdx( aRg.aEnd.GetNode() );
1232  m_bInDelUpdOutline = false;
1233  }
1234 
1235  }
1236  else
1237  {
1238  if( bUpdateOutline )
1239  m_bInDelUpdOutline = true;
1240  }
1241 }
1242 
1252 sal_uInt16 SwNodes::GetSectionLevel(const SwNodeIndex &rIdx)
1253 {
1254  // special treatment for 1st Node
1255  if(rIdx == 0) return 1;
1256  // no recursion! This calls a SwNode::GetSectionLevel (missing "s")
1257  return rIdx.GetNode().GetSectionLevel();
1258 }
1259 
1260 void SwNodes::GoStartOfSection(SwNodeIndex *pIdx)
1261 {
1262  // after the next start node
1263  SwNodeIndex aTmp( *pIdx->GetNode().StartOfSectionNode(), +1 );
1264 
1265  // If index points to no ContentNode, then go to one.
1266  // If there is no further available, do not change the index' position!
1267  while( !aTmp.GetNode().IsContentNode() )
1268  { // go from this StartNode (can only be one) to its end
1269  if( *pIdx <= aTmp )
1270  return; // ERROR: already after the section
1271  aTmp = aTmp.GetNode().EndOfSectionIndex()+1;
1272  if( *pIdx <= aTmp )
1273  return; // ERROR: already after the section
1274  }
1275  (*pIdx) = aTmp; // is on a ContentNode
1276 }
1277 
1278 void SwNodes::GoEndOfSection(SwNodeIndex *pIdx)
1279 {
1280  if( !pIdx->GetNode().IsEndNode() )
1281  (*pIdx) = *pIdx->GetNode().EndOfSectionNode();
1282 }
1283 
1284 SwContentNode* SwNodes::GoNext(SwNodeIndex *pIdx) const
1285 {
1286  if( pIdx->GetIndex() >= Count() - 1 )
1287  return nullptr;
1288 
1289  SwNodeIndex aTmp(*pIdx, +1);
1290  SwNode* pNd = nullptr;
1291  while( aTmp < Count()-1 && !( pNd = &aTmp.GetNode())->IsContentNode() )
1292  ++aTmp;
1293 
1294  if( aTmp == Count()-1 )
1295  pNd = nullptr;
1296  else
1297  (*pIdx) = aTmp;
1298  return static_cast<SwContentNode*>(pNd);
1299 }
1300 
1301 SwContentNode* SwNodes::GoPrevious(SwNodeIndex *pIdx)
1302 {
1303  if( !pIdx->GetIndex() )
1304  return nullptr;
1305 
1306  SwNodeIndex aTmp( *pIdx, -1 );
1307  SwNode* pNd = nullptr;
1308  while( aTmp.GetIndex() && !( pNd = &aTmp.GetNode())->IsContentNode() )
1309  --aTmp;
1310 
1311  if( !aTmp.GetIndex() )
1312  pNd = nullptr;
1313  else
1314  (*pIdx) = aTmp;
1315  return static_cast<SwContentNode*>(pNd);
1316 }
1317 
1323 void SwNodes::DelNodes( const SwNodeIndex & rStart, sal_uLong nCnt )
1324 {
1325  sal_uLong nSttIdx = rStart.GetIndex();
1326 
1327  if( !nSttIdx && nCnt == GetEndOfContent().GetIndex()+1 )
1328  {
1329  // The whole nodes array will be destroyed, you're in the Doc's DTOR!
1330  // The initial start/end nodes should be only destroyed in the SwNodes' DTOR!
1331  SwNode* aEndNdArr[] = { m_pEndOfContent.get(),
1332  m_pEndOfPostIts, m_pEndOfInserts,
1333  m_pEndOfAutotext, m_pEndOfRedlines,
1334  nullptr
1335  };
1336 
1337  SwNode** ppEndNdArr = aEndNdArr;
1338  while( *ppEndNdArr )
1339  {
1340  nSttIdx = (*ppEndNdArr)->StartOfSectionIndex() + 1;
1341  sal_uLong nEndIdx = (*ppEndNdArr)->GetIndex();
1342 
1343  if( nSttIdx != nEndIdx )
1344  RemoveNode( nSttIdx, nEndIdx - nSttIdx, true );
1345 
1346  ++ppEndNdArr;
1347  }
1348  }
1349  else
1350  {
1351  int bUpdateNum = 0;
1352  for( sal_uLong n = nSttIdx, nEnd = nSttIdx + nCnt; n < nEnd; ++n )
1353  {
1354  SwNode* pNd = (*this)[ n ];
1355 
1356  if (pNd->IsTextNode() && pNd->GetTextNode()->IsOutline())
1357  {
1358  // remove the outline indices
1359  SwOutlineNodes::size_type nIdxPos;
1360  if( m_pOutlineNodes->Seek_Entry( pNd, &nIdxPos ))
1361  {
1362  m_pOutlineNodes->erase(nIdxPos);
1363  bUpdateNum = 1;
1364  }
1365  }
1366  if( pNd->IsContentNode() )
1367  {
1368  static_cast<SwContentNode*>(pNd)->InvalidateNumRule();
1369  static_cast<SwContentNode*>(pNd)->DelFrames(nullptr);
1370  }
1371  }
1372  RemoveNode( nSttIdx, nCnt, true );
1373 
1374  // update numbering
1375  if( bUpdateNum )
1376  UpdateOutlineIdx( rStart.GetNode() );
1377  }
1378 }
1379 
1380 namespace {
1381 
1382 struct HighLevel
1383 {
1384  sal_uInt16 nLevel, nTop;
1385  explicit HighLevel( sal_uInt16 nLv ) : nLevel( nLv ), nTop( nLv ) {}
1386 };
1387 
1388 }
1389 
1390 static bool lcl_HighestLevel( const SwNodePtr& rpNode, void * pPara )
1391 {
1392  HighLevel * pHL = static_cast<HighLevel*>(pPara);
1393  if( rpNode->GetStartNode() )
1394  pHL->nLevel++;
1395  else if( rpNode->GetEndNode() )
1396  pHL->nLevel--;
1397  if( pHL->nTop > pHL->nLevel )
1398  pHL->nTop = pHL->nLevel;
1399  return true;
1400 
1401 }
1402 
1409 sal_uInt16 HighestLevel( SwNodes & rNodes, const SwNodeRange & rRange )
1410 {
1411  HighLevel aPara( SwNodes::GetSectionLevel( rRange.aStart ));
1412  rNodes.ForEach( rRange.aStart, rRange.aEnd, lcl_HighestLevel, &aPara );
1413  return aPara.nTop;
1414 
1415 }
1416 
1423 void SwNodes::MoveRange( SwPaM & rPam, SwPosition & rPos, SwNodes& rNodes )
1424 {
1425  SwPosition * const pStt = rPam.Start();
1426  SwPosition * const pEnd = rPam.End();
1427 
1428  if( !rPam.HasMark() || *pStt >= *pEnd )
1429  return;
1430 
1431  if( this == &rNodes && *pStt <= rPos && rPos < *pEnd )
1432  return;
1433 
1434  SwNodeIndex aEndIdx( pEnd->nNode );
1435  SwNodeIndex aSttIdx( pStt->nNode );
1436  SwTextNode *const pSrcNd = aSttIdx.GetNode().GetTextNode();
1437  SwTextNode * pDestNd = rPos.nNode.GetNode().GetTextNode();
1438  bool bSplitDestNd = true;
1439  bool bCopyCollFormat = pDestNd && pDestNd->GetText().isEmpty();
1440 
1441  if( pSrcNd )
1442  {
1443  // if the first node is a TextNode, then there must
1444  // be also a TextNode in the NodesArray to store the content
1445  if( !pDestNd )
1446  {
1447  pDestNd = rNodes.MakeTextNode( rPos.nNode, pSrcNd->GetTextColl() );
1448  --rPos.nNode;
1449  rPos.nContent.Assign( pDestNd, 0 );
1450  bCopyCollFormat = true;
1451  }
1452  bSplitDestNd = pDestNd->Len() > rPos.nContent.GetIndex() ||
1453  pEnd->nNode.GetNode().IsTextNode();
1454 
1455  // move the content into the new node
1456  bool bOneNd = pStt->nNode == pEnd->nNode;
1457  const sal_Int32 nLen =
1458  ( bOneNd ? std::min(pEnd->nContent.GetIndex(), pSrcNd->Len()) : pSrcNd->Len() )
1459  - pStt->nContent.GetIndex();
1460 
1461  if( !pEnd->nNode.GetNode().IsContentNode() )
1462  {
1463  bOneNd = true;
1464  sal_uLong nSttNdIdx = pStt->nNode.GetIndex() + 1;
1465  const sal_uLong nEndNdIdx = pEnd->nNode.GetIndex();
1466  for( ; nSttNdIdx < nEndNdIdx; ++nSttNdIdx )
1467  {
1468  if( (*this)[ nSttNdIdx ]->IsContentNode() )
1469  {
1470  bOneNd = false;
1471  break;
1472  }
1473  }
1474  }
1475 
1476  // templates must be copied/set after a split
1477  if( !bOneNd && bSplitDestNd )
1478  {
1479  if( !rPos.nContent.GetIndex() )
1480  {
1481  bCopyCollFormat = true;
1482  }
1483  if( rNodes.IsDocNodes() )
1484  {
1485  SwDoc& rInsDoc = pDestNd->GetDoc();
1486  ::sw::UndoGuard const ug(rInsDoc.GetIDocumentUndoRedo());
1487  rInsDoc.getIDocumentContentOperations().SplitNode( rPos, false );
1488  }
1489  else
1490  {
1491  pDestNd->SplitContentNode(rPos, nullptr);
1492  }
1493 
1494  if( rPos.nNode == aEndIdx )
1495  {
1496  --aEndIdx;
1497  }
1498  bSplitDestNd = true;
1499 
1500  pDestNd = rNodes[ rPos.nNode.GetIndex() - 1 ]->GetTextNode();
1501  if( nLen )
1502  {
1503  pSrcNd->CutText( pDestNd, SwIndex( pDestNd, pDestNd->Len()),
1504  pStt->nContent, nLen );
1505  }
1506  }
1507  else if ( nLen )
1508  {
1509  pSrcNd->CutText( pDestNd, rPos.nContent, pStt->nContent, nLen );
1510  }
1511 
1512  if( bCopyCollFormat )
1513  {
1514  SwDoc& rInsDoc = pDestNd->GetDoc();
1515  ::sw::UndoGuard const undoGuard(rInsDoc.GetIDocumentUndoRedo());
1516  pSrcNd->CopyCollFormat( *pDestNd );
1517  bCopyCollFormat = false;
1518  }
1519 
1520  if( bOneNd )
1521  {
1522  // Correct the PaM, because it might have happened that the move
1523  // went over the node borders (so the data might be in different nodes).
1524  // Also, a selection is invalidated.
1525  pEnd->nContent = pStt->nContent;
1526  rPam.DeleteMark();
1527  GetDoc().GetDocShell()->Broadcast( SwFormatFieldHint( nullptr,
1528  rNodes.IsDocNodes() ? SwFormatFieldHintWhich::INSERTED : SwFormatFieldHintWhich::REMOVED ) );
1529  return;
1530  }
1531 
1532  ++aSttIdx;
1533  }
1534  else if( pDestNd )
1535  {
1536  if( rPos.nContent.GetIndex() )
1537  {
1538  if( rPos.nContent.GetIndex() == pDestNd->Len() )
1539  {
1540  ++rPos.nNode;
1541  }
1542  else if( rPos.nContent.GetIndex() )
1543  {
1544  // if the EndNode is split than correct the EndIdx
1545  const bool bCorrEnd = aEndIdx == rPos.nNode;
1546 
1547  // if no text is attached to the TextNode, split it
1548  if( rNodes.IsDocNodes() )
1549  {
1550  SwDoc& rInsDoc = pDestNd->GetDoc();
1551  ::sw::UndoGuard const ug(rInsDoc.GetIDocumentUndoRedo());
1552  rInsDoc.getIDocumentContentOperations().SplitNode( rPos, false );
1553  }
1554  else
1555  {
1556  pDestNd->SplitContentNode(rPos, nullptr);
1557  }
1558 
1559  if ( bCorrEnd )
1560  {
1561  --aEndIdx;
1562  }
1563  }
1564  }
1565  // at the end only an empty TextNode is left over
1566  bSplitDestNd = true;
1567  }
1568 
1569  SwTextNode* const pEndSrcNd = aEndIdx.GetNode().GetTextNode();
1570  if ( pEndSrcNd )
1571  {
1572  // at the end of this range a new TextNode will be created
1573  if( !bSplitDestNd )
1574  {
1575  if( rPos.nNode < rNodes.GetEndOfContent().GetIndex() )
1576  {
1577  ++rPos.nNode;
1578  }
1579 
1580  pDestNd =
1581  rNodes.MakeTextNode( rPos.nNode, pEndSrcNd->GetTextColl() );
1582  --rPos.nNode;
1583  rPos.nContent.Assign( pDestNd, 0 );
1584  }
1585  else
1586  {
1587  pDestNd = rPos.nNode.GetNode().GetTextNode();
1588  }
1589 
1590  if (pDestNd && pEnd->nContent.GetIndex())
1591  {
1592  // move the content into the new node
1593  SwIndex aIdx( pEndSrcNd, 0 );
1594  pEndSrcNd->CutText( pDestNd, rPos.nContent, aIdx,
1595  pEnd->nContent.GetIndex());
1596  }
1597 
1598  if (pDestNd && bCopyCollFormat)
1599  {
1600  SwDoc& rInsDoc = pDestNd->GetDoc();
1601  ::sw::UndoGuard const ug(rInsDoc.GetIDocumentUndoRedo());
1602  pEndSrcNd->CopyCollFormat( *pDestNd );
1603  }
1604  }
1605  else
1606  {
1607  if ( pSrcNd && aEndIdx.GetNode().IsContentNode() )
1608  {
1609  ++aEndIdx;
1610  }
1611  if( !bSplitDestNd )
1612  {
1613  ++rPos.nNode;
1614  rPos.nContent.Assign( rPos.nNode.GetNode().GetContentNode(), 0 );
1615  }
1616  }
1617 
1618  if( aEndIdx != aSttIdx )
1619  {
1620  // move the nodes into the NodesArray
1621  const sal_uLong nSttDiff = aSttIdx.GetIndex() - pStt->nNode.GetIndex();
1622  SwNodeRange aRg( aSttIdx, aEndIdx );
1623  MoveNodes( aRg, rNodes, rPos.nNode );
1624 
1625  // if in the same node array, all indices are now at new positions (so correct them)
1626  if( &rNodes == this )
1627  {
1628  pStt->nNode = aRg.aEnd.GetIndex() - nSttDiff;
1629  }
1630  }
1631 
1632  // if the StartNode was moved to whom the cursor pointed, so
1633  // the content must be registered in the current content!
1634  if ( &pStt->nNode.GetNode() == &GetEndOfContent() )
1635  {
1636  const bool bSuccess = GoPrevious( &pStt->nNode );
1637  OSL_ENSURE( bSuccess, "Move() - no ContentNode here" );
1638  }
1639  pStt->nContent.Assign( pStt->nNode.GetNode().GetContentNode(),
1640  pStt->nContent.GetIndex() );
1641  // Correct the PaM, because it might have happened that the move
1642  // went over the node borders (so the data might be in different nodes).
1643  // Also, a selection is invalidated.
1644  *pEnd = *pStt;
1645  rPam.DeleteMark();
1646  GetDoc().GetDocShell()->Broadcast( SwFormatFieldHint( nullptr,
1647  rNodes.IsDocNodes() ? SwFormatFieldHintWhich::INSERTED : SwFormatFieldHintWhich::REMOVED ) );
1648 }
1649 
1651 void SwNodes::CopyNodes( const SwNodeRange& rRange,
1652  const SwNodeIndex& rIndex, bool bNewFrames, bool bTableInsDummyNode ) const
1653 {
1654  SwDoc& rDoc = rIndex.GetNode().GetDoc();
1655 
1656  SwNode * pCurrentNode;
1657  if( rIndex == 0 ||
1658  ( (pCurrentNode = &rIndex.GetNode())->GetStartNode() &&
1659  !pCurrentNode->StartOfSectionIndex() ))
1660  return;
1661 
1662  SwNodeRange aRg( rRange );
1663 
1664  // skip "simple" StartNodes or EndNodes
1665  while( SwNodeType::Start == (pCurrentNode = & aRg.aStart.GetNode())->GetNodeType()
1666  || ( pCurrentNode->IsEndNode() &&
1667  !pCurrentNode->m_pStartOfSection->IsSectionNode() ) )
1668  ++aRg.aStart;
1669 
1670  const SwNode *aEndNode = &aRg.aEnd.GetNode();
1671  int nIsEndOfContent = (aEndNode == &aEndNode->GetNodes().GetEndOfContent()) ? 1 : 0;
1672 
1673  if (0 == nIsEndOfContent)
1674  {
1675  // if aEnd-1 points to no ContentNode, search previous one
1676  --aRg.aEnd;
1677  // #i107142#: if aEnd is start node of a special section, do nothing.
1678  // Otherwise this could lead to crash: going through all previous
1679  // special section nodes and then one before the first.
1680  if (aRg.aEnd.GetNode().StartOfSectionIndex() != 0)
1681  {
1682  while( ((pCurrentNode = & aRg.aEnd.GetNode())->GetStartNode() &&
1683  !pCurrentNode->IsSectionNode() ) ||
1684  ( pCurrentNode->IsEndNode() &&
1685  SwNodeType::Start == pCurrentNode->m_pStartOfSection->GetNodeType()) )
1686  {
1687  --aRg.aEnd;
1688  }
1689  }
1690  ++aRg.aEnd;
1691  }
1692 
1693  // is there anything left to copy?
1694  if( aRg.aStart >= aRg.aEnd )
1695  return;
1696 
1697  // when inserting into the source range, nothing need to be done
1698  OSL_ENSURE( &aRg.aStart.GetNodes() == this,
1699  "aRg should use this node array" );
1700  OSL_ENSURE( &aRg.aStart.GetNodes() == &aRg.aEnd.GetNodes(),
1701  "Range across different nodes arrays? You deserve punishment!");
1702  if( &rIndex.GetNodes() == &aRg.aStart.GetNodes() &&
1703  rIndex.GetIndex() >= aRg.aStart.GetIndex() &&
1704  rIndex.GetIndex() < aRg.aEnd.GetIndex() )
1705  return;
1706 
1707  SwNodeIndex aInsPos( rIndex );
1708  SwNodeIndex aOrigInsPos( rIndex, -1 ); // original insertion position
1709  int nLevel = 0; // level counter
1710 
1711  for( tools::Long nNodeCnt = aRg.aEnd.GetIndex() - aRg.aStart.GetIndex();
1712  nNodeCnt > 0; --nNodeCnt )
1713  {
1714  pCurrentNode = &aRg.aStart.GetNode();
1715  switch( pCurrentNode->GetNodeType() )
1716  {
1717  case SwNodeType::Table:
1718  // Does it copy a table in(to) a footnote?
1719  if( aInsPos < rDoc.GetNodes().GetEndOfInserts().GetIndex() &&
1720  rDoc.GetNodes().GetEndOfInserts().StartOfSectionIndex()
1721  < aInsPos.GetIndex() )
1722  {
1723  const tools::Long nDistance =
1724  pCurrentNode->EndOfSectionIndex() -
1725  aRg.aStart.GetIndex();
1726  if (nDistance < nNodeCnt)
1727  nNodeCnt -= nDistance;
1728  else
1729  nNodeCnt = 1;
1730 
1731  // insert a DummyNode for a TableNode
1732  if( bTableInsDummyNode )
1733  new SwPlaceholderNode(aInsPos);
1734 
1735  // copy all of the table's nodes into the current cell
1736  for( ++aRg.aStart; aRg.aStart.GetIndex() <
1737  pCurrentNode->EndOfSectionIndex();
1738  ++aRg.aStart )
1739  {
1740  // insert a DummyNode for the box-StartNode?
1741  if( bTableInsDummyNode )
1742  new SwPlaceholderNode(aInsPos);
1743 
1744  SwStartNode* pSttNd = aRg.aStart.GetNode().GetStartNode();
1745  CopyNodes( SwNodeRange( *pSttNd, + 1,
1746  *pSttNd->EndOfSectionNode() ),
1747  aInsPos, bNewFrames );
1748 
1749  // insert a DummyNode for the box-EndNode?
1750  if( bTableInsDummyNode )
1751  new SwPlaceholderNode(aInsPos);
1752  aRg.aStart = *pSttNd->EndOfSectionNode();
1753  }
1754  // insert a DummyNode for the table-EndNode
1755  if( bTableInsDummyNode )
1756  new SwPlaceholderNode(aInsPos);
1757  aRg.aStart = *pCurrentNode->EndOfSectionNode();
1758  }
1759  else
1760  {
1761  SwNodeIndex nStt( aInsPos, -1 );
1762  SwTableNode* pTableNd = static_cast<SwTableNode*>(pCurrentNode)->
1763  MakeCopy( rDoc, aInsPos );
1764  const tools::Long nDistance = aInsPos.GetIndex() - nStt.GetIndex() - 2;
1765  if (nDistance < nNodeCnt)
1766  nNodeCnt -= nDistance;
1767  else
1768  nNodeCnt = 1 - nIsEndOfContent;
1769 
1770  aRg.aStart = pCurrentNode->EndOfSectionIndex();
1771 
1772  if( bNewFrames && pTableNd )
1773  {
1774  nStt = aInsPos;
1775  pTableNd->MakeOwnFrames(&nStt);
1776  }
1777  }
1778  break;
1779 
1780  case SwNodeType::Section:
1781  // If the end of the section is outside the copy range,
1782  // the section node will skipped, not copied!
1783  // If someone want to change this behaviour, he has to adjust the function
1784  // lcl_NonCopyCount(..) in ndcopy.cxx which relies on it.
1785  if( pCurrentNode->EndOfSectionIndex() < aRg.aEnd.GetIndex() )
1786  {
1787  // copy of the whole section, so create a new SectionNode
1788  SwNodeIndex nStt( aInsPos, -1 );
1789  SwSectionNode* pSectNd = static_cast<SwSectionNode*>(pCurrentNode)->
1790  MakeCopy( rDoc, aInsPos );
1791 
1792  const tools::Long nDistance = aInsPos.GetIndex() - nStt.GetIndex() - 2;
1793  if (nDistance < nNodeCnt)
1794  nNodeCnt -= nDistance;
1795  else
1796  nNodeCnt = 1 - nIsEndOfContent;
1797  aRg.aStart = pCurrentNode->EndOfSectionIndex();
1798 
1799  if( bNewFrames && pSectNd &&
1800  !pSectNd->GetSection().IsHidden() )
1801  pSectNd->MakeOwnFrames(&nStt);
1802  }
1803  break;
1804 
1805  case SwNodeType::Start:
1806  {
1807  SwStartNode* pTmp = new SwStartNode( aInsPos, SwNodeType::Start,
1808  static_cast<SwStartNode*>(pCurrentNode)->GetStartNodeType() );
1809  new SwEndNode( aInsPos, *pTmp );
1810  --aInsPos;
1811  nLevel++;
1812  }
1813  break;
1814 
1815  case SwNodeType::End:
1816  if( nLevel ) // complete section
1817  {
1818  --nLevel;
1819  ++aInsPos; // EndNode already exists
1820  }
1821  else if( 1 == nNodeCnt && 1 == nIsEndOfContent )
1822  // we have reached the EndOfContent node - nothing to do!
1823  continue;
1824  else if( !pCurrentNode->m_pStartOfSection->IsSectionNode() )
1825  {
1826  // create a section at the original InsertPosition
1827  SwNodeRange aTmpRg( aOrigInsPos, 1, aInsPos );
1828  rDoc.GetNodes().SectionDown( &aTmpRg,
1829  pCurrentNode->m_pStartOfSection->GetStartNodeType() );
1830  }
1831  break;
1832 
1833  case SwNodeType::Text:
1834  case SwNodeType::Grf:
1835  case SwNodeType::Ole:
1836  {
1837  static_cast<SwContentNode*>(pCurrentNode)->MakeCopy(
1838  rDoc, aInsPos, bNewFrames);
1839  }
1840  break;
1841 
1842  case SwNodeType::PlaceHolder:
1843  if (GetDoc().GetIDocumentUndoRedo().IsUndoNodes(*this))
1844  {
1845  // than a SectionNode (start/end) is needed at the current
1846  // InsPos; if so skip it, otherwise ignore current node
1847  SwNode *const pTmpNd = & aInsPos.GetNode();
1848  if( pTmpNd->IsSectionNode() ||
1849  pTmpNd->StartOfSectionNode()->IsSectionNode() )
1850  ++aInsPos; // skip
1851  }
1852  else {
1853  assert(!"How can this node be in the node array?");
1854  }
1855  break;
1856 
1857  default:
1858  assert(false);
1859  }
1860  ++aRg.aStart;
1861  }
1862 }
1863 
1864 void SwNodes::DelDummyNodes( const SwNodeRange& rRg )
1865 {
1866  SwNodeIndex aIdx( rRg.aStart );
1867  while( aIdx.GetIndex() < rRg.aEnd.GetIndex() )
1868  {
1869  if (SwNodeType::PlaceHolder == aIdx.GetNode().GetNodeType())
1870  RemoveNode( aIdx.GetIndex(), 1, true );
1871  else
1872  ++aIdx;
1873  }
1874 }
1875 
1876 SwStartNode* SwNodes::MakeEmptySection( const SwNodeIndex& rIdx,
1877  SwStartNodeType eSttNdTyp )
1878 {
1879  SwStartNode* pSttNd = new SwStartNode( rIdx, SwNodeType::Start, eSttNdTyp );
1880  new SwEndNode( rIdx, *pSttNd );
1881  return pSttNd;
1882 }
1883 
1884 SwStartNode* SwNodes::MakeTextSection( const SwNodeIndex & rWhere,
1885  SwStartNodeType eSttNdTyp,
1886  SwTextFormatColl *pColl )
1887 {
1888  SwStartNode* pSttNd = new SwStartNode( rWhere, SwNodeType::Start, eSttNdTyp );
1889  new SwEndNode( rWhere, *pSttNd );
1890  MakeTextNode( SwNodeIndex( rWhere, - 1 ), pColl );
1891  return pSttNd;
1892 }
1893 
1894 //TODO: provide better documentation
1907 SwContentNode* SwNodes::GoNextSection( SwNodeIndex * pIdx,
1908  bool bSkipHidden, bool bSkipProtect ) const
1909 {
1910  bool bFirst = true;
1911  SwNodeIndex aTmp( *pIdx );
1912  const SwNode* pNd;
1913  while( aTmp < Count() - 1 )
1914  {
1915  pNd = & aTmp.GetNode();
1916  if (SwNodeType::Section == pNd->GetNodeType())
1917  {
1918  const SwSection& rSect = static_cast<const SwSectionNode*>(pNd)->GetSection();
1919  if( (bSkipHidden && rSect.IsHiddenFlag()) ||
1920  (bSkipProtect && rSect.IsProtectFlag()) )
1921  // than skip the section
1922  aTmp = *pNd->EndOfSectionNode();
1923  }
1924  else if( bFirst )
1925  {
1926  if( pNd->m_pStartOfSection->IsSectionNode() )
1927  {
1928  const SwSection& rSect = static_cast<SwSectionNode*>(pNd->
1929  m_pStartOfSection)->GetSection();
1930  if( (bSkipHidden && rSect.IsHiddenFlag()) ||
1931  (bSkipProtect && rSect.IsProtectFlag()) )
1932  // than skip the section
1933  aTmp = *pNd->EndOfSectionNode();
1934  }
1935  }
1936  else if( SwNodeType::ContentMask & pNd->GetNodeType() )
1937  {
1938  const SwSectionNode* pSectNd;
1939  if( ( bSkipHidden || bSkipProtect ) &&
1940  nullptr != (pSectNd = pNd->FindSectionNode() ) &&
1941  ( ( bSkipHidden && pSectNd->GetSection().IsHiddenFlag() ) ||
1942  ( bSkipProtect && pSectNd->GetSection().IsProtectFlag() )) )
1943  {
1944  aTmp = *pSectNd->EndOfSectionNode();
1945  }
1946  else
1947  {
1948  (*pIdx) = aTmp;
1949  return const_cast<SwContentNode*>(static_cast<const SwContentNode*>(pNd));
1950  }
1951  }
1952  ++aTmp;
1953  bFirst = false;
1954  }
1955  return nullptr;
1956 }
1957 
1959 SwContentNode* SwNodes::GoPrevSection( SwNodeIndex * pIdx,
1960  bool bSkipHidden, bool bSkipProtect )
1961 {
1962  bool bFirst = true;
1963  SwNodeIndex aTmp( *pIdx );
1964  const SwNode* pNd;
1965  while( aTmp > 0 )
1966  {
1967  pNd = & aTmp.GetNode();
1968  if (SwNodeType::End == pNd->GetNodeType())
1969  {
1970  if( pNd->m_pStartOfSection->IsSectionNode() )
1971  {
1972  const SwSection& rSect = static_cast<SwSectionNode*>(pNd->
1973  m_pStartOfSection)->GetSection();
1974  if( (bSkipHidden && rSect.IsHiddenFlag()) ||
1975  (bSkipProtect && rSect.IsProtectFlag()) )
1976  // than skip section
1977  aTmp = *pNd->StartOfSectionNode();
1978  }
1979  bFirst = false;
1980  }
1981  else if( bFirst )
1982  {
1983  bFirst = false;
1984  if( pNd->m_pStartOfSection->IsSectionNode() )
1985  {
1986  const SwSection& rSect = static_cast<SwSectionNode*>(pNd->
1987  m_pStartOfSection)->GetSection();
1988  if( (bSkipHidden && rSect.IsHiddenFlag()) ||
1989  (bSkipProtect && rSect.IsProtectFlag()) )
1990  // than skip section
1991  aTmp = *pNd->StartOfSectionNode();
1992  }
1993  }
1994  else if( SwNodeType::ContentMask & pNd->GetNodeType() )
1995  {
1996  const SwSectionNode* pSectNd;
1997  if( ( bSkipHidden || bSkipProtect ) &&
1998  nullptr != (pSectNd = pNd->FindSectionNode() ) &&
1999  ( ( bSkipHidden && pSectNd->GetSection().IsHiddenFlag() ) ||
2000  ( bSkipProtect && pSectNd->GetSection().IsProtectFlag() )) )
2001  {
2002  aTmp = *pSectNd;
2003  }
2004  else
2005  {
2006  (*pIdx) = aTmp;
2007  return const_cast<SwContentNode*>(static_cast<const SwContentNode*>(pNd));
2008  }
2009  }
2010  --aTmp;
2011  }
2012  return nullptr;
2013 }
2014 
2015 //TODO: improve documentation
2016 //TODO: The inventor of the "single responsibility principle" will be crying if you ever show this code to him!
2026 SwNode* SwNodes::FindPrvNxtFrameNode( SwNodeIndex& rFrameIdx,
2027  const SwNode* pEnd ) const
2028 {
2029  SwNode* pFrameNd = nullptr;
2030 
2031  // no layout -> skip
2032  if( GetDoc().getIDocumentLayoutAccess().GetCurrentViewShell() )
2033  {
2034  SwNode* pSttNd = &rFrameIdx.GetNode();
2035 
2036  // move of a hidden section?
2037  SwSectionNode* pSectNd = pSttNd->IsSectionNode()
2038  ? pSttNd->StartOfSectionNode()->FindSectionNode()
2039  : pSttNd->FindSectionNode();
2040  if( !( pSectNd && pSectNd->GetSection().CalcHiddenFlag() ) )
2041  {
2042  // in a table in table situation we have to assure that we don't leave the
2043  // outer table cell when the inner table is looking for a PrvNxt...
2044  SwTableNode* pTableNd = pSttNd->IsTableNode()
2045  ? pSttNd->StartOfSectionNode()->FindTableNode()
2046  : pSttNd->FindTableNode();
2047  SwNodeIndex aIdx( rFrameIdx );
2048  SwNode* pNd;
2049  if( pEnd )
2050  {
2051  --aIdx;
2052  pNd = &aIdx.GetNode();
2053  }
2054  else
2055  pNd = pSttNd;
2056 
2057  if( ( pFrameNd = pNd )->IsContentNode() )
2058  rFrameIdx = aIdx;
2059 
2060  // search forward or backward for a content node
2061  else if( nullptr != ( pFrameNd = GoPrevSection( &aIdx, true, false )) &&
2062  ::CheckNodesRange( aIdx, rFrameIdx, true ) &&
2063  // Never out of the table at the start
2064  pFrameNd->FindTableNode() == pTableNd &&
2065  // Bug 37652: Never out of the table at the end
2066  (!pFrameNd->FindTableNode() || pFrameNd->FindTableBoxStartNode()
2067  == pSttNd->FindTableBoxStartNode() ) &&
2068  (!pSectNd || pSttNd->IsSectionNode() ||
2069  pSectNd->GetIndex() < pFrameNd->GetIndex())
2070  )
2071  {
2072  rFrameIdx = aIdx;
2073  }
2074  else
2075  {
2076  if( pEnd )
2077  aIdx = pEnd->GetIndex() + 1;
2078  else
2079  aIdx = rFrameIdx;
2080 
2081  // NEVER leave the section when doing this!
2082  if( ( pEnd && ( pFrameNd = &aIdx.GetNode())->IsContentNode() ) ||
2083  ( nullptr != ( pFrameNd = GoNextSection( &aIdx, true, false )) &&
2084  ::CheckNodesRange( aIdx, rFrameIdx, true ) &&
2085  ( pFrameNd->FindTableNode() == pTableNd &&
2086  // NEVER go out of the table cell at the end
2087  (!pFrameNd->FindTableNode() || pFrameNd->FindTableBoxStartNode()
2088  == pSttNd->FindTableBoxStartNode() ) ) &&
2089  (!pSectNd || pSttNd->IsSectionNode() ||
2090  pSectNd->EndOfSectionIndex() > pFrameNd->GetIndex())
2091  ))
2092  {
2093  // Undo when merging a table with one before, if there is also one after it.
2094  // However, if the node is in a table, it needs to be returned if the
2095  // SttNode is a section or a table!
2096  SwTableNode* pTableNode;
2097  if (pSttNd->IsTableNode() &&
2098  nullptr != (pTableNode = pFrameNd->FindTableNode()) &&
2099  // TABLE IN TABLE:
2100  pTableNode != pSttNd->StartOfSectionNode()->FindTableNode())
2101  {
2102  pFrameNd = pTableNode;
2103  rFrameIdx = *pFrameNd;
2104  }
2105  else
2106  rFrameIdx = aIdx;
2107  }
2108  else if( pNd->IsEndNode() && pNd->StartOfSectionNode()->IsTableNode() )
2109  {
2110  pFrameNd = pNd->StartOfSectionNode();
2111  rFrameIdx = *pFrameNd;
2112  }
2113  else
2114  {
2115  if( pEnd )
2116  aIdx = pEnd->GetIndex() + 1;
2117  else
2118  aIdx = rFrameIdx.GetIndex() + 1;
2119 
2120  if( (pFrameNd = &aIdx.GetNode())->IsTableNode() )
2121  rFrameIdx = aIdx;
2122  else
2123  {
2124  pFrameNd = nullptr;
2125 
2126  // is there some sectionnodes before a tablenode?
2127  while( aIdx.GetNode().IsSectionNode() )
2128  {
2129  const SwSection& rSect = aIdx.GetNode().
2130  GetSectionNode()->GetSection();
2131  if( rSect.IsHiddenFlag() )
2132  aIdx = aIdx.GetNode().EndOfSectionIndex()+1;
2133  else
2134  ++aIdx;
2135  }
2136  if( aIdx.GetNode().IsTableNode() )
2137  {
2138  rFrameIdx = aIdx;
2139  pFrameNd = &aIdx.GetNode();
2140  }
2141  }
2142  }
2143  }
2144  }
2145  }
2146  return pFrameNd;
2147 }
2148 
2149 void SwNodes::ForEach( sal_uLong nStart, sal_uLong nEnd,
2150  FnForEach_SwNodes fn, void* pArgs )
2151 {
2152  if( nEnd > m_nSize )
2153  nEnd = m_nSize;
2154 
2155  if( nStart >= nEnd )
2156  return;
2157 
2158  sal_uInt16 cur = Index2Block( nStart );
2159  BlockInfo** pp = m_ppInf.get() + cur;
2160  BlockInfo* p = *pp;
2161  sal_uInt16 nElem = sal_uInt16( nStart - p->nStart );
2162  auto pElem = p->mvData.begin() + nElem;
2163  nElem = p->nElem - nElem;
2164  for(;;)
2165  {
2166  if( !(*fn)( static_cast<SwNode *>(*pElem++), pArgs ) || ++nStart >= nEnd )
2167  break;
2168 
2169  // next element
2170  if( !--nElem )
2171  {
2172  // new block
2173  p = *++pp;
2174  pElem = p->mvData.begin();
2175  nElem = p->nElem;
2176  }
2177  }
2178 }
2179 
2180 void SwNodes::ForEach( const SwNodeIndex& rStart, const SwNodeIndex& rEnd,
2181  FnForEach_SwNodes fnForEach, void* pArgs )
2182 {
2183  ForEach( rStart.GetIndex(), rEnd.GetIndex(), fnForEach, pArgs );
2184 }
2185 
2186 void SwNodes::RemoveNode( sal_uLong nDelPos, sal_uLong nSz, bool bDel )
2187 {
2188 #ifndef NDEBUG
2189  SwNode *const pFirst((*this)[nDelPos]);
2190 #endif
2191  for (sal_uLong nCnt = 0; nCnt < nSz; nCnt++)
2192  {
2193  SwNode* pNode = (*this)[ nDelPos + nCnt ];
2194  SwTextNode * pTextNd = pNode->GetTextNode();
2195 
2196  if (pTextNd)
2197  {
2198  pTextNd->RemoveFromList();
2199  // remove RndStdIds::FLY_AS_CHAR *before* adjusting SwNodeIndex
2200  // so their anchor still points to correct node when deleted!
2201  // NOTE: this will call RemoveNode() recursively!
2202  // so adjust our indexes to account for removed nodes
2203  sal_uLong const nPos = pTextNd->GetIndex();
2204  SwpHints *const pHints(pTextNd->GetpSwpHints());
2205  if (pHints)
2206  {
2207  std::vector<SwTextAttr*> flys;
2208  for (size_t i = 0; i < pHints->Count(); ++i)
2209  {
2210  SwTextAttr *const pHint(pHints->Get(i));
2211  if (RES_TXTATR_FLYCNT == pHint->Which())
2212  {
2213  flys.push_back(pHint);
2214  }
2215  }
2216  for (SwTextAttr * pHint : flys)
2217  {
2218  pTextNd->DeleteAttribute(pHint);
2219  } // pHints may be dead now
2220  sal_uLong const nDiff = nPos - pTextNd->GetIndex();
2221  if (nDiff)
2222  {
2223  nDelPos -= nDiff;
2224  }
2225  assert(pTextNd == (*this)[nDelPos + nCnt]);
2226  assert(pFirst == (*this)[nDelPos]);
2227  }
2228  }
2229  SwTableNode* pTableNode = pNode->GetTableNode();
2230  if (pTableNode)
2231  {
2232  // The node that is deleted is a table node.
2233  // Need to make sure that all the redlines that are
2234  // related to this table are removed from the
2235  // 'Extra Redlines' array
2236  pTableNode->RemoveRedlines();
2237  }
2238  }
2239 
2240  sal_uLong nEnd = nDelPos + nSz;
2241  SwNode* pNew = (*this)[ nEnd ];
2242 
2243  for (SwNodeIndex& rIndex : m_vIndices->GetRingContainer())
2244  {
2245  sal_uLong const nIdx = rIndex.GetIndex();
2246  if (nDelPos <= nIdx && nIdx < nEnd)
2247  rIndex = *pNew;
2248  }
2249 
2250  std::vector<BigPtrEntry> aTempEntries;
2251  if( bDel )
2252  {
2253  sal_uLong nCnt = nSz;
2254  BigPtrEntry *pDel = (*this)[ nDelPos+nCnt-1 ], *pPrev = (*this)[ nDelPos+nCnt-2 ];
2255 
2256  // set temporary object
2257  // JP 24.08.98: this should actually be removed because one could
2258  // call Remove recursively, e.g. for character bound frames. However,
2259  // since there happens way too much here, this temporary object was
2260  // inserted that will be deleted in Remove again (see Bug 55406)
2261  aTempEntries.resize(nCnt);
2262 
2263  while( nCnt-- )
2264  {
2265  delete pDel;
2266  pDel = pPrev;
2267  sal_uLong nPrevNdIdx = pPrev->GetPos();
2268  BigPtrEntry* pTempEntry = &aTempEntries[nCnt];
2269  BigPtrArray::Replace( nPrevNdIdx+1, pTempEntry );
2270  if( nCnt )
2271  pPrev = BigPtrArray::operator []( nPrevNdIdx - 1 );
2272  // the accessed element can be a naked BigPtrEntry from
2273  // aTempEntries, so the downcast to SwNode* in
2274  // SwNodes::operator[] would be illegal (and unnecessary)
2275  }
2276  nDelPos = pDel->GetPos() + 1;
2277  }
2278 
2279  BigPtrArray::Remove( nDelPos, nSz );
2280 }
2281 
2282 void SwNodes::InsertNode( const SwNodePtr pNode,
2283  const SwNodeIndex& rPos )
2284 {
2285  BigPtrEntry* pIns = pNode;
2286  BigPtrArray::Insert( pIns, rPos.GetIndex() );
2287 }
2288 
2289 void SwNodes::InsertNode( const SwNodePtr pNode,
2290  sal_uLong nPos )
2291 {
2292  BigPtrEntry* pIns = pNode;
2293  BigPtrArray::Insert( pIns, nPos );
2294 }
2295 
2296 // ->#112139#
2297 SwNode * SwNodes::DocumentSectionStartNode(SwNode * pNode) const
2298 {
2299  if (nullptr != pNode)
2300  {
2301  SwNodeIndex aIdx(*pNode);
2302 
2303  if (aIdx <= (*this)[0]->EndOfSectionIndex())
2304  pNode = (*this)[0];
2305  else
2306  {
2307  while ((*this)[0] != pNode->StartOfSectionNode())
2308  pNode = pNode->StartOfSectionNode();
2309  }
2310  }
2311 
2312  return pNode;
2313 }
2314 
2315 SwNode * SwNodes::DocumentSectionEndNode(SwNode * pNode) const
2316 {
2317  return DocumentSectionStartNode(pNode)->EndOfSectionNode();
2318 }
2319 
2320 bool SwNodes::IsDocNodes() const
2321 {
2322  return this == &m_rMyDoc.GetNodes();
2323 }
2324 
2325 void SwNodes::dumpAsXml(xmlTextWriterPtr pWriter) const
2326 {
2327  xmlTextWriterStartElement(pWriter, BAD_CAST("SwNodes"));
2328  for (sal_uLong i = 0; i < Count(); ++i)
2329  (*this)[i]->dumpAsXml(pWriter);
2330  xmlTextWriterEndElement(pWriter);
2331 }
2332 
2333 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SwNode::FindSectionNode
SwSectionNode * FindSectionNode()
Search section node, in which it is.
Definition: ndsect.cxx:962
SwFieldType
Instances of SwFields and those derived from it occur 0 to n times.
Definition: fldbas.hxx:240
SwNode::EndOfSectionNode
const SwEndNode * EndOfSectionNode() const
Definition: node.hxx:690
SwStartNode
Starts a section of nodes in the document model.
Definition: node.hxx:311
SwPaM::DeleteMark
void DeleteMark()
Definition: pam.hxx:177
SwNodes::GetEndOfInserts
SwNode & GetEndOfInserts() const
Section for all footnotes.
Definition: ndarr.hxx:154
SwNode::GetIndex
sal_uLong GetIndex() const
Definition: node.hxx:290
SwNode::m_pStartOfSection
SwStartNode * m_pStartOfSection
Definition: node.hxx:112
SwNodes::Count
sal_uLong Count() const
Definition: ndarr.hxx:142
SwTextFormatColl
Represents the style of a paragraph.
Definition: fmtcol.hxx:55
SwPosition
Marks a position in the document model.
Definition: pam.hxx:35
SwNode::IsSectionNode
bool IsSectionNode() const
Definition: node.hxx:652
SwFormatField::GetField
const SwField * GetField() const
Definition: fmtfld.hxx:111
SwNode::StartOfSectionIndex
sal_uLong StartOfSectionIndex() const
Definition: node.hxx:681
SwTableNode::DelFrames
void DelFrames(SwRootFrame const *pLayout=nullptr)
Method deletes all views of document for the node.
Definition: ndtbl.cxx:2436
RES_TXTATR_METAFIELD
constexpr TypedWhichId< SwFormatMeta > RES_TXTATR_METAFIELD(49)
SwTextNode::GetText
const OUString & GetText() const
Definition: ndtxt.hxx:211
SwTextNode::IsOutline
bool IsOutline() const
Returns if this text node is an outline.
Definition: ndtxt.cxx:3968
SwDoc::GetDocShell
SwDocShell * GetDocShell()
Definition: doc.hxx:1348
SwTextNode::GetpSwpHints
SwpHints * GetpSwpHints()
Definition: ndtxt.hxx:219
RES_TXTATR_META
constexpr TypedWhichId< SwFormatMeta > RES_TXTATR_META(48)
SwPosition::nNode
SwNodeIndex nNode
Definition: pam.hxx:37
HighestLevel
static sal_uInt16 HighestLevel(SwNodes &rNodes, const SwNodeRange &rRange)
Calculate the highest level in a range.
Definition: nodes.cxx:1409
SwTextNode::AddToList
void AddToList()
Definition: ndtxt.cxx:4251
SwNodes::GetDoc
SwDoc & GetDoc()
Which Doc contains the nodes-array?
Definition: ndarr.hxx:302
SwNodes::GetSectionLevel
static sal_uInt16 GetSectionLevel(const SwNodeIndex &rIndex)
get section level at the given position
Definition: nodes.cxx:1252
SwTextNode::Len
virtual sal_Int32 Len() const override
Definition: ndtxt.cxx:275
sal_uLong
sal_uIntPtr sal_uLong
tools::Long
long Long
SwNodes::DocumentSectionStartNode
SwNode * DocumentSectionStartNode(SwNode *pNode) const
Definition: nodes.cxx:2297
n
sal_Int64 n
SwDoc
Definition: doc.hxx:184
SwNodes::GoPrevSection
static SwContentNode * GoPrevSection(SwNodeIndex *, bool bSkipHidden=true, bool bSkipProtect=true)
Definition: nodes.cxx:1959
SwNodes::m_pEndOfInserts
SwNode * m_pEndOfInserts
These are the fixed ranges.
Definition: ndarr.hxx:106
SwTextNode::CutText
void CutText(SwTextNode *const pDest, const SwIndex &rStart, const sal_Int32 nLen)
Definition: ndtxt.cxx:2369
SwNodeType::Section
SwSectionNode is derived from SwStartNode.
SwNodes::DelDummyNodes
void DelDummyNodes(const SwNodeRange &rRg)
Definition: nodes.cxx:1864
RES_TXTATR_FLYCNT
constexpr TypedWhichId< SwFormatFlyCnt > RES_TXTATR_FLYCNT(57)
SwNodes::GoPrevious
static SwContentNode * GoPrevious(SwNodeIndex *)
Definition: nodes.cxx:1301
SwNodeIndex::GetNode
SwNode & GetNode() const
Definition: ndindex.hxx:119
FnForEach_SwNodes
bool(* FnForEach_SwNodes)(const SwNodePtr &, void *pArgs)
Definition: ndarr.hxx:68
SwNumRule::GetName
const OUString & GetName() const
Definition: numrule.hxx:223
SwNodes::DocumentSectionEndNode
SwNode * DocumentSectionEndNode(SwNode *pNode) const
Definition: nodes.cxx:2315
SwNodes::~SwNodes
~SwNodes()
Destructor.
Definition: nodes.cxx:91
SwTableNode::RemoveRedlines
void RemoveRedlines()
Definition: ndtbl.cxx:2489
BlockInfo::nElem
sal_uInt16 nElem
number of elements
Definition: bparr.hxx:61
SwTextNode::SplitContentNode
SwTextNode * SplitContentNode(const SwPosition &, std::function< void(SwTextNode *, sw::mark::RestoreMode)> const *pContentIndexRestore)
Definition: ndtxt.cxx:412
SwDoc::GetIDocumentUndoRedo
IDocumentUndoRedo & GetIDocumentUndoRedo()
Definition: doc.cxx:144
SwTextAttr::Which
sal_uInt16 Which() const
Definition: txatbase.hxx:110
SwNodes::UpdateOutlineIdx
void UpdateOutlineIdx(const SwNode &)
Update all OutlineNodes starting from Node.
Definition: ndnum.cxx:75
BigPtrArray::m_nSize
sal_uLong m_nSize
number of elements
Definition: bparr.hxx:69
SwDoc::getIDocumentContentOperations
IDocumentContentOperations const & getIDocumentContentOperations() const
Definition: doc.cxx:315
RES_TXTATR_ANNOTATION
constexpr TypedWhichId< SwFormatField > RES_TXTATR_ANNOTATION(59)
BigPtrArray::Index2Block
sal_uInt16 Index2Block(sal_uLong) const
block search
Definition: bparr.cxx:91
SwTable::GetFrameFormat
SwTableFormat * GetFrameFormat()
Definition: swtable.hxx:202
SwNodes::ChgNode
void ChgNode(SwNodeIndex const &rDelPos, sal_uLong nSize, SwNodeIndex &rInsPos, bool bNewFrames)
Definition: nodes.cxx:112
SwSectionNode::GetSection
const SwSection & GetSection() const
Definition: node.hxx:549
BigPtrArray::Move
void Move(sal_uLong from, sal_uLong to)
Definition: bparr.cxx:70
SwContentNode::MakeFramesForAdjacentContentNode
void MakeFramesForAdjacentContentNode(SwContentNode &rNode)
Method creates all views of document for given node.
Definition: node.cxx:1343
SwDoc::getIDocumentFieldsAccess
IDocumentFieldsAccess const & getIDocumentFieldsAccess() const
Definition: doc.cxx:357
SwNodes::Delete
void Delete(const SwNodeIndex &rPos, sal_uLong nNodes=1)
delete nodes
Definition: nodes.cxx:1072
SwNode::GetTableNode
SwTableNode * GetTableNode()
Definition: node.hxx:607
SwNode::GetNodeType
SwNodeType GetNodeType() const
Definition: node.hxx:144
SwPosition::nContent
SwIndex nContent
Definition: pam.hxx:38
SwNodes::SwStartNode
friend class SwStartNode
Definition: ndarr.hxx:93
SwNodeRange::aStart
SwNodeIndex aStart
Definition: ndindex.hxx:132
assert
const BorderLinePrimitive2D *pCandidateB assert(pCandidateA)
IDocumentFieldsAccess::InsDelFieldInFieldLst
virtual void InsDelFieldInFieldLst(bool bIns, const SwTextField &rField)=0
SwSectionNode::MakeOwnFrames
void MakeOwnFrames(SwNodeIndex *pIdxBehind, SwNodeIndex *pEnd=nullptr)
Creates the frms for the SectionNode (i.e.
Definition: ndsect.cxx:1142
BigPtrArray::Replace
void Replace(sal_uLong pos, BigPtrEntry *p)
Definition: bparr.cxx:390
SwNodeIndex::GetIndex
sal_uLong GetIndex() const
Definition: ndindex.hxx:152
IDocumentUndoRedo::IsUndoNodes
virtual bool IsUndoNodes(SwNodes const &rNodes) const =0
SwNode::IsStartNode
bool IsStartNode() const
Definition: node.hxx:632
IDocumentFieldsAccess::SetFieldsDirty
virtual bool SetFieldsDirty(bool b, const SwNode *pChk, sal_uLong nLen)=0
SwNodes::GoEndOfSection
static void GoEndOfSection(SwNodeIndex *)
Definition: nodes.cxx:1278
CheckNodesRange
bool CheckNodesRange(const SwNodeIndex &rStt, const SwNodeIndex &rEnd, bool bChkSection)
Check if the given range is inside one of the defined top-level sections.
Definition: pam.cxx:256
SwTableNode::GetTable
const SwTable & GetTable() const
Definition: node.hxx:505
SwNodes::DelNodes
void DelNodes(const SwNodeIndex &rStart, sal_uLong nCnt=1)
Delete a number of nodes.
Definition: nodes.cxx:1323
SwSection::IsProtectFlag
bool IsProtectFlag() const
Definition: section.hxx:188
SwTextAttr::GetFormatField
const SwFormatField & GetFormatField() const
Definition: txatbase.hxx:191
RES_TXTATR_FTN
constexpr TypedWhichId< SwFormatFootnote > RES_TXTATR_FTN(58)
SwTextMeta::ChgTextNode
void ChgTextNode(SwTextNode *const pNode)
Definition: txtatr2.cxx:305
SwNodes::m_pEndOfContent
std::unique_ptr< SwNode > m_pEndOfContent
Definition: ndarr.hxx:108
SwNodes::m_pOutlineNodes
std::unique_ptr< SwOutlineNodes > m_pOutlineNodes
Array of all outline nodes.
Definition: ndarr.hxx:110
SwNodes::GetEndOfContent
SwNode & GetEndOfContent() const
Regular ContentSection (i.e. the BodyText).
Definition: ndarr.hxx:163
SwNodes::MakeTextSection
SwStartNode * MakeTextSection(const SwNodeIndex &rWhere, SwStartNodeType eSttNdTyp, SwTextFormatColl *pColl)
Definition: nodes.cxx:1884
lcl_HighestLevel
static bool lcl_HighestLevel(const SwNodePtr &rpNode, void *pPara)
Definition: nodes.cxx:1390
SwNode::IsContentNode
bool IsContentNode() const
Definition: node.hxx:636
SwPaM
PaM is Point and Mark: a selection of the document model.
Definition: pam.hxx:136
SwTextNode::RemoveFromList
void RemoveFromList()
Definition: ndtxt.cxx:4299
xmlTextWriterPtr
struct _xmlTextWriter * xmlTextWriterPtr
SwDoc::FindNumRulePtr
SwNumRule * FindNumRulePtr(const OUString &rName) const
Definition: docnum.cxx:2414
GetStartNode
static SwNodePtr GetStartNode(SwOutlineNodes const *pOutlNds, int nOutlineLevel, SwOutlineNodes::size_type *nOutl)
Definition: docglbl.cxx:89
RES_TXTATR_FIELD
constexpr TypedWhichId< SwFormatField > RES_TXTATR_FIELD(RES_TXTATR_NOEND_BEGIN)
BlockInfo::nStart
sal_uLong nStart
Definition: bparr.hxx:60
SwFrameFormat
Style of a layout element.
Definition: frmfmt.hxx:57
BigPtrArray::m_ppInf
std::unique_ptr< BlockInfo *[]> m_ppInf
block info
Definition: bparr.hxx:68
SwpHints::Count
size_t Count() const
Definition: ndhints.hxx:142
SwNodes::SectionDown
void SectionDown(SwNodeRange *pRange, SwStartNodeType=SwNormalStartNode)
create a start/end section pair
Definition: nodes.cxx:899
SvtBroadcaster::Broadcast
void Broadcast(const SfxHint &rHint)
SwpHints::Get
SwTextAttr * Get(size_t nPos) const
Definition: ndhints.hxx:144
i
int i
SwNode::GetEndNode
SwEndNode * GetEndNode()
Definition: node.hxx:591
SwNode::StartOfSectionNode
const SwStartNode * StartOfSectionNode() const
Definition: node.hxx:131
SwNodes::ForEach
void ForEach(FnForEach_SwNodes fnForEach, void *pArgs=nullptr)
Definition: ndarr.hxx:143
SwNode::GetDoc
SwDoc & GetDoc()
Definition: node.hxx:211
SwIndex::Assign
SwIndex & Assign(SwIndexReg *, sal_Int32)
Definition: index.cxx:206
BigPtrArray::Insert
void Insert(BigPtrEntry *p, sal_uLong pos)
Definition: bparr.cxx:201
SwSection::IsHidden
bool IsHidden() const
Definition: section.hxx:178
SwNodes::GoStartOfSection
static void GoStartOfSection(SwNodeIndex *)
Definition: nodes.cxx:1260
SwSection::IsHiddenFlag
bool IsHiddenFlag() const
Definition: section.hxx:187
SwNode::GetContentNode
SwContentNode * GetContentNode()
Definition: node.hxx:623
SwPaM::HasMark
bool HasMark() const
A PaM marks a selection if Point and Mark are distinct positions.
Definition: pam.hxx:205
BlockInfo::mvData
std::array< BigPtrEntry *, MAXENTRY > mvData
data block
Definition: bparr.hxx:59
SwIndex
Marks a character position inside a document model node.
Definition: index.hxx:33
SwTextNode::GetNumRule
SwNumRule * GetNumRule(bool bInParent=true) const
Returns numbering rule of this text node.
Definition: ndtxt.cxx:2779
SwStartNodePointers
std::vector< SwStartNode * > SwStartNodePointers
Definition: nodes.cxx:47
SwNode::IsNoTextNode
bool IsNoTextNode() const
Definition: node.hxx:656
SwTableNode::MakeOwnFrames
void MakeOwnFrames(SwNodeIndex *pIdxBehind)
Creates the frms for the table node (i.e. the TabFrames).
Definition: ndtbl.cxx:2397
SwNodeIndex
Marks a node in the document model.
Definition: ndindex.hxx:31
SwNode::IsEndNode
bool IsEndNode() const
Definition: node.hxx:640
SwNode::GetNodes
SwNodes & GetNodes()
Node is in which nodes-array/doc?
Definition: node.hxx:701
static_txtattr_cast
T static_txtattr_cast(S *s)
Definition: txatbase.hxx:237
sw::Ring::GetRingContainer
ring_container GetRingContainer()
Definition: ring.hxx:240
SwNodes::m_vIndices
SwNodeIndex * m_vIndices
ring of all indices on nodes.
Definition: ndarr.hxx:96
SwStartNode::GetStartNodeType
SwStartNodeType GetStartNodeType() const
Definition: node.hxx:328
SwNode::GetStartNode
SwStartNode * GetStartNode()
Definition: node.hxx:599
SwDDEFieldType::DecRefCnt
void DecRefCnt()
Definition: ddefld.hxx:99
SwDoc::getIDocumentLayoutAccess
IDocumentLayoutAccess const & getIDocumentLayoutAccess() const
Definition: doc.cxx:405
SwPaM::Start
const SwPosition * Start() const
Definition: pam.hxx:212
SwField::GetTyp
SwFieldType * GetTyp() const
Definition: fldbas.hxx:396
SwTextNode::DeleteAttribute
void DeleteAttribute(SwTextAttr *const pTextAttr)
delete the attribute pTextAttr
Definition: thints.cxx:1666
SwSection::CalcHiddenFlag
bool CalcHiddenFlag() const
Definition: section.cxx:340
SwNodes::SwNodes
SwNodes(SwNodes const &)=delete
sw::BroadcasterMixin::GetNotifier
SvtBroadcaster & GetNotifier()
Definition: calbck.hxx:95
SwFormat::Which
sal_uInt16 Which() const
for Querying of Writer-functions.
Definition: format.hxx:78
SwNodes::m_rMyDoc
SwDoc & m_rMyDoc
This Doc contains the nodes-array.
Definition: ndarr.hxx:104
SwNodes::SectionUpDown
static void SectionUpDown(const SwNodeIndex &aStart, const SwNodeIndex &aEnd)
correct indices after movement
Definition: nodes.cxx:1024
SwFormatField::IsFieldInDoc
bool IsFieldInDoc() const
Definition: atrfld.cxx:394
SwNode::EndOfSectionIndex
sal_uLong EndOfSectionIndex() const
Definition: node.hxx:685
SwTextNode::CopyCollFormat
void CopyCollFormat(SwTextNode &rDestNd)
Copy collection with all auto formats to dest-node.
Definition: ndcopy.cxx:334
BigPtrArray::operator[]
BigPtrEntry * operator[](sal_uLong) const
Definition: bparr.cxx:82
SwTextNode
SwTextNode is a paragraph in the document model.
Definition: ndtxt.hxx:80
SwNodes::m_pEndOfPostIts
SwNode * m_pEndOfPostIts
Definition: ndarr.hxx:106
SwNodes::dumpAsXml
void dumpAsXml(xmlTextWriterPtr pWriter) const
Dumps the entire nodes structure to the given destination (file nodes.xml in the current directory by...
Definition: nodes.cxx:2325
SwNodes::m_bInNodesDel
bool m_bInNodesDel
In Case of recursive calling.
Definition: ndarr.hxx:112
SwNumRule::SetInvalidRule
void SetInvalidRule(bool bFlag)
Definition: number.cxx:908
SwpHints
An SwTextAttr container, stores all directly formatted text portions for a text node.
Definition: ndhints.hxx:67
SwContentNode::ChkCondColl
void ChkCondColl()
Definition: node.cxx:2004
IDocumentLayoutAccess::GetCurrentViewShell
virtual const SwViewShell * GetCurrentViewShell() const =0
Returns the layout set at the document.
SwNodeIndex::GetNodes
const SwNodes & GetNodes() const
Definition: ndindex.hxx:156
SwNodes::SectionUp
void SectionUp(SwNodeRange *)
increase level of the given range
Definition: nodes.cxx:953
BigPtrEntry::GetPos
sal_uLong GetPos() const
Definition: bparr.hxx:97
SwStartNode::m_pEndOfSection
SwEndNode * m_pEndOfSection
Definition: node.hxx:317
SwIndex::GetIndex
sal_Int32 GetIndex() const
Definition: index.hxx:91
SwDoc::GetNodes
SwNodes & GetNodes()
Definition: doc.hxx:403
SwPaM::End
const SwPosition * End() const
Definition: pam.hxx:217
SwNodeRange::aEnd
SwNodeIndex aEnd
Definition: ndindex.hxx:133
SwNodes::InsertNode
void InsertNode(const SwNodePtr pNode, const SwNodeIndex &rPos)
Definition: nodes.cxx:2282
SwSectionNode::DelFrames
void DelFrames(SwRootFrame const *pLayout=nullptr, bool bForce=false)
Method deletes all views of document for the node.
Definition: ndsect.cxx:1162
SwNodeType::Table
SwTableNode is derived from SwStartNode.
p
void * p
SwDoc::MakeNumRule
sal_uInt16 MakeNumRule(const OUString &rName, const SwNumRule *pCpy=nullptr, bool bBroadcast=false, const SvxNumberFormat::SvxNumPositionAndSpaceMode eDefaultNumberFormatPositionAndSpaceMode=SvxNumberFormat::LABEL_WIDTH_AND_POSITION)
Definition: docnum.cxx:2448
RES_CONDTXTFMTCOLL
constexpr TypedWhichId< SwConditionTextFormatColl > RES_CONDTXTFMTCOLL(158)
RES_TXTATR_TOXMARK
constexpr TypedWhichId< SwTOXMark > RES_TXTATR_TOXMARK(47)
SwNodes::m_pEndOfAutotext
SwNode * m_pEndOfAutotext
Definition: ndarr.hxx:106
RES_TXTATR_INPUTFIELD
constexpr TypedWhichId< SwFormatField > RES_TXTATR_INPUTFIELD(55)
SwStartNodeType
SwStartNodeType
Definition: ndtyp.hxx:50
SwNode::FindTableBoxStartNode
const SwStartNode * FindTableBoxStartNode() const
Definition: node.hxx:196
SwContentNode::InvalidateNumRule
bool InvalidateNumRule()
Invalidates NumRule at the node.
Definition: node.cxx:1177
SwNode::FindTableNode
SwTableNode * FindTableNode()
Search table node, in which it is.
Definition: node.cxx:352
BigPtrArray::Remove
void Remove(sal_uLong pos, sal_uLong n=1)
Definition: bparr.cxx:306
IDocumentContentOperations::SplitNode
virtual bool SplitNode(const SwPosition &rPos, bool bChkTableStart)=0
Split a node at rPos (implemented only for TextNode).
SwTextAttr::GetAttr
const SfxPoolItem & GetAttr() const
Definition: txatbase.hxx:159
GetEndNode
static SwNodePtr GetEndNode(SwOutlineNodes const *pOutlNds, int nOutlineLevel, SwOutlineNodes::size_type *nOutl)
Definition: docglbl.cxx:103
SwNodes::GoNextSection
SwContentNode * GoNextSection(SwNodeIndex *, bool bSkipHidden=true, bool bSkipProtect=true) const
Go to next content-node that is not protected or hidden (Both set FALSE ==> GoNext/GoPrevious!!!).
Definition: nodes.cxx:1907
SwNodes::IsDocNodes
bool IsDocNodes() const
Is the NodesArray the regular one of Doc? (and not the UndoNds, ...) Implementation in doc...
Definition: nodes.cxx:2320
SwNode::IsTableNode
bool IsTableNode() const
Definition: node.hxx:648
SwNode::GetSectionNode
SwSectionNode * GetSectionNode()
Definition: node.hxx:615
SwNodes::CopyNodes
void CopyNodes(const SwNodeRange &, const SwNodeIndex &, bool bNewFrames, bool bTableInsDummyNode=false) const
Definition: nodes.cxx:1651
SwEndNode
Ends a section of nodes in the document model.
Definition: node.hxx:341
RES_TXTATR_REFMARK
constexpr TypedWhichId< SwFormatRefMark > RES_TXTATR_REFMARK(RES_TXTATR_WITHEND_BEGIN)
SwNode::GetSectionLevel
sal_uInt16 GetSectionLevel() const
Returns the section level at the position given by aIndex.
Definition: node.cxx:267
SwNodes::GetEndOfRedlines
SwNode & GetEndOfRedlines() const
Section for all Redlines.
Definition: ndarr.hxx:158
SwNodes::m_bInDelUpdOutline
bool m_bInDelUpdOutline
Flag for updating of Outline.
Definition: ndarr.hxx:114
o3tl::sorted_vector< SwNode *, CompareSwOutlineNodes >::size_type
std::vector< SwNode * >::size_type size_type
SwPlaceholderNode
This class is internal, used only during DocumentContentOperationsManager::CopyWithFlyInFly(), and for undo.
Definition: node.hxx:584
SwNode::IsTextNode
bool IsTextNode() const
Definition: node.hxx:644
SwFieldType::Which
SwFieldIds Which() const
Definition: fldbas.hxx:272
SwNodes::FindPrvNxtFrameNode
SwNode * FindPrvNxtFrameNode(SwNodeIndex &rFrameIdx, const SwNode *pEnd) const
Search previous / next content node or table node with frames.
Definition: nodes.cxx:2026
SwNodes::GoNext
SwContentNode * GoNext(SwNodeIndex *) const
Definition: nodes.cxx:1284
SwDDEFieldType::IncRefCnt
void IncRefCnt()
Definition: ddefld.hxx:98
nPos
sal_uInt16 nPos
SwNodes::RemoveNode
void RemoveNode(sal_uLong nDelPos, sal_uLong nLen, bool bDel)
Definition: nodes.cxx:2186
SwNode::GetTextNode
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
Definition: ndtxt.hxx:844
SwNodes::SwNodeIndex
friend class SwNodeIndex
Definition: ndarr.hxx:92
SwNodes::MakeTextNode
SwTextNode * MakeTextNode(const SwNodeIndex &rWhere, SwTextFormatColl *pColl, bool bNewFrames=true)
Implementations of "Make...Node" are in the given .cxx-files.
Definition: ndtxt.cxx:105
SwNodes::MoveNodes
bool MoveNodes(const SwNodeRange &, SwNodes &rNodes, const SwNodeIndex &, bool bNewFrames=true)
move the node pointer
Definition: nodes.cxx:394
SwNodes::m_pEndOfRedlines
SwNode * m_pEndOfRedlines
Definition: ndarr.hxx:106
SwNodes::MakeEmptySection
static SwStartNode * MakeEmptySection(const SwNodeIndex &rIdx, SwStartNodeType=SwNormalStartNode)
Create an empty section of Start- and EndNote.
Definition: nodes.cxx:1876
SwNode
Base class of the Writer document model elements.
Definition: node.hxx:79
SwTextNode::GetTextColl
SwTextFormatColl * GetTextColl() const
Definition: ndtxt.hxx:838
SwNodes::MoveRange
void MoveRange(SwPaM &, SwPosition &, SwNodes &rNodes)
move a range
Definition: nodes.cxx:1423
Generated on Mon Oct 26 2020 00:26:11 for LibreOffice Module sw (master) by   doxygen 1.8.10