1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26
27 #include <stdlib.h>
28
29 #include <node.hxx>
30 #include <doc.hxx>
31 #include <IDocumentUndoRedo.hxx>
32 #include <pam.hxx>
33 #include <txtfld.hxx>
34 #include <fmtfld.hxx>
35 #include <hints.hxx>
36 #include <numrule.hxx>
37 #include <ndtxt.hxx>
38 #include <ndnotxt.hxx>
39 #include <swtable.hxx> // fuer erzuegen / loeschen der Table-Frames
40 #include <tblsel.hxx>
41 #include <section.hxx>
42 #include <ddefld.hxx>
43 #include <swddetbl.hxx>
44 #include <frame.hxx>
45 #include <txtatr.hxx>
46 #include <tox.hxx> // InvalidateTOXMark
47
48 #include <docsh.hxx>
49 #include <svl/smplhint.hxx>
50
51 extern sal_Bool CheckNodesRange( const SwNodeIndex& rStt,
52 const SwNodeIndex& rEnd, sal_Bool bChkSection );
53
54 SV_DECL_PTRARR(SwSttNdPtrs,SwStartNode*,2,2)
55
56
57 //#define JP_DEBUG
58 #ifdef JP_DEBUG
59 #include "shellio.hxx"
60 #endif
61
62
63 // Funktion zum bestimmen des hoechsten Levels innerhalb des Bereiches
64
65 sal_uInt16 HighestLevel( SwNodes & rNodes, const SwNodeRange & rRange );
66
67 //-----------------------------------------------------------------------
68
69 /*******************************************************************
70 |* SwNodes::SwNodes
71 |*
72 |* Beschreibung
73 |* Konstruktor; legt die vier Grundsektions (PostIts,
74 |* Inserts, Icons, Inhalt) an
75 *******************************************************************/
SwNodes(SwDoc * pDocument)76 SwNodes::SwNodes( SwDoc* pDocument )
77 : pRoot( 0 ), pMyDoc( pDocument )
78 {
79 bInNodesDel = bInDelUpdOutl = bInDelUpdNum = sal_False;
80
81 ASSERT( pMyDoc, "in welchem Doc stehe ich denn?" );
82
83 sal_uLong nPos = 0;
84 SwStartNode* pSttNd = new SwStartNode( *this, nPos++ );
85 pEndOfPostIts = new SwEndNode( *this, nPos++, *pSttNd );
86
87 SwStartNode* pTmp = new SwStartNode( *this, nPos++ );
88 pEndOfInserts = new SwEndNode( *this, nPos++, *pTmp );
89
90 pTmp = new SwStartNode( *this, nPos++ );
91 pTmp->pStartOfSection = pSttNd;
92 pEndOfAutotext = new SwEndNode( *this, nPos++, *pTmp );
93
94 pTmp = new SwStartNode( *this, nPos++ );
95 pTmp->pStartOfSection = pSttNd;
96 pEndOfRedlines = new SwEndNode( *this, nPos++, *pTmp );
97
98 pTmp = new SwStartNode( *this, nPos++ );
99 pTmp->pStartOfSection = pSttNd;
100 pEndOfContent = new SwEndNode( *this, nPos++, *pTmp );
101
102 pOutlineNds = new SwOutlineNodes;
103 }
104
105 /*******************************************************************
106 |*
107 |* SwNodes::~SwNodes
108 |*
109 |* Beschreibung
110 |* dtor, loescht alle Nodes, deren Pointer in diesem dynamischen
111 |* Array sind. Ist kein Problem, da Nodes ausserhalb dieses
112 |* Arrays nicht erzeugt werden koennen und somit auch nicht
113 |* in mehreren drin sein koennen
114 |*
115 |* Ersterstellung
116 |* VER0100 vb 901214
117 |*
118 |* Stand
119 |* VER0100 vb 901214
120 |*
121 *******************************************************************/
122
~SwNodes()123 SwNodes::~SwNodes()
124 {
125 delete pOutlineNds;
126
127 {
128 SwNode *pNode;
129 SwNodeIndex aNdIdx( *this );
130 while( sal_True )
131 {
132 pNode = &aNdIdx.GetNode();
133 if( pNode == pEndOfContent )
134 break;
135
136 aNdIdx++;
137 delete pNode;
138 }
139 }
140
141 // jetzt muessen alle SwNodeIndizies abgemeldet sein!!!
142 delete pEndOfContent;
143 }
144
ChgNode(SwNodeIndex & rDelPos,sal_uLong nSz,SwNodeIndex & rInsPos,sal_Bool bNewFrms)145 void SwNodes::ChgNode( SwNodeIndex& rDelPos, sal_uLong nSz,
146 SwNodeIndex& rInsPos, sal_Bool bNewFrms )
147 {
148 // im UndoBereich brauchen wir keine Frames
149 SwNodes& rNds = rInsPos.GetNodes();
150 const SwNode* pPrevInsNd = rNds[ rInsPos.GetIndex() -1 ];
151
152 //JP 03.02.99: alle Felder als invalide erklaeren, aktu. erfolgt im
153 // Idle-Handler des Docs
154 if( GetDoc()->SetFieldsDirty( sal_True, &rDelPos.GetNode(), nSz ) &&
155 rNds.GetDoc() != GetDoc() )
156 rNds.GetDoc()->SetFieldsDirty( true, NULL, 0 );
157
158 //JP 12.03.99: 63293 - Nodes vom RedlineBereich NIE aufnehmen
159 sal_uLong nNd = rInsPos.GetIndex();
160 sal_Bool bInsOutlineIdx = !(
161 rNds.GetEndOfRedlines().StartOfSectionNode()->GetIndex() < nNd &&
162 nNd < rNds.GetEndOfRedlines().GetIndex() );
163
164 if( &rNds == this ) // im gleichen Nodes-Array -> moven !!
165 {
166 // wird von vorne nach hinten gemovt, so wird nach vorne immer
167 // nachgeschoben, d.H. die Loeschposition ist immer gleich
168 sal_uInt16 nDiff = rDelPos.GetIndex() < rInsPos.GetIndex() ? 0 : 1;
169
170 for( sal_uLong n = rDelPos.GetIndex(); nSz; n += nDiff, --nSz )
171 {
172 SwNodeIndex aDelIdx( *this, n );
173 SwNode& rNd = aDelIdx.GetNode();
174
175 // --> OD 2005-11-16 #i57920#
176 // correction of refactoring done by cws swnumtree:
177 // - <SwTxtNode::SetLevel( NO_NUMBERING ) is deprecated and
178 // set <IsCounted> state of the text node to <false>, which
179 // isn't correct here.
180 if ( rNd.IsTxtNode() )
181 {
182 SwTxtNode* pTxtNode = rNd.GetTxtNode();
183 pTxtNode->RemoveFromList();
184
185 //if ( pTxtNode->GetTxtColl()->GetOutlineLevel() != NO_NUMBERING )//#outline level,zhaojianwei
186 if ( pTxtNode->GetAttrOutlineLevel() != 0 )//<-end,zhaojianwei
187 {
188 const SwNodePtr pSrch = (SwNodePtr)&rNd;
189 pOutlineNds->Remove( pSrch );
190 }
191 }
192 // <--
193
194 BigPtrArray::Move( aDelIdx.GetIndex(), rInsPos.GetIndex() );
195
196 if( rNd.IsTxtNode() )
197 {
198 SwTxtNode& rTxtNd = (SwTxtNode&)rNd;
199 rTxtNd.AddToList();
200
201 if( bInsOutlineIdx &&
202 //NO_NUMBERING != rTxtNd.GetTxtColl()->GetOutlineLevel() )//#outline level,zhaojianwei
203 0 != rTxtNd.GetAttrOutlineLevel() )//<-end,zhaojianwei
204 {
205 const SwNodePtr pSrch = (SwNodePtr)&rNd;
206 pOutlineNds->Insert( pSrch );
207 }
208 rTxtNd.InvalidateNumRule();
209
210 //FEATURE::CONDCOLL
211 if( RES_CONDTXTFMTCOLL == rTxtNd.GetTxtColl()->Which() )
212 rTxtNd.ChkCondColl();
213 //FEATURE::CONDCOLL
214 }
215 else if( rNd.IsCntntNode() )
216 ((SwCntntNode&)rNd).InvalidateNumRule();
217 }
218 }
219 else
220 {
221 bool bSavePersData(GetDoc()->GetIDocumentUndoRedo().IsUndoNodes(rNds));
222 bool bRestPersData(GetDoc()->GetIDocumentUndoRedo().IsUndoNodes(*this));
223 SwDoc* pDestDoc = rNds.GetDoc() != GetDoc() ? rNds.GetDoc() : 0;
224 OSL_ENSURE(!pDestDoc, "SwNodes::ChgNode(): "
225 "the code to handle text fields here looks broken\n"
226 "if the target is in a different document.");
227 if( !bRestPersData && !bSavePersData && pDestDoc )
228 bSavePersData = bRestPersData = sal_True;
229
230 String sNumRule;
231 SwNodeIndex aInsPos( rInsPos );
232 for( sal_uLong n = 0; n < nSz; n++ )
233 {
234 SwNode* pNd = &rDelPos.GetNode();
235
236 // NoTextNode muessen ihre Persitenten Daten mitnehmen
237 if( pNd->IsNoTxtNode() )
238 {
239 if( bSavePersData )
240 ((SwNoTxtNode*)pNd)->SavePersistentData();
241 }
242 else if( pNd->IsTxtNode() )
243 {
244 SwTxtNode* pTxtNd = (SwTxtNode*)pNd;
245
246 // loesche die Gliederungs-Indizies aus dem alten Nodes-Array
247 //if( NO_NUMBERING != pTxtNd->GetTxtColl()->GetOutlineLevel() )//#outline level,zhaojianwei
248 if( 0 != pTxtNd->GetAttrOutlineLevel() )//<-end,zhaojianwei
249 pOutlineNds->Remove( pNd );
250
251 // muss die Rule kopiere werden?
252 if( pDestDoc )
253 {
254 const SwNumRule* pNumRule = pTxtNd->GetNumRule();
255 if( pNumRule && sNumRule != pNumRule->GetName() )
256 {
257 sNumRule = pNumRule->GetName();
258 SwNumRule* pDestRule = pDestDoc->FindNumRulePtr( sNumRule );
259 if( pDestRule )
260 pDestRule->SetInvalidRule( sal_True );
261 else
262 pDestDoc->MakeNumRule( sNumRule, pNumRule );
263 }
264 }
265 else
266 // wenns ins UndoNodes-Array gemoved wird, sollten die
267 // Numerierungen auch aktualisiert werden.
268 pTxtNd->InvalidateNumRule();
269
270 pTxtNd->RemoveFromList();
271 }
272
273 RemoveNode( rDelPos.GetIndex(), 1, sal_False ); // Indizies verschieben !!
274 SwCntntNode * pCNd = pNd->GetCntntNode();
275 rNds.InsertNode( pNd, aInsPos );
276
277 if( pCNd )
278 {
279 SwTxtNode* pTxtNd = pCNd->GetTxtNode();
280 if( pTxtNd )
281 {
282 SwpHints * const pHts = pTxtNd->GetpSwpHints();
283 // setze die OultineNodes im neuen Nodes-Array
284 //if( bInsOutlineIdx && NO_NUMBERING != //#outline level,removed by zhaojianwei
285 // pTxtNd->GetTxtColl()->GetOutlineLevel() )
286 if( bInsOutlineIdx &&
287 0 != pTxtNd->GetAttrOutlineLevel() ) //#outline level,added by zhaojianwei
288 {
289 rNds.pOutlineNds->Insert( pTxtNd );
290 }
291
292 pTxtNd->AddToList();
293
294 // Sonderbehandlung fuer die Felder!
295 if( pHts && pHts->Count() )
296 {
297 // this looks fishy if pDestDoc != 0
298 bool const bToUndo = !pDestDoc &&
299 GetDoc()->GetIDocumentUndoRedo().IsUndoNodes(rNds);
300 for( sal_uInt16 i = pHts->Count(); i; )
301 {
302 sal_uInt16 nDelMsg = 0;
303 SwTxtAttr * const pAttr = pHts->GetTextHint( --i );
304 switch ( pAttr->Which() )
305 {
306 case RES_TXTATR_FIELD:
307 case RES_TXTATR_ANNOTATION:
308 case RES_TXTATR_INPUTFIELD:
309 {
310 SwTxtFld* pTxtFld = static_cast<SwTxtFld*>(pAttr);
311 rNds.GetDoc()->InsDelFldInFldLst( !bToUndo, *pTxtFld );
312
313 const SwFieldType* pTyp = pTxtFld->GetFmtFld().GetField()->GetTyp();
314 if ( RES_POSTITFLD == pTyp->Which() )
315 {
316 rNds.GetDoc()->GetDocShell()->Broadcast(
317 SwFmtFldHint(
318 &pTxtFld->GetFmtFld(),
319 ( pTxtFld->GetFmtFld().IsFldInDoc()
320 ? SWFMTFLD_INSERTED
321 : SWFMTFLD_REMOVED ) ) );
322 }
323 else
324 if( RES_DDEFLD == pTyp->Which() )
325 {
326 if( bToUndo )
327 ((SwDDEFieldType*)pTyp)->DecRefCnt();
328 else
329 ((SwDDEFieldType*)pTyp)->IncRefCnt();
330 }
331 nDelMsg = RES_FIELD_DELETED;
332 }
333 break;
334
335 case RES_TXTATR_FTN:
336 nDelMsg = RES_FOOTNOTE_DELETED;
337 break;
338
339 case RES_TXTATR_TOXMARK:
340 static_cast<SwTOXMark&>(pAttr->GetAttr())
341 .InvalidateTOXMark();
342 break;
343
344 case RES_TXTATR_REFMARK:
345 nDelMsg = RES_REFMARK_DELETED;
346 break;
347
348 case RES_TXTATR_META:
349 case RES_TXTATR_METAFIELD:
350 {
351 SwTxtMeta *const pTxtMeta(
352 static_cast<SwTxtMeta*>(pAttr));
353 // force removal of UNO object
354 pTxtMeta->ChgTxtNode(0);
355 pTxtMeta->ChgTxtNode(pTxtNd);
356 }
357 break;
358
359 default:
360 break;
361 }
362
363 if( nDelMsg && bToUndo )
364 {
365 SwPtrMsgPoolItem aMsgHint( nDelMsg,
366 (void*)&pAttr->GetAttr() );
367 rNds.GetDoc()->GetUnoCallBack()->
368 ModifyNotification( &aMsgHint, &aMsgHint );
369 }
370 }
371 }
372 //FEATURE::CONDCOLL
373 if( RES_CONDTXTFMTCOLL == pTxtNd->GetTxtColl()->Which() )
374 pTxtNd->ChkCondColl();
375 //FEATURE::CONDCOLL
376 }
377 else
378 {
379 // in unterschiedliche Docs gemoved ?
380 // dann die Daten wieder persistent machen
381 if( pCNd->IsNoTxtNode() && bRestPersData )
382 ((SwNoTxtNode*)pCNd)->RestorePersistentData();
383 }
384 }
385 }
386 }
387
388 //JP 03.02.99: alle Felder als invalide erklaeren, aktu. erfolgt im
389 // Idle-Handler des Docs
390 GetDoc()->SetFieldsDirty( true, NULL, 0 );
391 if( rNds.GetDoc() != GetDoc() )
392 rNds.GetDoc()->SetFieldsDirty( true, NULL, 0 );
393
394
395 if( bNewFrms )
396 bNewFrms = &GetDoc()->GetNodes() == (const SwNodes*)&rNds &&
397 GetDoc()->GetCurrentViewShell(); //swmod 071108//swmod 071225
398 if( bNewFrms )
399 {
400 // Frames besorgen:
401 SwNodeIndex aIdx( *pPrevInsNd, 1 );
402 SwNodeIndex aFrmNdIdx( aIdx );
403 SwNode* pFrmNd = rNds.FindPrvNxtFrmNode( aFrmNdIdx,
404 rNds[ rInsPos.GetIndex() - 1 ] );
405
406 if( !pFrmNd && aFrmNdIdx > rNds.GetEndOfExtras().GetIndex() )
407 {
408 ASSERT( sal_False, "if that is correct ??" );
409 aFrmNdIdx = rNds.GetEndOfContent();
410 pFrmNd = rNds.GoPrevSection( &aFrmNdIdx, sal_True, sal_False );
411 if( pFrmNd && !((SwCntntNode*)pFrmNd)->GetDepends() )
412 pFrmNd = 0;
413
414 #ifdef DBG_UTIL
415 if( !pFrmNd )
416 ASSERT( sal_False, "ChgNode() - no FrameNode found" );
417 #endif
418 }
419 if( pFrmNd )
420 while( aIdx != rInsPos )
421 {
422 SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode();
423 if( pCNd )
424 {
425 if( pFrmNd->IsTableNode() )
426 ((SwTableNode*)pFrmNd)->MakeFrms( aIdx );
427 else if( pFrmNd->IsSectionNode() )
428 ((SwSectionNode*)pFrmNd)->MakeFrms( aIdx );
429 else
430 ((SwCntntNode*)pFrmNd)->MakeFrms( *pCNd );
431 pFrmNd = pCNd;
432 }
433 aIdx++;
434 }
435 }
436 }
437
438
439 /***********************************************************************
440 |*
441 |* SwNodes::Move
442 |*
443 |* Beschreibung
444 |* Move loescht die Node-Pointer ab und einschliesslich der Startposition
445 |* bis zu und ausschliesslich der Endposition und fuegt sie an
446 |* der vor der Zielposition ein.
447 |* Wenn das Ziel vor dem ersten oder dem letzten zu bewegenden Element oder
448 |* dazwischen liegt, geschieht nichts.
449 |* Wenn der zu bewegende Bereich leer ist oder das Ende vor
450 |* dem Anfang liegt, geschieht nichts.
451 |*
452 |* Allg.: aRange beschreibt den Bereich -exklusive- aEnd !!
453 |* ( 1.Node: aStart, letzer Node: aEnd-1 !! )
454 |*
455 |*
456 |*
457 ***********************************************************************/
458
_MoveNodes(const SwNodeRange & aRange,SwNodes & rNodes,const SwNodeIndex & aIndex,sal_Bool bNewFrms)459 sal_Bool SwNodes::_MoveNodes( const SwNodeRange& aRange, SwNodes & rNodes,
460 const SwNodeIndex& aIndex, sal_Bool bNewFrms )
461 {
462 SwNode * pAktNode;
463 if( aIndex == 0 ||
464 ( (pAktNode = &aIndex.GetNode())->GetStartNode() &&
465 !pAktNode->StartOfSectionIndex() ))
466 return sal_False;
467
468 SwNodeRange aRg( aRange );
469
470 // "einfache" StartNodes oder EndNodes ueberspringen
471 while( ND_STARTNODE == (pAktNode = &aRg.aStart.GetNode())->GetNodeType()
472 || ( pAktNode->IsEndNode() &&
473 !pAktNode->pStartOfSection->IsSectionNode() ) )
474 aRg.aStart++;
475 aRg.aStart--;
476
477 // falls aEnd-1 auf keinem ContentNode steht, dann suche den vorherigen
478 aRg.aEnd--;
479 while( ( (( pAktNode = &aRg.aEnd.GetNode())->GetStartNode() &&
480 !pAktNode->IsSectionNode() ) ||
481 ( pAktNode->IsEndNode() &&
482 ND_STARTNODE == pAktNode->pStartOfSection->GetNodeType()) ) &&
483 aRg.aEnd > aRg.aStart )
484 aRg.aEnd--;
485
486
487 // wird im selben Array's verschoben, dann ueberpruefe die Einfuegepos.
488 if( aRg.aStart >= aRg.aEnd )
489 return sal_False;
490
491 if( this == &rNodes )
492 {
493 if( ( aIndex.GetIndex()-1 >= aRg.aStart.GetIndex() &&
494 aIndex.GetIndex()-1 < aRg.aEnd.GetIndex()) ||
495 ( aIndex.GetIndex()-1 == aRg.aEnd.GetIndex() ) )
496 return sal_False;
497 }
498
499 sal_uInt16 nLevel = 0; // Level-Counter
500 sal_uLong nInsPos = 0; // Cnt fuer das TmpArray
501
502 // das Array bildet einen Stack, es werden alle StartOfSelction's gesichert
503 SwSttNdPtrs aSttNdStack( 1, 5 );
504
505 // setze den Start-Index
506 SwNodeIndex aIdx( aIndex );
507 /*
508 --- JP 17.11.94: sollte ueberholt sein, wird im ChgNode schon erledigt!
509 sal_Bool bCorrNum = pSect && pSect->aStart.GetIndex() == aIdx.GetIndex();
510 */
511
512 SwStartNode* pStartNode = aIdx.GetNode().pStartOfSection;
513 aSttNdStack.C40_INSERT( SwStartNode, pStartNode, 0 );
514 // aSttNdStack.Insert( rNodes[ aIdx ]->pStartOfSection, 0 );
515 SwNodeRange aOrigInsPos( aIdx, -1, aIdx ); // Originale Insert Pos
516
517 //JP 16.01.98: SectionNodes: DelFrms/MakeFrms beim obersten SectionNode!
518 sal_uInt16 nSectNdCnt = 0;
519 sal_Bool bSaveNewFrms = bNewFrms;
520
521 // Check that the range of nodes to move is valid.
522 // This is a very specific test that only checks that table nodes
523 // are completely covered by the range. Issue 121479 has a
524 // document for which this test fails.
525 SwNodeIndex aNodeIndex (aRg.aEnd);
526 while (aNodeIndex > aRg.aStart)
527 {
528 SwNode& rNode (aNodeIndex.GetNode());
529 if (rNode.GetNodeType() != ND_ENDNODE)
530 break;
531 SwStartNode* pStartNode = rNode.pStartOfSection;
532 if (pStartNode==NULL)
533 break;
534 if ( ! pStartNode->IsTableNode())
535 break;
536 aNodeIndex = *pStartNode;
537 if (aNodeIndex < aRg.aStart.GetIndex())
538 {
539 return sal_False;
540 }
541 --aNodeIndex;
542 }
543
544
545 // bis alles verschoben ist
546 while( aRg.aStart < aRg.aEnd )
547 switch( (pAktNode = &aRg.aEnd.GetNode())->GetNodeType() )
548 {
549 case ND_ENDNODE:
550 {
551 if( nInsPos ) // verschieb schon mal alle bis hier her
552 {
553 // loeschen und kopieren. ACHTUNG: die Indizies ab
554 // "aRg.aEnd+1" werden mit verschoben !!
555 SwNodeIndex aSwIndex( aRg.aEnd, 1 );
556 ChgNode( aSwIndex, nInsPos, aIdx, bNewFrms );
557 aIdx -= nInsPos;
558 nInsPos = 0;
559 }
560
561 SwStartNode* pSttNd = pAktNode->pStartOfSection;
562 if( pSttNd->IsTableNode() )
563 {
564 SwTableNode* pTblNd = (SwTableNode*)pSttNd;
565
566 // dann bewege die gesamte Tabelle/den Bereich !!
567 nInsPos = (aRg.aEnd.GetIndex() -
568 pSttNd->GetIndex() )+1;
569 aRg.aEnd -= nInsPos;
570
571 //JP 12.03.99: 63293 - Nodes vom RedlineBereich NIE aufnehmen
572 sal_uLong nNd = aIdx.GetIndex();
573 sal_Bool bInsOutlineIdx = !( rNodes.GetEndOfRedlines().
574 StartOfSectionNode()->GetIndex() < nNd &&
575 nNd < rNodes.GetEndOfRedlines().GetIndex() );
576
577 if( bNewFrms )
578 // loesche erstmal die Frames
579 pTblNd->DelFrms();
580 if( &rNodes == this ) // in sich selbst moven ??
581 {
582 // dann bewege alle Start/End/ContentNodes. Loesche
583 // bei den ContentNodes auch die Frames !!
584 pTblNd->pStartOfSection = aIdx.GetNode().pStartOfSection;
585 for( sal_uLong n = 0; n < nInsPos; ++n )
586 {
587 SwNodeIndex aMvIdx( aRg.aEnd, 1 );
588 SwCntntNode* pCNd = 0;
589 SwNode* pTmpNd = &aMvIdx.GetNode();
590 if( pTmpNd->IsCntntNode() )
591 {
592 pCNd = (SwCntntNode*)pTmpNd;
593 if( pTmpNd->IsTxtNode() )
594 ((SwTxtNode*)pTmpNd)->RemoveFromList();
595
596 // if( bNewFrms )
597 // pCNd->DelFrms();
598
599 // setze bei Start/EndNodes die richtigen Indizies
600 // loesche die Gliederungs-Indizies aus
601 // dem alten Nodes-Array
602 //if( pCNd->IsTxtNode() && NO_NUMBERING != //#outline level,zhaojianwei
603 // ((SwTxtNode*)pCNd)->GetTxtColl()->GetOutlineLevel() )
604 if( pCNd->IsTxtNode() && 0 !=
605 ((SwTxtNode*)pCNd)->GetAttrOutlineLevel() )//<-end,by zhaojianwei
606 pOutlineNds->Remove( pCNd );
607 else
608 pCNd = 0;
609 }
610 // else if( bNewFrms && pTmpNd->IsSectionNode() )
611 // ((SwSectionNode*)pTmpNd)->DelFrms();
612 BigPtrArray::Move( aMvIdx.GetIndex(), aIdx.GetIndex() );
613
614 if( bInsOutlineIdx && pCNd )
615 pOutlineNds->Insert( pCNd );
616 if( pTmpNd->IsTxtNode() )
617 ((SwTxtNode*)pTmpNd)->AddToList();
618 }
619 }
620 else
621 {
622 // StartNode holen
623 // Even aIdx points to a startnode, we need the startnode
624 // of the environment of aIdx (#i80941)
625 SwStartNode* pSttNode = aIdx.GetNode().pStartOfSection;
626
627 // Hole alle Boxen mit Inhalt. Deren Indizies auf die
628 // StartNodes muessen umgemeldet werden !!
629 // (Array kopieren und alle gefunden wieder loeschen;
630 // erleichtert das suchen!!)
631 SwNodeIndex aMvIdx( aRg.aEnd, 1 );
632 for( sal_uLong n = 0; n < nInsPos; ++n )
633 {
634 SwNode* pNd = &aMvIdx.GetNode();
635 /* if( bNewFrms )
636 {
637 if( pNd->IsCntntNode() )
638 ((SwCntntNode*)pNd)->DelFrms();
639 else if( pNd->IsSectionNode() )
640 ((SwSectionNode*)pNd)->DelFrms();
641 }
642 */
643 //sal_Bool bOutlNd = pNd->IsTxtNode() && NO_NUMBERING !=//#outline level,zhaojianwei
644 // ((SwTxtNode*)pNd)->GetTxtColl()->GetOutlineLevel();
645 const bool bOutlNd = pNd->IsTxtNode() &&
646 0 != ((SwTxtNode*)pNd)->GetAttrOutlineLevel();//<-end,zhaojianwei
647 // loesche die Gliederungs-Indizies aus
648 // dem alten Nodes-Array
649 if( bOutlNd )
650 pOutlineNds->Remove( pNd );
651
652 RemoveNode( aMvIdx.GetIndex(), 1, sal_False );
653 pNd->pStartOfSection = pSttNode;
654 rNodes.InsertNode( pNd, aIdx );
655
656 // setze bei Start/EndNodes die richtigen Indizies
657 if( bInsOutlineIdx && bOutlNd )
658 // und setze sie im neuen Nodes-Array
659 rNodes.pOutlineNds->Insert( pNd );
660 else if( pNd->IsStartNode() )
661 pSttNode = (SwStartNode*)pNd;
662 else if( pNd->IsEndNode() )
663 {
664 pSttNode->pEndOfSection = (SwEndNode*)pNd;
665 if( pSttNode->IsSectionNode() )
666 ((SwSectionNode*)pSttNode)->NodesArrChgd();
667 pSttNode = pSttNode->pStartOfSection;
668 }
669 }
670
671 if( pTblNd->GetTable().IsA( TYPE( SwDDETable ) ))
672 {
673 SwDDEFieldType* pTyp = ((SwDDETable&)pTblNd->
674 GetTable()).GetDDEFldType();
675 if( pTyp )
676 {
677 if( rNodes.IsDocNodes() )
678 pTyp->IncRefCnt();
679 else
680 pTyp->DecRefCnt();
681 }
682 }
683
684 if (GetDoc()->GetIDocumentUndoRedo().IsUndoNodes(
685 rNodes))
686 {
687 SwFrmFmt* pTblFmt = pTblNd->GetTable().GetFrmFmt();
688 SwPtrMsgPoolItem aMsgHint( RES_REMOVE_UNO_OBJECT,
689 pTblFmt );
690 pTblFmt->ModifyNotification( &aMsgHint, &aMsgHint );
691 }
692 }
693 if( bNewFrms )
694 {
695 SwNodeIndex aTmp( aIdx );
696 pTblNd->MakeFrms( &aTmp );
697 }
698 aIdx -= nInsPos;
699 nInsPos = 0;
700 }
701 else if( pSttNd->GetIndex() < aRg.aStart.GetIndex() )
702 {
703 // SectionNode: es wird nicht die gesamte Section
704 // verschoben, also bewege nur die
705 // ContentNodes
706 // StartNode: erzeuge an der Postion eine neue Section
707 do { // middle check loop
708 if( !pSttNd->IsSectionNode() )
709 {
710 // Start und EndNode an der InsertPos erzeugen
711 SwStartNode* pTmp = new SwStartNode( aIdx,
712 ND_STARTNODE,
713 /*?? welcher NodeTyp ??*/
714 SwNormalStartNode );
715
716 nLevel++; // den Index auf StartNode auf den Stack
717 aSttNdStack.C40_INSERT( SwStartNode, pTmp, nLevel );
718
719 // noch den EndNode erzeugen
720 new SwEndNode( aIdx, *pTmp );
721 }
722 else if (GetDoc()->GetIDocumentUndoRedo().IsUndoNodes(
723 rNodes))
724 {
725 // im UndoNodes-Array spendieren wir einen
726 // Platzhalter
727 new SwNode( aIdx, ND_SECTIONDUMMY );
728 }
729 else
730 {
731 // JP 18.5.2001: neue Section anlegen?? Bug 70454
732 aRg.aEnd--;
733 break;
734
735 }
736
737 aRg.aEnd--;
738 aIdx--;
739 } while( sal_False );
740 }
741 else
742 {
743 // Start und EndNode komplett verschieben
744 // s. u. SwIndex aOldStt( pSttNd->theIndex );
745 //JP 21.05.97: sollte der Start genau der Start des Bereiches sein, so muss
746 // der Node auf jedenfall noch besucht werden!
747 if( &aRg.aStart.GetNode() == pSttNd )
748 --aRg.aStart;
749
750 SwSectionNode* pSctNd = pSttNd->GetSectionNode();
751 if( bNewFrms && pSctNd )
752 pSctNd->DelFrms();
753
754 RemoveNode( aRg.aEnd.GetIndex(), 1, sal_False ); // EndNode loeschen
755 sal_uLong nSttPos = pSttNd->GetIndex();
756
757 // dieser StartNode wird spaeter wieder entfernt!
758 SwStartNode* pTmpSttNd = new SwStartNode( *this, nSttPos+1 );
759 pTmpSttNd->pStartOfSection = pSttNd->pStartOfSection;
760
761 RemoveNode( nSttPos, 1, sal_False ); // SttNode loeschen
762
763 pSttNd->pStartOfSection = aIdx.GetNode().pStartOfSection;
764 rNodes.InsertNode( pSttNd, aIdx );
765 rNodes.InsertNode( pAktNode, aIdx );
766 aIdx--;
767 pSttNd->pEndOfSection = (SwEndNode*)pAktNode;
768
769 aRg.aEnd--;
770
771 nLevel++; // den Index auf StartNode auf den Stack
772 aSttNdStack.C40_INSERT( SwStartNode, pSttNd, nLevel );
773
774 // SectionNode muss noch ein paar Indizies ummelden
775 if( pSctNd )
776 {
777 pSctNd->NodesArrChgd();
778 ++nSectNdCnt;
779 bNewFrms = sal_False;
780 }
781 }
782 }
783 break;
784
785
786
787 case ND_SECTIONNODE:
788 if( !nLevel &&
789 GetDoc()->GetIDocumentUndoRedo().IsUndoNodes(rNodes))
790 {
791 // dann muss an der akt. InsPos ein SectionDummyNode
792 // eingefuegt werden
793 if( nInsPos ) // verschieb schon mal alle bis hier her
794 {
795 // loeschen und kopieren. ACHTUNG: die Indizies ab
796 // "aRg.aEnd+1" werden mit verschoben !!
797 SwNodeIndex aSwIndex( aRg.aEnd, 1 );
798 ChgNode( aSwIndex, nInsPos, aIdx, bNewFrms );
799 aIdx -= nInsPos;
800 nInsPos = 0;
801 }
802 new SwNode( aIdx, ND_SECTIONDUMMY );
803 aRg.aEnd--;
804 aIdx--;
805 break;
806 }
807 // kein break !!
808 case ND_TABLENODE:
809 case ND_STARTNODE:
810 {
811 // Bug #78589# - empty section -> nothing to do
812 // and only if it's a top level section
813 if( !nInsPos && !nLevel )
814 {
815 aRg.aEnd--;
816 break;
817 }
818
819 if( !nLevel ) // es wird eine Stufe runter gestuft
820 {
821 // erzeuge die Runterstufung
822 SwNodeIndex aTmpSIdx( aOrigInsPos.aStart, 1 );
823 SwStartNode* pTmpStt = new SwStartNode( aTmpSIdx,
824 ND_STARTNODE,
825 ((SwStartNode*)pAktNode)->GetStartNodeType() );
826
827 aTmpSIdx--;
828
829 SwNodeIndex aTmpEIdx( aOrigInsPos.aEnd );
830 new SwEndNode( aTmpEIdx, *pTmpStt );
831 aTmpEIdx--;
832 aTmpSIdx++;
833
834 // setze die StartOfSection richtig
835 aRg.aEnd++;
836 {
837 SwNodeIndex aCntIdx( aRg.aEnd );
838 for( sal_uLong n = 0; n < nInsPos; n++, aCntIdx++)
839 aCntIdx.GetNode().pStartOfSection = pTmpStt;
840 }
841
842 // Setze auch bei allen runtergestuften den richtigen StartNode
843 while( aTmpSIdx < aTmpEIdx )
844 if( 0 != (( pAktNode = &aTmpEIdx.GetNode())->GetEndNode()) )
845 aTmpEIdx = pAktNode->StartOfSectionIndex();
846 else
847 {
848 pAktNode->pStartOfSection = pTmpStt;
849 aTmpEIdx--;
850 }
851
852 aIdx--; // hinter den eingefuegten StartNode
853 aRg.aEnd--; // vor den StartNode
854 // kopiere jetzt das Array. ACHTUNG: die Indizies ab
855 // "aRg.aEnd+1" werden mit verschoben !!
856 SwNodeIndex aSwIndex( aRg.aEnd, 1 );
857 ChgNode( aSwIndex, nInsPos, aIdx, bNewFrms );
858 aIdx -= nInsPos+1;
859 nInsPos = 0;
860 }
861 else // es wurden alle Nodes innerhalb eines
862 { // Start- und End-Nodes verschoben
863 ASSERT( pAktNode == aSttNdStack[nLevel] ||
864 ( pAktNode->IsStartNode() &&
865 aSttNdStack[nLevel]->IsSectionNode()),
866 "falscher StartNode" );
867
868 SwNodeIndex aSwIndex( aRg.aEnd, 1 );
869 ChgNode( aSwIndex, nInsPos, aIdx, bNewFrms );
870 aIdx -= nInsPos+1; // vor den eingefuegten StartNode
871 nInsPos = 0;
872
873 // loesche nur noch den Pointer aus dem Nodes-Array.
874 // RemoveNode( aRg.aEnd.GetIndex(), 1, sal_False );
875 RemoveNode( aRg.aEnd.GetIndex(), 1, sal_True );
876 aRg.aEnd--;
877
878 SwSectionNode* pSectNd = aSttNdStack[ nLevel ]->GetSectionNode();
879 if( pSectNd && !--nSectNdCnt )
880 {
881 SwNodeIndex aTmp( *pSectNd );
882 pSectNd->MakeFrms( &aTmp );
883 bNewFrms = bSaveNewFrms;
884 }
885 aSttNdStack.Remove( nLevel ); // vom Stack loeschen
886 nLevel--;
887 }
888
889 // loesche alle entstehenden leeren Start-/End-Node-Paare
890 SwNode* pTmpNode = (*this)[ aRg.aEnd.GetIndex()+1 ]->GetEndNode();
891 if( pTmpNode && ND_STARTNODE == (pAktNode = &aRg.aEnd.GetNode())
892 ->GetNodeType() && pAktNode->StartOfSectionIndex() &&
893 pTmpNode->StartOfSectionNode() == pAktNode )
894 {
895 DelNodes( aRg.aEnd, 2 );
896 aRg.aEnd--;
897 }
898 // aRg.aEnd--;
899 }
900 break;
901
902 case ND_TEXTNODE:
903 //Solution:Add special function to text node.
904 {
905 if( bNewFrms && pAktNode->GetCntntNode() )
906 ((SwCntntNode*)pAktNode)->DelFrms( sal_False );
907 pAktNode->pStartOfSection = aSttNdStack[ nLevel ];
908 nInsPos++;
909 aRg.aEnd--;
910 }
911 break;
912 case ND_GRFNODE:
913 case ND_OLENODE:
914 {
915 if( bNewFrms && pAktNode->GetCntntNode() )
916 ((SwCntntNode*)pAktNode)->DelFrms();
917
918 pAktNode->pStartOfSection = aSttNdStack[ nLevel ];
919 nInsPos++;
920 aRg.aEnd--;
921 }
922 break;
923
924 case ND_SECTIONDUMMY:
925 if (GetDoc()->GetIDocumentUndoRedo().IsUndoNodes(*this))
926 {
927 if( &rNodes == this ) // innerhalb vom UndoNodesArray
928 {
929 // mit verschieben
930 pAktNode->pStartOfSection = aSttNdStack[ nLevel ];
931 nInsPos++;
932 }
933 else // in ein "normales" Nodes-Array verschieben
934 {
935 // dann muss an der akt. InsPos auch ein SectionNode
936 // (Start/Ende) stehen; dann diesen ueberspringen.
937 // Andernfalls nicht weiter beachten.
938 if( nInsPos ) // verschieb schon mal alle bis hier her
939 {
940 // loeschen und kopieren. ACHTUNG: die Indizies ab
941 // "aRg.aEnd+1" werden mit verschoben !!
942 SwNodeIndex aSwIndex( aRg.aEnd, 1 );
943 ChgNode( aSwIndex, nInsPos, aIdx, bNewFrms );
944 aIdx -= nInsPos;
945 nInsPos = 0;
946 }
947 SwNode* pTmpNd = &aIdx.GetNode();
948 if( pTmpNd->IsSectionNode() ||
949 pTmpNd->StartOfSectionNode()->IsSectionNode() )
950 aIdx--; // ueberspringen
951 }
952 }
953 else {
954 ASSERT( sal_False, "wie kommt diser Node ins Nodes-Array??" );
955 }
956 aRg.aEnd--;
957 break;
958
959 default:
960 ASSERT( sal_False, "was ist das fuer ein Node??" );
961 break;
962 }
963
964 if( nInsPos ) // kopiere den Rest
965 {
966 // der Rest muesste so stimmen
967 SwNodeIndex aSwIndex( aRg.aEnd, 1 );
968 ChgNode( aSwIndex, nInsPos, aIdx, bNewFrms );
969 }
970 aRg.aEnd++; // wieder exklusive Ende
971
972 // loesche alle leeren Start-/End-Node-Paare
973 if( ( pAktNode = &aRg.aStart.GetNode())->GetStartNode() &&
974 pAktNode->StartOfSectionIndex() &&
975 aRg.aEnd.GetNode().GetEndNode() )
976 DelNodes( aRg.aStart, 2 );
977
978 // rufe jetzt noch das Update fuer die Gliederung/Nummerierung auf
979 aOrigInsPos.aStart++;
980 // im gleichen Nodes-Array verschoben ??,
981 // dann von oben nach unten das Update aufrufen !!
982 if( this == &rNodes &&
983 aRg.aEnd.GetIndex() >= aOrigInsPos.aStart.GetIndex() )
984 {
985 UpdtOutlineIdx( aOrigInsPos.aStart.GetNode() );
986 UpdtOutlineIdx( aRg.aEnd.GetNode() );
987 }
988 else
989 {
990 UpdtOutlineIdx( aRg.aEnd.GetNode() );
991 rNodes.UpdtOutlineIdx( aOrigInsPos.aStart.GetNode() );
992 }
993
994 #ifdef JP_DEBUG
995 {
996 extern Writer* GetDebugWriter(const String&);
997
998 Writer* pWriter = GetDebugWriter(aEmptyStr);
999 if( pWriter )
1000 {
1001 int nError;
1002 SvFileStream aStrm( "c:\\$$move.db", STREAM_WRITE );
1003 SwWriter aWriter( aStrm, *pMyDoc );
1004 aWriter.Write( &nError, pWriter );
1005 }
1006 }
1007 #endif
1008
1009 return sal_True;
1010 }
1011
1012
1013 /*******************************************************************
1014 |*
1015 |* SwNodes::SectionDown
1016 |*
1017 |* Beschreibung
1018 |* SectionDown() legt ein Paar von Start- und EndSection-Node
1019 |* (andere Nodes koennen dazwischen liegen) an.
1020 |*
1021 |* Zustand des SRange beim Verlassen der Funktion: nStart ist der
1022 |* Index des ersten Node hinter dem Start Section Node, nEnd ist
1023 |* der Index des End Section Nodes. Beispiel: Wird Insert Section
1024 |* mehrmals hintereinander aufgerufen, so werden mehrere
1025 |* unmittelbar geschachtelte Sections (keine Content Nodes
1026 |* zwischen Start- bzw. End Nodes) angelegt.
1027 |*
1028 |* Allg.: aRange beschreibt den Bereich -exklusive- aEnd !!
1029 |* ( 1.Node: aStart, letzer Node: aEnd-1 !! )
1030 |*
1031 |* Parameter
1032 |* SwRange &rRange
1033 |* IO:
1034 |* IN
1035 |* rRange.aStart: Einfuegeposition des StartNodes
1036 |* rRange.aEnd: Einfuegeposition des EndNodes
1037 |* OUT
1038 |* rRange.aStart: steht hinter dem eingefuegten Startnode
1039 |* rRange.aEnd: steht auf dem eingefuegen Endnode
1040 |*
1041 |* Ausnahmen
1042 |* 1. SRange-Anfang und SRange-Ende muessen auf dem gleichen Level sein
1043 |* 2. duerfen nicht auf dem obersten Level sein
1044 |* Ist dies nicht der Fall, wird die
1045 |* Funktion durch Aufruf von ERR_RAISE verlassen.
1046 |*
1047 |* Debug-Funktionen
1048 |* die Debugging Tools geben rRange beim Eintritt und beim
1049 |* Verlassen der Funktion aus
1050 |*
1051 |* Ersterstellung
1052 |* VER0100 vb 901214
1053 |*
1054 |* Stand
1055 |* VER0100 vb 901214
1056 |*
1057 *******************************************************************/
SectionDown(SwNodeRange * pRange,SwStartNodeType eSttNdTyp)1058 void SwNodes::SectionDown(SwNodeRange *pRange, SwStartNodeType eSttNdTyp )
1059 {
1060 if( pRange->aStart >= pRange->aEnd ||
1061 pRange->aEnd >= Count() ||
1062 !CheckNodesRange( pRange->aStart, pRange->aEnd ))
1063 return;
1064
1065 // Ist der Anfang vom Bereich vor oder auf einem EndNode, so loesche
1066 // diesen, denn sonst wuerden leere S/E-Nodes oder E/S-Nodes enstehen.
1067 // Bei anderen Nodes wird eine neuer StartNode eingefuegt
1068 SwNode * pAktNode = &pRange->aStart.GetNode();
1069 SwNodeIndex aTmpIdx( *pAktNode->StartOfSectionNode() );
1070
1071 if( pAktNode->GetEndNode() )
1072 DelNodes( pRange->aStart, 1 ); // verhinder leere Section
1073 else
1074 {
1075 // fuege einen neuen StartNode ein
1076 SwNode* pSttNd = new SwStartNode( pRange->aStart, ND_STARTNODE, eSttNdTyp );
1077 pRange->aStart = *pSttNd;
1078 aTmpIdx = pRange->aStart;
1079 }
1080
1081 // Ist das Ende vom Bereich vor oder auf einem StartNode, so loesche
1082 // diesen, denn sonst wuerden leere S/E-Nodes oder E/S-Nodes enstehen
1083 // Bei anderen Nodes wird eine neuer EndNode eingefuegt
1084 pRange->aEnd--;
1085 if( pRange->aEnd.GetNode().GetStartNode() )
1086 DelNodes( pRange->aEnd, 1 );
1087 else
1088 {
1089 pRange->aEnd++;
1090 // fuege einen neuen EndNode ein
1091 new SwEndNode( pRange->aEnd, *pRange->aStart.GetNode().GetStartNode() );
1092 }
1093 pRange->aEnd--;
1094
1095 SectionUpDown( aTmpIdx, pRange->aEnd );
1096 }
1097
1098 /*******************************************************************
1099 |*
1100 |* SwNodes::SectionUp
1101 |*
1102 |* Beschreibung
1103 |* Der von rRange umspannte Bereich wird auf die naechst hoehere
1104 |* Ebene gehoben. Das geschieht dadurch, dass bei
1105 |* rRange.aStart ein Endnode und bei rRange.aEnd ein
1106 |* Startnode eingefuegt wird. Die Indices fuer den Bereich
1107 |* innerhalb von rRange werden geupdated.
1108 |*
1109 |* Allg.: aRange beschreibt den Bereich -exklusive- aEnd !!
1110 |* ( 1.Node: aStart, letzer Node: aEnd-1 !! )
1111 |*
1112 |* Parameter
1113 |* SwRange &rRange
1114 |* IO:
1115 |* IN
1116 |* rRange.aStart: Anfang des hoeher zubewegenden Bereiches
1117 |* rRange.aEnd: der 1.Node hinter dem Bereich
1118 |* OUT
1119 |* rRange.aStart: an der ersten Position innerhalb des
1120 |* hochbewegten Bereiches
1121 |* rRange.aEnd: an der letzten Position innerhalb des
1122 |* hochbewegten Bereiches
1123 |*
1124 |* Debug-Funktionen
1125 |* die Debugging Tools geben rRange beim Eintritt und beim
1126 |* Verlassen der Funktion aus
1127 |*
1128 |* Ersterstellung
1129 |* VER0100 vb 901214
1130 |*
1131 |* Stand
1132 |* VER0100 vb 901214
1133 |*
1134 *******************************************************************/
SectionUp(SwNodeRange * pRange)1135 void SwNodes::SectionUp(SwNodeRange *pRange)
1136 {
1137 if( pRange->aStart >= pRange->aEnd ||
1138 pRange->aEnd >= Count() ||
1139 !CheckNodesRange( pRange->aStart, pRange->aEnd ) ||
1140 !( HighestLevel( *this, *pRange ) > 1 ))
1141 return;
1142
1143 // Ist der Anfang vom Bereich vor oder auf einem StartNode, so loesche
1144 // diesen, denn sonst wuerden leere S/E-Nodes oder E/S-Nodes enstehen.
1145 // Bei anderen Nodes wird eine neuer EndNode eingefuegt
1146 SwNode * pAktNode = &pRange->aStart.GetNode();
1147 SwNodeIndex aIdx( *pAktNode->StartOfSectionNode() );
1148 if( pAktNode->IsStartNode() ) // selbst StartNode
1149 {
1150 SwEndNode* pEndNd = pRange->aEnd.GetNode().GetEndNode();
1151 if( pAktNode == pEndNd->pStartOfSection )
1152 {
1153 // dann wurde paarig aufgehoben, also nur die im Berich neu anpassen
1154 SwStartNode* pTmpSttNd = pAktNode->pStartOfSection;
1155 RemoveNode( pRange->aStart.GetIndex(), 1, sal_True );
1156 RemoveNode( pRange->aEnd.GetIndex(), 1, sal_True );
1157
1158 SwNodeIndex aTmpIdx( pRange->aStart );
1159 while( aTmpIdx < pRange->aEnd )
1160 {
1161 pAktNode = &aTmpIdx.GetNode();
1162 pAktNode->pStartOfSection = pTmpSttNd;
1163 if( pAktNode->IsStartNode() )
1164 aTmpIdx = pAktNode->EndOfSectionIndex() + 1;
1165 else
1166 aTmpIdx++;
1167 }
1168 return ;
1169 }
1170 DelNodes( pRange->aStart, 1 );
1171 }
1172 else if( aIdx == pRange->aStart.GetIndex()-1 ) // vor StartNode
1173 DelNodes( aIdx, 1 );
1174 else
1175 new SwEndNode( pRange->aStart, *aIdx.GetNode().GetStartNode() );
1176
1177 // Ist das Ende vom Bereich vor oder auf einem StartNode, so loesche
1178 // diesen, denn sonst wuerden leere S/E-Nodes oder E/S-Nodes entstehen
1179 // Bei anderen Nodes wird eine neuer EndNode eingefuegt
1180 SwNodeIndex aTmpIdx( pRange->aEnd );
1181 if( pRange->aEnd.GetNode().IsEndNode() )
1182 DelNodes( pRange->aEnd, 1 );
1183 else
1184 {
1185 pAktNode = new SwStartNode( pRange->aEnd );
1186 /*?? welcher NodeTyp ??*/
1187 aTmpIdx = *pRange->aEnd.GetNode().EndOfSectionNode();
1188 pRange->aEnd--;
1189 }
1190
1191 SectionUpDown( aIdx, aTmpIdx );
1192 }
1193
1194
1195 /*************************************************************************
1196 |*
1197 |* SwNodes::SectionUpDown()
1198 |*
1199 |* Beschreibung
1200 |* Methode setzt die Indizies die bei SectionUp oder SectionDwon
1201 |* veraendert wurden wieder richtig, sodass die Ebenen wieder
1202 |* Konsistent sind.
1203 |*
1204 |* Parameter
1205 |* SwIndex & aStart StartNode !!!
1206 |* SwIndex & aEnd EndPunkt
1207 |*
1208 |* Ersterstellung JP 23.04.91
1209 |* Letzte Aenderung JP 23.04.91
1210 |*
1211 *************************************************************************/
SectionUpDown(const SwNodeIndex & aStart,const SwNodeIndex & aEnd)1212 void SwNodes::SectionUpDown( const SwNodeIndex & aStart, const SwNodeIndex & aEnd )
1213 {
1214 SwNode * pAktNode;
1215 SwNodeIndex aTmpIdx( aStart, +1 );
1216 // das Array bildet einen Stack, es werden alle StartOfSelction's gesichert
1217 SwSttNdPtrs aSttNdStack( 1, 5 );
1218 SwStartNode* pTmp = aStart.GetNode().GetStartNode();
1219 aSttNdStack.C40_INSERT( SwStartNode, pTmp, 0 );
1220
1221 // durchlaufe bis der erste zu aendernde Start-Node gefunden wurde
1222 // ( Es wird vom eingefuegten EndNode bis nach vorne die Indexe gesetzt )
1223 for( ;; aTmpIdx++ )
1224 {
1225 pAktNode = &aTmpIdx.GetNode();
1226 pAktNode->pStartOfSection = aSttNdStack[ aSttNdStack.Count()-1 ];
1227
1228 if( pAktNode->GetStartNode() )
1229 {
1230 pTmp = (SwStartNode*)pAktNode;
1231 aSttNdStack.C40_INSERT( SwStartNode, pTmp, aSttNdStack.Count() );
1232 }
1233 else if( pAktNode->GetEndNode() )
1234 {
1235 SwStartNode* pSttNd = aSttNdStack[ aSttNdStack.Count() - 1 ];
1236 pSttNd->pEndOfSection = (SwEndNode*)pAktNode;
1237 aSttNdStack.Remove( aSttNdStack.Count() - 1 );
1238 if( aSttNdStack.Count() )
1239 continue; // noch genuegend EndNodes auf dem Stack
1240
1241 else if( aTmpIdx < aEnd ) // Uebergewicht an StartNodes
1242 // ist das Ende noch nicht erreicht, so hole den Start von
1243 // der uebergeordneten Section
1244 {
1245 aSttNdStack.C40_INSERT( SwStartNode, pSttNd->pStartOfSection, 0 );
1246 }
1247 else // wenn ueber den Bereich hinaus, dann Ende
1248 break;
1249 }
1250 }
1251 }
1252
1253
1254
1255
1256 /*******************************************************************
1257 |*
1258 |* SwNodes::Delete
1259 |*
1260 |* Beschreibung
1261 |* Spezielle Implementierung der Delete-Funktion des
1262 |* variablen Array. Diese spezielle Implementierung ist
1263 |* notwendig, da durch das Loeschen von Start- bzw.
1264 |* Endnodes Inkonsistenzen entstehen koennen. Diese werden
1265 |* durch diese Funktion beseitigt.
1266 |*
1267 |* Parameter
1268 |* IN
1269 |* SwIndex &rIndex bezeichnet die Position, an der
1270 |* geloescht wird
1271 |* rIndex ist nach Aufruf der Funktion unveraendert (Kopie?!)
1272 |* sal_uInt16 nNodes bezeichnet die Anzahl der zu loeschenden
1273 |* Nodes; ist auf 1 defaulted
1274 |*
1275 |* Debug-Funktionen
1276 |* geben beim Eintritt in die Funktion Position und Anzahl
1277 |* der zu loeschenden Nodes aus.
1278 |*
1279 |* Ersterstellung
1280 |* VER0100 vb 901214
1281 |*
1282 |* Stand
1283 |* VER0100 vb 901214
1284 |*
1285 *******************************************************************/
Delete(const SwNodeIndex & rIndex,sal_uLong nNodes)1286 void SwNodes::Delete(const SwNodeIndex &rIndex, sal_uLong nNodes)
1287 {
1288 sal_uInt16 nLevel = 0; // Level-Counter
1289 SwNode * pAktNode;
1290
1291 sal_uLong nCnt = Count() - rIndex.GetIndex() - 1;
1292 if( nCnt > nNodes ) nCnt = nNodes;
1293
1294 if( nCnt == 0 ) // keine Anzahl -> return
1295 return;
1296
1297 SwNodeRange aRg( rIndex, 0, rIndex, nCnt-1 );
1298 // ueberprufe ob rIndex..rIndex + nCnt ueber einen Bereich hinausragt !!
1299 if( ( !aRg.aStart.GetNode().StartOfSectionIndex() &&
1300 !aRg.aStart.GetIndex() ) ||
1301 ! CheckNodesRange( aRg.aStart, aRg.aEnd ) )
1302 return;
1303
1304
1305 // falls aEnd auf keinem ContentNode steht, dann suche den vorherigen
1306 while( ( pAktNode = &aRg.aEnd.GetNode())->GetStartNode() ||
1307 ( pAktNode->GetEndNode() &&
1308 !pAktNode->pStartOfSection->IsTableNode() ))
1309 aRg.aEnd--;
1310
1311 nCnt = 0;
1312 // Start erhoehen, damit auf < abgefragt wird. ( bei <= kann es zu
1313 // Problemen fuehren; ist aEnd == aStart und wird aEnd geloscht,
1314 // so ist aEnd <= aStart
1315 aRg.aStart--;
1316
1317 sal_Bool bSaveInNodesDel = bInNodesDel;
1318 bInNodesDel = sal_True;
1319 sal_Bool bUpdateOutline = sal_False;
1320
1321 // bis alles geloescht ist
1322 while( aRg.aStart < aRg.aEnd )
1323 {
1324 pAktNode = &aRg.aEnd.GetNode();
1325
1326 if( pAktNode->GetEndNode() )
1327 {
1328 // die gesamte Section loeschen ?
1329 if( pAktNode->StartOfSectionIndex() > aRg.aStart.GetIndex() )
1330 {
1331 SwTableNode* pTblNd = pAktNode->pStartOfSection->GetTableNode();
1332 if( pTblNd )
1333 pTblNd->DelFrms();
1334
1335 SwNode *pNd, *pChkNd = pAktNode->pStartOfSection;
1336 sal_uInt16 nIdxPos;
1337 do {
1338 pNd = &aRg.aEnd.GetNode();
1339
1340 if( pNd->IsTxtNode() )
1341 {
1342 //if( NO_NUMBERING != //#outline level,zhaojianwei
1343 // ((SwTxtNode*)pNd)->GetTxtColl()->GetOutlineLevel() &&
1344 if( 0 != ((SwTxtNode*)pNd)->GetAttrOutlineLevel() &&//<-end,zhaojianwei
1345 pOutlineNds->Seek_Entry( pNd, &nIdxPos ))
1346 {
1347 // loesche die Gliederungs-Indizies.
1348 pOutlineNds->Remove( nIdxPos );
1349 bUpdateOutline = sal_True;
1350 }
1351 ((SwTxtNode*)pNd)->InvalidateNumRule();
1352 }
1353 else if( pNd->IsEndNode() &&
1354 pNd->pStartOfSection->IsTableNode() )
1355 ((SwTableNode*)pNd->pStartOfSection)->DelFrms();
1356
1357 aRg.aEnd--;
1358 nCnt++;
1359
1360 } while( pNd != pChkNd );
1361 }
1362 else
1363 {
1364 RemoveNode( aRg.aEnd.GetIndex()+1, nCnt, sal_True ); // loesche
1365 nCnt = 0;
1366 aRg.aEnd--; // vor den EndNode
1367 nLevel++;
1368 }
1369 }
1370 else if( pAktNode->GetStartNode() ) // StartNode gefunden
1371 {
1372 if( nLevel == 0 ) // es wird eine Stufe runter gestuft
1373 {
1374 if( nCnt )
1375 {
1376 // loesche jetzt das Array
1377 aRg.aEnd++;
1378 RemoveNode( aRg.aEnd.GetIndex(), nCnt, sal_True );
1379 nCnt = 0;
1380 }
1381 }
1382 else // es werden alle Nodes Innerhalb eines Start- und
1383 { // End-Nodes geloescht, loesche mit Start/EndNode
1384 RemoveNode( aRg.aEnd.GetIndex(), nCnt + 2, sal_True ); // loesche Array
1385 nCnt = 0;
1386 nLevel--;
1387 }
1388
1389 // nach dem loeschen kann aEnd auf einem EndNode stehen
1390 // loesche alle leeren Start-/End-Node-Paare
1391 SwNode* pTmpNode = aRg.aEnd.GetNode().GetEndNode();
1392 aRg.aEnd--;
1393 while( pTmpNode &&
1394 ( pAktNode = &aRg.aEnd.GetNode())->GetStartNode() &&
1395 pAktNode->StartOfSectionIndex() )
1396 {
1397 // loesche den EndNode und StartNode
1398 DelNodes( aRg.aEnd, 2 );
1399 pTmpNode = aRg.aEnd.GetNode().GetEndNode();
1400 aRg.aEnd--;
1401 }
1402 }
1403 else // normaler Node, also ins TmpArray einfuegen
1404 {
1405 SwTxtNode* pTxtNd = pAktNode->GetTxtNode();
1406 if( pTxtNd )
1407 {
1408 if( pTxtNd->IsOutline())
1409 { // loesche die Gliederungs-Indizies.
1410 pOutlineNds->Remove( pTxtNd );
1411 bUpdateOutline = sal_True;
1412 }
1413 pTxtNd->InvalidateNumRule();
1414 }
1415 else if( pAktNode->IsCntntNode() )
1416 ((SwCntntNode*)pAktNode)->InvalidateNumRule();
1417
1418 aRg.aEnd--;
1419 nCnt++;
1420 }
1421 }
1422
1423 aRg.aEnd++;
1424 if( nCnt != 0 )
1425 RemoveNode( aRg.aEnd.GetIndex(), nCnt, sal_True ); // loesche den Rest
1426
1427 // loesche alle leeren Start-/End-Node-Paare
1428 while( aRg.aEnd.GetNode().GetEndNode() &&
1429 ( pAktNode = &aRg.aStart.GetNode())->GetStartNode() &&
1430 pAktNode->StartOfSectionIndex() )
1431 // aber ja keinen der heiligen 5.
1432 {
1433 DelNodes( aRg.aStart, 2 ); // loesche den Start- und EndNode
1434 aRg.aStart--;
1435 }
1436
1437 bInNodesDel = bSaveInNodesDel;
1438
1439 if( !bInNodesDel )
1440 {
1441 // rufe jetzt noch das Update fuer die Gliederung/Nummerierung auf
1442 if( bUpdateOutline || bInDelUpdOutl )
1443 {
1444 UpdtOutlineIdx( aRg.aEnd.GetNode() );
1445 bInDelUpdOutl = sal_False;
1446 }
1447
1448 }
1449 else
1450 {
1451 if( bUpdateOutline )
1452 bInDelUpdOutl = sal_True;
1453 }
1454 }
1455
1456 /*******************************************************************
1457 |*
1458 |* SwNodes::GetSectionLevel
1459 |*
1460 |* Beschreibung
1461 |* Die Funktion liefert den Sectionlevel an der durch
1462 |* aIndex bezeichneten Position. Die Funktion ruft die
1463 |* GetSectionlevel-Funktion des durch aIndex bezeichneten
1464 |* Nodes. Diese ist eine virtuelle Funktion, die fuer
1465 |* Endnodes speziell implementiert werden musste.
1466 |* Die Sectionlevels werden ermittelt, indem rekursiv durch
1467 |* die Nodesstruktur (jeweils zum naechsten theEndOfSection)
1468 |* gegangen wird, bis die oberste Ebene erreicht ist
1469 |* (theEndOfSection == 0)
1470 |*
1471 |* Parameter
1472 |* aIndex bezeichnet die Position des Nodes, dessen
1473 |* Sectionlevel ermittelt werden soll. Hier wird eine Kopie
1474 |* uebergeben, da eine Veraenderung der Variablen in der
1475 |* rufenden Funktion nicht wuenschenswert ist.
1476 |*
1477 |* Ausnahmen
1478 |* Der erste Node im Array sollte immer ein Startnode sein.
1479 |* Dieser erfaehrt in der Funktion SwNodes::GetSectionLevel()
1480 |* eine Sonderbehandlung; es wird davon ausgegangen, dass der
1481 |* erste Node auch ein Startnode ist.
1482 |*
1483 |* Ersterstellung
1484 |* VER0100 vb 901214
1485 |*
1486 |* Stand
1487 |* VER0100 vb 901214
1488 |*
1489 *******************************************************************/
GetSectionLevel(const SwNodeIndex & rIdx) const1490 sal_uInt16 SwNodes::GetSectionLevel(const SwNodeIndex &rIdx) const {
1491 // Sonderbehandlung 1. Node
1492 if(rIdx == 0) return 1;
1493 /*
1494 * Keine Rekursion! - hier wird das SwNode::GetSectionLevel
1495 * aufgerufen
1496 */
1497 return rIdx.GetNode().GetSectionLevel();
1498 }
1499
GoStartOfSection(SwNodeIndex * pIdx) const1500 void SwNodes::GoStartOfSection(SwNodeIndex *pIdx) const
1501 {
1502 // hinter den naechsten Startnode
1503 SwNodeIndex aTmp( *pIdx->GetNode().StartOfSectionNode(), +1 );
1504
1505 // steht der Index auf keinem ContentNode, dann gehe dahin. Ist aber
1506 // kein weiterer vorhanden, dann lasse den Index an alter Pos stehen !!!
1507 while( !aTmp.GetNode().IsCntntNode() )
1508 { // gehe vom StartNode ( es kann nur ein StartNode sein ! ) an sein
1509 // Ende
1510 if( *pIdx <= aTmp )
1511 return; // FEHLER: Steht schon hinter der Sektion
1512 aTmp = aTmp.GetNode().EndOfSectionIndex()+1;
1513 if( *pIdx <= aTmp )
1514 return; // FEHLER: Steht schon hinter der Sektion
1515 }
1516 (*pIdx) = aTmp; // steht auf einem ContentNode
1517 }
1518
GoEndOfSection(SwNodeIndex * pIdx) const1519 void SwNodes::GoEndOfSection(SwNodeIndex *pIdx) const
1520 {
1521 // falls er vor einem Endnode steht --> nichts tun
1522 if( !pIdx->GetNode().IsEndNode() )
1523 (*pIdx) = *pIdx->GetNode().EndOfSectionNode();
1524 }
1525
GoNext(SwNodeIndex * pIdx) const1526 SwCntntNode* SwNodes::GoNext(SwNodeIndex *pIdx) const
1527 {
1528 if( pIdx->GetIndex() >= Count() - 1 )
1529 return 0;
1530
1531 SwNodeIndex aTmp(*pIdx, +1);
1532 SwNode* pNd = 0;
1533 while( aTmp < Count()-1 && 0 == ( pNd = &aTmp.GetNode())->IsCntntNode() )
1534 aTmp++;
1535
1536 if( aTmp == Count()-1 )
1537 pNd = 0;
1538 else
1539 (*pIdx) = aTmp;
1540 return (SwCntntNode*)pNd;
1541 }
1542
GoPrevious(SwNodeIndex * pIdx) const1543 SwCntntNode* SwNodes::GoPrevious(SwNodeIndex *pIdx) const
1544 {
1545 if( !pIdx->GetIndex() )
1546 return 0;
1547
1548 SwNodeIndex aTmp( *pIdx, -1 );
1549 SwNode* pNd = 0;
1550 while( aTmp.GetIndex() && 0 == ( pNd = &aTmp.GetNode())->IsCntntNode() )
1551 aTmp--;
1552
1553 if( !aTmp.GetIndex() )
1554 pNd = 0;
1555 else
1556 (*pIdx) = aTmp;
1557 return (SwCntntNode*)pNd;
1558 }
1559
1560 /*************************************************************************
1561 |*
1562 |* sal_Bool SwNodes::CheckNodesRange()
1563 |*
1564 |* Beschreibung
1565 |* Teste ob der uebergene SRange nicht ueber die Grenzen der
1566 |* einzelnen Bereiche (PosIts, Autotext, Content, Icons und Inserts )
1567 |* hinaus reicht.
1568 |* Nach Wahrscheinlichkeit des Ranges sortiert.
1569 |*
1570 |* Alg.: Da festgelegt ist, das aRange.aEnd den 1.Node hinter dem Bereich
1571 |* bezeichnet, wird hier auf aEnd <= End.. getestet !!
1572 |*
1573 |* Parameter SwIndex & Start-Index vom Bereich
1574 |* SwIndex & End-Index vom Bereich
1575 |* sal_Bool sal_True: Start+End in gleicher Section!
1576 |* sal_False: Start+End in verschiedenen Sect.
1577 |* Return-Wert sal_Bool sal_True: gueltiger SRange
1578 |* sal_False: ungueltiger SRange
1579 |*
1580 |* Ersterstellung JP 23.04.91
1581 |* Letzte Aenderung JP 18.06.92
1582 |*
1583 *************************************************************************/
1584
TstIdx(sal_uLong nSttIdx,sal_uLong nEndIdx,sal_uLong nStt,sal_uLong nEnd)1585 inline int TstIdx( sal_uLong nSttIdx, sal_uLong nEndIdx, sal_uLong nStt, sal_uLong nEnd )
1586 {
1587 return nStt < nSttIdx && nEnd >= nSttIdx &&
1588 nStt < nEndIdx && nEnd >= nEndIdx;
1589 }
1590
CheckNodesRange(const SwNodeIndex & rStt,const SwNodeIndex & rEnd) const1591 sal_Bool SwNodes::CheckNodesRange( const SwNodeIndex& rStt, const SwNodeIndex& rEnd ) const
1592 {
1593 sal_uLong nStt = rStt.GetIndex(), nEnd = rEnd.GetIndex();
1594 if( TstIdx( nStt, nEnd, pEndOfContent->StartOfSectionIndex(),
1595 pEndOfContent->GetIndex() )) return sal_True;
1596 if( TstIdx( nStt, nEnd, pEndOfAutotext->StartOfSectionIndex(),
1597 pEndOfAutotext->GetIndex() )) return sal_True;
1598 if( TstIdx( nStt, nEnd, pEndOfPostIts->StartOfSectionIndex(),
1599 pEndOfPostIts->GetIndex() )) return sal_True;
1600 if( TstIdx( nStt, nEnd, pEndOfInserts->StartOfSectionIndex(),
1601 pEndOfInserts->GetIndex() )) return sal_True;
1602 if( TstIdx( nStt, nEnd, pEndOfRedlines->StartOfSectionIndex(),
1603 pEndOfRedlines->GetIndex() )) return sal_True;
1604
1605 return sal_False; // liegt irgendwo dazwischen, FEHLER
1606 }
1607
1608
1609 /*************************************************************************
1610 |*
1611 |* void SwNodes::DelNodes()
1612 |*
1613 |* Beschreibung
1614 |* Loesche aus den NodesArray ab einer Position entsprechend Node's.
1615 |*
1616 |* Parameter SwIndex & Der Startpunkt im Nodes-Array
1617 |* sal_uInt16 die Anzahl
1618 |*
1619 |* Ersterstellung JP 23.04.91
1620 |* Letzte Aenderung JP 23.04.91
1621 |*
1622 *************************************************************************/
DelNodes(const SwNodeIndex & rStart,sal_uLong nCnt)1623 void SwNodes::DelNodes( const SwNodeIndex & rStart, sal_uLong nCnt )
1624 {
1625 int bUpdateNum = 0;
1626 sal_uLong nSttIdx = rStart.GetIndex();
1627
1628 if( !nSttIdx && nCnt == GetEndOfContent().GetIndex()+1 )
1629 {
1630 // es wird das gesamte Nodes-Array zerstoert, man ist im Doc DTOR!
1631 // Die initialen Start-/End-Nodes duerfen nur im SwNodes-DTOR
1632 // zerstoert werden!
1633 SwNode* aEndNdArr[] = { pEndOfContent,
1634 pEndOfPostIts, pEndOfInserts,
1635 pEndOfAutotext, pEndOfRedlines,
1636 0
1637 };
1638
1639 SwNode** ppEndNdArr = aEndNdArr;
1640 while( *ppEndNdArr )
1641 {
1642 nSttIdx = (*ppEndNdArr)->StartOfSectionIndex() + 1;
1643 sal_uLong nEndIdx = (*ppEndNdArr)->GetIndex();
1644
1645 if( nSttIdx != nEndIdx )
1646 RemoveNode( nSttIdx, nEndIdx - nSttIdx, sal_True );
1647
1648 ++ppEndNdArr;
1649 }
1650 }
1651 else
1652 {
1653 for( sal_uLong n = nSttIdx, nEnd = nSttIdx + nCnt; n < nEnd; ++n )
1654 {
1655 SwNode* pNd = (*this)[ n ];
1656
1657 if( pNd->IsTxtNode() &&
1658 //NO_NUMBERING != ((SwTxtNode*)pNd)->GetTxtColl()->GetOutlineLevel() )//#outline level,zhaojianwei
1659 0 != ((SwTxtNode*)pNd)->GetAttrOutlineLevel() ) //<-end,zhaojianwei
1660 { // loesche die Gliederungs-Indizies.
1661 sal_uInt16 nIdxPos;
1662 if( pOutlineNds->Seek_Entry( pNd, &nIdxPos ))
1663 {
1664 pOutlineNds->Remove( nIdxPos );
1665 bUpdateNum = 1;
1666 }
1667 }
1668 if( pNd->IsCntntNode() )
1669 {
1670 ((SwCntntNode*)pNd)->InvalidateNumRule();
1671 ((SwCntntNode*)pNd)->DelFrms();
1672 }
1673 }
1674 RemoveNode( nSttIdx, nCnt, sal_True );
1675
1676 // rufe noch das Update fuer die Gliederungsnumerierung auf
1677 if( bUpdateNum )
1678 UpdtOutlineIdx( rStart.GetNode() );
1679 }
1680 }
1681
1682
1683 /*************************************************************************
1684 |*
1685 |* sal_uInt16 HighestLevel( SwNodes & rNodes, const SwNodeRange & rRange )
1686 |*
1687 |* Beschreibung
1688 |* Berechne den hoehsten Level innerhalb des Bereiches
1689 |*
1690 |* Parameter SwNodes & das Node-Array
1691 |* SwNodeRange & der zu ueberpruefende Bereich
1692 |* Return sal_uInt16 der hoechste Level
1693 |*
1694 |* Ersterstellung JP 24.04.91
1695 |* Letzte Aenderung JP 24.04.91
1696 |*
1697 *************************************************************************/
1698
1699 struct HighLevel
1700 {
1701 sal_uInt16 nLevel, nTop;
HighLevelHighLevel1702 HighLevel( sal_uInt16 nLv ) : nLevel( nLv ), nTop( nLv ) {}
1703
1704 };
1705
_HighestLevel(const SwNodePtr & rpNode,void * pPara)1706 sal_Bool _HighestLevel( const SwNodePtr& rpNode, void * pPara )
1707 {
1708 HighLevel * pHL = (HighLevel*)pPara;
1709 if( rpNode->GetStartNode() )
1710 pHL->nLevel++;
1711 else if( rpNode->GetEndNode() )
1712 pHL->nLevel--;
1713 if( pHL->nTop > pHL->nLevel )
1714 pHL->nTop = pHL->nLevel;
1715 return sal_True;
1716
1717 }
1718
HighestLevel(SwNodes & rNodes,const SwNodeRange & rRange)1719 sal_uInt16 HighestLevel( SwNodes & rNodes, const SwNodeRange & rRange )
1720 {
1721 HighLevel aPara( rNodes.GetSectionLevel( rRange.aStart ));
1722 rNodes.ForEach( rRange.aStart, rRange.aEnd, _HighestLevel, &aPara );
1723 return aPara.nTop;
1724
1725 }
1726
1727 /*************************************************************************
1728 |*
1729 |* SwNodes::Move()
1730 |*
1731 |* Beschreibung
1732 |* Parameter SwPaM& zu kopierender Bereich
1733 |* SwNodes& in dieses Nodes-Array
1734 |* SwPosition& auf diese Position im Nodes-Array
1735 |* Ersterstellung JP 09.07.92
1736 |* Letzte Aenderung JP 09.07.92
1737 |*
1738 *************************************************************************/
MoveRange(SwPaM & rPam,SwPosition & rPos,SwNodes & rNodes)1739 void SwNodes::MoveRange( SwPaM & rPam, SwPosition & rPos, SwNodes& rNodes )
1740 {
1741 SwPosition * const pStt = rPam.Start();
1742 SwPosition * const pEnd = rPam.End();
1743
1744 if( !rPam.HasMark() || *pStt >= *pEnd )
1745 return;
1746
1747 if( this == &rNodes && *pStt <= rPos && rPos < *pEnd )
1748 return;
1749
1750 SwNodeIndex aEndIdx( pEnd->nNode );
1751 SwNodeIndex aSttIdx( pStt->nNode );
1752 SwTxtNode *const pSrcNd = aSttIdx.GetNode().GetTxtNode();
1753 SwTxtNode * pDestNd = rPos.nNode.GetNode().GetTxtNode();
1754 sal_Bool bSplitDestNd = sal_True;
1755 sal_Bool bCopyCollFmt = pDestNd && !pDestNd->GetTxt().Len();
1756
1757 if( pSrcNd )
1758 {
1759 // ist der 1.Node ein TextNode, dann muss im NodesArray auch
1760 // ein TextNode vorhanden sein, in den der Inhalt geschoben wird
1761 if( !pDestNd )
1762 {
1763 pDestNd = rNodes.MakeTxtNode( rPos.nNode, pSrcNd->GetTxtColl() );
1764 rPos.nNode--;
1765 rPos.nContent.Assign( pDestNd, 0 );
1766 bCopyCollFmt = sal_True;
1767 }
1768 bSplitDestNd = pDestNd->Len() > rPos.nContent.GetIndex() ||
1769 pEnd->nNode.GetNode().IsTxtNode();
1770
1771 // verschiebe jetzt noch den Inhalt in den neuen Node
1772 sal_Bool bOneNd = pStt->nNode == pEnd->nNode;
1773 const xub_StrLen nLen =
1774 ( (bOneNd) ? pEnd->nContent.GetIndex() : pSrcNd->Len() )
1775 - pStt->nContent.GetIndex();
1776
1777 if( !pEnd->nNode.GetNode().IsCntntNode() )
1778 {
1779 bOneNd = sal_True;
1780 sal_uLong nSttNdIdx = pStt->nNode.GetIndex() + 1;
1781 const sal_uLong nEndNdIdx = pEnd->nNode.GetIndex();
1782 for( ; nSttNdIdx < nEndNdIdx; ++nSttNdIdx )
1783 {
1784 if( (*this)[ nSttNdIdx ]->IsCntntNode() )
1785 {
1786 bOneNd = sal_False;
1787 break;
1788 }
1789 }
1790 }
1791
1792 // das kopieren / setzen der Vorlagen darf erst nach
1793 // dem Splitten erfolgen
1794 if( !bOneNd && bSplitDestNd )
1795 {
1796 if( !rPos.nContent.GetIndex() )
1797 {
1798 bCopyCollFmt = sal_True;
1799 }
1800 if( rNodes.IsDocNodes() )
1801 {
1802 SwDoc* const pInsDoc = pDestNd->GetDoc();
1803 ::sw::UndoGuard const ug(pInsDoc->GetIDocumentUndoRedo());
1804 pInsDoc->SplitNode( rPos, false );
1805 }
1806 else
1807 {
1808 pDestNd->SplitCntntNode( rPos );
1809 }
1810
1811 if( rPos.nNode == aEndIdx )
1812 {
1813 aEndIdx--;
1814 }
1815 bSplitDestNd = sal_True;
1816
1817 pDestNd = rNodes[ rPos.nNode.GetIndex() - 1 ]->GetTxtNode();
1818 if( nLen )
1819 {
1820 pSrcNd->CutText( pDestNd, SwIndex( pDestNd, pDestNd->Len()),
1821 pStt->nContent, nLen );
1822 }
1823 }
1824 else if ( nLen )
1825 {
1826 pSrcNd->CutText( pDestNd, rPos.nContent, pStt->nContent, nLen );
1827 }
1828
1829 if( bCopyCollFmt )
1830 {
1831 SwDoc* const pInsDoc = pDestNd->GetDoc();
1832 ::sw::UndoGuard const undoGuard(pInsDoc->GetIDocumentUndoRedo());
1833 pSrcNd->CopyCollFmt( *pDestNd );
1834 bCopyCollFmt = sal_False;
1835 }
1836
1837 if( bOneNd ) // das wars schon
1838 {
1839 // der PaM wird korrigiert, denn falls ueber Nodegrenzen verschoben
1840 // wurde, so stehen sie in unterschieden Nodes. Auch die Selektion
1841 // wird aufgehoben !
1842 pEnd->nContent = pStt->nContent;
1843 rPam.DeleteMark();
1844 GetDoc()->GetDocShell()->Broadcast( SwFmtFldHint( 0,
1845 rNodes.IsDocNodes() ? SWFMTFLD_INSERTED : SWFMTFLD_REMOVED ) );
1846 return;
1847 }
1848
1849 aSttIdx++;
1850 }
1851 else if( pDestNd )
1852 {
1853 if( rPos.nContent.GetIndex() )
1854 {
1855 if( rPos.nContent.GetIndex() == pDestNd->Len() )
1856 {
1857 rPos.nNode++;
1858 }
1859 else if( rPos.nContent.GetIndex() )
1860 {
1861 // falls im EndNode gesplittet wird, dann muss der EndIdx
1862 // korrigiert werden !!
1863 const bool bCorrEnd = aEndIdx == rPos.nNode;
1864 // es wird kein Text an den TextNode angehaengt, also splitte ihn
1865
1866 if( rNodes.IsDocNodes() )
1867 {
1868 SwDoc* const pInsDoc = pDestNd->GetDoc();
1869 ::sw::UndoGuard const ug(pInsDoc->GetIDocumentUndoRedo());
1870 pInsDoc->SplitNode( rPos, false );
1871 }
1872 else
1873 {
1874 pDestNd->SplitCntntNode( rPos );
1875 }
1876
1877 pDestNd = rPos.nNode.GetNode().GetTxtNode();
1878
1879 if ( bCorrEnd )
1880 {
1881 aEndIdx--;
1882 }
1883 }
1884 }
1885 // am Ende steht noch ein leerer Text Node herum.
1886 bSplitDestNd = sal_True;
1887 }
1888
1889 SwTxtNode* const pEndSrcNd = aEndIdx.GetNode().GetTxtNode();
1890 if ( pEndSrcNd )
1891 {
1892 {
1893 // am Bereichsende entsteht ein neuer TextNode
1894 if( !bSplitDestNd )
1895 {
1896 if( rPos.nNode < rNodes.GetEndOfContent().GetIndex() )
1897 {
1898 rPos.nNode++;
1899 }
1900
1901 pDestNd =
1902 rNodes.MakeTxtNode( rPos.nNode, pEndSrcNd->GetTxtColl() );
1903 rPos.nNode--;
1904 rPos.nContent.Assign( pDestNd, 0 );
1905 }
1906 else
1907 {
1908 pDestNd = rPos.nNode.GetNode().GetTxtNode();
1909 }
1910
1911 if( pDestNd && pEnd->nContent.GetIndex() )
1912 {
1913 // verschiebe jetzt noch den Inhalt in den neuen Node
1914 SwIndex aIdx( pEndSrcNd, 0 );
1915 pEndSrcNd->CutText( pDestNd, rPos.nContent, aIdx,
1916 pEnd->nContent.GetIndex());
1917 }
1918
1919 if( bCopyCollFmt )
1920 {
1921 SwDoc* const pInsDoc = pDestNd->GetDoc();
1922 ::sw::UndoGuard const ug(pInsDoc->GetIDocumentUndoRedo());
1923 pEndSrcNd->CopyCollFmt( *pDestNd );
1924 }
1925 }
1926 }
1927 else
1928 {
1929 if ( pSrcNd && aEndIdx.GetNode().IsCntntNode() )
1930 {
1931 aEndIdx++;
1932 }
1933 if( !bSplitDestNd )
1934 {
1935 rPos.nNode++;
1936 rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(), 0 );
1937 }
1938 }
1939
1940 if( aEndIdx != aSttIdx )
1941 {
1942 // verschiebe jetzt die Nodes in das NodesArary
1943 const sal_uLong nSttDiff = aSttIdx.GetIndex() - pStt->nNode.GetIndex();
1944 SwNodeRange aRg( aSttIdx, aEndIdx );
1945 _MoveNodes( aRg, rNodes, rPos.nNode );
1946 // falls ins gleiche Nodes-Array verschoben wurde, stehen die
1947 // Indizies jetzt auch an der neuen Position !!!!
1948 // (also alles wieder umsetzen)
1949 if( &rNodes == this )
1950 {
1951 pStt->nNode = aRg.aEnd.GetIndex() - nSttDiff;
1952 }
1953 }
1954
1955 // falls der Start-Node verschoben wurde, in dem der Cursor stand, so
1956 // muss der Content im akt. Content angemeldet werden !!!
1957 if ( &pStt->nNode.GetNode() == &GetEndOfContent() )
1958 {
1959 const bool bSuccess = GoPrevious( &pStt->nNode );
1960 ASSERT( bSuccess, "Move() - no ContentNode here" );
1961 (void) bSuccess;
1962 }
1963 pStt->nContent.Assign( pStt->nNode.GetNode().GetCntntNode(),
1964 pStt->nContent.GetIndex() );
1965 // der PaM wird korrigiert, denn falls ueber Nodegrenzen verschoben
1966 // wurde, so stehen sie in unterschielichen Nodes. Auch die Selektion
1967 // wird aufgehoben !
1968 *pEnd = *pStt;
1969 rPam.DeleteMark();
1970 GetDoc()->GetDocShell()->Broadcast( SwFmtFldHint( 0,
1971 rNodes.IsDocNodes() ? SWFMTFLD_INSERTED : SWFMTFLD_REMOVED ) );
1972 }
1973
1974
1975
1976 /*************************************************************************
1977 |*
1978 |* SwNodes::_Copy()
1979 |*
1980 |* Beschreibung
1981 |* Parameter SwNodeRange& zu kopierender Bereich
1982 |* SwDoc& in dieses Dokument
1983 |* SwIndex& auf diese Position im Nodes-Array
1984 |* Ersterstellung JP 11.11.92
1985 |* Letzte Aenderung JP 11.11.92
1986 |*
1987 *************************************************************************/
1988
MaxLvl(sal_uInt8 nMin,sal_uInt8 nMax,short nNew)1989 inline sal_uInt8 MaxLvl( sal_uInt8 nMin, sal_uInt8 nMax, short nNew )
1990 {
1991 return (sal_uInt8)(nNew < nMin ? nMin : nNew > nMax ? nMax : nNew);
1992 }
1993
_CopyNodes(const SwNodeRange & rRange,const SwNodeIndex & rIndex,sal_Bool bNewFrms,sal_Bool bTblInsDummyNode) const1994 void SwNodes::_CopyNodes( const SwNodeRange& rRange,
1995 const SwNodeIndex& rIndex, sal_Bool bNewFrms, sal_Bool bTblInsDummyNode ) const
1996 {
1997 SwDoc* pDoc = rIndex.GetNode().GetDoc();
1998
1999 SwNode * pAktNode;
2000 if( rIndex == 0 ||
2001 ( (pAktNode = &rIndex.GetNode())->GetStartNode() &&
2002 !pAktNode->StartOfSectionIndex() ))
2003 return;
2004
2005 SwNodeRange aRg( rRange );
2006
2007 // "einfache" StartNodes oder EndNodes ueberspringen
2008 while( ND_STARTNODE == (pAktNode = & aRg.aStart.GetNode())->GetNodeType()
2009 || ( pAktNode->IsEndNode() &&
2010 !pAktNode->pStartOfSection->IsSectionNode() ) )
2011 aRg.aStart++;
2012
2013 // falls aEnd-1 auf keinem ContentNode steht, dann suche den vorherigen
2014 aRg.aEnd--;
2015 // #i107142#: if aEnd is start node of a special section, do nothing.
2016 // Otherwise this could lead to crash: going through all previous
2017 // special section nodes and then one before the first.
2018 if (aRg.aEnd.GetNode().StartOfSectionIndex() != 0)
2019 {
2020 while( ((pAktNode = & aRg.aEnd.GetNode())->GetStartNode() &&
2021 !pAktNode->IsSectionNode() ) ||
2022 ( pAktNode->IsEndNode() &&
2023 ND_STARTNODE == pAktNode->pStartOfSection->GetNodeType()) )
2024 {
2025 aRg.aEnd--;
2026 }
2027 }
2028 aRg.aEnd++;
2029
2030 // wird im selben Array's verschoben, dann ueberpruefe die Einfuegepos.
2031 if( aRg.aStart >= aRg.aEnd )
2032 return;
2033
2034 // when inserting into the source range, nothing need to be done
2035 DBG_ASSERT( &aRg.aStart.GetNodes() == this,
2036 "aRg should use thisnodes array" );
2037 DBG_ASSERT( &aRg.aStart.GetNodes() == &aRg.aEnd.GetNodes(),
2038 "Range across different nodes arrays? You deserve punishment!");
2039 if( &rIndex.GetNodes() == &aRg.aStart.GetNodes() &&
2040 rIndex.GetIndex() >= aRg.aStart.GetIndex() &&
2041 rIndex.GetIndex() < aRg.aEnd.GetIndex() )
2042 return;
2043
2044 SwNodeIndex aInsPos( rIndex );
2045 SwNodeIndex aOrigInsPos( rIndex, -1 ); // Originale Insert Pos
2046 sal_uInt16 nLevel = 0; // Level-Counter
2047
2048 for( sal_uLong nNodeCnt = aRg.aEnd.GetIndex() - aRg.aStart.GetIndex();
2049 nNodeCnt > 0; --nNodeCnt )
2050 {
2051 pAktNode = &aRg.aStart.GetNode();
2052 switch( pAktNode->GetNodeType() )
2053 {
2054 case ND_TABLENODE:
2055 // dann kopiere mal den TableNode
2056 // Tabell in Fussnote kopieren ?
2057 if( aInsPos < pDoc->GetNodes().GetEndOfInserts().GetIndex() &&
2058 pDoc->GetNodes().GetEndOfInserts().StartOfSectionIndex()
2059 < aInsPos.GetIndex() )
2060 {
2061 nNodeCnt -=
2062 ( pAktNode->EndOfSectionIndex() -
2063 aRg.aStart.GetIndex() );
2064
2065 // dann alle Nodes der Tabelle in die akt. Zelle kopieren
2066 // fuer den TabellenNode einen DummyNode einfuegen?
2067 if( bTblInsDummyNode )
2068 new SwNode( aInsPos, ND_SECTIONDUMMY );
2069
2070 for( aRg.aStart++; aRg.aStart.GetIndex() <
2071 pAktNode->EndOfSectionIndex();
2072 aRg.aStart++ )
2073 {
2074 // fuer den Box-StartNode einen DummyNode einfuegen?
2075 if( bTblInsDummyNode )
2076 new SwNode( aInsPos, ND_SECTIONDUMMY );
2077
2078 SwStartNode* pSttNd = aRg.aStart.GetNode().GetStartNode();
2079 _CopyNodes( SwNodeRange( *pSttNd, + 1,
2080 *pSttNd->EndOfSectionNode() ),
2081 aInsPos, bNewFrms, sal_False );
2082
2083 // fuer den Box-EndNode einen DummyNode einfuegen?
2084 if( bTblInsDummyNode )
2085 new SwNode( aInsPos, ND_SECTIONDUMMY );
2086 aRg.aStart = *pSttNd->EndOfSectionNode();
2087 }
2088 // fuer den TabellenEndNode einen DummyNode einfuegen?
2089 if( bTblInsDummyNode )
2090 new SwNode( aInsPos, ND_SECTIONDUMMY );
2091 aRg.aStart = *pAktNode->EndOfSectionNode();
2092 }
2093 else
2094 {
2095 SwNodeIndex nStt( aInsPos, -1 );
2096 SwTableNode* pTblNd = ((SwTableNode*)pAktNode)->
2097 MakeCopy( pDoc, aInsPos );
2098 nNodeCnt -= aInsPos.GetIndex() - nStt.GetIndex() -2;
2099
2100 aRg.aStart = pAktNode->EndOfSectionIndex();
2101
2102 if( bNewFrms && pTblNd )
2103 {
2104 nStt = aInsPos;
2105 pTblNd->MakeFrms( &nStt );
2106 }
2107 }
2108 break;
2109
2110 case ND_SECTIONNODE: // SectionNode
2111 // If the end of the section is outside the copy range,
2112 // the section node will skipped, not copied!
2113 // If someone want to change this behaviour, he has to adjust the function
2114 // lcl_NonCopyCount(..) in ndcopy.cxx which relies on it.
2115 if( pAktNode->EndOfSectionIndex() < aRg.aEnd.GetIndex() )
2116 {
2117 // also der gesamte, lege einen neuen SectionNode an
2118 SwNodeIndex nStt( aInsPos, -1 );
2119 SwSectionNode* pSectNd = ((SwSectionNode*)pAktNode)->
2120 MakeCopy( pDoc, aInsPos );
2121
2122 nNodeCnt -= aInsPos.GetIndex() - nStt.GetIndex() -2;
2123 aRg.aStart = pAktNode->EndOfSectionIndex();
2124
2125 if( bNewFrms && pSectNd &&
2126 !pSectNd->GetSection().IsHidden() )
2127 pSectNd->MakeFrms( &nStt );
2128 }
2129 break;
2130
2131 case ND_STARTNODE: // StartNode gefunden
2132 {
2133 SwStartNode* pTmp = new SwStartNode( aInsPos, ND_STARTNODE,
2134 ((SwStartNode*)pAktNode)->GetStartNodeType() );
2135 new SwEndNode( aInsPos, *pTmp );
2136 aInsPos--;
2137 nLevel++;
2138 }
2139 break;
2140
2141 case ND_ENDNODE:
2142 if( nLevel ) // vollstaendige Section
2143 {
2144 --nLevel;
2145 aInsPos++; // EndNode schon vorhanden
2146 }
2147 else if( !pAktNode->pStartOfSection->IsSectionNode() )
2148 {
2149 // erzeuge eine Section an der originalen InsertPosition
2150 SwNodeRange aTmpRg( aOrigInsPos, 1, aInsPos );
2151 pDoc->GetNodes().SectionDown( &aTmpRg,
2152 pAktNode->pStartOfSection->GetStartNodeType() );
2153 }
2154 break;
2155
2156 case ND_TEXTNODE:
2157 case ND_GRFNODE:
2158 case ND_OLENODE:
2159 {
2160 SwCntntNode* pNew = ((SwCntntNode*)pAktNode)->MakeCopy(
2161 pDoc, aInsPos );
2162 if( !bNewFrms ) // dflt. werden die Frames immer angelegt
2163 pNew->DelFrms();
2164 }
2165 break;
2166
2167 case ND_SECTIONDUMMY:
2168 if (GetDoc()->GetIDocumentUndoRedo().IsUndoNodes(*this))
2169 {
2170 // dann muss an der akt. InsPos auch ein SectionNode
2171 // (Start/Ende) stehen; dann diesen ueberspringen.
2172 // Andernfalls nicht weiter beachten.
2173 SwNode *const pTmpNd = & aInsPos.GetNode();
2174 if( pTmpNd->IsSectionNode() ||
2175 pTmpNd->StartOfSectionNode()->IsSectionNode() )
2176 aInsPos++; // ueberspringen
2177 }
2178 else {
2179 ASSERT( sal_False, "wie kommt diser Node ins Nodes-Array??" );
2180 }
2181 break;
2182
2183 default:
2184 ASSERT( sal_False, "weder Start-/End-/Content-Node, unbekannter Typ" );
2185 }
2186 aRg.aStart++;
2187 }
2188
2189
2190 #ifdef JP_DEBUG
2191 {
2192 extern Writer* GetDebugWriter(const String&);
2193
2194 Writer* pWriter = GetDebugWriter(aEmptyStr);
2195 if( pWriter )
2196 {
2197 int nError;
2198 SvFileStream aStrm( "c:\\$$copy.db", STREAM_WRITE );
2199 SwWriter aWriter( aStrm, *pMyDoc );
2200 aWriter.Write( &nError, pWriter );
2201 }
2202 }
2203 #endif
2204 }
2205
_DelDummyNodes(const SwNodeRange & rRg)2206 void SwNodes::_DelDummyNodes( const SwNodeRange& rRg )
2207 {
2208 SwNodeIndex aIdx( rRg.aStart );
2209 while( aIdx.GetIndex() < rRg.aEnd.GetIndex() )
2210 {
2211 if( ND_SECTIONDUMMY == aIdx.GetNode().GetNodeType() )
2212 RemoveNode( aIdx.GetIndex(), 1, sal_True );
2213 else
2214 aIdx++;
2215 }
2216 }
2217
MakeEmptySection(const SwNodeIndex & rIdx,SwStartNodeType eSttNdTyp)2218 SwStartNode* SwNodes::MakeEmptySection( const SwNodeIndex& rIdx,
2219 SwStartNodeType eSttNdTyp )
2220 {
2221 SwStartNode* pSttNd = new SwStartNode( rIdx, ND_STARTNODE, eSttNdTyp );
2222 new SwEndNode( rIdx, *pSttNd );
2223 return pSttNd;
2224 }
2225
2226
MakeTextSection(const SwNodeIndex & rWhere,SwStartNodeType eSttNdTyp,SwTxtFmtColl * pColl,SwAttrSet * pAutoAttr)2227 SwStartNode* SwNodes::MakeTextSection( const SwNodeIndex & rWhere,
2228 SwStartNodeType eSttNdTyp,
2229 SwTxtFmtColl *pColl,
2230 SwAttrSet* pAutoAttr )
2231 {
2232 SwStartNode* pSttNd = new SwStartNode( rWhere, ND_STARTNODE, eSttNdTyp );
2233 new SwEndNode( rWhere, *pSttNd );
2234 MakeTxtNode( SwNodeIndex( rWhere, - 1 ), pColl, pAutoAttr );
2235 return pSttNd;
2236 }
2237
2238 // zum naechsten Content-Node, der nicht geschuetzt oder versteckt ist
2239 // (beides auf sal_False ==> GoNext/GoPrevious!!!)
GoNextSection(SwNodeIndex * pIdx,int bSkipHidden,int bSkipProtect) const2240 SwCntntNode* SwNodes::GoNextSection( SwNodeIndex * pIdx,
2241 int bSkipHidden, int bSkipProtect ) const
2242 {
2243 int bFirst = sal_True;
2244 SwNodeIndex aTmp( *pIdx );
2245 const SwNode* pNd;
2246 while( aTmp < Count() - 1 )
2247 {
2248 pNd = & aTmp.GetNode();
2249 if (ND_SECTIONNODE == pNd->GetNodeType())
2250 {
2251 const SwSection& rSect = ((SwSectionNode*)pNd)->GetSection();
2252 if( (bSkipHidden && rSect.IsHiddenFlag()) ||
2253 (bSkipProtect && rSect.IsProtectFlag()) )
2254 // dann diese Section ueberspringen
2255 aTmp = *pNd->EndOfSectionNode();
2256 bFirst = sal_False;
2257 }
2258 else if( bFirst )
2259 {
2260 bFirst = sal_False;
2261 if( pNd->pStartOfSection->IsSectionNode() )
2262 {
2263 const SwSection& rSect = ((SwSectionNode*)pNd->
2264 pStartOfSection)->GetSection();
2265 if( (bSkipHidden && rSect.IsHiddenFlag()) ||
2266 (bSkipProtect && rSect.IsProtectFlag()) )
2267 // dann diese Section ueberspringen
2268 aTmp = *pNd->EndOfSectionNode();
2269 }
2270 }
2271 else if( ND_CONTENTNODE & pNd->GetNodeType() )
2272 {
2273 const SwSectionNode* pSectNd;
2274 if( ( bSkipHidden || bSkipProtect ) &&
2275 0 != (pSectNd = pNd->FindSectionNode() ) &&
2276 ( ( bSkipHidden && pSectNd->GetSection().IsHiddenFlag() ) ||
2277 ( bSkipProtect && pSectNd->GetSection().IsProtectFlag() )) )
2278 {
2279 aTmp = *pSectNd->EndOfSectionNode();
2280 }
2281 else
2282 {
2283 (*pIdx) = aTmp;
2284 return (SwCntntNode*)pNd;
2285 }
2286 }
2287 aTmp++;
2288 bFirst = sal_False;
2289 }
2290 return 0;
2291 }
2292
GoPrevSection(SwNodeIndex * pIdx,int bSkipHidden,int bSkipProtect) const2293 SwCntntNode* SwNodes::GoPrevSection( SwNodeIndex * pIdx,
2294 int bSkipHidden, int bSkipProtect ) const
2295 {
2296 int bFirst = sal_True;
2297 SwNodeIndex aTmp( *pIdx );
2298 const SwNode* pNd;
2299 while( aTmp > 0 )
2300 {
2301 pNd = & aTmp.GetNode();
2302 if (ND_ENDNODE == pNd->GetNodeType())
2303 {
2304 if( pNd->pStartOfSection->IsSectionNode() )
2305 {
2306 const SwSection& rSect = ((SwSectionNode*)pNd->
2307 pStartOfSection)->GetSection();
2308 if( (bSkipHidden && rSect.IsHiddenFlag()) ||
2309 (bSkipProtect && rSect.IsProtectFlag()) )
2310 // dann diese Section ueberspringen
2311 aTmp = *pNd->StartOfSectionNode();
2312 }
2313 bFirst = sal_False;
2314 }
2315 else if( bFirst )
2316 {
2317 bFirst = sal_False;
2318 if( pNd->pStartOfSection->IsSectionNode() )
2319 {
2320 const SwSection& rSect = ((SwSectionNode*)pNd->
2321 pStartOfSection)->GetSection();
2322 if( (bSkipHidden && rSect.IsHiddenFlag()) ||
2323 (bSkipProtect && rSect.IsProtectFlag()) )
2324 // dann diese Section ueberspringen
2325 aTmp = *pNd->StartOfSectionNode();
2326 }
2327 }
2328 else if( ND_CONTENTNODE & pNd->GetNodeType() )
2329 {
2330 const SwSectionNode* pSectNd;
2331 if( ( bSkipHidden || bSkipProtect ) &&
2332 0 != (pSectNd = pNd->FindSectionNode() ) &&
2333 ( ( bSkipHidden && pSectNd->GetSection().IsHiddenFlag() ) ||
2334 ( bSkipProtect && pSectNd->GetSection().IsProtectFlag() )) )
2335 {
2336 aTmp = *pSectNd;
2337 }
2338 else
2339 {
2340 (*pIdx) = aTmp;
2341 return (SwCntntNode*)pNd;
2342 }
2343 }
2344 aTmp--;
2345 }
2346 return 0;
2347 }
2348
2349
2350 // suche den vorhergehenden [/nachfolgenden ] ContentNode oder
2351 // TabellenNode mit Frames. Wird kein Ende angeben, dann wird mit
2352 // dem FrameIndex begonnen; ansonsten, wird mit dem vor rFrmIdx und
2353 // dem hintern pEnd die Suche gestartet. Sollte kein gueltiger Node
2354 // gefunden werden, wird 0 returnt. rFrmIdx zeigt auf dem Node mit
2355 // Frames
FindPrvNxtFrmNode(SwNodeIndex & rFrmIdx,const SwNode * pEnd) const2356 SwNode* SwNodes::FindPrvNxtFrmNode( SwNodeIndex& rFrmIdx,
2357 const SwNode* pEnd ) const
2358 {
2359 SwNode* pFrmNd = 0;
2360
2361 // habe wir gar kein Layout, vergiss es
2362 if( GetDoc()->GetCurrentViewShell() ) //swmod 071108//swmod 071225
2363 {
2364 SwNode* pSttNd = &rFrmIdx.GetNode();
2365
2366 // wird in eine versteckte Section verschoben ??
2367 SwSectionNode* pSectNd = pSttNd->IsSectionNode()
2368 ? pSttNd->StartOfSectionNode()->FindSectionNode()
2369 : pSttNd->FindSectionNode();
2370 if( !( pSectNd && pSectNd->GetSection().CalcHiddenFlag()/*IsHiddenFlag()*/ ) )
2371 {
2372 // #130650# in a table in table situation we have to assure that we don't leave the
2373 // outer table cell when the inner table is looking for a PrvNxt...
2374 SwTableNode* pTableNd = pSttNd->IsTableNode()
2375 ? pSttNd->StartOfSectionNode()->FindTableNode()
2376 : pSttNd->FindTableNode();
2377 SwNodeIndex aIdx( rFrmIdx );
2378 SwNode* pNd;
2379 if( pEnd )
2380 {
2381 aIdx--;
2382 pNd = &aIdx.GetNode();
2383 }
2384 else
2385 pNd = pSttNd;
2386
2387 if( ( pFrmNd = pNd )->IsCntntNode() )
2388 rFrmIdx = aIdx;
2389
2390 // suche nach vorne/hinten nach einem Content Node
2391 else if( 0 != ( pFrmNd = GoPrevSection( &aIdx, sal_True, sal_False )) &&
2392 ::CheckNodesRange( aIdx, rFrmIdx, sal_True ) &&
2393 // nach vorne nie aus der Tabelle hinaus!
2394 pFrmNd->FindTableNode() == pTableNd &&
2395 // Bug 37652: nach hinten nie aus der Tabellenzelle hinaus!
2396 (!pFrmNd->FindTableNode() || pFrmNd->FindTableBoxStartNode()
2397 == pSttNd->FindTableBoxStartNode() ) &&
2398 (!pSectNd || pSttNd->IsSectionNode() ||
2399 pSectNd->GetIndex() < pFrmNd->GetIndex())
2400 )
2401 {
2402 rFrmIdx = aIdx;
2403 }
2404 else
2405 {
2406 if( pEnd )
2407 aIdx = pEnd->GetIndex() + 1;
2408 else
2409 aIdx = rFrmIdx;
2410
2411 // JP 19.09.93: aber nie die Section dafuer verlassen !!
2412 if( ( pEnd && ( pFrmNd = &aIdx.GetNode())->IsCntntNode() ) ||
2413 ( 0 != ( pFrmNd = GoNextSection( &aIdx, sal_True, sal_False )) &&
2414 ::CheckNodesRange( aIdx, rFrmIdx, sal_True ) &&
2415 ( pFrmNd->FindTableNode() == pTableNd &&
2416 // Bug 37652: nach hinten nie aus der Tabellenzelle hinaus!
2417 (!pFrmNd->FindTableNode() || pFrmNd->FindTableBoxStartNode()
2418 == pSttNd->FindTableBoxStartNode() ) ) &&
2419 (!pSectNd || pSttNd->IsSectionNode() ||
2420 pSectNd->EndOfSectionIndex() > pFrmNd->GetIndex())
2421 ))
2422 {
2423 //JP 18.02.99: Undo von Merge einer Tabelle mit der
2424 // der vorherigen, wenn dahinter auch noch eine steht
2425 // falls aber der Node in einer Tabelle steht, muss
2426 // natuerlich dieser returnt werden, wenn der SttNode eine
2427 // Section oder Tabelle ist!
2428 SwTableNode* pTblNd;
2429 if( pSttNd->IsTableNode() &&
2430 0 != ( pTblNd = pFrmNd->FindTableNode() ) &&
2431 // TABLE IN TABLE:
2432 pTblNd != pSttNd->StartOfSectionNode()->FindTableNode() )
2433 {
2434 pFrmNd = pTblNd;
2435 rFrmIdx = *pFrmNd;
2436 }
2437 else
2438 rFrmIdx = aIdx;
2439 }
2440 else if( pNd->IsEndNode() && pNd->StartOfSectionNode()->IsTableNode() )
2441 {
2442 pFrmNd = pNd->StartOfSectionNode();
2443 rFrmIdx = *pFrmNd;
2444 }
2445 else
2446 {
2447 if( pEnd )
2448 aIdx = pEnd->GetIndex() + 1;
2449 else
2450 aIdx = rFrmIdx.GetIndex() + 1;
2451
2452 if( (pFrmNd = &aIdx.GetNode())->IsTableNode() )
2453 rFrmIdx = aIdx;
2454 else
2455 {
2456 pFrmNd = 0;
2457
2458 // is there some sectionnodes before a tablenode?
2459 while( aIdx.GetNode().IsSectionNode() )
2460 {
2461 const SwSection& rSect = aIdx.GetNode().
2462 GetSectionNode()->GetSection();
2463 if( rSect.IsHiddenFlag() )
2464 aIdx = aIdx.GetNode().EndOfSectionIndex()+1;
2465 else
2466 aIdx++;
2467 }
2468 if( aIdx.GetNode().IsTableNode() )
2469 {
2470 rFrmIdx = aIdx;
2471 pFrmNd = &aIdx.GetNode();
2472 }
2473 }
2474 }
2475 }
2476 }
2477 }
2478 return pFrmNd;
2479 }
2480
ForEach(const SwNodeIndex & rStart,const SwNodeIndex & rEnd,FnForEach_SwNodes fnForEach,void * pArgs)2481 void SwNodes::ForEach( const SwNodeIndex& rStart, const SwNodeIndex& rEnd,
2482 FnForEach_SwNodes fnForEach, void* pArgs )
2483 {
2484 BigPtrArray::ForEach( rStart.GetIndex(), rEnd.GetIndex(),
2485 (FnForEach) fnForEach, pArgs );
2486 }
2487
2488 struct _TempBigPtrEntry : public BigPtrEntry
2489 {
_TempBigPtrEntry_TempBigPtrEntry2490 _TempBigPtrEntry() {}
2491 };
2492
2493
RemoveNode(sal_uLong nDelPos,sal_uLong nSz,sal_Bool bDel)2494 void SwNodes::RemoveNode( sal_uLong nDelPos, sal_uLong nSz, sal_Bool bDel )
2495 {
2496 sal_uLong nEnd = nDelPos + nSz;
2497 SwNode* pNew = (*this)[ nEnd ];
2498
2499 if( pRoot )
2500 {
2501 SwNodeIndex *p = pRoot;
2502 while( p )
2503 {
2504 sal_uLong nIdx = p->GetIndex();
2505 SwNodeIndex* pNext = p->pNext;
2506 if( nDelPos <= nIdx && nIdx < nEnd )
2507 (*p) = *pNew;
2508
2509 p = pNext;
2510 }
2511
2512 p = pRoot->pPrev;
2513 while( p )
2514 {
2515 sal_uLong nIdx = p->GetIndex();
2516 SwNodeIndex* pPrev = p->pPrev;
2517 if( nDelPos <= nIdx && nIdx < nEnd )
2518 (*p) = *pNew;
2519
2520 p = pPrev;
2521 }
2522 }
2523
2524 {
2525 for (sal_uLong nCnt = 0; nCnt < nSz; nCnt++)
2526 {
2527 SwTxtNode * pTxtNd = ((*this)[ nDelPos + nCnt ])->GetTxtNode();
2528
2529 if (pTxtNd)
2530 {
2531 // --> OD 2008-03-13 #refactorlists#
2532 // pTxtNd->UnregisterNumber();
2533 pTxtNd->RemoveFromList();
2534 // <--
2535 }
2536 }
2537 }
2538
2539 if( bDel )
2540 {
2541 sal_uLong nCnt = nSz;
2542 SwNode *pDel = (*this)[ nDelPos+nCnt-1 ], *pPrev = (*this)[ nDelPos+nCnt-2 ];
2543
2544 // temp. Object setzen
2545 //JP 24.08.98: muessten eigentlich einzeln removed werden, weil
2546 // das Remove auch rekursiv gerufen werden kann, z.B. bei
2547 // zeichengebundenen Rahmen. Da aber dabei viel zu viel
2548 // ablaueft, wird hier ein temp. Objekt eingefuegt, das
2549 // dann mit dem Remove wieder entfernt wird.
2550 // siehe Bug 55406
2551 _TempBigPtrEntry aTempEntry;
2552 BigPtrEntry* pTempEntry = &aTempEntry;
2553
2554 while( nCnt-- )
2555 {
2556 delete pDel;
2557 pDel = pPrev;
2558 sal_uLong nPrevNdIdx = pPrev->GetIndex();
2559 BigPtrArray::Replace( nPrevNdIdx+1, pTempEntry );
2560 if( nCnt )
2561 pPrev = (*this)[ nPrevNdIdx - 1 ];
2562 }
2563 nDelPos = pDel->GetIndex() + 1;
2564 }
2565
2566 BigPtrArray::Remove( nDelPos, nSz );
2567 }
2568
RegisterIndex(SwNodeIndex & rIdx)2569 void SwNodes::RegisterIndex( SwNodeIndex& rIdx )
2570 {
2571 if( !pRoot ) // noch keine Root gesetzt?
2572 {
2573 pRoot = &rIdx;
2574 pRoot->pPrev = 0;
2575 pRoot->pNext = 0;
2576 }
2577 else
2578 {
2579 // immer hinter die Root haengen
2580 rIdx.pNext = pRoot->pNext;
2581 pRoot->pNext = &rIdx;
2582 rIdx.pPrev = pRoot;
2583 if( rIdx.pNext )
2584 rIdx.pNext->pPrev = &rIdx;
2585 }
2586 }
2587
DeRegisterIndex(SwNodeIndex & rIdx)2588 void SwNodes::DeRegisterIndex( SwNodeIndex& rIdx )
2589 {
2590 SwNodeIndex* pN = rIdx.pNext;
2591 SwNodeIndex* pP = rIdx.pPrev;
2592
2593 if( pRoot == &rIdx )
2594 pRoot = pP ? pP : pN;
2595
2596 if( pP )
2597 pP->pNext = pN;
2598 if( pN )
2599 pN->pPrev = pP;
2600
2601 rIdx.pNext = 0;
2602 rIdx.pPrev = 0;
2603 }
2604
InsertNode(const SwNodePtr pNode,const SwNodeIndex & rPos)2605 void SwNodes::InsertNode( const SwNodePtr pNode,
2606 const SwNodeIndex& rPos )
2607 {
2608 const ElementPtr pIns = pNode;
2609 BigPtrArray::Insert( pIns, rPos.GetIndex() );
2610 }
2611
InsertNode(const SwNodePtr pNode,sal_uLong nPos)2612 void SwNodes::InsertNode( const SwNodePtr pNode,
2613 sal_uLong nPos )
2614 {
2615 const ElementPtr pIns = pNode;
2616 BigPtrArray::Insert( pIns, nPos );
2617 }
2618
2619 // ->#112139#
DocumentSectionStartNode(SwNode * pNode) const2620 SwNode * SwNodes::DocumentSectionStartNode(SwNode * pNode) const
2621 {
2622 if (NULL != pNode)
2623 {
2624 SwNodeIndex aIdx(*pNode);
2625
2626 if (aIdx <= (*this)[0]->EndOfSectionIndex())
2627 pNode = (*this)[0];
2628 else
2629 {
2630 while ((*this)[0] != pNode->StartOfSectionNode())
2631 pNode = pNode->StartOfSectionNode();
2632 }
2633 }
2634
2635 return pNode;
2636 }
2637
DocumentSectionEndNode(SwNode * pNode) const2638 SwNode * SwNodes::DocumentSectionEndNode(SwNode * pNode) const
2639 {
2640 return DocumentSectionStartNode(pNode)->EndOfSectionNode();
2641 }
2642
2643 //SwNode * SwNodes::operator[](int n) const
2644 //{
2645 // return operator[]((sal_uLong) n);
2646 //}
2647 // <-#112139#
2648
IsDocNodes() const2649 sal_Bool SwNodes::IsDocNodes() const
2650 {
2651 return this == &pMyDoc->GetNodes();
2652 }
2653