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