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