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