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 <sal/config.h>
21 :
22 : #include <utility>
23 :
24 : #include <UndoAttribute.hxx>
25 : #include <svl/itemiter.hxx>
26 : #include <editeng/tstpitem.hxx>
27 : #include <svx/svdmodel.hxx>
28 : #include <svx/svdpage.hxx>
29 : #include <drawdoc.hxx>
30 : #include <hintids.hxx>
31 : #include <fmtflcnt.hxx>
32 : #include <txtftn.hxx>
33 : #include <fmtornt.hxx>
34 : #include <fmtanchr.hxx>
35 : #include <fmtfsize.hxx>
36 : #include <frmfmt.hxx>
37 : #include <fmtcntnt.hxx>
38 : #include <ftnidx.hxx>
39 : #include <doc.hxx>
40 : #include <IDocumentUndoRedo.hxx>
41 : #include <IDocumentDrawModelAccess.hxx>
42 : #include <IDocumentLayoutAccess.hxx>
43 : #include <IDocumentRedlineAccess.hxx>
44 : #include <IShellCursorSupplier.hxx>
45 : #include <docary.hxx>
46 : #include <swundo.hxx>
47 : #include <pam.hxx>
48 : #include <ndtxt.hxx>
49 : #include <swtable.hxx>
50 : #include <swtblfmt.hxx>
51 : #include <UndoCore.hxx>
52 : #include <hints.hxx>
53 : #include <rolbck.hxx>
54 : #include <ndnotxt.hxx>
55 : #include <dcontact.hxx>
56 : #include <ftninfo.hxx>
57 : #include <redline.hxx>
58 : #include <section.hxx>
59 : #include <charfmt.hxx>
60 : #include <switerator.hxx>
61 :
62 158 : SwUndoFmtAttrHelper::SwUndoFmtAttrHelper( SwFmt& rFmt, bool bSvDrwPt )
63 : : SwClient( &rFmt )
64 158 : , m_bSaveDrawPt( bSvDrwPt )
65 : {
66 158 : }
67 :
68 156 : void SwUndoFmtAttrHelper::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
69 : {
70 156 : if( pOld )
71 : {
72 156 : if ( pOld->Which() == RES_OBJECTDYING )
73 : {
74 0 : CheckRegistration( pOld, pNew );
75 : }
76 156 : else if ( pNew )
77 : {
78 156 : if( POOLATTR_END >= pOld->Which() )
79 : {
80 0 : if ( GetUndo() )
81 : {
82 0 : m_pUndo->PutAttr( *pOld );
83 : }
84 : else
85 : {
86 : m_pUndo.reset( new SwUndoFmtAttr( *pOld,
87 0 : *static_cast<SwFmt*>(GetRegisteredInNonConst()), m_bSaveDrawPt ) );
88 : }
89 : }
90 156 : else if ( RES_ATTRSET_CHG == pOld->Which() )
91 : {
92 156 : if ( GetUndo() )
93 : {
94 : SfxItemIter aIter(
95 10 : *(static_cast<const SwAttrSetChg*>(pOld))->GetChgSet() );
96 10 : const SfxPoolItem* pItem = aIter.GetCurItem();
97 28 : while ( pItem )
98 : {
99 18 : m_pUndo->PutAttr( *pItem );
100 18 : if( aIter.IsAtEnd() )
101 10 : break;
102 8 : pItem = aIter.NextItem();
103 10 : }
104 : }
105 : else
106 : {
107 : m_pUndo.reset( new SwUndoFmtAttr(
108 146 : *static_cast<const SwAttrSetChg*>(pOld)->GetChgSet(),
109 146 : *static_cast<SwFmt*>(GetRegisteredInNonConst()), m_bSaveDrawPt ) );
110 : }
111 : }
112 : }
113 : }
114 156 : }
115 :
116 3630 : SwUndoFmtAttr::SwUndoFmtAttr( const SfxItemSet& rOldSet,
117 : SwFmt& rChgFmt,
118 : bool bSaveDrawPt )
119 : : SwUndo( UNDO_INSFMTATTR )
120 : , m_pFmt( &rChgFmt )
121 : // #i56253#
122 3630 : , m_pOldSet( new SfxItemSet( rOldSet ) )
123 : , m_nNodeIndex( 0 )
124 3630 : , m_nFmtWhich( rChgFmt.Which() )
125 10890 : , m_bSaveDrawPt( bSaveDrawPt )
126 : {
127 3630 : Init();
128 3630 : }
129 :
130 0 : SwUndoFmtAttr::SwUndoFmtAttr( const SfxPoolItem& rItem, SwFmt& rChgFmt,
131 : bool bSaveDrawPt )
132 : : SwUndo( UNDO_INSFMTATTR )
133 : , m_pFmt( &rChgFmt )
134 0 : , m_pOldSet( m_pFmt->GetAttrSet().Clone( false ) )
135 : , m_nNodeIndex( 0 )
136 0 : , m_nFmtWhich( rChgFmt.Which() )
137 0 : , m_bSaveDrawPt( bSaveDrawPt )
138 : {
139 0 : m_pOldSet->Put( rItem );
140 0 : Init();
141 0 : }
142 :
143 3630 : void SwUndoFmtAttr::Init()
144 : {
145 : // treat change of anchor specially
146 3630 : if ( SfxItemState::SET == m_pOldSet->GetItemState( RES_ANCHOR, false ))
147 : {
148 16 : SaveFlyAnchor( m_bSaveDrawPt );
149 : }
150 3614 : else if ( RES_FRMFMT == m_nFmtWhich )
151 : {
152 228 : SwDoc* pDoc = m_pFmt->GetDoc();
153 228 : if ( pDoc->GetTblFrmFmts()->Contains(static_cast<const SwFrmFmt*>(m_pFmt)))
154 : {
155 : // Table Format: save table position, table formats are volatile!
156 44 : SwTable * pTbl = SwIterator<SwTable,SwFmt>::FirstElement( *m_pFmt );
157 44 : if ( pTbl )
158 : {
159 44 : m_nNodeIndex = pTbl->GetTabSortBoxes()[ 0 ]->GetSttNd()
160 44 : ->FindTableNode()->GetIndex();
161 : }
162 : }
163 184 : else if ( pDoc->GetSections().Contains(static_cast<const SwSectionFmt*>(m_pFmt)))
164 : {
165 0 : m_nNodeIndex = m_pFmt->GetCntnt().GetCntntIdx()->GetIndex();
166 : }
167 184 : else if ( 0 != dynamic_cast< SwTableBoxFmt* >( m_pFmt ) )
168 : {
169 4 : SwTableBox * pTblBox = SwIterator<SwTableBox,SwFmt>::FirstElement( *m_pFmt );
170 4 : if ( pTblBox )
171 : {
172 4 : m_nNodeIndex = pTblBox->GetSttIdx();
173 : }
174 : }
175 : }
176 3630 : }
177 :
178 7260 : SwUndoFmtAttr::~SwUndoFmtAttr()
179 : {
180 7260 : }
181 :
182 4 : void SwUndoFmtAttr::UndoImpl(::sw::UndoRedoContext & rContext)
183 : {
184 : // OD 2004-10-26 #i35443#
185 : // Important note: <Undo(..)> also called by <ReDo(..)>
186 :
187 4 : if ( !m_pOldSet.get() || !m_pFmt || !IsFmtInDoc( &rContext.GetDoc() ))
188 4 : return;
189 :
190 : // #i35443# - If anchor attribute has been successful
191 : // restored, all other attributes are also restored.
192 : // Thus, keep track of its restoration
193 4 : bool bAnchorAttrRestored( false );
194 4 : if ( SfxItemState::SET == m_pOldSet->GetItemState( RES_ANCHOR, false ))
195 : {
196 0 : bAnchorAttrRestored = RestoreFlyAnchor(rContext);
197 0 : if ( bAnchorAttrRestored )
198 : {
199 : // Anchor attribute successful restored.
200 : // Thus, keep anchor position for redo
201 0 : SaveFlyAnchor();
202 : }
203 : else
204 : {
205 : // Anchor attribute not restored due to invalid anchor position.
206 : // Thus, delete anchor attribute.
207 0 : m_pOldSet->ClearItem( RES_ANCHOR );
208 : }
209 : }
210 :
211 4 : if ( !bAnchorAttrRestored )
212 : {
213 4 : SwUndoFmtAttrHelper aTmp( *m_pFmt, m_bSaveDrawPt );
214 4 : m_pFmt->SetFmtAttr( *m_pOldSet );
215 4 : if ( aTmp.GetUndo() )
216 : {
217 : // transfer ownership of helper object's old set
218 4 : m_pOldSet = std::move(aTmp.GetUndo()->m_pOldSet);
219 : }
220 : else
221 : {
222 0 : m_pOldSet->ClearItem();
223 : }
224 :
225 4 : if ( RES_FLYFRMFMT == m_nFmtWhich || RES_DRAWFRMFMT == m_nFmtWhich )
226 : {
227 0 : rContext.SetSelections(static_cast<SwFrmFmt*>(m_pFmt), 0);
228 4 : }
229 : }
230 : }
231 :
232 4 : bool SwUndoFmtAttr::IsFmtInDoc( SwDoc* pDoc )
233 : {
234 : // search for the Format in the Document; if it does not exist any more,
235 : // the attribute is not restored!
236 4 : sal_uInt16 nPos = USHRT_MAX;
237 4 : switch ( m_nFmtWhich )
238 : {
239 : case RES_TXTFMTCOLL:
240 : nPos = pDoc->GetTxtFmtColls()->GetPos(
241 0 : static_cast<const SwTxtFmtColl*>(m_pFmt) );
242 0 : break;
243 :
244 : case RES_GRFFMTCOLL:
245 : nPos = pDoc->GetGrfFmtColls()->GetPos(
246 0 : static_cast<const SwGrfFmtColl*>(m_pFmt) );
247 0 : break;
248 :
249 : case RES_CHRFMT:
250 : nPos = pDoc->GetCharFmts()->GetPos(
251 0 : static_cast<SwCharFmt*>(m_pFmt) );
252 0 : break;
253 :
254 : case RES_FRMFMT:
255 4 : if ( m_nNodeIndex && (m_nNodeIndex < pDoc->GetNodes().Count()) )
256 : {
257 4 : SwNode* pNd = pDoc->GetNodes()[ m_nNodeIndex ];
258 4 : if ( pNd->IsTableNode() )
259 : {
260 : m_pFmt =
261 2 : static_cast<SwTableNode*>(pNd)->GetTable().GetFrmFmt();
262 2 : nPos = 0;
263 2 : break;
264 : }
265 2 : else if ( pNd->IsSectionNode() )
266 : {
267 : m_pFmt =
268 0 : static_cast<SwSectionNode*>(pNd)->GetSection().GetFmt();
269 0 : nPos = 0;
270 0 : break;
271 : }
272 4 : else if ( pNd->IsStartNode() && (SwTableBoxStartNode ==
273 2 : static_cast< SwStartNode* >(pNd)->GetStartNodeType()) )
274 : {
275 2 : SwTableNode* pTblNode = pNd->FindTableNode();
276 2 : if ( pTblNode )
277 : {
278 : SwTableBox* pBox =
279 2 : pTblNode->GetTable().GetTblBox( m_nNodeIndex );
280 2 : if ( pBox )
281 : {
282 2 : m_pFmt = pBox->GetFrmFmt();
283 2 : nPos = 0;
284 2 : break;
285 : }
286 : }
287 : }
288 : }
289 : // no break!
290 : case RES_DRAWFRMFMT:
291 : case RES_FLYFRMFMT:
292 : nPos = pDoc->GetSpzFrmFmts()->GetPos(
293 0 : static_cast<const SwFrmFmt*>(m_pFmt) );
294 0 : if ( USHRT_MAX == nPos )
295 : {
296 : nPos = pDoc->GetFrmFmts()->GetPos(
297 0 : static_cast<const SwFrmFmt*>(m_pFmt) );
298 : }
299 0 : break;
300 : }
301 :
302 4 : if ( USHRT_MAX == nPos )
303 : {
304 : // Format does not exist; reset
305 0 : m_pFmt = 0;
306 : }
307 :
308 4 : return 0 != m_pFmt;
309 : }
310 :
311 : // Check if it is still in Doc
312 0 : SwFmt* SwUndoFmtAttr::GetFmt( SwDoc& rDoc )
313 : {
314 0 : return m_pFmt && IsFmtInDoc( &rDoc ) ? m_pFmt : 0;
315 : }
316 :
317 0 : void SwUndoFmtAttr::RedoImpl(::sw::UndoRedoContext & rContext)
318 : {
319 : // #i35443# - Because the undo stores the attributes for
320 : // redo, the same code as for <Undo(..)> can be applied for <Redo(..)>
321 0 : UndoImpl(rContext);
322 0 : }
323 :
324 0 : void SwUndoFmtAttr::RepeatImpl(::sw::RepeatContext & rContext)
325 : {
326 0 : if ( !m_pOldSet.get() )
327 0 : return;
328 :
329 0 : SwDoc & rDoc(rContext.GetDoc());
330 :
331 0 : switch ( m_nFmtWhich )
332 : {
333 : case RES_GRFFMTCOLL:
334 : {
335 : SwNoTxtNode *const pNd =
336 0 : rContext.GetRepeatPaM().GetNode().GetNoTxtNode();
337 0 : if( pNd )
338 : {
339 0 : rDoc.SetAttr( m_pFmt->GetAttrSet(), *pNd->GetFmtColl() );
340 : }
341 : }
342 0 : break;
343 :
344 : case RES_TXTFMTCOLL:
345 : {
346 : SwTxtNode *const pNd =
347 0 : rContext.GetRepeatPaM().GetNode().GetTxtNode();
348 0 : if( pNd )
349 : {
350 0 : rDoc.SetAttr( m_pFmt->GetAttrSet(), *pNd->GetFmtColl() );
351 : }
352 : }
353 0 : break;
354 :
355 : case RES_FLYFRMFMT:
356 : {
357 : // Check if the cursor is in a flying frame
358 : // Steps: search in all FlyFrmFormats for the FlyCntnt attribute
359 : // and validate if the cursor is in the respective section
360 : SwFrmFmt *const pFly =
361 0 : rContext.GetRepeatPaM().GetNode().GetFlyFmt();
362 0 : if( pFly )
363 : {
364 : // Bug 43672: do not set all attributes!
365 0 : if (SfxItemState::SET ==
366 0 : m_pFmt->GetAttrSet().GetItemState( RES_CNTNT ))
367 : {
368 0 : SfxItemSet aTmpSet( m_pFmt->GetAttrSet() );
369 0 : aTmpSet.ClearItem( RES_CNTNT );
370 0 : if( aTmpSet.Count() )
371 : {
372 0 : rDoc.SetAttr( aTmpSet, *pFly );
373 0 : }
374 : }
375 : else
376 : {
377 0 : rDoc.SetAttr( m_pFmt->GetAttrSet(), *pFly );
378 : }
379 : }
380 0 : break;
381 : }
382 : }
383 : }
384 :
385 3626 : SwRewriter SwUndoFmtAttr::GetRewriter() const
386 : {
387 3626 : SwRewriter aRewriter;
388 :
389 3626 : if (m_pFmt)
390 : {
391 3626 : aRewriter.AddRule(UndoArg1, m_pFmt->GetName());
392 : }
393 :
394 3626 : return aRewriter;
395 : }
396 :
397 18 : void SwUndoFmtAttr::PutAttr( const SfxPoolItem& rItem )
398 : {
399 18 : m_pOldSet->Put( rItem );
400 18 : if ( RES_ANCHOR == rItem.Which() )
401 : {
402 0 : SaveFlyAnchor( m_bSaveDrawPt );
403 : }
404 18 : }
405 :
406 16 : void SwUndoFmtAttr::SaveFlyAnchor( bool bSvDrwPt )
407 : {
408 : // Format is valid, otherwise you would not reach this point here
409 16 : if( bSvDrwPt )
410 : {
411 16 : if ( RES_DRAWFRMFMT == m_pFmt->Which() )
412 : {
413 0 : Point aPt( static_cast<SwFrmFmt*>(m_pFmt)->FindSdrObject()
414 0 : ->GetRelativePos() );
415 : // store old value as attribute, to keep SwUndoFmtAttr small
416 0 : m_pOldSet->Put( SwFmtFrmSize( ATT_VAR_SIZE, aPt.X(), aPt.Y() ) );
417 : }
418 : }
419 :
420 : const SwFmtAnchor& rAnchor =
421 16 : static_cast<const SwFmtAnchor&>( m_pOldSet->Get( RES_ANCHOR, false ) );
422 16 : if( !rAnchor.GetCntntAnchor() )
423 4 : return;
424 :
425 14 : sal_Int32 nCntnt = 0;
426 14 : switch( rAnchor.GetAnchorId() )
427 : {
428 : case FLY_AS_CHAR:
429 : case FLY_AT_CHAR:
430 10 : nCntnt = rAnchor.GetCntntAnchor()->nContent.GetIndex();
431 : // fallthrough
432 : case FLY_AT_PARA:
433 : case FLY_AT_FLY:
434 14 : m_nNodeIndex = rAnchor.GetCntntAnchor()->nNode.GetIndex();
435 14 : break;
436 : default:
437 0 : return;
438 : }
439 :
440 14 : SwFmtAnchor aAnchor( rAnchor.GetAnchorId(), nCntnt );
441 14 : m_pOldSet->Put( aAnchor );
442 : }
443 :
444 : // #i35443# - Add return value, type <bool>.
445 : // Return value indicates, if anchor attribute is restored.
446 : // Note: If anchor attribute is restored, all other existing attributes
447 : // are also restored.
448 0 : bool SwUndoFmtAttr::RestoreFlyAnchor(::sw::UndoRedoContext & rContext)
449 : {
450 0 : SwDoc *const pDoc = & rContext.GetDoc();
451 0 : SwFlyFrmFmt* pFrmFmt = static_cast<SwFlyFrmFmt*>(m_pFmt);
452 : const SwFmtAnchor& rAnchor =
453 0 : static_cast<const SwFmtAnchor&>( m_pOldSet->Get( RES_ANCHOR, false ) );
454 :
455 0 : SwFmtAnchor aNewAnchor( rAnchor.GetAnchorId() );
456 0 : if (FLY_AT_PAGE != rAnchor.GetAnchorId())
457 : {
458 0 : SwNode* pNd = pDoc->GetNodes()[ m_nNodeIndex ];
459 :
460 0 : if ( (FLY_AT_FLY == rAnchor.GetAnchorId())
461 0 : ? ( !pNd->IsStartNode() || (SwFlyStartNode !=
462 0 : static_cast<SwStartNode*>(pNd)->GetStartNodeType()) )
463 0 : : !pNd->IsTxtNode() )
464 : {
465 : // #i35443# - invalid position.
466 : // Thus, anchor attribute not restored
467 0 : return false;
468 : }
469 :
470 0 : SwPosition aPos( *pNd );
471 0 : if ((FLY_AS_CHAR == rAnchor.GetAnchorId()) ||
472 0 : (FLY_AT_CHAR == rAnchor.GetAnchorId()))
473 : {
474 0 : aPos.nContent.Assign( (SwTxtNode*)pNd, rAnchor.GetPageNum() );
475 0 : if ( aPos.nContent.GetIndex() >
476 0 : static_cast<SwTxtNode*>(pNd)->GetTxt().getLength())
477 : {
478 : // #i35443# - invalid position.
479 : // Thus, anchor attribute not restored
480 0 : return false;
481 : }
482 : }
483 0 : aNewAnchor.SetAnchor( &aPos );
484 : }
485 : else
486 0 : aNewAnchor.SetPageNum( rAnchor.GetPageNum() );
487 :
488 0 : Point aDrawSavePt, aDrawOldPt;
489 0 : if( pDoc->getIDocumentLayoutAccess().GetCurrentViewShell() )
490 : {
491 0 : if( RES_DRAWFRMFMT == pFrmFmt->Which() )
492 : {
493 : // get the old cached value
494 : const SwFmtFrmSize& rOldSize = static_cast<const SwFmtFrmSize&>(
495 0 : m_pOldSet->Get( RES_FRM_SIZE ) );
496 0 : aDrawSavePt.X() = rOldSize.GetWidth();
497 0 : aDrawSavePt.Y() = rOldSize.GetHeight();
498 0 : m_pOldSet->ClearItem( RES_FRM_SIZE );
499 :
500 : // write the current value into cache
501 0 : aDrawOldPt = pFrmFmt->FindSdrObject()->GetRelativePos();
502 : }
503 : else
504 : {
505 0 : pFrmFmt->DelFrms(); // delete Frms
506 : }
507 : }
508 :
509 0 : const SwFmtAnchor &rOldAnch = pFrmFmt->GetAnchor();
510 : // #i54336#
511 : // Consider case, that as-character anchored object has moved its anchor position.
512 0 : if (FLY_AS_CHAR == rOldAnch.GetAnchorId())
513 : {
514 : // With InCntnts it's tricky: the text attribute needs to be deleted.
515 : // Unfortunately, this not only destroys the Frms but also the format.
516 : // To prevent that, first detach the connection between attribute and
517 : // format.
518 0 : const SwPosition *pPos = rOldAnch.GetCntntAnchor();
519 0 : SwTxtNode *pTxtNode = (SwTxtNode*)&pPos->nNode.GetNode();
520 : OSL_ENSURE( pTxtNode->HasHints(), "Missing FlyInCnt-Hint." );
521 0 : const sal_Int32 nIdx = pPos->nContent.GetIndex();
522 : SwTxtAttr * const pHnt =
523 0 : pTxtNode->GetTxtAttrForCharAt( nIdx, RES_TXTATR_FLYCNT );
524 : OSL_ENSURE( pHnt && pHnt->Which() == RES_TXTATR_FLYCNT,
525 : "Missing FlyInCnt-Hint." );
526 : OSL_ENSURE( pHnt && pHnt->GetFlyCnt().GetFrmFmt() == pFrmFmt,
527 : "Wrong TxtFlyCnt-Hint." );
528 0 : const_cast<SwFmtFlyCnt&>(pHnt->GetFlyCnt()).SetFlyFmt();
529 :
530 : // Connection is now detached, therefore the attribute can be deleted
531 0 : pTxtNode->DeleteAttributes( RES_TXTATR_FLYCNT, nIdx, nIdx );
532 : }
533 :
534 : {
535 0 : m_pOldSet->Put( aNewAnchor );
536 0 : SwUndoFmtAttrHelper aTmp( *m_pFmt, m_bSaveDrawPt );
537 0 : m_pFmt->SetFmtAttr( *m_pOldSet );
538 0 : if ( aTmp.GetUndo() )
539 : {
540 0 : m_nNodeIndex = aTmp.GetUndo()->m_nNodeIndex;
541 : // transfer ownership of helper object's old set
542 0 : m_pOldSet = std::move(aTmp.GetUndo()->m_pOldSet);
543 : }
544 : else
545 : {
546 0 : m_pOldSet->ClearItem();
547 0 : }
548 : }
549 :
550 0 : if ( RES_DRAWFRMFMT == pFrmFmt->Which() )
551 : {
552 : SwDrawContact *pCont =
553 0 : static_cast<SwDrawContact*>(pFrmFmt->FindContactObj());
554 : // The Draw model also prepared an Undo object for its right positioning
555 : // which unfortunately is relative. Therefore block here a position
556 : // change of the Contact object by setting the anchor.
557 0 : SdrObject* pObj = pCont->GetMaster();
558 :
559 0 : if( pCont->GetAnchorFrm() && !pObj->IsInserted() )
560 : {
561 : OSL_ENSURE( pDoc->getIDocumentDrawModelAccess().GetDrawModel(),
562 : "RestoreFlyAnchor without DrawModel" );
563 0 : pDoc->getIDocumentDrawModelAccess().GetDrawModel()->GetPage( 0 )->InsertObject( pObj );
564 : }
565 0 : pObj->SetRelativePos( aDrawSavePt );
566 :
567 : // cache the old value again
568 : m_pOldSet->Put(
569 0 : SwFmtFrmSize( ATT_VAR_SIZE, aDrawOldPt.X(), aDrawOldPt.Y() ) );
570 : }
571 :
572 0 : if (FLY_AS_CHAR == aNewAnchor.GetAnchorId())
573 : {
574 0 : const SwPosition* pPos = aNewAnchor.GetCntntAnchor();
575 0 : SwTxtNode* pTxtNd = pPos->nNode.GetNode().GetTxtNode();
576 : OSL_ENSURE( pTxtNd, "no Text Node at position." );
577 0 : SwFmtFlyCnt aFmt( pFrmFmt );
578 0 : pTxtNd->InsertItem( aFmt, pPos->nContent.GetIndex(), 0 );
579 : }
580 :
581 0 : if( RES_DRAWFRMFMT != pFrmFmt->Which() )
582 0 : pFrmFmt->MakeFrms();
583 :
584 0 : rContext.SetSelections(pFrmFmt, 0);
585 :
586 : // #i35443# - anchor attribute restored.
587 0 : return true;
588 : }
589 :
590 0 : SwUndoFmtResetAttr::SwUndoFmtResetAttr( SwFmt& rChangedFormat,
591 : const sal_uInt16 nWhichId )
592 : : SwUndo( UNDO_RESETATTR )
593 : , m_pChangedFormat( &rChangedFormat )
594 0 : , m_nWhichId( nWhichId )
595 : {
596 0 : const SfxPoolItem* pItem = 0;
597 0 : if (rChangedFormat.GetItemState( nWhichId, false, &pItem ) == SfxItemState::SET)
598 : {
599 0 : m_pOldItem.reset( pItem->Clone() );
600 : }
601 0 : }
602 :
603 0 : SwUndoFmtResetAttr::~SwUndoFmtResetAttr()
604 : {
605 0 : }
606 :
607 0 : void SwUndoFmtResetAttr::UndoImpl(::sw::UndoRedoContext &)
608 : {
609 0 : if ( m_pOldItem.get() )
610 : {
611 0 : m_pChangedFormat->SetFmtAttr( *m_pOldItem );
612 : }
613 0 : }
614 :
615 0 : void SwUndoFmtResetAttr::RedoImpl(::sw::UndoRedoContext &)
616 : {
617 0 : if ( m_pOldItem.get() )
618 : {
619 0 : m_pChangedFormat->ResetFmtAttr( m_nWhichId );
620 : }
621 0 : }
622 :
623 22 : SwUndoResetAttr::SwUndoResetAttr( const SwPaM& rRange, sal_uInt16 nFmtId )
624 : : SwUndo( UNDO_RESETATTR ), SwUndRng( rRange )
625 22 : , m_pHistory( new SwHistory )
626 44 : , m_nFormatId( nFmtId )
627 : {
628 22 : }
629 :
630 10 : SwUndoResetAttr::SwUndoResetAttr( const SwPosition& rPos, sal_uInt16 nFmtId )
631 : : SwUndo( UNDO_RESETATTR )
632 10 : , m_pHistory( new SwHistory )
633 20 : , m_nFormatId( nFmtId )
634 : {
635 10 : nSttNode = nEndNode = rPos.nNode.GetIndex();
636 10 : nSttCntnt = nEndCntnt = rPos.nContent.GetIndex();
637 10 : }
638 :
639 64 : SwUndoResetAttr::~SwUndoResetAttr()
640 : {
641 64 : }
642 :
643 0 : void SwUndoResetAttr::UndoImpl(::sw::UndoRedoContext & rContext)
644 : {
645 : // reset old values
646 0 : SwDoc & rDoc = rContext.GetDoc();
647 0 : m_pHistory->TmpRollback( &rDoc, 0 );
648 0 : m_pHistory->SetTmpEnd( m_pHistory->Count() );
649 :
650 0 : if ((RES_CONDTXTFMTCOLL == m_nFormatId) &&
651 0 : (nSttNode == nEndNode) && (nSttCntnt == nEndCntnt))
652 : {
653 0 : SwTxtNode* pTNd = rDoc.GetNodes()[ nSttNode ]->GetTxtNode();
654 0 : if( pTNd )
655 : {
656 0 : SwIndex aIdx( pTNd, nSttCntnt );
657 0 : pTNd->DontExpandFmt( aIdx, false );
658 : }
659 : }
660 :
661 0 : AddUndoRedoPaM(rContext);
662 0 : }
663 :
664 0 : void SwUndoResetAttr::RedoImpl(::sw::UndoRedoContext & rContext)
665 : {
666 0 : SwDoc & rDoc = rContext.GetDoc();
667 0 : SwPaM & rPam = AddUndoRedoPaM(rContext);
668 :
669 0 : switch ( m_nFormatId )
670 : {
671 : case RES_CHRFMT:
672 0 : rDoc.RstTxtAttrs(rPam);
673 0 : break;
674 : case RES_TXTFMTCOLL:
675 0 : rDoc.ResetAttrs(rPam, false, m_Ids );
676 0 : break;
677 : case RES_CONDTXTFMTCOLL:
678 0 : rDoc.ResetAttrs(rPam, true, m_Ids );
679 :
680 0 : break;
681 : case RES_TXTATR_TOXMARK:
682 : // special treatment for TOXMarks
683 : {
684 0 : SwTOXMarks aArr;
685 0 : SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode );
686 0 : SwPosition aPos( aIdx, SwIndex( aIdx.GetNode().GetCntntNode(),
687 0 : nSttCntnt ));
688 :
689 0 : sal_uInt16 nCnt = rDoc.GetCurTOXMark( aPos, aArr );
690 0 : if( nCnt )
691 : {
692 0 : if( 1 < nCnt )
693 : {
694 : // search for the right one
695 0 : SwHistoryHint* pHHint = (GetHistory())[ 0 ];
696 0 : if( pHHint && HSTRY_SETTOXMARKHNT == pHHint->Which() )
697 : {
698 0 : while( nCnt )
699 : {
700 0 : if ( static_cast<SwHistorySetTOXMark*>(pHHint)
701 0 : ->IsEqual( *aArr[ --nCnt ] ) )
702 : {
703 0 : ++nCnt;
704 0 : break;
705 : }
706 : }
707 : }
708 : else
709 0 : nCnt = 0;
710 : }
711 : // found one, thus delete it
712 0 : if( nCnt-- )
713 : {
714 0 : rDoc.DeleteTOXMark( aArr[ nCnt ] );
715 : }
716 0 : }
717 : }
718 0 : break;
719 : }
720 0 : }
721 :
722 0 : void SwUndoResetAttr::RepeatImpl(::sw::RepeatContext & rContext)
723 : {
724 0 : if (m_nFormatId < RES_FMT_BEGIN)
725 : {
726 0 : return;
727 : }
728 :
729 0 : switch ( m_nFormatId )
730 : {
731 : case RES_CHRFMT:
732 0 : rContext.GetDoc().RstTxtAttrs(rContext.GetRepeatPaM());
733 0 : break;
734 : case RES_TXTFMTCOLL:
735 0 : rContext.GetDoc().ResetAttrs(rContext.GetRepeatPaM(), false, m_Ids);
736 0 : break;
737 : case RES_CONDTXTFMTCOLL:
738 0 : rContext.GetDoc().ResetAttrs(rContext.GetRepeatPaM(), true, m_Ids);
739 0 : break;
740 : }
741 : }
742 :
743 6 : void SwUndoResetAttr::SetAttrs( const std::set<sal_uInt16> &rAttrs )
744 : {
745 6 : m_Ids.clear();
746 6 : m_Ids.insert( rAttrs.begin(), rAttrs.end() );
747 6 : }
748 :
749 582 : SwUndoAttr::SwUndoAttr( const SwPaM& rRange, const SfxPoolItem& rAttr,
750 : const SetAttrMode nFlags )
751 : : SwUndo( UNDO_INSATTR ), SwUndRng( rRange )
752 1746 : , m_AttrSet( rRange.GetDoc()->GetAttrPool(), rAttr.Which(), rAttr.Which() )
753 582 : , m_pHistory( new SwHistory )
754 : , m_nNodeIndex( ULONG_MAX )
755 2910 : , m_nInsertFlags( nFlags )
756 : {
757 582 : m_AttrSet.Put( rAttr );
758 582 : }
759 :
760 17960 : SwUndoAttr::SwUndoAttr( const SwPaM& rRange, const SfxItemSet& rSet,
761 : const SetAttrMode nFlags )
762 : : SwUndo( UNDO_INSATTR ), SwUndRng( rRange )
763 : , m_AttrSet( rSet )
764 17960 : , m_pHistory( new SwHistory )
765 : , m_nNodeIndex( ULONG_MAX )
766 35920 : , m_nInsertFlags( nFlags )
767 : {
768 17960 : }
769 :
770 37082 : SwUndoAttr::~SwUndoAttr()
771 : {
772 37082 : }
773 :
774 0 : void SwUndoAttr::SaveRedlineData( const SwPaM& rPam, bool bIsCntnt )
775 : {
776 0 : SwDoc* pDoc = rPam.GetDoc();
777 0 : if ( pDoc->getIDocumentRedlineAccess().IsRedlineOn() )
778 : {
779 : m_pRedlineData.reset( new SwRedlineData( bIsCntnt
780 : ? nsRedlineType_t::REDLINE_INSERT
781 : : nsRedlineType_t::REDLINE_FORMAT,
782 0 : pDoc->getIDocumentRedlineAccess().GetRedlineAuthor() ) );
783 : }
784 :
785 0 : m_pRedlineSaveData.reset( new SwRedlineSaveDatas );
786 0 : if ( !FillSaveDataForFmt( rPam, *m_pRedlineSaveData ))
787 : {
788 0 : m_pRedlineSaveData.reset(0);
789 : }
790 :
791 0 : SetRedlineMode( pDoc->getIDocumentRedlineAccess().GetRedlineMode() );
792 0 : if ( bIsCntnt )
793 : {
794 0 : m_nNodeIndex = rPam.GetPoint()->nNode.GetIndex();
795 : }
796 0 : }
797 :
798 0 : void SwUndoAttr::UndoImpl(::sw::UndoRedoContext & rContext)
799 : {
800 0 : SwDoc *const pDoc = & rContext.GetDoc();
801 :
802 0 : RemoveIdx( *pDoc );
803 :
804 0 : if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
805 : {
806 0 : SwPaM aPam(pDoc->GetNodes().GetEndOfContent());
807 0 : if ( ULONG_MAX != m_nNodeIndex )
808 : {
809 0 : aPam.DeleteMark();
810 0 : aPam.GetPoint()->nNode = m_nNodeIndex;
811 0 : aPam.GetPoint()->nContent.Assign( aPam.GetCntntNode(), nSttCntnt );
812 0 : aPam.SetMark();
813 0 : aPam.GetPoint()->nContent++;
814 0 : pDoc->getIDocumentRedlineAccess().DeleteRedline(aPam, false, USHRT_MAX);
815 : }
816 : else
817 : {
818 : // remove all format redlines, will be recreated if needed
819 0 : SetPaM(aPam);
820 0 : pDoc->getIDocumentRedlineAccess().DeleteRedline(aPam, false, nsRedlineType_t::REDLINE_FORMAT);
821 0 : if ( m_pRedlineSaveData.get() )
822 : {
823 0 : SetSaveData( *pDoc, *m_pRedlineSaveData );
824 : }
825 0 : }
826 : }
827 :
828 0 : const bool bToLast = (1 == m_AttrSet.Count())
829 0 : && (RES_TXTATR_FIELD <= *m_AttrSet.GetRanges())
830 0 : && (*m_AttrSet.GetRanges() <= RES_TXTATR_ANNOTATION);
831 :
832 : // restore old values
833 0 : m_pHistory->TmpRollback( pDoc, 0, !bToLast );
834 0 : m_pHistory->SetTmpEnd( m_pHistory->Count() );
835 :
836 : // set cursor onto Undo area
837 0 : AddUndoRedoPaM(rContext);
838 0 : }
839 :
840 0 : void SwUndoAttr::RepeatImpl(::sw::RepeatContext & rContext)
841 : {
842 : // RefMarks are not repeat capable
843 0 : if ( SfxItemState::SET != m_AttrSet.GetItemState( RES_TXTATR_REFMARK, false ) )
844 : {
845 0 : rContext.GetDoc().getIDocumentContentOperations().InsertItemSet( rContext.GetRepeatPaM(),
846 0 : m_AttrSet, m_nInsertFlags );
847 : }
848 0 : else if ( 1 < m_AttrSet.Count() )
849 : {
850 0 : SfxItemSet aTmpSet( m_AttrSet );
851 0 : aTmpSet.ClearItem( RES_TXTATR_REFMARK );
852 0 : rContext.GetDoc().getIDocumentContentOperations().InsertItemSet( rContext.GetRepeatPaM(),
853 0 : aTmpSet, m_nInsertFlags );
854 : }
855 0 : }
856 :
857 0 : void SwUndoAttr::RedoImpl(::sw::UndoRedoContext & rContext)
858 : {
859 0 : SwDoc & rDoc = rContext.GetDoc();
860 0 : SwPaM & rPam = AddUndoRedoPaM(rContext);
861 :
862 0 : if ( m_pRedlineData.get() &&
863 0 : IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ) )
864 : {
865 0 : RedlineMode_t eOld = rDoc.getIDocumentRedlineAccess().GetRedlineMode();
866 0 : rDoc.getIDocumentRedlineAccess().SetRedlineMode_intern(static_cast<RedlineMode_t>(
867 0 : eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
868 0 : rDoc.getIDocumentContentOperations().InsertItemSet( rPam, m_AttrSet, m_nInsertFlags );
869 :
870 0 : if ( ULONG_MAX != m_nNodeIndex )
871 : {
872 0 : rPam.SetMark();
873 0 : if ( rPam.Move( fnMoveBackward ) )
874 : {
875 0 : rDoc.getIDocumentRedlineAccess().AppendRedline( new SwRangeRedline( *m_pRedlineData, rPam ),
876 0 : true);
877 : }
878 0 : rPam.DeleteMark();
879 : }
880 : else
881 : {
882 0 : rDoc.getIDocumentRedlineAccess().AppendRedline( new SwRangeRedline( *m_pRedlineData, rPam ), true);
883 : }
884 :
885 0 : rDoc.getIDocumentRedlineAccess().SetRedlineMode_intern( eOld );
886 : }
887 : else
888 : {
889 0 : rDoc.getIDocumentContentOperations().InsertItemSet( rPam, m_AttrSet, m_nInsertFlags );
890 : }
891 0 : }
892 :
893 0 : void SwUndoAttr::RemoveIdx( SwDoc& rDoc )
894 : {
895 0 : if ( SfxItemState::SET != m_AttrSet.GetItemState( RES_TXTATR_FTN, false ))
896 0 : return ;
897 :
898 : SwHistoryHint* pHstHnt;
899 0 : SwNodes& rNds = rDoc.GetNodes();
900 0 : for ( sal_uInt16 n = 0; n < m_pHistory->Count(); ++n )
901 : {
902 0 : sal_Int32 nCntnt = 0;
903 0 : sal_uLong nNode = 0;
904 0 : pHstHnt = (*m_pHistory)[ n ];
905 0 : switch ( pHstHnt->Which() )
906 : {
907 : case HSTRY_RESETTXTHNT:
908 : {
909 : SwHistoryResetTxt * pHistoryHint
910 0 : = static_cast<SwHistoryResetTxt*>(pHstHnt);
911 0 : if ( RES_TXTATR_FTN == pHistoryHint->GetWhich() )
912 : {
913 0 : nNode = pHistoryHint->GetNode();
914 0 : nCntnt = pHistoryHint->GetCntnt();
915 : }
916 : }
917 0 : break;
918 :
919 : case HSTRY_RESETATTRSET:
920 : {
921 : SwHistoryResetAttrSet * pHistoryHint
922 0 : = static_cast<SwHistoryResetAttrSet*>(pHstHnt);
923 0 : nCntnt = pHistoryHint->GetCntnt();
924 0 : if ( COMPLETE_STRING != nCntnt )
925 : {
926 0 : const std::vector<sal_uInt16>& rArr = pHistoryHint->GetArr();
927 0 : for ( size_t i = rArr.size(); i; )
928 : {
929 0 : if ( RES_TXTATR_FTN == rArr[ --i ] )
930 : {
931 0 : nNode = pHistoryHint->GetNode();
932 0 : break;
933 : }
934 : }
935 : }
936 : }
937 0 : break;
938 :
939 : default:
940 0 : break;
941 : }
942 :
943 0 : if( nNode )
944 : {
945 0 : SwTxtNode* pTxtNd = rNds[ nNode ]->GetTxtNode();
946 0 : if( pTxtNd )
947 : {
948 : SwTxtAttr *const pTxtHt =
949 0 : pTxtNd->GetTxtAttrForCharAt(nCntnt, RES_TXTATR_FTN);
950 0 : if( pTxtHt )
951 : {
952 : // ok, so get values
953 0 : SwTxtFtn* pFtn = static_cast<SwTxtFtn*>(pTxtHt);
954 0 : RemoveIdxFromSection( rDoc, pFtn->GetStartNode()->GetIndex() );
955 0 : return ;
956 : }
957 : }
958 : }
959 : }
960 : }
961 :
962 750 : SwUndoDefaultAttr::SwUndoDefaultAttr( const SfxItemSet& rSet )
963 750 : : SwUndo( UNDO_SETDEFTATTR )
964 : {
965 : const SfxPoolItem* pItem;
966 750 : if( SfxItemState::SET == rSet.GetItemState( RES_PARATR_TABSTOP, false, &pItem ) )
967 : {
968 : // store separately, because it may change!
969 122 : m_pTabStop.reset( static_cast<SvxTabStopItem*>(pItem->Clone()) );
970 122 : if ( 1 != rSet.Count() ) // are there more attributes?
971 : {
972 4 : m_pOldSet.reset( new SfxItemSet( rSet ) );
973 : }
974 : }
975 : else
976 : {
977 628 : m_pOldSet.reset( new SfxItemSet( rSet ) );
978 : }
979 750 : }
980 :
981 1500 : SwUndoDefaultAttr::~SwUndoDefaultAttr()
982 : {
983 1500 : }
984 :
985 0 : void SwUndoDefaultAttr::UndoImpl(::sw::UndoRedoContext & rContext)
986 : {
987 0 : SwDoc & rDoc = rContext.GetDoc();
988 0 : if ( m_pOldSet.get() )
989 : {
990 : SwUndoFmtAttrHelper aTmp(
991 0 : *const_cast<SwTxtFmtColl*>(rDoc.GetDfltTxtFmtColl()) );
992 0 : rDoc.SetDefault( *m_pOldSet );
993 0 : m_pOldSet.reset( 0 );
994 0 : if ( aTmp.GetUndo() )
995 : {
996 : // transfer ownership of helper object's old set
997 0 : m_pOldSet = std::move(aTmp.GetUndo()->m_pOldSet);
998 0 : }
999 : }
1000 0 : if ( m_pTabStop.get() )
1001 : {
1002 : SvxTabStopItem* pOld = static_cast<SvxTabStopItem*>(
1003 0 : rDoc.GetDefault( RES_PARATR_TABSTOP ).Clone() );
1004 0 : rDoc.SetDefault( *m_pTabStop );
1005 0 : m_pTabStop.reset( pOld );
1006 : }
1007 0 : }
1008 :
1009 0 : void SwUndoDefaultAttr::RedoImpl(::sw::UndoRedoContext & rContext)
1010 : {
1011 0 : UndoImpl(rContext);
1012 0 : }
1013 :
1014 0 : SwUndoMoveLeftMargin::SwUndoMoveLeftMargin(
1015 : const SwPaM& rPam, bool bFlag, bool bMod )
1016 : : SwUndo( bFlag ? UNDO_INC_LEFTMARGIN : UNDO_DEC_LEFTMARGIN )
1017 : , SwUndRng( rPam )
1018 0 : , m_pHistory( new SwHistory )
1019 0 : , m_bModulus( bMod )
1020 : {
1021 0 : }
1022 :
1023 0 : SwUndoMoveLeftMargin::~SwUndoMoveLeftMargin()
1024 : {
1025 0 : }
1026 :
1027 0 : void SwUndoMoveLeftMargin::UndoImpl(::sw::UndoRedoContext & rContext)
1028 : {
1029 0 : SwDoc & rDoc = rContext.GetDoc();
1030 :
1031 : // restore old values
1032 0 : m_pHistory->TmpRollback( & rDoc, 0 );
1033 0 : m_pHistory->SetTmpEnd( m_pHistory->Count() );
1034 :
1035 0 : AddUndoRedoPaM(rContext);
1036 0 : }
1037 :
1038 0 : void SwUndoMoveLeftMargin::RedoImpl(::sw::UndoRedoContext & rContext)
1039 : {
1040 0 : SwDoc & rDoc = rContext.GetDoc();
1041 0 : SwPaM & rPam = AddUndoRedoPaM(rContext);
1042 :
1043 : rDoc.MoveLeftMargin( rPam,
1044 0 : GetId() == UNDO_INC_LEFTMARGIN, m_bModulus );
1045 0 : }
1046 :
1047 0 : void SwUndoMoveLeftMargin::RepeatImpl(::sw::RepeatContext & rContext)
1048 : {
1049 0 : SwDoc & rDoc = rContext.GetDoc();
1050 0 : rDoc.MoveLeftMargin(rContext.GetRepeatPaM(), GetId() == UNDO_INC_LEFTMARGIN,
1051 0 : m_bModulus );
1052 0 : }
1053 :
1054 4 : SwUndoChangeFootNote::SwUndoChangeFootNote(
1055 : const SwPaM& rRange, const OUString& rTxt,
1056 : sal_uInt16 nNum, bool bIsEndNote )
1057 : : SwUndo( UNDO_CHGFTN ), SwUndRng( rRange )
1058 0 : , m_pHistory( new SwHistory() )
1059 : , m_Text( rTxt )
1060 : , m_nNumber( nNum )
1061 4 : , m_bEndNote( bIsEndNote )
1062 : {
1063 4 : }
1064 :
1065 8 : SwUndoChangeFootNote::~SwUndoChangeFootNote()
1066 : {
1067 8 : }
1068 :
1069 0 : void SwUndoChangeFootNote::UndoImpl(::sw::UndoRedoContext & rContext)
1070 : {
1071 0 : SwDoc & rDoc = rContext.GetDoc();
1072 :
1073 0 : m_pHistory->TmpRollback( &rDoc, 0 );
1074 0 : m_pHistory->SetTmpEnd( m_pHistory->Count() );
1075 :
1076 0 : rDoc.GetFtnIdxs().UpdateAllFtn();
1077 :
1078 0 : AddUndoRedoPaM(rContext);
1079 0 : }
1080 :
1081 0 : void SwUndoChangeFootNote::RedoImpl(::sw::UndoRedoContext & rContext)
1082 : {
1083 0 : SwDoc & rDoc( rContext.GetDoc() );
1084 0 : SwPaM & rPaM = AddUndoRedoPaM(rContext);
1085 0 : rDoc.SetCurFtn(rPaM, m_Text, m_nNumber, m_bEndNote);
1086 0 : SetPaM(rPaM);
1087 0 : }
1088 :
1089 0 : void SwUndoChangeFootNote::RepeatImpl(::sw::RepeatContext & rContext)
1090 : {
1091 0 : SwDoc & rDoc = rContext.GetDoc();
1092 0 : rDoc.SetCurFtn( rContext.GetRepeatPaM(), m_Text, m_nNumber, m_bEndNote );
1093 0 : }
1094 :
1095 26 : SwUndoFootNoteInfo::SwUndoFootNoteInfo( const SwFtnInfo &rInfo )
1096 : : SwUndo( UNDO_FTNINFO )
1097 26 : , m_pFootNoteInfo( new SwFtnInfo( rInfo ) )
1098 : {
1099 26 : }
1100 :
1101 52 : SwUndoFootNoteInfo::~SwUndoFootNoteInfo()
1102 : {
1103 52 : }
1104 :
1105 0 : void SwUndoFootNoteInfo::UndoImpl(::sw::UndoRedoContext & rContext)
1106 : {
1107 0 : SwDoc & rDoc = rContext.GetDoc();
1108 0 : SwFtnInfo *pInf = new SwFtnInfo( rDoc.GetFtnInfo() );
1109 0 : rDoc.SetFtnInfo( *m_pFootNoteInfo );
1110 0 : m_pFootNoteInfo.reset( pInf );
1111 0 : }
1112 :
1113 0 : void SwUndoFootNoteInfo::RedoImpl(::sw::UndoRedoContext & rContext)
1114 : {
1115 0 : SwDoc & rDoc = rContext.GetDoc();
1116 0 : SwFtnInfo *pInf = new SwFtnInfo( rDoc.GetFtnInfo() );
1117 0 : rDoc.SetFtnInfo( *m_pFootNoteInfo );
1118 0 : m_pFootNoteInfo.reset( pInf );
1119 0 : }
1120 :
1121 14 : SwUndoEndNoteInfo::SwUndoEndNoteInfo( const SwEndNoteInfo &rInfo )
1122 : : SwUndo( UNDO_FTNINFO )
1123 14 : , m_pEndNoteInfo( new SwEndNoteInfo( rInfo ) )
1124 : {
1125 14 : }
1126 :
1127 28 : SwUndoEndNoteInfo::~SwUndoEndNoteInfo()
1128 : {
1129 28 : }
1130 :
1131 0 : void SwUndoEndNoteInfo::UndoImpl(::sw::UndoRedoContext & rContext)
1132 : {
1133 0 : SwDoc & rDoc = rContext.GetDoc();
1134 0 : SwEndNoteInfo *pInf = new SwEndNoteInfo( rDoc.GetEndNoteInfo() );
1135 0 : rDoc.SetEndNoteInfo( *m_pEndNoteInfo );
1136 0 : m_pEndNoteInfo.reset( pInf );
1137 0 : }
1138 :
1139 0 : void SwUndoEndNoteInfo::RedoImpl(::sw::UndoRedoContext & rContext)
1140 : {
1141 0 : SwDoc & rDoc = rContext.GetDoc();
1142 0 : SwEndNoteInfo *pInf = new SwEndNoteInfo( rDoc.GetEndNoteInfo() );
1143 0 : rDoc.SetEndNoteInfo( *m_pEndNoteInfo );
1144 0 : m_pEndNoteInfo.reset( pInf );
1145 0 : }
1146 :
1147 2 : SwUndoDontExpandFmt::SwUndoDontExpandFmt( const SwPosition& rPos )
1148 : : SwUndo( UNDO_DONTEXPAND )
1149 2 : , m_nNodeIndex( rPos.nNode.GetIndex() )
1150 4 : , m_nContentIndex( rPos.nContent.GetIndex() )
1151 : {
1152 2 : }
1153 :
1154 0 : void SwUndoDontExpandFmt::UndoImpl(::sw::UndoRedoContext & rContext)
1155 : {
1156 0 : SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
1157 0 : SwDoc *const pDoc = & rContext.GetDoc();
1158 :
1159 0 : SwPosition& rPos = *pPam->GetPoint();
1160 0 : rPos.nNode = m_nNodeIndex;
1161 0 : rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(), m_nContentIndex);
1162 0 : pDoc->DontExpandFmt( rPos, false );
1163 0 : }
1164 :
1165 0 : void SwUndoDontExpandFmt::RedoImpl(::sw::UndoRedoContext & rContext)
1166 : {
1167 0 : SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
1168 0 : SwDoc *const pDoc = & rContext.GetDoc();
1169 :
1170 0 : SwPosition& rPos = *pPam->GetPoint();
1171 0 : rPos.nNode = m_nNodeIndex;
1172 0 : rPos.nContent.Assign( rPos.nNode.GetNode().GetCntntNode(), m_nContentIndex);
1173 0 : pDoc->DontExpandFmt( rPos );
1174 0 : }
1175 :
1176 0 : void SwUndoDontExpandFmt::RepeatImpl(::sw::RepeatContext & rContext)
1177 : {
1178 0 : SwPaM & rPam = rContext.GetRepeatPaM();
1179 0 : SwDoc & rDoc = rContext.GetDoc();
1180 0 : rDoc.DontExpandFmt( *rPam.GetPoint() );
1181 270 : }
1182 :
1183 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
