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