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