Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <UndoNumbering.hxx>
21 : #include <hintids.hxx>
22 : #include <editeng/lrspitem.hxx>
23 : #include <doc.hxx>
24 : #include <IDocumentUndoRedo.hxx>
25 : #include <swundo.hxx>
26 : #include <pam.hxx>
27 : #include <ndtxt.hxx>
28 : #include <UndoCore.hxx>
29 : #include <rolbck.hxx>
30 :
31 0 : SwUndoInsNum::SwUndoInsNum( const SwNumRule& rOldRule,
32 : const SwNumRule& rNewRule,
33 : SwUndoId nUndoId )
34 : : SwUndo( nUndoId ),
35 : aNumRule( rNewRule ), pHistory( 0 ), nSttSet( ULONG_MAX ),
36 0 : pOldNumRule( new SwNumRule( rOldRule )), nLRSavePos( 0 )
37 : {
38 0 : }
39 :
40 70 : SwUndoInsNum::SwUndoInsNum( const SwPaM& rPam, const SwNumRule& rRule )
41 : : SwUndo( UNDO_INSNUM ), SwUndRng( rPam ),
42 : aNumRule( rRule ), pHistory( 0 ),
43 70 : nSttSet( ULONG_MAX ), pOldNumRule( 0 ), nLRSavePos( 0 )
44 : {
45 70 : }
46 :
47 0 : SwUndoInsNum::SwUndoInsNum( const SwPosition& rPos, const SwNumRule& rRule,
48 : const OUString& rReplaceRule )
49 : : SwUndo( UNDO_INSNUM ),
50 : aNumRule( rRule ), pHistory( 0 ),
51 : nSttSet( ULONG_MAX ), pOldNumRule( 0 ),
52 0 : sReplaceRule( rReplaceRule ), nLRSavePos( 0 )
53 : {
54 : // No selection!
55 0 : nEndNode = 0, nEndContent = COMPLETE_STRING;
56 0 : nSttNode = rPos.nNode.GetIndex();
57 0 : nSttContent = rPos.nContent.GetIndex();
58 0 : }
59 :
60 210 : SwUndoInsNum::~SwUndoInsNum()
61 : {
62 70 : delete pHistory;
63 70 : delete pOldNumRule;
64 140 : }
65 :
66 70 : SwRewriter SwUndoInsNum::GetRewriter() const
67 : {
68 70 : SwRewriter aResult;
69 70 : if( UNDO_INSFMTATTR == GetId() )
70 0 : aResult.AddRule(UndoArg1, aNumRule.GetName());
71 70 : return aResult;
72 : }
73 :
74 0 : void SwUndoInsNum::UndoImpl(::sw::UndoRedoContext & rContext)
75 : {
76 0 : SwDoc & rDoc = rContext.GetDoc();
77 :
78 0 : if( pOldNumRule )
79 0 : rDoc.ChgNumRuleFormats( *pOldNumRule );
80 :
81 0 : if( pHistory )
82 : {
83 : SwTextNode* pNd;
84 0 : if( ULONG_MAX != nSttSet &&
85 0 : 0 != ( pNd = rDoc.GetNodes()[ nSttSet ]->GetTextNode() ))
86 0 : pNd->SetListRestart( true );
87 : else
88 0 : pNd = 0;
89 :
90 0 : if( nLRSavePos )
91 : {
92 : // Update immediately so that potential "old" LRSpaces will be valid again.
93 0 : pHistory->TmpRollback( &rDoc, nLRSavePos );
94 :
95 : }
96 0 : pHistory->TmpRollback( &rDoc, 0 );
97 0 : pHistory->SetTmpEnd( pHistory->Count() );
98 : }
99 :
100 0 : if (nSttNode)
101 : {
102 0 : AddUndoRedoPaM(rContext);
103 : }
104 0 : }
105 :
106 0 : void SwUndoInsNum::RedoImpl(::sw::UndoRedoContext & rContext)
107 : {
108 0 : SwDoc & rDoc = rContext.GetDoc();
109 :
110 0 : if ( pOldNumRule )
111 0 : rDoc.ChgNumRuleFormats( aNumRule );
112 0 : else if ( pHistory )
113 : {
114 0 : SwPaM & rPam( AddUndoRedoPaM(rContext) );
115 0 : if( !sReplaceRule.isEmpty() )
116 : {
117 0 : rDoc.ReplaceNumRule( *rPam.GetPoint(), sReplaceRule, aNumRule.GetName() );
118 : }
119 : else
120 : {
121 : // #i42921# - adapt to changed signature
122 0 : rDoc.SetNumRule(rPam, aNumRule, false);
123 : }
124 : }
125 0 : }
126 :
127 0 : void SwUndoInsNum::SetLRSpaceEndPos()
128 : {
129 0 : if( pHistory )
130 0 : nLRSavePos = pHistory->Count();
131 0 : }
132 :
133 0 : void SwUndoInsNum::RepeatImpl(::sw::RepeatContext & rContext)
134 : {
135 0 : SwDoc & rDoc( rContext.GetDoc() );
136 0 : if ( nSttNode )
137 : {
138 0 : if( sReplaceRule.isEmpty() )
139 : {
140 : // #i42921# - adapt to changed signature
141 0 : rDoc.SetNumRule(rContext.GetRepeatPaM(), aNumRule, false);
142 : }
143 : }
144 : else
145 : {
146 0 : rDoc.ChgNumRuleFormats( aNumRule );
147 : }
148 0 : }
149 :
150 0 : SwHistory* SwUndoInsNum::GetHistory()
151 : {
152 0 : if( !pHistory )
153 0 : pHistory = new SwHistory;
154 0 : return pHistory;
155 : }
156 :
157 0 : void SwUndoInsNum::SaveOldNumRule( const SwNumRule& rOld )
158 : {
159 0 : if( !pOldNumRule )
160 0 : pOldNumRule = new SwNumRule( rOld );
161 0 : }
162 :
163 0 : SwUndoDelNum::SwUndoDelNum( const SwPaM& rPam )
164 0 : : SwUndo( UNDO_DELNUM ), SwUndRng( rPam )
165 : {
166 0 : aNodes.reserve( nEndNode - nSttNode > 255 ? 255 : nEndNode - nSttNode );
167 0 : pHistory = new SwHistory;
168 0 : }
169 :
170 0 : SwUndoDelNum::~SwUndoDelNum()
171 : {
172 0 : delete pHistory;
173 0 : }
174 :
175 0 : void SwUndoDelNum::UndoImpl(::sw::UndoRedoContext & rContext)
176 : {
177 0 : SwDoc & rDoc = rContext.GetDoc();
178 :
179 0 : pHistory->TmpRollback( &rDoc, 0 );
180 0 : pHistory->SetTmpEnd( pHistory->Count() );
181 :
182 0 : for( std::vector<NodeLevel>::const_iterator i = aNodes.begin(); i != aNodes.end(); ++i )
183 : {
184 0 : SwTextNode* pNd = rDoc.GetNodes()[ i->index ]->GetTextNode();
185 : OSL_ENSURE( pNd, "Where has the TextNode gone?" );
186 0 : pNd->SetAttrListLevel( i->level );
187 :
188 0 : if( pNd->GetCondFormatColl() )
189 0 : pNd->ChkCondColl();
190 : }
191 :
192 0 : AddUndoRedoPaM(rContext);
193 0 : }
194 :
195 0 : void SwUndoDelNum::RedoImpl(::sw::UndoRedoContext & rContext)
196 : {
197 0 : SwPaM & rPam( AddUndoRedoPaM(rContext) );
198 0 : rContext.GetDoc().DelNumRules(rPam);
199 0 : }
200 :
201 0 : void SwUndoDelNum::RepeatImpl(::sw::RepeatContext & rContext)
202 : {
203 0 : rContext.GetDoc().DelNumRules(rContext.GetRepeatPaM());
204 0 : }
205 :
206 0 : void SwUndoDelNum::AddNode( const SwTextNode& rNd, bool )
207 : {
208 0 : if( rNd.GetNumRule() )
209 : {
210 0 : aNodes.push_back( NodeLevel( rNd.GetIndex(), rNd.GetActualListLevel() ) );
211 : }
212 0 : }
213 :
214 0 : SwUndoMoveNum::SwUndoMoveNum( const SwPaM& rPam, long nOff, bool bIsOutlMv )
215 : : SwUndo( bIsOutlMv ? UNDO_OUTLINE_UD : UNDO_MOVENUM ),
216 : SwUndRng( rPam ),
217 0 : nNewStt( 0 ), nOffset( nOff )
218 : {
219 : // nOffset: Down => 1
220 : // Up => -1
221 0 : }
222 :
223 0 : void SwUndoMoveNum::UndoImpl(::sw::UndoRedoContext & rContext)
224 : {
225 0 : sal_uLong nTmpStt = nSttNode, nTmpEnd = nEndNode;
226 :
227 0 : if (nEndNode || nEndContent != COMPLETE_STRING) // section?
228 : {
229 0 : if( nNewStt < nSttNode ) // moved forwards
230 0 : nEndNode = nEndNode - ( nSttNode - nNewStt );
231 : else
232 0 : nEndNode = nEndNode + ( nNewStt - nSttNode );
233 : }
234 0 : nSttNode = nNewStt;
235 :
236 0 : SwPaM & rPam( AddUndoRedoPaM(rContext) );
237 0 : rContext.GetDoc().MoveParagraph( rPam, -nOffset,
238 0 : UNDO_OUTLINE_UD == GetId() );
239 0 : nSttNode = nTmpStt;
240 0 : nEndNode = nTmpEnd;
241 0 : }
242 :
243 0 : void SwUndoMoveNum::RedoImpl(::sw::UndoRedoContext & rContext)
244 : {
245 0 : SwPaM & rPam( AddUndoRedoPaM(rContext) );
246 0 : rContext.GetDoc().MoveParagraph(rPam, nOffset, UNDO_OUTLINE_UD == GetId());
247 0 : }
248 :
249 0 : void SwUndoMoveNum::RepeatImpl(::sw::RepeatContext & rContext)
250 : {
251 0 : SwDoc & rDoc = rContext.GetDoc();
252 0 : if( UNDO_OUTLINE_UD == GetId() )
253 : {
254 0 : rDoc.MoveOutlinePara(rContext.GetRepeatPaM(),
255 0 : 0 < nOffset ? 1 : -1 );
256 : }
257 : else
258 : {
259 0 : rDoc.MoveParagraph(rContext.GetRepeatPaM(), nOffset, false);
260 : }
261 0 : }
262 :
263 0 : SwUndoNumUpDown::SwUndoNumUpDown( const SwPaM& rPam, short nOff )
264 : : SwUndo( nOff > 0 ? UNDO_NUMUP : UNDO_NUMDOWN ), SwUndRng( rPam ),
265 0 : nOffset( nOff )
266 : {
267 : // nOffset: Down => 1
268 : // Up => -1
269 0 : }
270 :
271 0 : void SwUndoNumUpDown::UndoImpl(::sw::UndoRedoContext & rContext)
272 : {
273 0 : SwPaM & rPam( AddUndoRedoPaM(rContext) );
274 0 : rContext.GetDoc().NumUpDown(rPam, 1 != nOffset );
275 0 : }
276 :
277 0 : void SwUndoNumUpDown::RedoImpl(::sw::UndoRedoContext & rContext)
278 : {
279 0 : SwPaM & rPam( AddUndoRedoPaM(rContext) );
280 0 : rContext.GetDoc().NumUpDown(rPam, 1 == nOffset);
281 0 : }
282 :
283 0 : void SwUndoNumUpDown::RepeatImpl(::sw::RepeatContext & rContext)
284 : {
285 0 : rContext.GetDoc().NumUpDown(rContext.GetRepeatPaM(), 1 == nOffset);
286 0 : }
287 :
288 : // #115901#
289 0 : SwUndoNumOrNoNum::SwUndoNumOrNoNum( const SwNodeIndex& rIdx, bool bOldNum,
290 : bool bNewNum)
291 0 : : SwUndo( UNDO_NUMORNONUM ), nIdx( rIdx.GetIndex() ), mbNewNum(bNewNum),
292 0 : mbOldNum(bOldNum)
293 : {
294 0 : }
295 :
296 : // #115901#, #i40034#
297 0 : void SwUndoNumOrNoNum::UndoImpl(::sw::UndoRedoContext & rContext)
298 : {
299 0 : SwNodeIndex aIdx( rContext.GetDoc().GetNodes(), nIdx );
300 0 : SwTextNode * pTextNd = aIdx.GetNode().GetTextNode();
301 :
302 0 : if (NULL != pTextNd)
303 : {
304 0 : pTextNd->SetCountedInList(mbOldNum);
305 0 : }
306 0 : }
307 :
308 : // #115901#, #i40034#
309 0 : void SwUndoNumOrNoNum::RedoImpl(::sw::UndoRedoContext & rContext)
310 : {
311 0 : SwNodeIndex aIdx( rContext.GetDoc().GetNodes(), nIdx );
312 0 : SwTextNode * pTextNd = aIdx.GetNode().GetTextNode();
313 :
314 0 : if (NULL != pTextNd)
315 : {
316 0 : pTextNd->SetCountedInList(mbNewNum);
317 0 : }
318 0 : }
319 :
320 : // #115901#
321 0 : void SwUndoNumOrNoNum::RepeatImpl(::sw::RepeatContext & rContext)
322 : {
323 0 : SwDoc & rDoc = rContext.GetDoc();
324 0 : if (mbOldNum && ! mbNewNum)
325 : {
326 0 : rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode, false);
327 : }
328 0 : else if ( ! mbOldNum && mbNewNum )
329 : {
330 0 : rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode, true);
331 : }
332 0 : }
333 :
334 12 : SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, bool bFlg )
335 : : SwUndo( UNDO_SETNUMRULESTART ),
336 12 : nIdx( rPos.nNode.GetIndex() ), nOldStt( USHRT_MAX ),
337 24 : nNewStt( USHRT_MAX ), bSetSttValue( false ), bFlag( bFlg )
338 : {
339 12 : }
340 :
341 2 : SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, sal_uInt16 nStt )
342 : : SwUndo(UNDO_SETNUMRULESTART)
343 2 : , nIdx(rPos.nNode.GetIndex())
344 : , nOldStt(USHRT_MAX)
345 : , nNewStt(nStt)
346 : , bSetSttValue(true)
347 4 : , bFlag(false)
348 : {
349 2 : SwTextNode* pTextNd = rPos.nNode.GetNode().GetTextNode();
350 2 : if ( pTextNd )
351 : {
352 2 : if ( pTextNd->HasAttrListRestartValue() )
353 : {
354 0 : nOldStt = static_cast<sal_uInt16>(pTextNd->GetAttrListRestartValue());
355 : }
356 : else
357 : {
358 2 : nOldStt = USHRT_MAX; // indicating, that the list restart value is not set
359 : }
360 : }
361 2 : }
362 :
363 0 : void SwUndoNumRuleStart::UndoImpl(::sw::UndoRedoContext & rContext)
364 : {
365 0 : SwDoc & rDoc = rContext.GetDoc();
366 0 : SwPosition const aPos( *rDoc.GetNodes()[ nIdx ] );
367 0 : if( bSetSttValue )
368 : {
369 0 : rDoc.SetNodeNumStart( aPos, nOldStt );
370 : }
371 : else
372 : {
373 0 : rDoc.SetNumRuleStart( aPos, !bFlag );
374 0 : }
375 0 : }
376 :
377 0 : void SwUndoNumRuleStart::RedoImpl(::sw::UndoRedoContext & rContext)
378 : {
379 0 : SwDoc & rDoc = rContext.GetDoc();
380 0 : SwPosition const aPos( *rDoc.GetNodes()[ nIdx ] );
381 0 : if( bSetSttValue )
382 : {
383 0 : rDoc.SetNodeNumStart( aPos, nNewStt );
384 : }
385 : else
386 : {
387 0 : rDoc.SetNumRuleStart( aPos, bFlag );
388 0 : }
389 0 : }
390 :
391 0 : void SwUndoNumRuleStart::RepeatImpl(::sw::RepeatContext & rContext)
392 : {
393 0 : SwDoc & rDoc = rContext.GetDoc();
394 0 : if( bSetSttValue )
395 : {
396 0 : rDoc.SetNodeNumStart(*rContext.GetRepeatPaM().GetPoint(), nNewStt);
397 : }
398 : else
399 : {
400 0 : rDoc.SetNumRuleStart(*rContext.GetRepeatPaM().GetPoint(), bFlag);
401 : }
402 177 : }
403 :
404 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
