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 :
21 : #include <svl/lstner.hxx>
22 :
23 : #include <svx/svdundo.hxx>
24 : #include <svx/svdotext.hxx>
25 : #include <svx/svdobj.hxx>
26 : #include <svx/svdpage.hxx>
27 : #include <svx/svdlayer.hxx>
28 : #include <svx/svdmodel.hxx>
29 : #include <svx/svdview.hxx>
30 : #include "svx/svdstr.hrc"
31 : #include "svdglob.hxx"
32 : #include <svx/scene3d.hxx>
33 : #include <editeng/editdata.hxx>
34 : #include <editeng/outlobj.hxx>
35 : #include <svx/svdogrp.hxx>
36 : #include <sdr/properties/itemsettools.hxx>
37 : #include <svx/sdr/properties/properties.hxx>
38 : #include <svx/svdocapt.hxx>
39 : #include <svl/whiter.hxx>
40 : #include <svx/e3dsceneupdater.hxx>
41 : #include <svx/svdviter.hxx>
42 : #include <svx/svdograf.hxx>
43 : #include <sdr/contact/viewcontactofgraphic.hxx>
44 : #include <svx/svdotable.hxx> // #i124389#
45 : #include <vcl/svapp.hxx>
46 :
47 :
48 : // iterates over all views and unmarks this SdrObject if it is marked
49 0 : static void ImplUnmarkObject( SdrObject* pObj )
50 : {
51 0 : SdrViewIter aIter( pObj );
52 0 : for ( SdrView* pView = aIter.FirstView(); pView; pView = aIter.NextView() )
53 : {
54 0 : pView->MarkObj( pObj, pView->GetSdrPageView(), true );
55 : }
56 0 : }
57 :
58 :
59 :
60 0 : TYPEINIT1(SdrUndoAction,SfxUndoAction);
61 :
62 9234 : SdrUndoAction::~SdrUndoAction() {}
63 :
64 20 : bool SdrUndoAction::CanRepeat(SfxRepeatTarget& rView) const
65 : {
66 20 : SdrView* pV=PTR_CAST(SdrView,&rView);
67 20 : if (pV!=NULL) return CanSdrRepeat(*pV);
68 20 : return false;
69 : }
70 :
71 0 : void SdrUndoAction::Repeat(SfxRepeatTarget& rView)
72 : {
73 0 : SdrView* pV=PTR_CAST(SdrView,&rView);
74 0 : if (pV!=NULL) SdrRepeat(*pV);
75 : DBG_ASSERT(pV!=NULL,"Repeat: SfxRepeatTarget that was handed over is not a SdrView");
76 0 : }
77 :
78 0 : OUString SdrUndoAction::GetRepeatComment(SfxRepeatTarget& rView) const
79 : {
80 0 : SdrView* pV=PTR_CAST(SdrView,&rView);
81 0 : if (pV!=NULL) return GetSdrRepeatComment(*pV);
82 0 : return OUString();
83 : }
84 :
85 0 : bool SdrUndoAction::CanSdrRepeat(SdrView& /*rView*/) const
86 : {
87 0 : return false;
88 : }
89 :
90 0 : void SdrUndoAction::SdrRepeat(SdrView& /*rView*/)
91 : {
92 0 : }
93 :
94 0 : OUString SdrUndoAction::GetSdrRepeatComment(SdrView& /*rView*/) const
95 : {
96 0 : return OUString();
97 : }
98 :
99 :
100 :
101 217 : SdrUndoGroup::SdrUndoGroup(SdrModel& rNewMod)
102 : : SdrUndoAction(rNewMod),
103 : aBuf(),
104 217 : eFunction(SDRREPFUNC_OBJ_NONE)
105 217 : {}
106 :
107 639 : SdrUndoGroup::~SdrUndoGroup()
108 : {
109 213 : Clear();
110 426 : }
111 :
112 213 : void SdrUndoGroup::Clear()
113 : {
114 479 : for (sal_uIntPtr nu=0; nu<GetActionCount(); nu++) {
115 266 : SdrUndoAction* pAct=GetAction(nu);
116 266 : delete pAct;
117 : }
118 213 : aBuf.clear();
119 213 : }
120 :
121 296 : void SdrUndoGroup::AddAction(SdrUndoAction* pAct)
122 : {
123 296 : aBuf.push_back(pAct);
124 296 : }
125 :
126 4 : void SdrUndoGroup::Undo()
127 : {
128 13 : for (sal_uIntPtr nu=GetActionCount(); nu>0;) {
129 5 : nu--;
130 5 : SdrUndoAction* pAct=GetAction(nu);
131 5 : pAct->Undo();
132 : }
133 4 : }
134 :
135 2 : void SdrUndoGroup::Redo()
136 : {
137 4 : for (sal_uIntPtr nu=0; nu<GetActionCount(); nu++) {
138 2 : SdrUndoAction* pAct=GetAction(nu);
139 2 : pAct->Redo();
140 : }
141 2 : }
142 :
143 151 : OUString SdrUndoGroup::GetComment() const
144 : {
145 151 : return aComment.replaceAll("%1", aObjDescription);
146 : }
147 :
148 0 : bool SdrUndoGroup::CanSdrRepeat(SdrView& rView) const
149 : {
150 0 : switch (eFunction)
151 : {
152 0 : case SDRREPFUNC_OBJ_NONE : return false;
153 0 : case SDRREPFUNC_OBJ_DELETE : return rView.AreObjectsMarked();
154 0 : case SDRREPFUNC_OBJ_COMBINE_POLYPOLY: return rView.IsCombinePossible(false);
155 0 : case SDRREPFUNC_OBJ_COMBINE_ONEPOLY : return rView.IsCombinePossible(true);
156 0 : case SDRREPFUNC_OBJ_DISMANTLE_POLYS : return rView.IsDismantlePossible(false);
157 0 : case SDRREPFUNC_OBJ_DISMANTLE_LINES : return rView.IsDismantlePossible(true);
158 0 : case SDRREPFUNC_OBJ_CONVERTTOPOLY : return rView.IsConvertToPolyObjPossible(false);
159 0 : case SDRREPFUNC_OBJ_CONVERTTOPATH : return rView.IsConvertToPathObjPossible(false);
160 0 : case SDRREPFUNC_OBJ_GROUP : return rView.IsGroupPossible();
161 0 : case SDRREPFUNC_OBJ_UNGROUP : return rView.IsUnGroupPossible();
162 0 : case SDRREPFUNC_OBJ_PUTTOTOP : return rView.IsToTopPossible();
163 0 : case SDRREPFUNC_OBJ_PUTTOBTM : return rView.IsToBtmPossible();
164 0 : case SDRREPFUNC_OBJ_MOVTOTOP : return rView.IsToTopPossible();
165 0 : case SDRREPFUNC_OBJ_MOVTOBTM : return rView.IsToBtmPossible();
166 0 : case SDRREPFUNC_OBJ_REVORDER : return rView.IsReverseOrderPossible();
167 0 : case SDRREPFUNC_OBJ_IMPORTMTF : return rView.IsImportMtfPossible();
168 0 : default: break;
169 : } // switch
170 0 : return false;
171 : }
172 :
173 0 : void SdrUndoGroup::SdrRepeat(SdrView& rView)
174 : {
175 0 : switch (eFunction)
176 : {
177 0 : case SDRREPFUNC_OBJ_NONE : break;
178 0 : case SDRREPFUNC_OBJ_DELETE : rView.DeleteMarked(); break;
179 0 : case SDRREPFUNC_OBJ_COMBINE_POLYPOLY: rView.CombineMarkedObjects(false); break;
180 0 : case SDRREPFUNC_OBJ_COMBINE_ONEPOLY : rView.CombineMarkedObjects(true); break;
181 0 : case SDRREPFUNC_OBJ_DISMANTLE_POLYS : rView.DismantleMarkedObjects(false); break;
182 0 : case SDRREPFUNC_OBJ_DISMANTLE_LINES : rView.DismantleMarkedObjects(true); break;
183 0 : case SDRREPFUNC_OBJ_CONVERTTOPOLY : rView.ConvertMarkedToPolyObj(false); break;
184 0 : case SDRREPFUNC_OBJ_CONVERTTOPATH : rView.ConvertMarkedToPathObj(false); break;
185 0 : case SDRREPFUNC_OBJ_GROUP : rView.GroupMarked(); break;
186 0 : case SDRREPFUNC_OBJ_UNGROUP : rView.UnGroupMarked(); break;
187 0 : case SDRREPFUNC_OBJ_PUTTOTOP : rView.PutMarkedToTop(); break;
188 0 : case SDRREPFUNC_OBJ_PUTTOBTM : rView.PutMarkedToBtm(); break;
189 0 : case SDRREPFUNC_OBJ_MOVTOTOP : rView.MovMarkedToTop(); break;
190 0 : case SDRREPFUNC_OBJ_MOVTOBTM : rView.MovMarkedToBtm(); break;
191 0 : case SDRREPFUNC_OBJ_REVORDER : rView.ReverseOrderOfMarked(); break;
192 0 : case SDRREPFUNC_OBJ_IMPORTMTF : rView.DoImportMarkedMtf(); break;
193 0 : default: break;
194 : } // switch
195 0 : }
196 :
197 0 : OUString SdrUndoGroup::GetSdrRepeatComment(SdrView& /*rView*/) const
198 : {
199 0 : return aComment.replaceAll("%1", ImpGetResStr(STR_ObjNameSingulPlural));
200 : }
201 :
202 2568 : SdrUndoObj::SdrUndoObj(SdrObject& rNewObj)
203 2568 : : SdrUndoAction(*rNewObj.GetModel())
204 2568 : , pObj(&rNewObj)
205 : {
206 2568 : }
207 :
208 2765 : OUString SdrUndoObj::GetDescriptionStringForObject( const SdrObject& _rForObject, sal_uInt16 nStrCacheID, bool bRepeat )
209 : {
210 2765 : OUString rStr = ImpGetResStr(nStrCacheID);
211 :
212 2765 : sal_Int32 nPos = rStr.indexOf("%1");
213 :
214 2765 : if(nPos != -1)
215 : {
216 2765 : if(bRepeat)
217 : {
218 0 : rStr = rStr.replaceAt(nPos, 2, ImpGetResStr(STR_ObjNameSingulPlural));
219 : }
220 : else
221 : {
222 2765 : OUString aStr(_rForObject.TakeObjNameSingul());
223 2765 : rStr = rStr.replaceAt(nPos, 2, aStr);
224 : }
225 : }
226 :
227 2765 : return rStr;
228 : }
229 :
230 2335 : void SdrUndoObj::ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, OUString& rStr, bool bRepeat) const
231 : {
232 2335 : if ( pObj )
233 2335 : rStr = GetDescriptionStringForObject( *pObj, nStrCacheID, bRepeat );
234 2335 : }
235 :
236 : // common call method for possible change of the page when UNDO/REDO is triggered
237 2 : void SdrUndoObj::ImpShowPageOfThisObject()
238 : {
239 2 : if(pObj && pObj->IsInserted() && pObj->GetPage() && pObj->GetModel())
240 : {
241 1 : SdrHint aHint(HINT_SWITCHTOPAGE);
242 :
243 1 : aHint.SetObject(pObj);
244 1 : aHint.SetPage(pObj->GetPage());
245 :
246 1 : pObj->GetModel()->Broadcast(aHint);
247 : }
248 2 : }
249 :
250 0 : void SdrUndoAttrObj::ensureStyleSheetInStyleSheetPool(SfxStyleSheetBasePool& rStyleSheetPool, SfxStyleSheet& rSheet)
251 : {
252 0 : SfxStyleSheetBase* pThere = rStyleSheetPool.Find(rSheet.GetName(), rSheet.GetFamily());
253 :
254 0 : if(!pThere)
255 : {
256 : // re-insert remembered style which was removed in the meantime. To do this
257 : // without assertion, do it without parent and set parent after insertion
258 0 : const OUString aParent(rSheet.GetParent());
259 :
260 0 : rSheet.SetParent(OUString());
261 0 : rStyleSheetPool.Insert(&rSheet);
262 0 : rSheet.SetParent(aParent);
263 : }
264 0 : }
265 :
266 0 : SdrUndoAttrObj::SdrUndoAttrObj(SdrObject& rNewObj, bool bStyleSheet1, bool bSaveText)
267 : : SdrUndoObj(rNewObj)
268 : , pUndoSet(NULL)
269 : , pRedoSet(NULL)
270 : , pRepeatSet(NULL)
271 : , mxUndoStyleSheet()
272 : , mxRedoStyleSheet()
273 : , bHaveToTakeRedoSet(true)
274 : , pTextUndo(NULL)
275 : , pTextRedo(NULL)
276 0 : , pUndoGroup(NULL)
277 : {
278 0 : bStyleSheet = bStyleSheet1;
279 :
280 0 : SdrObjList* pOL = rNewObj.GetSubList();
281 0 : bool bIsGroup(pOL!=NULL && pOL->GetObjCount());
282 0 : bool bIs3DScene(bIsGroup && pObj->ISA(E3dScene));
283 :
284 0 : if(bIsGroup)
285 : {
286 : // it's a group object!
287 0 : pUndoGroup = new SdrUndoGroup(*pObj->GetModel());
288 0 : const size_t nObjCount(pOL->GetObjCount());
289 :
290 0 : for(size_t nObjNum = 0; nObjNum < nObjCount; ++nObjNum)
291 : {
292 : pUndoGroup->AddAction(
293 0 : new SdrUndoAttrObj(*pOL->GetObj(nObjNum), bStyleSheet1));
294 : }
295 : }
296 :
297 0 : if(!bIsGroup || bIs3DScene)
298 : {
299 0 : pUndoSet = new SfxItemSet(pObj->GetMergedItemSet());
300 :
301 0 : if(bStyleSheet)
302 0 : mxUndoStyleSheet = pObj->GetStyleSheet();
303 :
304 0 : if(bSaveText)
305 : {
306 0 : pTextUndo = pObj->GetOutlinerParaObject();
307 0 : if(pTextUndo)
308 0 : pTextUndo = new OutlinerParaObject(*pTextUndo);
309 : }
310 : }
311 0 : }
312 :
313 0 : SdrUndoAttrObj::~SdrUndoAttrObj()
314 : {
315 0 : delete pUndoSet;
316 0 : delete pRedoSet;
317 0 : delete pRepeatSet;
318 0 : delete pUndoGroup;
319 0 : delete pTextUndo;
320 0 : delete pTextRedo;
321 0 : }
322 :
323 0 : void SdrUndoAttrObj::Undo()
324 : {
325 0 : E3DModifySceneSnapRectUpdater aUpdater(pObj);
326 0 : bool bIs3DScene(pObj && pObj->ISA(E3dScene));
327 :
328 : // Trigger PageChangeCall
329 0 : ImpShowPageOfThisObject();
330 :
331 0 : if(!pUndoGroup || bIs3DScene)
332 : {
333 0 : if(bHaveToTakeRedoSet)
334 : {
335 0 : bHaveToTakeRedoSet = false;
336 :
337 0 : delete pRedoSet;
338 :
339 0 : pRedoSet = new SfxItemSet(pObj->GetMergedItemSet());
340 :
341 0 : if(bStyleSheet)
342 0 : mxRedoStyleSheet = pObj->GetStyleSheet();
343 :
344 0 : if(pTextUndo)
345 : {
346 : // #i8508#
347 0 : pTextRedo = pObj->GetOutlinerParaObject();
348 :
349 0 : if(pTextRedo)
350 0 : pTextRedo = new OutlinerParaObject(*pTextRedo);
351 : }
352 : }
353 :
354 0 : if(bStyleSheet)
355 : {
356 0 : mxRedoStyleSheet = pObj->GetStyleSheet();
357 0 : SfxStyleSheet* pSheet = dynamic_cast< SfxStyleSheet* >(mxUndoStyleSheet.get());
358 :
359 0 : if(pSheet && pObj->GetModel() && pObj->GetModel()->GetStyleSheetPool())
360 : {
361 0 : ensureStyleSheetInStyleSheetPool(*pObj->GetModel()->GetStyleSheetPool(), *pSheet);
362 0 : pObj->SetStyleSheet(pSheet, true);
363 : }
364 : else
365 : {
366 : OSL_ENSURE(false, "OOps, something went wrong in SdrUndoAttrObj (!)");
367 : }
368 : }
369 :
370 0 : sdr::properties::ItemChangeBroadcaster aItemChange(*pObj);
371 :
372 : // Since ClearItem sets back everything to normal
373 : // it also sets fit-to-size text to non-fit-to-size text and
374 : // switches on autogrowheight (the default). That may lead to
375 : // losing the geometry size info for the object when it is
376 : // laid out again from AdjustTextFrameWidthAndHeight(). This makes
377 : // rescuing the size of the object necessary.
378 0 : const Rectangle aSnapRect = pObj->GetSnapRect();
379 :
380 0 : if(pUndoSet)
381 : {
382 0 : if(pObj->ISA(SdrCaptionObj))
383 : {
384 : // do a more smooth item deletion here, else the text
385 : // rect will be reformatted, especially when information regarding
386 : // vertical text is changed. When clearing only set items it's
387 : // slower, but safer regarding such information (it's not changed
388 : // usually)
389 0 : SfxWhichIter aIter(*pUndoSet);
390 0 : sal_uInt16 nWhich(aIter.FirstWhich());
391 :
392 0 : while(nWhich)
393 : {
394 0 : if(SfxItemState::SET != pUndoSet->GetItemState(nWhich, false))
395 : {
396 0 : pObj->ClearMergedItem(nWhich);
397 : }
398 :
399 0 : nWhich = aIter.NextWhich();
400 0 : }
401 : }
402 : else
403 : {
404 0 : pObj->ClearMergedItem();
405 : }
406 :
407 0 : pObj->SetMergedItemSet(*pUndoSet);
408 : }
409 :
410 : // Restore previous size here when it was changed.
411 0 : if(aSnapRect != pObj->GetSnapRect())
412 : {
413 0 : pObj->NbcSetSnapRect(aSnapRect);
414 : }
415 :
416 0 : pObj->GetProperties().BroadcastItemChange(aItemChange);
417 :
418 0 : if(pTextUndo)
419 : {
420 0 : pObj->SetOutlinerParaObject(new OutlinerParaObject(*pTextUndo));
421 0 : }
422 : }
423 :
424 0 : if(pUndoGroup)
425 : {
426 0 : pUndoGroup->Undo();
427 0 : }
428 0 : }
429 :
430 0 : void SdrUndoAttrObj::Redo()
431 : {
432 0 : E3DModifySceneSnapRectUpdater aUpdater(pObj);
433 0 : bool bIs3DScene(pObj && pObj->ISA(E3dScene));
434 :
435 0 : if(!pUndoGroup || bIs3DScene)
436 : {
437 0 : if(bStyleSheet)
438 : {
439 0 : mxUndoStyleSheet = pObj->GetStyleSheet();
440 0 : SfxStyleSheet* pSheet = dynamic_cast< SfxStyleSheet* >(mxRedoStyleSheet.get());
441 :
442 0 : if(pSheet && pObj->GetModel() && pObj->GetModel()->GetStyleSheetPool())
443 : {
444 0 : ensureStyleSheetInStyleSheetPool(*pObj->GetModel()->GetStyleSheetPool(), *pSheet);
445 0 : pObj->SetStyleSheet(pSheet, true);
446 : }
447 : else
448 : {
449 : OSL_ENSURE(false, "OOps, something went wrong in SdrUndoAttrObj (!)");
450 : }
451 : }
452 :
453 0 : sdr::properties::ItemChangeBroadcaster aItemChange(*pObj);
454 :
455 0 : const Rectangle aSnapRect = pObj->GetSnapRect();
456 :
457 0 : if(pRedoSet)
458 : {
459 0 : if(pObj->ISA(SdrCaptionObj))
460 : {
461 : // do a more smooth item deletion here, else the text
462 : // rect will be reformatted, especially when information regarding
463 : // vertical text is changed. When clearing only set items it's
464 : // slower, but safer regarding such information (it's not changed
465 : // usually)
466 0 : SfxWhichIter aIter(*pRedoSet);
467 0 : sal_uInt16 nWhich(aIter.FirstWhich());
468 :
469 0 : while(nWhich)
470 : {
471 0 : if(SfxItemState::SET != pRedoSet->GetItemState(nWhich, false))
472 : {
473 0 : pObj->ClearMergedItem(nWhich);
474 : }
475 :
476 0 : nWhich = aIter.NextWhich();
477 0 : }
478 : }
479 : else
480 : {
481 0 : pObj->ClearMergedItem();
482 : }
483 :
484 0 : pObj->SetMergedItemSet(*pRedoSet);
485 : }
486 :
487 : // Restore previous size here when it was changed.
488 0 : if(aSnapRect != pObj->GetSnapRect())
489 : {
490 0 : pObj->NbcSetSnapRect(aSnapRect);
491 : }
492 :
493 0 : pObj->GetProperties().BroadcastItemChange(aItemChange);
494 :
495 : // #i8508#
496 0 : if(pTextRedo)
497 : {
498 0 : pObj->SetOutlinerParaObject(new OutlinerParaObject(*pTextRedo));
499 0 : }
500 : }
501 :
502 0 : if(pUndoGroup)
503 : {
504 0 : pUndoGroup->Redo();
505 : }
506 :
507 : // Trigger PageChangeCall
508 0 : ImpShowPageOfThisObject();
509 0 : }
510 :
511 0 : OUString SdrUndoAttrObj::GetComment() const
512 : {
513 0 : OUString aStr;
514 :
515 0 : if(bStyleSheet)
516 : {
517 0 : ImpTakeDescriptionStr(STR_EditSetStylesheet, aStr);
518 : }
519 : else
520 : {
521 0 : ImpTakeDescriptionStr(STR_EditSetAttributes, aStr);
522 : }
523 :
524 0 : return aStr;
525 : }
526 :
527 0 : void SdrUndoAttrObj::SdrRepeat(SdrView& rView)
528 : {
529 0 : if(pRepeatSet)
530 : {
531 0 : rView.SetAttrToMarked(*pRepeatSet, false);
532 : }
533 0 : }
534 :
535 0 : bool SdrUndoAttrObj::CanSdrRepeat(SdrView& rView) const
536 : {
537 0 : return (pRepeatSet!=0L && rView.AreObjectsMarked());
538 : }
539 :
540 0 : OUString SdrUndoAttrObj::GetSdrRepeatComment(SdrView& /*rView*/) const
541 : {
542 0 : OUString aStr;
543 :
544 0 : if(bStyleSheet)
545 : {
546 0 : ImpTakeDescriptionStr(STR_EditSetStylesheet, aStr, true);
547 : }
548 : else
549 : {
550 0 : ImpTakeDescriptionStr(STR_EditSetAttributes, aStr, true);
551 : }
552 :
553 0 : return aStr;
554 : }
555 :
556 :
557 :
558 0 : SdrUndoMoveObj::~SdrUndoMoveObj() {}
559 :
560 0 : void SdrUndoMoveObj::Undo()
561 : {
562 : // Trigger PageChangeCall
563 0 : ImpShowPageOfThisObject();
564 :
565 0 : pObj->Move(Size(-aDistance.Width(),-aDistance.Height()));
566 0 : }
567 :
568 0 : void SdrUndoMoveObj::Redo()
569 : {
570 0 : pObj->Move(Size(aDistance.Width(),aDistance.Height()));
571 :
572 : // Trigger PageChangeCall
573 0 : ImpShowPageOfThisObject();
574 0 : }
575 :
576 0 : OUString SdrUndoMoveObj::GetComment() const
577 : {
578 0 : OUString aStr;
579 0 : ImpTakeDescriptionStr(STR_EditMove,aStr);
580 0 : return aStr;
581 : }
582 :
583 0 : void SdrUndoMoveObj::SdrRepeat(SdrView& rView)
584 : {
585 0 : rView.MoveMarkedObj(aDistance);
586 0 : }
587 :
588 0 : bool SdrUndoMoveObj::CanSdrRepeat(SdrView& rView) const
589 : {
590 0 : return rView.AreObjectsMarked();
591 : }
592 :
593 0 : OUString SdrUndoMoveObj::GetSdrRepeatComment(SdrView& /*rView*/) const
594 : {
595 0 : OUString aStr;
596 0 : ImpTakeDescriptionStr(STR_EditMove,aStr,true);
597 0 : return aStr;
598 : }
599 :
600 :
601 :
602 33 : SdrUndoGeoObj::SdrUndoGeoObj(SdrObject& rNewObj)
603 : : SdrUndoObj(rNewObj)
604 : , pUndoGeo(NULL)
605 : , pRedoGeo(NULL)
606 33 : , pUndoGroup(NULL)
607 : {
608 33 : SdrObjList* pOL=rNewObj.GetSubList();
609 33 : if (pOL!=NULL && pOL->GetObjCount() && !rNewObj.ISA(E3dScene))
610 : {
611 : // this is a group object!
612 : // If this were 3D scene, we'd only add an Undo for the scene itself
613 : // (which we do elsewhere).
614 0 : pUndoGroup=new SdrUndoGroup(*pObj->GetModel());
615 0 : const size_t nObjCount = pOL->GetObjCount();
616 0 : for (size_t nObjNum = 0; nObjNum<nObjCount; ++nObjNum) {
617 0 : pUndoGroup->AddAction(new SdrUndoGeoObj(*pOL->GetObj(nObjNum)));
618 : }
619 : }
620 : else
621 : {
622 33 : pUndoGeo=pObj->GetGeoData();
623 : }
624 33 : }
625 :
626 72 : SdrUndoGeoObj::~SdrUndoGeoObj()
627 : {
628 31 : delete pUndoGeo;
629 31 : delete pRedoGeo;
630 31 : delete pUndoGroup;
631 41 : }
632 :
633 1 : void SdrUndoGeoObj::Undo()
634 : {
635 : // Trigger PageChangeCall
636 1 : ImpShowPageOfThisObject();
637 :
638 1 : if(pUndoGroup)
639 : {
640 0 : pUndoGroup->Undo();
641 :
642 : // only repaint, no objectchange
643 0 : pObj->ActionChanged();
644 : }
645 : else
646 : {
647 1 : delete pRedoGeo;
648 1 : pRedoGeo=pObj->GetGeoData();
649 1 : pObj->SetGeoData(*pUndoGeo);
650 : }
651 1 : }
652 :
653 0 : void SdrUndoGeoObj::Redo()
654 : {
655 0 : if(pUndoGroup)
656 : {
657 0 : pUndoGroup->Redo();
658 :
659 : // only repaint, no objectchange
660 0 : pObj->ActionChanged();
661 : }
662 : else
663 : {
664 0 : delete pUndoGeo;
665 0 : pUndoGeo=pObj->GetGeoData();
666 0 : pObj->SetGeoData(*pRedoGeo);
667 : }
668 :
669 : // Trigger PageChangeCall
670 0 : ImpShowPageOfThisObject();
671 0 : }
672 :
673 25 : OUString SdrUndoGeoObj::GetComment() const
674 : {
675 25 : OUString aStr;
676 25 : ImpTakeDescriptionStr(STR_DragMethObjOwn,aStr);
677 25 : return aStr;
678 : }
679 :
680 :
681 :
682 1260 : SdrUndoObjList::SdrUndoObjList(SdrObject& rNewObj, bool bOrdNumDirect)
683 : : SdrUndoObj(rNewObj)
684 : , bOwner(false)
685 : , pView(NULL)
686 1260 : , pPageView(NULL)
687 : {
688 1260 : pObjList=pObj->GetObjList();
689 1260 : if (bOrdNumDirect)
690 : {
691 126 : nOrdNum=pObj->GetOrdNumDirect();
692 : }
693 : else
694 : {
695 1134 : nOrdNum=pObj->GetOrdNum();
696 : }
697 1260 : }
698 :
699 2400 : SdrUndoObjList::~SdrUndoObjList()
700 : {
701 1200 : SolarMutexGuard aGuard;
702 :
703 1200 : if (pObj!=NULL && IsOwner())
704 : {
705 : // Attribute have to go back to the regular Pool
706 737 : SetOwner(false);
707 :
708 : // now delete
709 737 : SdrObject::Free( pObj );
710 1200 : }
711 1200 : }
712 :
713 1508 : void SdrUndoObjList::SetOwner(bool bNew)
714 : {
715 1508 : bOwner = bNew;
716 1508 : }
717 :
718 :
719 0 : void SdrUndoObjList::SetOrdNum(sal_uInt32 nOrdNum_)
720 : {
721 0 : nOrdNum = nOrdNum_;
722 0 : }
723 :
724 :
725 :
726 1 : void SdrUndoRemoveObj::Undo()
727 : {
728 : // Trigger PageChangeCall
729 1 : ImpShowPageOfThisObject();
730 :
731 : DBG_ASSERT(!pObj->IsInserted(),"UndoRemoveObj: pObj has already been inserted.");
732 1 : if (!pObj->IsInserted())
733 : {
734 : // #i11426#
735 : // For UNDOs in Calc/Writer it is necessary to adapt the anchor
736 : // position of the target object.
737 1 : Point aOwnerAnchorPos(0, 0);
738 :
739 2 : if(pObjList &&
740 1 : pObjList->GetOwnerObj() &&
741 0 : pObjList->GetOwnerObj()->ISA(SdrObjGroup))
742 : {
743 0 : aOwnerAnchorPos = pObjList->GetOwnerObj()->GetAnchorPos();
744 : }
745 :
746 1 : E3DModifySceneSnapRectUpdater aUpdater(pObjList->GetOwnerObj());
747 1 : SdrInsertReason aReason(SDRREASON_UNDO);
748 1 : pObjList->InsertObject(pObj,nOrdNum,&aReason);
749 :
750 : // #i11426#
751 1 : if(aOwnerAnchorPos.X() || aOwnerAnchorPos.Y())
752 : {
753 0 : pObj->NbcSetAnchorPos(aOwnerAnchorPos);
754 1 : }
755 : }
756 1 : }
757 :
758 0 : void SdrUndoRemoveObj::Redo()
759 : {
760 : DBG_ASSERT(pObj->IsInserted(),"RedoRemoveObj: pObj is not inserted.");
761 0 : if (pObj->IsInserted())
762 : {
763 0 : ImplUnmarkObject( pObj );
764 0 : E3DModifySceneSnapRectUpdater aUpdater(pObj);
765 0 : pObjList->RemoveObject(nOrdNum);
766 : }
767 :
768 : // Trigger PageChangeCall
769 0 : ImpShowPageOfThisObject();
770 0 : }
771 :
772 946 : SdrUndoRemoveObj::~SdrUndoRemoveObj()
773 : {
774 946 : }
775 :
776 :
777 :
778 0 : void SdrUndoInsertObj::Undo()
779 : {
780 : // Trigger PageChangeCall
781 0 : ImpShowPageOfThisObject();
782 :
783 : DBG_ASSERT(pObj->IsInserted(),"UndoInsertObj: pObj is not inserted.");
784 0 : if (pObj->IsInserted())
785 : {
786 0 : ImplUnmarkObject( pObj );
787 :
788 : #ifdef DBG_UTIL
789 : SdrObject* pChkObj=
790 : #endif
791 0 : pObjList->RemoveObject(nOrdNum);
792 : DBG_ASSERT(pChkObj==pObj,"UndoInsertObj: RemoveObjNum!=pObj");
793 : }
794 0 : }
795 :
796 0 : void SdrUndoInsertObj::Redo()
797 : {
798 : DBG_ASSERT(!pObj->IsInserted(),"RedoInsertObj: pObj is already inserted");
799 0 : if (!pObj->IsInserted())
800 : {
801 : // Restore anchor position of an object,
802 : // which becomes a member of a group, because its cleared in method
803 : // <InsertObject(..)>. Needed for correct Redo in Writer. (#i45952#)
804 0 : Point aAnchorPos( 0, 0 );
805 0 : if ( pObjList &&
806 0 : pObjList->GetOwnerObj() &&
807 0 : pObjList->GetOwnerObj()->ISA(SdrObjGroup) )
808 : {
809 0 : aAnchorPos = pObj->GetAnchorPos();
810 : }
811 :
812 0 : SdrInsertReason aReason(SDRREASON_UNDO);
813 0 : pObjList->InsertObject(pObj,nOrdNum,&aReason);
814 :
815 : // Arcs lose position when grouped (#i45952#)
816 0 : if ( aAnchorPos.X() || aAnchorPos.Y() )
817 : {
818 0 : pObj->NbcSetAnchorPos( aAnchorPos );
819 : }
820 : }
821 :
822 : // Trigger PageChangeCall
823 0 : ImpShowPageOfThisObject();
824 0 : }
825 :
826 770 : SdrUndoDelObj::SdrUndoDelObj(SdrObject& rNewObj, bool bOrdNumDirect)
827 770 : : SdrUndoRemoveObj(rNewObj,bOrdNumDirect)
828 : {
829 770 : SetOwner(true);
830 770 : }
831 :
832 1 : void SdrUndoDelObj::Undo()
833 : {
834 1 : SdrUndoRemoveObj::Undo();
835 : DBG_ASSERT(IsOwner(),"UndoDeleteObj: pObj does not belong to UndoAction");
836 1 : SetOwner(false);
837 1 : }
838 :
839 0 : void SdrUndoDelObj::Redo()
840 : {
841 0 : SdrUndoRemoveObj::Redo();
842 : DBG_ASSERT(!IsOwner(),"RedoDeleteObj: pObj already belongs to UndoAction");
843 0 : SetOwner(true);
844 0 : }
845 :
846 782 : OUString SdrUndoDelObj::GetComment() const
847 : {
848 782 : OUString aStr;
849 782 : ImpTakeDescriptionStr(STR_EditDelete,aStr);
850 782 : return aStr;
851 : }
852 :
853 0 : void SdrUndoDelObj::SdrRepeat(SdrView& rView)
854 : {
855 0 : rView.DeleteMarked();
856 0 : }
857 :
858 0 : bool SdrUndoDelObj::CanSdrRepeat(SdrView& rView) const
859 : {
860 0 : return rView.AreObjectsMarked();
861 : }
862 :
863 0 : OUString SdrUndoDelObj::GetSdrRepeatComment(SdrView& /*rView*/) const
864 : {
865 0 : OUString aStr;
866 0 : ImpTakeDescriptionStr(STR_EditDelete,aStr,true);
867 0 : return aStr;
868 : }
869 :
870 :
871 :
872 0 : void SdrUndoNewObj::Undo()
873 : {
874 0 : SdrUndoInsertObj::Undo();
875 : DBG_ASSERT(!IsOwner(),"RedoNewObj: pObj already belongs to UndoAction");
876 0 : SetOwner(true);
877 0 : }
878 :
879 0 : void SdrUndoNewObj::Redo()
880 : {
881 0 : SdrUndoInsertObj::Redo();
882 : DBG_ASSERT(IsOwner(),"RedoNewObj: pObj does not belong to UndoAction");
883 0 : SetOwner(false);
884 0 : }
885 :
886 430 : OUString SdrUndoNewObj::GetComment( const SdrObject& _rForObject )
887 : {
888 430 : return GetDescriptionStringForObject( _rForObject, STR_UndoInsertObj );
889 : }
890 :
891 120 : OUString SdrUndoNewObj::GetComment() const
892 : {
893 120 : OUString aStr;
894 120 : ImpTakeDescriptionStr(STR_UndoInsertObj,aStr);
895 120 : return aStr;
896 : }
897 :
898 20 : SdrUndoReplaceObj::SdrUndoReplaceObj(SdrObject& rOldObj1, SdrObject& rNewObj1, bool bOrdNumDirect)
899 : : SdrUndoObj(rOldObj1)
900 : , bOldOwner(false)
901 : , bNewOwner(false)
902 20 : , pNewObj(&rNewObj1)
903 : {
904 20 : SetOldOwner(true);
905 :
906 20 : pObjList=pObj->GetObjList();
907 20 : if (bOrdNumDirect)
908 : {
909 0 : nOrdNum=pObj->GetOrdNumDirect();
910 : }
911 : else
912 : {
913 20 : nOrdNum=pObj->GetOrdNum();
914 : }
915 20 : }
916 :
917 40 : SdrUndoReplaceObj::~SdrUndoReplaceObj()
918 : {
919 20 : if (pObj!=NULL && IsOldOwner())
920 : {
921 : // Attribute have to go back into the Pool
922 20 : SetOldOwner(false);
923 :
924 : // now delete
925 20 : SdrObject::Free( pObj );
926 : }
927 20 : if (pNewObj!=NULL && IsNewOwner())
928 : {
929 : // Attribute have to go back into the Pool
930 0 : SetNewOwner(false);
931 :
932 : // now delete
933 0 : SdrObject::Free( pNewObj );
934 : }
935 20 : }
936 :
937 0 : void SdrUndoReplaceObj::Undo()
938 : {
939 : // Trigger PageChangeCall
940 0 : ImpShowPageOfThisObject();
941 :
942 0 : if (IsOldOwner() && !IsNewOwner())
943 : {
944 : DBG_ASSERT(!pObj->IsInserted(),"SdrUndoReplaceObj::Undo(): Old object is already inserted!");
945 : DBG_ASSERT(pNewObj->IsInserted(),"SdrUndoReplaceObj::Undo(): New object is not inserted!");
946 0 : SetOldOwner(false);
947 0 : SetNewOwner(true);
948 :
949 0 : ImplUnmarkObject( pNewObj );
950 0 : pObjList->ReplaceObject(pObj,nOrdNum);
951 : }
952 : else
953 : {
954 : OSL_FAIL("SdrUndoReplaceObj::Undo(): Wrong IsMine flags. Did you call Undo twice?");
955 : }
956 0 : }
957 :
958 0 : void SdrUndoReplaceObj::Redo()
959 : {
960 0 : if (!IsOldOwner() && IsNewOwner())
961 : {
962 : DBG_ASSERT(!pNewObj->IsInserted(),"SdrUndoReplaceObj::Redo(): New object is already inserted!!");
963 : DBG_ASSERT(pObj->IsInserted(),"SdrUndoReplaceObj::Redo(): Old object is not inserted!!");
964 0 : SetOldOwner(true);
965 0 : SetNewOwner(false);
966 :
967 0 : ImplUnmarkObject( pObj );
968 0 : pObjList->ReplaceObject(pNewObj,nOrdNum);
969 :
970 : }
971 : else
972 : {
973 : OSL_FAIL("SdrUndoReplaceObj::Redo(): Wrong IsMine flags. Did you call Redo twice?");
974 : }
975 :
976 : // Trigger PageChangeCall
977 0 : ImpShowPageOfThisObject();
978 0 : }
979 :
980 0 : void SdrUndoReplaceObj::SetNewOwner(bool bNew)
981 : {
982 0 : bNewOwner = bNew;
983 0 : }
984 :
985 40 : void SdrUndoReplaceObj::SetOldOwner(bool bNew)
986 : {
987 40 : bOldOwner = bNew;
988 40 : }
989 :
990 :
991 :
992 0 : OUString SdrUndoCopyObj::GetComment() const
993 : {
994 0 : OUString aStr;
995 0 : ImpTakeDescriptionStr(STR_UndoCopyObj,aStr);
996 0 : return aStr;
997 : }
998 :
999 :
1000 : // #i11702#
1001 :
1002 0 : SdrUndoObjectLayerChange::SdrUndoObjectLayerChange(SdrObject& rObj, SdrLayerID aOldLayer, SdrLayerID aNewLayer)
1003 : : SdrUndoObj(rObj)
1004 : , maOldLayer(aOldLayer)
1005 0 : , maNewLayer(aNewLayer)
1006 : {
1007 0 : }
1008 :
1009 0 : void SdrUndoObjectLayerChange::Undo()
1010 : {
1011 0 : ImpShowPageOfThisObject();
1012 0 : pObj->SetLayer(maOldLayer);
1013 0 : }
1014 :
1015 0 : void SdrUndoObjectLayerChange::Redo()
1016 : {
1017 0 : pObj->SetLayer(maNewLayer);
1018 0 : ImpShowPageOfThisObject();
1019 0 : }
1020 :
1021 :
1022 :
1023 0 : SdrUndoObjOrdNum::SdrUndoObjOrdNum(SdrObject& rNewObj, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1)
1024 : : SdrUndoObj(rNewObj)
1025 : , nOldOrdNum(nOldOrdNum1)
1026 0 : , nNewOrdNum(nNewOrdNum1)
1027 : {
1028 0 : }
1029 :
1030 0 : void SdrUndoObjOrdNum::Undo()
1031 : {
1032 : // Trigger PageChangeCall
1033 0 : ImpShowPageOfThisObject();
1034 :
1035 0 : SdrObjList* pOL=pObj->GetObjList();
1036 0 : if (pOL==NULL)
1037 : {
1038 : OSL_FAIL("UndoObjOrdNum: pObj does not have an ObjList.");
1039 0 : return;
1040 : }
1041 0 : pOL->SetObjectOrdNum(nNewOrdNum,nOldOrdNum);
1042 : }
1043 :
1044 0 : void SdrUndoObjOrdNum::Redo()
1045 : {
1046 0 : SdrObjList* pOL=pObj->GetObjList();
1047 0 : if (pOL==NULL)
1048 : {
1049 : OSL_FAIL("RedoObjOrdNum: pObj does not have an ObjList.");
1050 0 : return;
1051 : }
1052 0 : pOL->SetObjectOrdNum(nOldOrdNum,nNewOrdNum);
1053 :
1054 : // Trigger PageChangeCall
1055 0 : ImpShowPageOfThisObject();
1056 : }
1057 :
1058 0 : OUString SdrUndoObjOrdNum::GetComment() const
1059 : {
1060 0 : OUString aStr;
1061 0 : ImpTakeDescriptionStr(STR_UndoObjOrdNum,aStr);
1062 0 : return aStr;
1063 : }
1064 :
1065 :
1066 :
1067 2 : SdrUndoObjSetText::SdrUndoObjSetText(SdrObject& rNewObj, sal_Int32 nText)
1068 : : SdrUndoObj(rNewObj)
1069 : , pOldText(NULL)
1070 : , pNewText(NULL)
1071 : , bNewTextAvailable(false)
1072 : , bEmptyPresObj(false)
1073 2 : , mnText(nText)
1074 : {
1075 2 : SdrText* pText = static_cast< SdrTextObj*>( &rNewObj )->getText(mnText);
1076 2 : if( pText && pText->GetOutlinerParaObject() )
1077 2 : pOldText = new OutlinerParaObject(*pText->GetOutlinerParaObject());
1078 :
1079 2 : bEmptyPresObj = rNewObj.IsEmptyPresObj();
1080 2 : }
1081 :
1082 4 : SdrUndoObjSetText::~SdrUndoObjSetText()
1083 : {
1084 2 : delete pOldText;
1085 2 : delete pNewText;
1086 2 : }
1087 :
1088 2 : void SdrUndoObjSetText::AfterSetText()
1089 : {
1090 2 : if (!bNewTextAvailable)
1091 : {
1092 2 : SdrText* pText = static_cast< SdrTextObj*>( pObj )->getText(mnText);
1093 2 : if( pText && pText->GetOutlinerParaObject() )
1094 2 : pNewText = new OutlinerParaObject(*pText->GetOutlinerParaObject());
1095 2 : bNewTextAvailable=true;
1096 : }
1097 2 : }
1098 :
1099 0 : void SdrUndoObjSetText::Undo()
1100 : {
1101 : // only works with SdrTextObj
1102 0 : SdrTextObj* pTarget = dynamic_cast< SdrTextObj* >(pObj);
1103 :
1104 0 : if(!pTarget)
1105 : {
1106 : OSL_ENSURE(false, "SdrUndoObjSetText::Undo with SdrObject not based on SdrTextObj (!)");
1107 0 : return;
1108 : }
1109 :
1110 : // Trigger PageChangeCall
1111 0 : ImpShowPageOfThisObject();
1112 :
1113 : // save old text for Redo
1114 0 : if(!bNewTextAvailable)
1115 : {
1116 0 : AfterSetText();
1117 : }
1118 :
1119 0 : SdrText* pText = pTarget->getText(mnText);
1120 0 : if (pText)
1121 : {
1122 : // copy text for Undo, because the original now belongs to SetOutlinerParaObject()
1123 0 : OutlinerParaObject* pText1 = pOldText ? new OutlinerParaObject(*pOldText) : NULL;
1124 0 : pText->SetOutlinerParaObject(pText1);
1125 0 : pTarget->NbcSetOutlinerParaObjectForText(pText1, pText);
1126 : }
1127 :
1128 0 : pTarget->SetEmptyPresObj(bEmptyPresObj);
1129 0 : pTarget->ActionChanged();
1130 :
1131 : // #i124389# if it's a table, also need to relayout TextFrame
1132 0 : if(0 != dynamic_cast< sdr::table::SdrTableObj* >(pTarget))
1133 : {
1134 0 : pTarget->NbcAdjustTextFrameWidthAndHeight();
1135 : }
1136 :
1137 : // #i122410# SetOutlinerParaObject at SdrText does not trigger a
1138 : // BroadcastObjectChange, but it is needed to make evtl. SlideSorters
1139 : // update their preview.
1140 0 : pTarget->BroadcastObjectChange();
1141 : }
1142 :
1143 0 : void SdrUndoObjSetText::Redo()
1144 : {
1145 : // only works with SdrTextObj
1146 0 : SdrTextObj* pTarget = dynamic_cast< SdrTextObj* >(pObj);
1147 :
1148 0 : if(!pTarget)
1149 : {
1150 : OSL_ENSURE(false, "SdrUndoObjSetText::Redo with SdrObject not based on SdrTextObj (!)");
1151 0 : return;
1152 : }
1153 :
1154 0 : SdrText* pText = pTarget->getText(mnText);
1155 0 : if (pText)
1156 : {
1157 : // copy text for Undo, because the original now belongs to SetOutlinerParaObject()
1158 0 : OutlinerParaObject* pText1 = pNewText ? new OutlinerParaObject(*pNewText) : NULL;
1159 0 : pTarget->NbcSetOutlinerParaObjectForText( pText1, pText );
1160 : }
1161 :
1162 0 : pTarget->ActionChanged();
1163 :
1164 : // #i124389# if it's a table, als oneed to relayout TextFrame
1165 0 : if(0 != dynamic_cast< sdr::table::SdrTableObj* >(pTarget))
1166 : {
1167 0 : pTarget->NbcAdjustTextFrameWidthAndHeight();
1168 : }
1169 :
1170 : // #i122410# NbcSetOutlinerParaObjectForText at SdrTextObj does not trigger a
1171 : // BroadcastObjectChange, but it is needed to make evtl. SlideSorters
1172 : // update their preview.
1173 0 : pTarget->BroadcastObjectChange();
1174 :
1175 : // Trigger PageChangeCall
1176 0 : ImpShowPageOfThisObject();
1177 : }
1178 :
1179 2 : OUString SdrUndoObjSetText::GetComment() const
1180 : {
1181 2 : OUString aStr;
1182 2 : ImpTakeDescriptionStr(STR_UndoObjSetText,aStr);
1183 2 : return aStr;
1184 : }
1185 :
1186 0 : OUString SdrUndoObjSetText::GetSdrRepeatComment(SdrView& /*rView*/) const
1187 : {
1188 0 : OUString aStr;
1189 0 : ImpTakeDescriptionStr(STR_UndoObjSetText,aStr);
1190 0 : return aStr;
1191 : }
1192 :
1193 0 : void SdrUndoObjSetText::SdrRepeat(SdrView& rView)
1194 : {
1195 0 : if (bNewTextAvailable && rView.AreObjectsMarked())
1196 : {
1197 0 : const SdrMarkList& rML=rView.GetMarkedObjectList();
1198 :
1199 0 : const bool bUndo = rView.IsUndoEnabled();
1200 0 : if( bUndo )
1201 : {
1202 0 : OUString aStr;
1203 0 : ImpTakeDescriptionStr(STR_UndoObjSetText,aStr);
1204 0 : rView.BegUndo(aStr);
1205 : }
1206 :
1207 0 : const size_t nCount=rML.GetMarkCount();
1208 0 : for (size_t nm=0; nm<nCount; ++nm)
1209 : {
1210 0 : SdrObject* pObj2=rML.GetMark(nm)->GetMarkedSdrObj();
1211 0 : SdrTextObj* pTextObj=PTR_CAST(SdrTextObj,pObj2);
1212 0 : if (pTextObj!=NULL)
1213 : {
1214 0 : if( bUndo )
1215 0 : rView.AddUndo(new SdrUndoObjSetText(*pTextObj,0));
1216 :
1217 0 : OutlinerParaObject* pText1=pNewText;
1218 0 : if (pText1!=NULL)
1219 0 : pText1 = new OutlinerParaObject(*pText1);
1220 0 : pTextObj->SetOutlinerParaObject(pText1);
1221 : }
1222 : }
1223 :
1224 0 : if( bUndo )
1225 0 : rView.EndUndo();
1226 : }
1227 0 : }
1228 :
1229 0 : bool SdrUndoObjSetText::CanSdrRepeat(SdrView& rView) const
1230 : {
1231 0 : bool bOk = false;
1232 0 : if (bNewTextAvailable && rView.AreObjectsMarked()) {
1233 0 : bOk=true;
1234 : }
1235 0 : return bOk;
1236 : }
1237 :
1238 : // Undo/Redo for setting object's name (#i73249#)
1239 704 : SdrUndoObjStrAttr::SdrUndoObjStrAttr( SdrObject& rNewObj,
1240 : const ObjStrAttrType eObjStrAttr,
1241 : const OUString& sOldStr,
1242 : const OUString& sNewStr)
1243 : : SdrUndoObj( rNewObj )
1244 : , meObjStrAttr( eObjStrAttr )
1245 : , msOldStr( sOldStr )
1246 704 : , msNewStr( sNewStr )
1247 : {
1248 704 : }
1249 :
1250 0 : void SdrUndoObjStrAttr::Undo()
1251 : {
1252 0 : ImpShowPageOfThisObject();
1253 :
1254 0 : switch ( meObjStrAttr )
1255 : {
1256 : case OBJ_NAME:
1257 0 : pObj->SetName( msOldStr );
1258 0 : break;
1259 : case OBJ_TITLE:
1260 0 : pObj->SetTitle( msOldStr );
1261 0 : break;
1262 : case OBJ_DESCRIPTION:
1263 0 : pObj->SetDescription( msOldStr );
1264 0 : break;
1265 : }
1266 0 : }
1267 :
1268 0 : void SdrUndoObjStrAttr::Redo()
1269 : {
1270 0 : switch ( meObjStrAttr )
1271 : {
1272 : case OBJ_NAME:
1273 0 : pObj->SetName( msNewStr );
1274 0 : break;
1275 : case OBJ_TITLE:
1276 0 : pObj->SetTitle( msNewStr );
1277 0 : break;
1278 : case OBJ_DESCRIPTION:
1279 0 : pObj->SetDescription( msNewStr );
1280 0 : break;
1281 : }
1282 :
1283 0 : ImpShowPageOfThisObject();
1284 0 : }
1285 :
1286 1406 : OUString SdrUndoObjStrAttr::GetComment() const
1287 : {
1288 1406 : OUString aStr;
1289 1406 : switch ( meObjStrAttr )
1290 : {
1291 : case OBJ_NAME:
1292 1406 : ImpTakeDescriptionStr( STR_UndoObjName, aStr );
1293 1406 : aStr += " '" + msNewStr + "'";
1294 1406 : break;
1295 : case OBJ_TITLE:
1296 0 : ImpTakeDescriptionStr( STR_UndoObjTitle, aStr );
1297 0 : break;
1298 : case OBJ_DESCRIPTION:
1299 0 : ImpTakeDescriptionStr( STR_UndoObjDescription, aStr );
1300 0 : break;
1301 : }
1302 :
1303 1406 : return aStr;
1304 : }
1305 :
1306 :
1307 1 : SdrUndoLayer::SdrUndoLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
1308 : : SdrUndoAction(rNewModel)
1309 1 : , pLayer(rNewLayerAdmin.GetLayer(nLayerNum))
1310 : , pLayerAdmin(&rNewLayerAdmin)
1311 : , nNum(nLayerNum)
1312 2 : , bItsMine(false)
1313 : {
1314 1 : }
1315 :
1316 2 : SdrUndoLayer::~SdrUndoLayer()
1317 : {
1318 1 : if (bItsMine)
1319 : {
1320 1 : delete pLayer;
1321 : }
1322 1 : }
1323 :
1324 :
1325 :
1326 0 : void SdrUndoNewLayer::Undo()
1327 : {
1328 : DBG_ASSERT(!bItsMine,"SdrUndoNewLayer::Undo(): Layer already belongs to UndoAction.");
1329 0 : bItsMine=true;
1330 : #ifdef DBG_UTIL
1331 : SdrLayer* pCmpLayer=
1332 : #endif
1333 0 : pLayerAdmin->RemoveLayer(nNum);
1334 : DBG_ASSERT(pCmpLayer==pLayer,"SdrUndoNewLayer::Undo(): Removed layer is != pLayer.");
1335 0 : }
1336 :
1337 0 : void SdrUndoNewLayer::Redo()
1338 : {
1339 : DBG_ASSERT(bItsMine,"SdrUndoNewLayer::Undo(): Layer does not belong to UndoAction.");
1340 0 : bItsMine=false;
1341 0 : pLayerAdmin->InsertLayer(pLayer,nNum);
1342 0 : }
1343 :
1344 0 : OUString SdrUndoNewLayer::GetComment() const
1345 : {
1346 0 : return ImpGetResStr(STR_UndoNewLayer);
1347 : }
1348 :
1349 :
1350 :
1351 0 : void SdrUndoDelLayer::Undo()
1352 : {
1353 : DBG_ASSERT(bItsMine,"SdrUndoDelLayer::Undo(): Layer does not belong to UndoAction.");
1354 0 : bItsMine=false;
1355 0 : pLayerAdmin->InsertLayer(pLayer,nNum);
1356 0 : }
1357 :
1358 0 : void SdrUndoDelLayer::Redo()
1359 : {
1360 : DBG_ASSERT(!bItsMine,"SdrUndoDelLayer::Undo(): Layer already belongs to UndoAction.");
1361 0 : bItsMine=true;
1362 : #ifdef DBG_UTIL
1363 : SdrLayer* pCmpLayer=
1364 : #endif
1365 0 : pLayerAdmin->RemoveLayer(nNum);
1366 : DBG_ASSERT(pCmpLayer==pLayer,"SdrUndoDelLayer::Redo(): Removed layer is != pLayer.");
1367 0 : }
1368 :
1369 1 : OUString SdrUndoDelLayer::GetComment() const
1370 : {
1371 1 : return ImpGetResStr(STR_UndoDelLayer);
1372 : }
1373 :
1374 :
1375 :
1376 0 : void SdrUndoMoveLayer::Undo()
1377 : {
1378 : #ifdef DBG_UTIL
1379 : SdrLayer* pCmpLayer=
1380 : #endif
1381 0 : pLayerAdmin->RemoveLayer(nNeuPos);
1382 : DBG_ASSERT(pCmpLayer==pLayer,"SdrUndoMoveLayer::Undo(): Removed layer is != pLayer.");
1383 0 : pLayerAdmin->InsertLayer(pLayer,nNum);
1384 0 : }
1385 :
1386 0 : void SdrUndoMoveLayer::Redo()
1387 : {
1388 : #ifdef DBG_UTIL
1389 : SdrLayer* pCmpLayer=
1390 : #endif
1391 0 : pLayerAdmin->RemoveLayer(nNum);
1392 : DBG_ASSERT(pCmpLayer==pLayer,"SdrUndoMoveLayer::Redo(): Removed layer is != pLayer.");
1393 0 : pLayerAdmin->InsertLayer(pLayer,nNeuPos);
1394 0 : }
1395 :
1396 0 : OUString SdrUndoMoveLayer::GetComment() const
1397 : {
1398 0 : return ImpGetResStr(STR_UndoMovLayer);
1399 : }
1400 :
1401 :
1402 683 : SdrUndoPage::SdrUndoPage(SdrPage& rNewPg)
1403 683 : : SdrUndoAction(*rNewPg.GetModel())
1404 683 : , mrPage(rNewPg)
1405 : {
1406 683 : }
1407 :
1408 0 : void SdrUndoPage::ImpInsertPage(sal_uInt16 nNum)
1409 : {
1410 : DBG_ASSERT(!mrPage.IsInserted(),"SdrUndoPage::ImpInsertPage(): mrPage is already inserted.");
1411 0 : if (!mrPage.IsInserted())
1412 : {
1413 0 : if (mrPage.IsMasterPage())
1414 : {
1415 0 : rMod.InsertMasterPage(&mrPage,nNum);
1416 : }
1417 : else
1418 : {
1419 0 : rMod.InsertPage(&mrPage,nNum);
1420 : }
1421 : }
1422 0 : }
1423 :
1424 0 : void SdrUndoPage::ImpRemovePage(sal_uInt16 nNum)
1425 : {
1426 : DBG_ASSERT(mrPage.IsInserted(),"SdrUndoPage::ImpRemovePage(): mrPage is not inserted.");
1427 0 : if (mrPage.IsInserted())
1428 : {
1429 0 : SdrPage* pChkPg=NULL;
1430 0 : if (mrPage.IsMasterPage())
1431 : {
1432 0 : pChkPg=rMod.RemoveMasterPage(nNum);
1433 : }
1434 : else
1435 : {
1436 0 : pChkPg=rMod.RemovePage(nNum);
1437 : }
1438 : DBG_ASSERT(pChkPg==&mrPage,"SdrUndoPage::ImpRemovePage(): RemovePage!=&mrPage");
1439 : (void)pChkPg;
1440 : }
1441 0 : }
1442 :
1443 0 : void SdrUndoPage::ImpMovePage(sal_uInt16 nOldNum, sal_uInt16 nNewNum)
1444 : {
1445 : DBG_ASSERT(mrPage.IsInserted(),"SdrUndoPage::ImpMovePage(): mrPage is not inserted.");
1446 0 : if (mrPage.IsInserted())
1447 : {
1448 0 : if (mrPage.IsMasterPage())
1449 : {
1450 0 : rMod.MoveMasterPage(nOldNum,nNewNum);
1451 : }
1452 : else
1453 : {
1454 0 : rMod.MovePage(nOldNum,nNewNum);
1455 : }
1456 : }
1457 0 : }
1458 :
1459 628 : void SdrUndoPage::ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, OUString& rStr, sal_uInt16 /*n*/, bool /*bRepeat*/)
1460 : {
1461 628 : rStr = ImpGetResStr(nStrCacheID);
1462 628 : }
1463 :
1464 :
1465 :
1466 683 : SdrUndoPageList::SdrUndoPageList(SdrPage& rNewPg)
1467 : : SdrUndoPage(rNewPg)
1468 683 : , bItsMine(false)
1469 : {
1470 683 : nPageNum=rNewPg.GetPageNum();
1471 683 : }
1472 :
1473 1366 : SdrUndoPageList::~SdrUndoPageList()
1474 : {
1475 683 : if(bItsMine)
1476 : {
1477 646 : delete (&mrPage);
1478 : }
1479 683 : }
1480 :
1481 :
1482 :
1483 646 : SdrUndoDelPage::SdrUndoDelPage(SdrPage& rNewPg)
1484 : : SdrUndoPageList(rNewPg)
1485 646 : , pUndoGroup(NULL)
1486 : {
1487 646 : bItsMine = true;
1488 :
1489 : // now remember the master page relationships
1490 646 : if(mrPage.IsMasterPage())
1491 : {
1492 2 : sal_uInt16 nPageAnz(rMod.GetPageCount());
1493 :
1494 8 : for(sal_uInt16 nPageNum2(0); nPageNum2 < nPageAnz; nPageNum2++)
1495 : {
1496 6 : SdrPage* pDrawPage = rMod.GetPage(nPageNum2);
1497 :
1498 6 : if(pDrawPage->TRG_HasMasterPage())
1499 : {
1500 6 : SdrPage& rMasterPage = pDrawPage->TRG_GetMasterPage();
1501 :
1502 6 : if(&mrPage == &rMasterPage)
1503 : {
1504 0 : if(!pUndoGroup)
1505 : {
1506 0 : pUndoGroup = new SdrUndoGroup(rMod);
1507 : }
1508 :
1509 0 : pUndoGroup->AddAction(rMod.GetSdrUndoFactory().CreateUndoPageRemoveMasterPage(*pDrawPage));
1510 : }
1511 : }
1512 : }
1513 : }
1514 646 : }
1515 :
1516 1938 : SdrUndoDelPage::~SdrUndoDelPage()
1517 : {
1518 646 : delete pUndoGroup;
1519 1292 : }
1520 :
1521 0 : void SdrUndoDelPage::Undo()
1522 : {
1523 0 : ImpInsertPage(nPageNum);
1524 0 : if (pUndoGroup!=NULL)
1525 : {
1526 : // recover master page relationships
1527 0 : pUndoGroup->Undo();
1528 : }
1529 : DBG_ASSERT(bItsMine,"UndoDeletePage: mrPage does not belong to UndoAction.");
1530 0 : bItsMine=false;
1531 0 : }
1532 :
1533 0 : void SdrUndoDelPage::Redo()
1534 : {
1535 0 : ImpRemovePage(nPageNum);
1536 : // master page relations are dissolved automatically
1537 : DBG_ASSERT(!bItsMine,"RedoDeletePage: mrPage already belongs to UndoAction.");
1538 0 : bItsMine=true;
1539 0 : }
1540 :
1541 628 : OUString SdrUndoDelPage::GetComment() const
1542 : {
1543 628 : OUString aStr;
1544 628 : ImpTakeDescriptionStr(STR_UndoDelPage,aStr,0,false);
1545 628 : return aStr;
1546 : }
1547 :
1548 0 : OUString SdrUndoDelPage::GetSdrRepeatComment(SdrView& /*rView*/) const
1549 : {
1550 0 : OUString aStr;
1551 0 : ImpTakeDescriptionStr(STR_UndoDelPage,aStr,0,false);
1552 0 : return aStr;
1553 : }
1554 :
1555 0 : void SdrUndoDelPage::SdrRepeat(SdrView& /*rView*/)
1556 : {
1557 0 : }
1558 :
1559 0 : bool SdrUndoDelPage::CanSdrRepeat(SdrView& /*rView*/) const
1560 : {
1561 0 : return false;
1562 : }
1563 :
1564 :
1565 :
1566 0 : void SdrUndoNewPage::Undo()
1567 : {
1568 0 : ImpRemovePage(nPageNum);
1569 : DBG_ASSERT(!bItsMine,"UndoNewPage: mrPage already belongs to UndoAction.");
1570 0 : bItsMine=true;
1571 0 : }
1572 :
1573 0 : void SdrUndoNewPage::Redo()
1574 : {
1575 0 : ImpInsertPage(nPageNum);
1576 : DBG_ASSERT(bItsMine,"RedoNewPage: mrPage does not belong to UndoAction.");
1577 0 : bItsMine=false;
1578 0 : }
1579 :
1580 0 : OUString SdrUndoNewPage::GetComment() const
1581 : {
1582 0 : OUString aStr;
1583 0 : ImpTakeDescriptionStr(STR_UndoNewPage,aStr,0,false);
1584 0 : return aStr;
1585 : }
1586 :
1587 :
1588 :
1589 0 : OUString SdrUndoCopyPage::GetComment() const
1590 : {
1591 0 : OUString aStr;
1592 0 : ImpTakeDescriptionStr(STR_UndoCopPage,aStr,0,false);
1593 0 : return aStr;
1594 : }
1595 :
1596 0 : OUString SdrUndoCopyPage::GetSdrRepeatComment(SdrView& /*rView*/) const
1597 : {
1598 0 : OUString aStr;
1599 0 : ImpTakeDescriptionStr(STR_UndoCopPage,aStr,0,false);
1600 0 : return aStr;
1601 : }
1602 :
1603 0 : void SdrUndoCopyPage::SdrRepeat(SdrView& /*rView*/)
1604 : {
1605 :
1606 0 : }
1607 :
1608 0 : bool SdrUndoCopyPage::CanSdrRepeat(SdrView& /*rView*/) const
1609 : {
1610 0 : return false;
1611 : }
1612 :
1613 :
1614 :
1615 0 : void SdrUndoSetPageNum::Undo()
1616 : {
1617 0 : ImpMovePage(nNewPageNum,nOldPageNum);
1618 0 : }
1619 :
1620 0 : void SdrUndoSetPageNum::Redo()
1621 : {
1622 0 : ImpMovePage(nOldPageNum,nNewPageNum);
1623 0 : }
1624 :
1625 0 : OUString SdrUndoSetPageNum::GetComment() const
1626 : {
1627 0 : OUString aStr;
1628 0 : ImpTakeDescriptionStr(STR_UndoMovPage,aStr,0,false);
1629 0 : return aStr;
1630 : }
1631 :
1632 0 : SdrUndoPageMasterPage::SdrUndoPageMasterPage(SdrPage& rChangedPage)
1633 : : SdrUndoPage(rChangedPage)
1634 0 : , mbOldHadMasterPage(mrPage.TRG_HasMasterPage())
1635 0 : , maOldMasterPageNumber(0)
1636 : {
1637 : // get current state from page
1638 0 : if(mbOldHadMasterPage)
1639 : {
1640 0 : maOldSet = mrPage.TRG_GetMasterPageVisibleLayers();
1641 0 : maOldMasterPageNumber = mrPage.TRG_GetMasterPage().GetPageNum();
1642 : }
1643 0 : }
1644 :
1645 0 : SdrUndoPageMasterPage::~SdrUndoPageMasterPage()
1646 : {
1647 0 : }
1648 :
1649 0 : SdrUndoPageRemoveMasterPage::SdrUndoPageRemoveMasterPage(SdrPage& rChangedPage)
1650 0 : : SdrUndoPageMasterPage(rChangedPage)
1651 : {
1652 0 : }
1653 :
1654 0 : void SdrUndoPageRemoveMasterPage::Undo()
1655 : {
1656 0 : if(mbOldHadMasterPage)
1657 : {
1658 0 : mrPage.TRG_SetMasterPage(*mrPage.GetModel()->GetMasterPage(maOldMasterPageNumber));
1659 0 : mrPage.TRG_SetMasterPageVisibleLayers(maOldSet);
1660 : }
1661 0 : }
1662 :
1663 0 : void SdrUndoPageRemoveMasterPage::Redo()
1664 : {
1665 0 : mrPage.TRG_ClearMasterPage();
1666 0 : }
1667 :
1668 0 : OUString SdrUndoPageRemoveMasterPage::GetComment() const
1669 : {
1670 0 : OUString aStr;
1671 0 : ImpTakeDescriptionStr(STR_UndoDelPageMasterDscr,aStr,0,false);
1672 0 : return aStr;
1673 : }
1674 :
1675 0 : SdrUndoPageChangeMasterPage::SdrUndoPageChangeMasterPage(SdrPage& rChangedPage)
1676 : : SdrUndoPageMasterPage(rChangedPage)
1677 : , mbNewHadMasterPage(false)
1678 0 : , maNewMasterPageNumber(0)
1679 : {
1680 0 : }
1681 :
1682 0 : void SdrUndoPageChangeMasterPage::Undo()
1683 : {
1684 : // remember values from new page
1685 0 : if(mrPage.TRG_HasMasterPage())
1686 : {
1687 0 : mbNewHadMasterPage = true;
1688 0 : maNewSet = mrPage.TRG_GetMasterPageVisibleLayers();
1689 0 : maNewMasterPageNumber = mrPage.TRG_GetMasterPage().GetPageNum();
1690 : }
1691 :
1692 : // restore old values
1693 0 : if(mbOldHadMasterPage)
1694 : {
1695 0 : mrPage.TRG_ClearMasterPage();
1696 0 : mrPage.TRG_SetMasterPage(*mrPage.GetModel()->GetMasterPage(maOldMasterPageNumber));
1697 0 : mrPage.TRG_SetMasterPageVisibleLayers(maOldSet);
1698 : }
1699 0 : }
1700 :
1701 0 : void SdrUndoPageChangeMasterPage::Redo()
1702 : {
1703 : // restore new values
1704 0 : if(mbNewHadMasterPage)
1705 : {
1706 0 : mrPage.TRG_ClearMasterPage();
1707 0 : mrPage.TRG_SetMasterPage(*mrPage.GetModel()->GetMasterPage(maNewMasterPageNumber));
1708 0 : mrPage.TRG_SetMasterPageVisibleLayers(maNewSet);
1709 : }
1710 0 : }
1711 :
1712 0 : OUString SdrUndoPageChangeMasterPage::GetComment() const
1713 : {
1714 0 : OUString aStr;
1715 0 : ImpTakeDescriptionStr(STR_UndoChgPageMasterDscr,aStr,0,false);
1716 0 : return aStr;
1717 : }
1718 :
1719 :
1720 321 : SdrUndoFactory::~SdrUndoFactory(){}
1721 : // shapes
1722 0 : SdrUndoAction* SdrUndoFactory::CreateUndoMoveObject( SdrObject& rObject )
1723 : {
1724 0 : return new SdrUndoMoveObj( rObject );
1725 : }
1726 :
1727 0 : SdrUndoAction* SdrUndoFactory::CreateUndoMoveObject( SdrObject& rObject, const Size& rDist )
1728 : {
1729 0 : return new SdrUndoMoveObj( rObject, rDist );
1730 : }
1731 :
1732 1 : SdrUndoAction* SdrUndoFactory::CreateUndoGeoObject( SdrObject& rObject )
1733 : {
1734 1 : return new SdrUndoGeoObj( rObject );
1735 : }
1736 :
1737 0 : SdrUndoAction* SdrUndoFactory::CreateUndoAttrObject( SdrObject& rObject, bool bStyleSheet1, bool bSaveText )
1738 : {
1739 0 : return new SdrUndoAttrObj( rObject, bStyleSheet1, bSaveText );
1740 : }
1741 :
1742 10 : SdrUndoAction* SdrUndoFactory::CreateUndoRemoveObject( SdrObject& rObject, bool bOrdNumDirect )
1743 : {
1744 10 : return new SdrUndoRemoveObj( rObject, bOrdNumDirect );
1745 : }
1746 :
1747 146 : SdrUndoAction* SdrUndoFactory::CreateUndoInsertObject( SdrObject& rObject, bool bOrdNumDirect )
1748 : {
1749 146 : return new SdrUndoInsertObj( rObject, bOrdNumDirect );
1750 : }
1751 :
1752 5 : SdrUndoAction* SdrUndoFactory::CreateUndoDeleteObject( SdrObject& rObject, bool bOrdNumDirect )
1753 : {
1754 5 : return new SdrUndoDelObj( rObject, bOrdNumDirect );
1755 : }
1756 :
1757 110 : SdrUndoAction* SdrUndoFactory::CreateUndoNewObject( SdrObject& rObject, bool bOrdNumDirect )
1758 : {
1759 110 : return new SdrUndoNewObj( rObject, bOrdNumDirect );
1760 : }
1761 :
1762 0 : SdrUndoAction* SdrUndoFactory::CreateUndoCopyObject( SdrObject& rObject, bool bOrdNumDirect )
1763 : {
1764 0 : return new SdrUndoCopyObj( rObject, bOrdNumDirect );
1765 : }
1766 :
1767 0 : SdrUndoAction* SdrUndoFactory::CreateUndoObjectOrdNum( SdrObject& rObject, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1)
1768 : {
1769 0 : return new SdrUndoObjOrdNum( rObject, nOldOrdNum1, nNewOrdNum1 );
1770 : }
1771 :
1772 0 : SdrUndoAction* SdrUndoFactory::CreateUndoReplaceObject( SdrObject& rOldObject, SdrObject& rNewObject, bool bOrdNumDirect )
1773 : {
1774 0 : return new SdrUndoReplaceObj( rOldObject, rNewObject, bOrdNumDirect );
1775 : }
1776 :
1777 0 : SdrUndoAction* SdrUndoFactory::CreateUndoObjectLayerChange( SdrObject& rObject, SdrLayerID aOldLayer, SdrLayerID aNewLayer )
1778 : {
1779 0 : return new SdrUndoObjectLayerChange( rObject, aOldLayer, aNewLayer );
1780 : }
1781 :
1782 0 : SdrUndoAction* SdrUndoFactory::CreateUndoObjectSetText( SdrObject& rNewObj, sal_Int32 nText )
1783 : {
1784 0 : return new SdrUndoObjSetText( rNewObj, nText );
1785 : }
1786 :
1787 704 : SdrUndoAction* SdrUndoFactory::CreateUndoObjectStrAttr( SdrObject& rObject,
1788 : SdrUndoObjStrAttr::ObjStrAttrType eObjStrAttrType,
1789 : const OUString& sOldStr,
1790 : const OUString& sNewStr )
1791 : {
1792 704 : return new SdrUndoObjStrAttr( rObject, eObjStrAttrType, sOldStr, sNewStr );
1793 : }
1794 :
1795 :
1796 : // layer
1797 0 : SdrUndoAction* SdrUndoFactory::CreateUndoNewLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
1798 : {
1799 0 : return new SdrUndoNewLayer( nLayerNum, rNewLayerAdmin, rNewModel );
1800 : }
1801 :
1802 1 : SdrUndoAction* SdrUndoFactory::CreateUndoDeleteLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
1803 : {
1804 1 : return new SdrUndoDelLayer( nLayerNum, rNewLayerAdmin, rNewModel );
1805 : }
1806 :
1807 0 : SdrUndoAction* SdrUndoFactory::CreateUndoMoveLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel, sal_uInt16 nNeuPos1)
1808 : {
1809 0 : return new SdrUndoMoveLayer( nLayerNum, rNewLayerAdmin, rNewModel, nNeuPos1 );
1810 : }
1811 :
1812 : // page
1813 628 : SdrUndoAction* SdrUndoFactory::CreateUndoDeletePage(SdrPage& rPage)
1814 : {
1815 628 : return new SdrUndoDelPage( rPage );
1816 : }
1817 :
1818 0 : SdrUndoAction* SdrUndoFactory::CreateUndoNewPage(SdrPage& rPage)
1819 : {
1820 0 : return new SdrUndoNewPage( rPage );
1821 : }
1822 :
1823 0 : SdrUndoAction* SdrUndoFactory::CreateUndoCopyPage(SdrPage& rPage)
1824 : {
1825 0 : return new SdrUndoCopyPage( rPage );
1826 : }
1827 :
1828 0 : SdrUndoAction* SdrUndoFactory::CreateUndoSetPageNum(SdrPage& rNewPg, sal_uInt16 nOldPageNum1, sal_uInt16 nNewPageNum1)
1829 : {
1830 0 : return new SdrUndoSetPageNum( rNewPg, nOldPageNum1, nNewPageNum1 );
1831 : }
1832 : // master page
1833 0 : SdrUndoAction* SdrUndoFactory::CreateUndoPageRemoveMasterPage(SdrPage& rChangedPage)
1834 : {
1835 0 : return new SdrUndoPageRemoveMasterPage( rChangedPage );
1836 : }
1837 :
1838 0 : SdrUndoAction* SdrUndoFactory::CreateUndoPageChangeMasterPage(SdrPage& rChangedPage)
1839 : {
1840 0 : return new SdrUndoPageChangeMasterPage(rChangedPage);
1841 435 : }
1842 :
1843 :
1844 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
