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 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 64 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 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 78 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 85 bool SdrUndoAction::CanSdrRepeat(SdrView& /*rView*/) const 86 { 87 return sal_False; 88 } 89 90 void SdrUndoAction::SdrRepeat(SdrView& /*rView*/) 91 { 92 } 93 94 XubString SdrUndoAction::GetSdrRepeatComment(SdrView& /*rView*/) const 95 { 96 return String(); 97 } 98 99 //////////////////////////////////////////////////////////////////////////////////////////////////// 100 101 SdrUndoGroup::SdrUndoGroup(SdrModel& rNewMod) 102 : SdrUndoAction(rNewMod), 103 aBuf(1024,32,32), 104 eFunction(SDRREPFUNC_OBJ_NONE) /*#72642#*/ 105 {} 106 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 114 SdrUndoGroup::~SdrUndoGroup() 115 { 116 Clear(); 117 } 118 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 128 void SdrUndoGroup::AddAction(SdrUndoAction* pAct) 129 { 130 aBuf.Insert(pAct,CONTAINER_APPEND); 131 } 132 133 void SdrUndoGroup::push_front( SdrUndoAction* pAct ) 134 { 135 aBuf.Insert(pAct, (sal_uIntPtr)0 ); 136 } 137 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 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 155 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 166 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 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 213 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 228 SdrUndoObj::SdrUndoObj(SdrObject& rNewObj): 229 SdrUndoAction(*rNewObj.GetModel()), 230 pObj(&rNewObj) 231 { 232 } 233 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 260 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 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 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 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 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 372 void SdrUndoAttrObj::SetRepeatAttr(const SfxItemSet& rSet) 373 { 374 if(pRepeatSet) 375 delete pRepeatSet; 376 377 pRepeatSet = new SfxItemSet(rSet); 378 } 379 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 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 574 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 590 void SdrUndoAttrObj::SdrRepeat(SdrView& rView) 591 { 592 if(pRepeatSet) 593 { 594 rView.SetAttrToMarked(*pRepeatSet, sal_False); 595 } 596 } 597 598 bool SdrUndoAttrObj::CanSdrRepeat(SdrView& rView) const 599 { 600 return (pRepeatSet!=0L && rView.AreObjectsMarked()); 601 } 602 603 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 621 void SdrUndoMoveObj::Undo() 622 { 623 // #94278# Trigger PageChangeCall 624 ImpShowPageOfThisObject(); 625 626 pObj->Move(Size(-aDistance.Width(),-aDistance.Height())); 627 } 628 629 void SdrUndoMoveObj::Redo() 630 { 631 pObj->Move(Size(aDistance.Width(),aDistance.Height())); 632 633 // #94278# Trigger PageChangeCall 634 ImpShowPageOfThisObject(); 635 } 636 637 XubString SdrUndoMoveObj::GetComment() const 638 { 639 XubString aStr; 640 ImpTakeDescriptionStr(STR_EditMove,aStr); 641 return aStr; 642 } 643 644 void SdrUndoMoveObj::SdrRepeat(SdrView& rView) 645 { 646 rView.MoveMarkedObj(aDistance); 647 } 648 649 bool SdrUndoMoveObj::CanSdrRepeat(SdrView& rView) const 650 { 651 return rView.AreObjectsMarked(); 652 } 653 654 XubString SdrUndoMoveObj::GetSdrRepeatComment(SdrView& /*rView*/) const 655 { 656 XubString aStr; 657 ImpTakeDescriptionStr(STR_EditMove,aStr,sal_True); 658 return aStr; 659 } 660 661 //////////////////////////////////////////////////////////////////////////////////////////////////// 662 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 684 SdrUndoGeoObj::~SdrUndoGeoObj() 685 { 686 if (pUndoGeo!=NULL) delete pUndoGeo; 687 if (pRedoGeo!=NULL) delete pRedoGeo; 688 if (pUndoGroup!=NULL) delete pUndoGroup; 689 } 690 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 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 733 XubString SdrUndoGeoObj::GetComment() const 734 { 735 XubString aStr; 736 ImpTakeDescriptionStr(STR_DragMethObjOwn,aStr); 737 return aStr; 738 } 739 740 //////////////////////////////////////////////////////////////////////////////////////////////////// 741 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 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 768 void SdrUndoObjList::SetOwner(bool bNew) 769 { 770 bOwner = bNew; 771 } 772 773 //////////////////////////////////////////////////////////////////////////////////////////////////// 774 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 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 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 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 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 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 903 SdrUndoDelObj::~SdrUndoDelObj() 904 { 905 } 906 907 void SdrUndoDelObj::Undo() 908 { 909 SdrUndoRemoveObj::Undo(); 910 DBG_ASSERT(IsOwner(),"UndoDeleteObj: pObj gehoert nicht der UndoAction"); 911 SetOwner(sal_False); 912 } 913 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 925 XubString SdrUndoDelObj::GetComment() const 926 { 927 XubString aStr; 928 ImpTakeDescriptionStr(STR_EditDelete,aStr); 929 return aStr; 930 } 931 932 void SdrUndoDelObj::SdrRepeat(SdrView& rView) 933 { 934 rView.DeleteMarked(); 935 } 936 937 bool SdrUndoDelObj::CanSdrRepeat(SdrView& rView) const 938 { 939 return rView.AreObjectsMarked(); 940 } 941 942 XubString SdrUndoDelObj::GetSdrRepeatComment(SdrView& /*rView*/) const 943 { 944 XubString aStr; 945 ImpTakeDescriptionStr(STR_EditDelete,aStr,sal_True); 946 return aStr; 947 } 948 949 //////////////////////////////////////////////////////////////////////////////////////////////////// 950 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 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 965 String SdrUndoNewObj::GetComment( const SdrObject& _rForObject ) 966 { 967 String sComment; 968 GetDescriptionStringForObject( _rForObject, STR_UndoInsertObj, sComment ); 969 return sComment; 970 } 971 972 XubString SdrUndoNewObj::GetComment() const 973 { 974 XubString aStr; 975 ImpTakeDescriptionStr(STR_UndoInsertObj,aStr); 976 return aStr; 977 } 978 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 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 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 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 1058 void SdrUndoReplaceObj::SetNewOwner(bool bNew) 1059 { 1060 bNewOwner = bNew; 1061 } 1062 1063 void SdrUndoReplaceObj::SetOldOwner(bool bNew) 1064 { 1065 bOldOwner = bNew; 1066 } 1067 1068 //////////////////////////////////////////////////////////////////////////////////////////////////// 1069 1070 XubString SdrUndoCopyObj::GetComment() const 1071 { 1072 XubString aStr; 1073 ImpTakeDescriptionStr(STR_UndoCopyObj,aStr); 1074 return aStr; 1075 } 1076 1077 //////////////////////////////////////////////////////////////////////////////////////////////////// 1078 // #i11702# 1079 1080 SdrUndoObjectLayerChange::SdrUndoObjectLayerChange(SdrObject& rObj, SdrLayerID aOldLayer, SdrLayerID aNewLayer) 1081 : SdrUndoObj(rObj), 1082 maOldLayer(aOldLayer), 1083 maNewLayer(aNewLayer) 1084 { 1085 } 1086 1087 void SdrUndoObjectLayerChange::Undo() 1088 { 1089 ImpShowPageOfThisObject(); 1090 pObj->SetLayer(maOldLayer); 1091 } 1092 1093 void SdrUndoObjectLayerChange::Redo() 1094 { 1095 pObj->SetLayer(maNewLayer); 1096 ImpShowPageOfThisObject(); 1097 } 1098 1099 //////////////////////////////////////////////////////////////////////////////////////////////////// 1100 1101 SdrUndoObjOrdNum::SdrUndoObjOrdNum(SdrObject& rNewObj, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1): 1102 SdrUndoObj(rNewObj), 1103 nOldOrdNum(nOldOrdNum1), 1104 nNewOrdNum(nNewOrdNum1) 1105 { 1106 } 1107 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 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 1134 XubString SdrUndoObjOrdNum::GetComment() const 1135 { 1136 XubString aStr; 1137 ImpTakeDescriptionStr(STR_UndoObjOrdNum,aStr); 1138 return aStr; 1139 } 1140 1141 //////////////////////////////////////////////////////////////////////////////////////////////////// 1142 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 1158 SdrUndoObjSetText::~SdrUndoObjSetText() 1159 { 1160 if ( pOldText ) 1161 delete pOldText; 1162 if ( pNewText ) 1163 delete pNewText; 1164 } 1165 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 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 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 1270 XubString SdrUndoObjSetText::GetComment() const 1271 { 1272 XubString aStr; 1273 ImpTakeDescriptionStr(STR_UndoObjSetText,aStr); 1274 return aStr; 1275 } 1276 1277 XubString SdrUndoObjSetText::GetSdrRepeatComment(SdrView& /*rView*/) const 1278 { 1279 XubString aStr; 1280 ImpTakeDescriptionStr(STR_UndoObjSetText,aStr); 1281 return aStr; 1282 } 1283 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 1320 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# 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 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 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 1389 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 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 1431 SdrUndoLayer::~SdrUndoLayer() 1432 { 1433 if (bItsMine) { 1434 delete pLayer; 1435 } 1436 } 1437 1438 //////////////////////////////////////////////////////////////////////////////////////////////////// 1439 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 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 1458 XubString SdrUndoNewLayer::GetComment() const 1459 { 1460 return ImpGetResStr(STR_UndoNewLayer); 1461 } 1462 1463 //////////////////////////////////////////////////////////////////////////////////////////////////// 1464 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 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 1483 XubString SdrUndoDelLayer::GetComment() const 1484 { 1485 return ImpGetResStr(STR_UndoDelLayer); 1486 } 1487 1488 //////////////////////////////////////////////////////////////////////////////////////////////////// 1489 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 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 1510 XubString SdrUndoMoveLayer::GetComment() const 1511 { 1512 return ImpGetResStr(STR_UndoMovLayer); 1513 } 1514 1515 //////////////////////////////////////////////////////////////////////////////////////////////////// 1516 // PAGES 1517 //////////////////////////////////////////////////////////////////////////////////////////////////// 1518 1519 SdrUndoPage::SdrUndoPage(SdrPage& rNewPg) 1520 : SdrUndoAction(*rNewPg.GetModel()), 1521 mrPage(rNewPg) 1522 { 1523 } 1524 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 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 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 1563 void SdrUndoPage::ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, XubString& rStr, sal_uInt16 /*n*/, FASTBOOL /*bRepeat*/) const 1564 { 1565 rStr=ImpGetResStr(nStrCacheID); 1566 } 1567 1568 //////////////////////////////////////////////////////////////////////////////////////////////////// 1569 1570 SdrUndoPageList::SdrUndoPageList(SdrPage& rNewPg): 1571 SdrUndoPage(rNewPg), 1572 bItsMine(sal_False) 1573 { 1574 nPageNum=rNewPg.GetPageNum(); 1575 } 1576 1577 SdrUndoPageList::~SdrUndoPageList() 1578 { 1579 if(bItsMine) 1580 { 1581 delete (&mrPage); 1582 } 1583 } 1584 1585 //////////////////////////////////////////////////////////////////////////////////////////////////// 1586 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 1620 SdrUndoDelPage::~SdrUndoDelPage() 1621 { 1622 if (pUndoGroup!=NULL) { 1623 delete pUndoGroup; 1624 } 1625 } 1626 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 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 1645 XubString SdrUndoDelPage::GetComment() const 1646 { 1647 XubString aStr; 1648 ImpTakeDescriptionStr(STR_UndoDelPage,aStr,0,sal_False); 1649 return aStr; 1650 } 1651 1652 XubString SdrUndoDelPage::GetSdrRepeatComment(SdrView& /*rView*/) const 1653 { 1654 XubString aStr; 1655 ImpTakeDescriptionStr(STR_UndoDelPage,aStr,0,sal_False); 1656 return aStr; 1657 } 1658 1659 void SdrUndoDelPage::SdrRepeat(SdrView& /*rView*/) 1660 { 1661 } 1662 1663 bool SdrUndoDelPage::CanSdrRepeat(SdrView& /*rView*/) const 1664 { 1665 return sal_False; 1666 } 1667 1668 //////////////////////////////////////////////////////////////////////////////////////////////////// 1669 1670 void SdrUndoNewPage::Undo() 1671 { 1672 ImpRemovePage(nPageNum); 1673 DBG_ASSERT(!bItsMine,"UndoNewPage: mrPage gehoert bereits der UndoAction"); 1674 bItsMine=sal_True; 1675 } 1676 1677 void SdrUndoNewPage::Redo() 1678 { 1679 ImpInsertPage(nPageNum); 1680 DBG_ASSERT(bItsMine,"RedoNewPage: mrPage gehoert nicht der UndoAction"); 1681 bItsMine=sal_False; 1682 } 1683 1684 XubString SdrUndoNewPage::GetComment() const 1685 { 1686 XubString aStr; 1687 ImpTakeDescriptionStr(STR_UndoNewPage,aStr,0,sal_False); 1688 return aStr; 1689 } 1690 1691 //////////////////////////////////////////////////////////////////////////////////////////////////// 1692 1693 XubString SdrUndoCopyPage::GetComment() const 1694 { 1695 XubString aStr; 1696 ImpTakeDescriptionStr(STR_UndoCopPage,aStr,0,sal_False); 1697 return aStr; 1698 } 1699 1700 XubString SdrUndoCopyPage::GetSdrRepeatComment(SdrView& /*rView*/) const 1701 { 1702 XubString aStr; 1703 ImpTakeDescriptionStr(STR_UndoCopPage,aStr,0,sal_False); 1704 return aStr; 1705 } 1706 1707 void SdrUndoCopyPage::SdrRepeat(SdrView& /*rView*/) 1708 { 1709 1710 } 1711 1712 bool SdrUndoCopyPage::CanSdrRepeat(SdrView& /*rView*/) const 1713 { 1714 return sal_False; 1715 } 1716 1717 //////////////////////////////////////////////////////////////////////////////////////////////////// 1718 1719 void SdrUndoSetPageNum::Undo() 1720 { 1721 ImpMovePage(nNewPageNum,nOldPageNum); 1722 } 1723 1724 void SdrUndoSetPageNum::Redo() 1725 { 1726 ImpMovePage(nOldPageNum,nNewPageNum); 1727 } 1728 1729 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 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 1752 SdrUndoPageMasterPage::~SdrUndoPageMasterPage() 1753 { 1754 } 1755 1756 //////////////////////////////////////////////////////////////////////////////////////////////////// 1757 1758 SdrUndoPageRemoveMasterPage::SdrUndoPageRemoveMasterPage(SdrPage& rChangedPage) 1759 : SdrUndoPageMasterPage(rChangedPage) 1760 { 1761 } 1762 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 1772 void SdrUndoPageRemoveMasterPage::Redo() 1773 { 1774 mrPage.TRG_ClearMasterPage(); 1775 } 1776 1777 XubString SdrUndoPageRemoveMasterPage::GetComment() const 1778 { 1779 XubString aStr; 1780 ImpTakeDescriptionStr(STR_UndoDelPageMasterDscr,aStr,0,sal_False); 1781 return aStr; 1782 } 1783 1784 //////////////////////////////////////////////////////////////////////////////////////////////////// 1785 1786 SdrUndoPageChangeMasterPage::SdrUndoPageChangeMasterPage(SdrPage& rChangedPage) 1787 : SdrUndoPageMasterPage(rChangedPage), 1788 mbNewHadMasterPage(sal_False) 1789 { 1790 } 1791 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 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 1822 XubString SdrUndoPageChangeMasterPage::GetComment() const 1823 { 1824 XubString aStr; 1825 ImpTakeDescriptionStr(STR_UndoChgPageMasterDscr,aStr,0,sal_False); 1826 return aStr; 1827 } 1828 1829 /////////////////////////////////////////////////////////////////////// 1830 SdrUndoFactory::~SdrUndoFactory(){} 1831 // shapes 1832 SdrUndoAction* SdrUndoFactory::CreateUndoMoveObject( SdrObject& rObject ) 1833 { 1834 return new SdrUndoMoveObj( rObject ); 1835 } 1836 1837 SdrUndoAction* SdrUndoFactory::CreateUndoMoveObject( SdrObject& rObject, const Size& rDist ) 1838 { 1839 return new SdrUndoMoveObj( rObject, rDist ); 1840 } 1841 1842 SdrUndoAction* SdrUndoFactory::CreateUndoGeoObject( SdrObject& rObject ) 1843 { 1844 return new SdrUndoGeoObj( rObject ); 1845 } 1846 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 1852 SdrUndoAction* SdrUndoFactory::CreateUndoRemoveObject( SdrObject& rObject, bool bOrdNumDirect ) 1853 { 1854 return new SdrUndoRemoveObj( rObject, bOrdNumDirect ? sal_True : sal_False ); 1855 } 1856 1857 SdrUndoAction* SdrUndoFactory::CreateUndoInsertObject( SdrObject& rObject, bool bOrdNumDirect ) 1858 { 1859 return new SdrUndoInsertObj( rObject, bOrdNumDirect ? sal_True : sal_False ); 1860 } 1861 1862 SdrUndoAction* SdrUndoFactory::CreateUndoDeleteObject( SdrObject& rObject, bool bOrdNumDirect ) 1863 { 1864 return new SdrUndoDelObj( rObject, bOrdNumDirect ? sal_True : sal_False ); 1865 } 1866 1867 SdrUndoAction* SdrUndoFactory::CreateUndoNewObject( SdrObject& rObject, bool bOrdNumDirect ) 1868 { 1869 return new SdrUndoNewObj( rObject, bOrdNumDirect ? sal_True : sal_False ); 1870 } 1871 1872 SdrUndoAction* SdrUndoFactory::CreateUndoCopyObject( SdrObject& rObject, bool bOrdNumDirect ) 1873 { 1874 return new SdrUndoCopyObj( rObject, bOrdNumDirect ? sal_True : sal_False ); 1875 } 1876 1877 SdrUndoAction* SdrUndoFactory::CreateUndoObjectOrdNum( SdrObject& rObject, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1) 1878 { 1879 return new SdrUndoObjOrdNum( rObject, nOldOrdNum1, nNewOrdNum1 ); 1880 } 1881 1882 SdrUndoAction* SdrUndoFactory::CreateUndoReplaceObject( SdrObject& rOldObject, SdrObject& rNewObject, bool bOrdNumDirect ) 1883 { 1884 return new SdrUndoReplaceObj( rOldObject, rNewObject, bOrdNumDirect ? sal_True : sal_False ); 1885 } 1886 1887 SdrUndoAction* SdrUndoFactory::CreateUndoObjectLayerChange( SdrObject& rObject, SdrLayerID aOldLayer, SdrLayerID aNewLayer ) 1888 { 1889 return new SdrUndoObjectLayerChange( rObject, aOldLayer, aNewLayer ); 1890 } 1891 1892 SdrUndoAction* SdrUndoFactory::CreateUndoObjectSetText( SdrObject& rNewObj, sal_Int32 nText ) 1893 { 1894 return new SdrUndoObjSetText( rNewObj, nText ); 1895 } 1896 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 1907 SdrUndoAction* SdrUndoFactory::CreateUndoNewLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel) 1908 { 1909 return new SdrUndoNewLayer( nLayerNum, rNewLayerAdmin, rNewModel ); 1910 } 1911 1912 SdrUndoAction* SdrUndoFactory::CreateUndoDeleteLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel) 1913 { 1914 return new SdrUndoDelLayer( nLayerNum, rNewLayerAdmin, rNewModel ); 1915 } 1916 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 1923 SdrUndoAction* SdrUndoFactory::CreateUndoDeletePage(SdrPage& rPage) 1924 { 1925 return new SdrUndoDelPage( rPage ); 1926 } 1927 1928 SdrUndoAction* SdrUndoFactory::CreateUndoNewPage(SdrPage& rPage) 1929 { 1930 return new SdrUndoNewPage( rPage ); 1931 } 1932 1933 SdrUndoAction* SdrUndoFactory::CreateUndoCopyPage(SdrPage& rPage) 1934 { 1935 return new SdrUndoCopyPage( rPage ); 1936 } 1937 1938 SdrUndoAction* SdrUndoFactory::CreateUndoSetPageNum(SdrPage& rNewPg, sal_uInt16 nOldPageNum1, sal_uInt16 nNewPageNum1) 1939 { 1940 return new SdrUndoSetPageNum( rNewPg, nOldPageNum1, nNewPageNum1 ); 1941 } 1942 // master page 1943 SdrUndoAction* SdrUndoFactory::CreateUndoPageRemoveMasterPage(SdrPage& rChangedPage) 1944 { 1945 return new SdrUndoPageRemoveMasterPage( rChangedPage ); 1946 } 1947 1948 SdrUndoAction* SdrUndoFactory::CreateUndoPageChangeMasterPage(SdrPage& rChangedPage) 1949 { 1950 return new SdrUndoPageChangeMasterPage(rChangedPage); 1951 } 1952 1953 /* vim: set noet sw=4 ts=4: */ 1954