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