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 #ifndef _SVDUNDO_HXX 23 #define _SVDUNDO_HXX 24 25 #ifndef _SOLAR_HRC 26 #include <svl/solar.hrc> 27 #endif 28 #include <svl/undo.hxx> 29 #include <tools/contnr.hxx> 30 #include <tools/gen.hxx> 31 #include <svx/svdtypes.hxx> // fuer enum RepeatFuncts 32 #include <svx/svdsob.hxx> 33 #include "svx/svxdllapi.h" 34 #include <svl/style.hxx> 35 36 //************************************************************ 37 // Vorausdeklarationen 38 //************************************************************ 39 40 class SfxItemSet; 41 class SfxStyleSheet; 42 class SdrView; 43 class SdrPageView; 44 class SdrModel; 45 class SdrObject; 46 class SdrPage; 47 class SdrObjList; 48 class SdrLayer; 49 class SdrLayerAdmin; 50 class SdrObjGeoData; 51 class OutlinerParaObject; 52 53 //************************************************************ 54 // SdrUndoAction 55 // 56 // Abstrakte Basisklasse fuer alle UndoActions der DrawingEngine 57 // 58 //************************************************************ 59 60 class SVX_DLLPUBLIC SdrUndoAction : public SfxUndoAction 61 { 62 protected: 63 SdrModel& rMod; 64 65 protected: 66 SdrUndoAction(SdrModel& rNewMod) 67 : rMod(rNewMod) 68 {} 69 70 public: 71 TYPEINFO(); 72 virtual ~SdrUndoAction() {} 73 74 virtual sal_Bool CanRepeat(SfxRepeatTarget& rView) const; 75 virtual void Repeat(SfxRepeatTarget& rView); 76 77 virtual String GetRepeatComment(SfxRepeatTarget& rView) const; 78 virtual String GetSdrRepeatComment(SdrView& rView) const; 79 80 virtual bool CanSdrRepeat(SdrView& rView) const; 81 virtual void SdrRepeat(SdrView& rView); 82 }; 83 84 //************************************************************ 85 // SdrUndoGroup 86 // 87 // Zusammenfassung beliebig vieler einzelner UndoActions zu einer einzigen 88 // UndoAction. Beim Undo() werden die Einzelactions rückwärts aufgerufen 89 // (die zuletzt angehängte zuerst...), beim Redo() dagegen entspricht die 90 // Aufrufreihenfolge der Einfügereihenfolge. 91 // 92 //************************************************************ 93 94 class SVX_DLLPUBLIC SdrUndoGroup : public SdrUndoAction 95 { 96 protected: 97 Container aBuf; 98 99 // Beschreibung der Action, nicht expandiert (beinhaltet %O) 100 String aComment; 101 String aObjDescription; 102 103 SdrRepeatFunc eFunction; 104 105 public: 106 SdrUndoGroup(SdrModel& rNewMod); 107 SdrUndoGroup(SdrModel& rNewMod,const String& rStr); 108 virtual ~SdrUndoGroup(); 109 110 void Clear(); 111 sal_uIntPtr GetActionCount() const { return aBuf.Count(); } 112 SdrUndoAction* GetAction(sal_uIntPtr nNum) const { return (SdrUndoAction*)(aBuf.GetObject(nNum)); } 113 void AddAction(SdrUndoAction* pAct); 114 void push_front( SdrUndoAction* pAct ); 115 116 void SetComment(const String& rStr) { aComment=rStr; } 117 void SetObjDescription(const String& rStr) { aObjDescription=rStr; } 118 virtual String GetComment() const; 119 virtual String GetSdrRepeatComment(SdrView& rView) const; 120 121 virtual void Undo(); 122 virtual void Redo(); 123 124 virtual bool CanSdrRepeat(SdrView& rView) const; 125 virtual void SdrRepeat(SdrView& rView); 126 void SetRepeatFunction(SdrRepeatFunc eFunc) { eFunction=eFunc; } 127 SdrRepeatFunc GetRepeatFunction() const { return eFunction; } 128 }; 129 130 //************************************************************ 131 // SdrUndoObj 132 // 133 // Abstrakte Basisklasse für alle UndoActions die mit Objekten zu tun haben. 134 // 135 //************************************************************ 136 137 class SVX_DLLPUBLIC SdrUndoObj : public SdrUndoAction 138 { 139 protected: 140 SdrObject* pObj; 141 142 protected: 143 SdrUndoObj(SdrObject& rNewObj); 144 virtual ~SdrUndoObj() {} 145 146 void ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, String& rStr, FASTBOOL bRepeat=sal_False) const; 147 148 static void GetDescriptionStringForObject( const SdrObject& _rForObject, sal_uInt16 nStrCacheID, String& rStr, FASTBOOL bRepeat = sal_False ); 149 150 // #94278# new method for evtl. PageChange at UNDO/REDO 151 void ImpShowPageOfThisObject(); 152 }; 153 154 //************************************************************ 155 // SdrUndoAttrObj 156 // 157 // Änderung der Objektattribute. 158 // Action direkt vor dem Setzen der neuen Attribute konstruieren. 159 // Auch für StyleSheets 160 // 161 //************************************************************ 162 163 class SVX_DLLPUBLIC SdrUndoAttrObj : public SdrUndoObj 164 { 165 protected: 166 SfxItemSet* pUndoSet; 167 SfxItemSet* pRedoSet; 168 SfxItemSet* pRepeatSet; 169 170 // oder besser den StyleSheetNamen merken? 171 rtl::Reference< SfxStyleSheetBase > mxUndoStyleSheet; 172 rtl::Reference< SfxStyleSheetBase > mxRedoStyleSheet; 173 FASTBOOL bStyleSheet; 174 FASTBOOL bHaveToTakeRedoSet; 175 176 // Bei Zuweisung von TextItems auf ein Zeichenobjekt mit Text: 177 OutlinerParaObject* pTextUndo; 178 // #i8508# 179 // The text rescue mechanism needs also to be implemented for redo actions. 180 OutlinerParaObject* pTextRedo; 181 182 // Wenn sich um ein Gruppenobjekt handelt: 183 SdrUndoGroup* pUndoGroup; 184 185 // helper to ensure StyleSheet is in pool (provided by SdrModel from SdrObject) 186 void ensureStyleSheetInStyleSheetPool(SfxStyleSheetBasePool& rStyleSheetPool, SfxStyleSheet& rSheet); 187 188 public: 189 SdrUndoAttrObj(SdrObject& rNewObj, FASTBOOL bStyleSheet1=sal_False, FASTBOOL bSaveText=sal_False); 190 virtual ~SdrUndoAttrObj(); 191 192 void SetRepeatAttr(const SfxItemSet& rSet); 193 virtual void Undo(); 194 virtual void Redo(); 195 196 virtual String GetComment() const; 197 virtual String GetSdrRepeatComment(SdrView& rView) const; 198 199 virtual void SdrRepeat(SdrView& rView); 200 virtual bool CanSdrRepeat(SdrView& rView) const; 201 }; 202 203 //************************************************************ 204 // SdrUndoMoveObj 205 // 206 // Bloßes verschieben eines Objektes. 207 // Action direkt vor dem Verschieben konstruieren. 208 // 209 //************************************************************ 210 211 class SVX_DLLPUBLIC SdrUndoMoveObj : public SdrUndoObj 212 { 213 protected: 214 Size aDistance; // Entfernung, um die verschoben wird 215 216 public: 217 SdrUndoMoveObj(SdrObject& rNewObj): SdrUndoObj(rNewObj) {} 218 SdrUndoMoveObj(SdrObject& rNewObj, const Size& rDist): SdrUndoObj(rNewObj),aDistance(rDist) {} 219 virtual ~SdrUndoMoveObj() {} 220 221 void SetDistance(const Size& rDist) { aDistance=rDist; } 222 const Size& GetDistance() const { return aDistance; } 223 224 virtual void Undo(); 225 virtual void Redo(); 226 227 virtual String GetComment() const; 228 virtual String GetSdrRepeatComment(SdrView& rView) const; 229 230 virtual void SdrRepeat(SdrView& rView); 231 virtual bool CanSdrRepeat(SdrView& rView) const; 232 }; 233 234 //************************************************************ 235 // SdrUndoGeoObj 236 // 237 // Änderung der Geometrie eines Objektes. 238 // Action direkt vor der geometrischen Transformation konstruieren. 239 // 240 //************************************************************ 241 242 class SVX_DLLPUBLIC SdrUndoGeoObj : public SdrUndoObj 243 { 244 protected: 245 SdrObjGeoData* pUndoGeo; 246 SdrObjGeoData* pRedoGeo; 247 // Wenn sich um ein Gruppenobjekt handelt: 248 SdrUndoGroup* pUndoGroup; 249 250 public: 251 SdrUndoGeoObj(SdrObject& rNewObj); 252 virtual ~SdrUndoGeoObj(); 253 254 virtual void Undo(); 255 virtual void Redo(); 256 257 virtual String GetComment() const; 258 }; 259 260 //************************************************************ 261 // SdrUndoObjList 262 // 263 // Manipulationen an einer ObjList: Neues Obj, DeleteObj, SetObjZLevel, Grouping, ... 264 // Abstrakte Basisklasse. 265 // 266 //************************************************************ 267 268 class SVX_DLLPUBLIC SdrUndoObjList : public SdrUndoObj { 269 bool bOwner; 270 271 protected: 272 SdrObjList* pObjList; 273 SdrView* pView; // um bei ObjDel, Undo die 274 SdrPageView* pPageView; // Selektion widerherstellen zu koennen 275 sal_uInt32 nOrdNum; 276 // Bei einem Undo/Redo findet möglicherweise Übereignung des Objektes 277 // statt. Im Dtor wird das Obj deleted, wenn bOwner==TRUE 278 279 protected: 280 SdrUndoObjList(SdrObject& rNewObj, bool bOrdNumDirect = false); 281 virtual ~SdrUndoObjList(); 282 283 void SetView(SdrView* pView1, SdrPageView* pPageView1) { pView=pView1; pPageView=pPageView1; } 284 bool IsOwner() { return bOwner; } 285 void SetOwner(bool bNew); 286 }; 287 288 //************************************************************ 289 // SdrUndoRemoveObj 290 // 291 // Entfernen Objekts aus einer Objektliste. Innerhalb einer UndoGroup 292 // mit korrespondierenden Inserts zu verwenden. 293 // Action vor dem entfernen aus der ObjList konstruieren. 294 // 295 //************************************************************ 296 297 class SVX_DLLPUBLIC SdrUndoRemoveObj : public SdrUndoObjList 298 { 299 public: 300 SdrUndoRemoveObj(SdrObject& rNewObj, FASTBOOL bOrdNumDirect=sal_False) 301 : SdrUndoObjList(rNewObj,bOrdNumDirect) {} 302 303 virtual void Undo(); 304 virtual void Redo(); 305 }; 306 307 //************************************************************ 308 // SdrUndoInsertObj 309 // 310 // Einfügen Objekts in eine Objektliste. Innerhalb einer UndoGroup 311 // mit korrespondierenden Removes zu verwenden. 312 // Action vor dem entfernen aus der ObjList konstruieren. 313 // 314 //************************************************************ 315 316 class SVX_DLLPUBLIC SdrUndoInsertObj : public SdrUndoObjList 317 { 318 public: 319 SdrUndoInsertObj(SdrObject& rNewObj, FASTBOOL bOrdNumDirect=sal_False) 320 : SdrUndoObjList(rNewObj,bOrdNumDirect) {} 321 322 virtual void Undo(); 323 virtual void Redo(); 324 }; 325 326 //************************************************************ 327 // SdrUndoDelObj 328 // 329 // Löschen eines Objekts. 330 // Action vor dem entfernen aus der ObjList konstruieren. 331 // 332 //************************************************************ 333 334 class SVX_DLLPUBLIC SdrUndoDelObj : public SdrUndoRemoveObj 335 { 336 private: 337 void TryToFlushGraphicContent(); 338 339 public: 340 SdrUndoDelObj(SdrObject& rNewObj, FASTBOOL bOrdNumDirect=sal_False); 341 virtual ~SdrUndoDelObj(); 342 343 virtual void Undo(); 344 virtual void Redo(); 345 346 virtual String GetComment() const; 347 virtual String GetSdrRepeatComment(SdrView& rView) const; 348 349 virtual void SdrRepeat(SdrView& rView); 350 virtual bool CanSdrRepeat(SdrView& rView) const; 351 }; 352 353 //************************************************************ 354 // SdrUndoNewObj 355 // 356 // Einfügen eines neuen Objektes. 357 // Action nach dem einfügen in die ObjList konstruieren. 358 // 359 //************************************************************ 360 361 class SVX_DLLPUBLIC SdrUndoNewObj : public SdrUndoInsertObj 362 { 363 public: 364 SdrUndoNewObj(SdrObject& rNewObj, FASTBOOL bOrdNumDirect=sal_False) 365 : SdrUndoInsertObj(rNewObj,bOrdNumDirect) {} 366 virtual ~SdrUndoNewObj() {} 367 368 virtual void Undo(); 369 virtual void Redo(); 370 371 virtual String GetComment() const; 372 373 static String GetComment( const SdrObject& _rForObject ); 374 }; 375 376 //************************************************************ 377 // SdrUndoReplaceObj 378 // 379 // Austausch eines Objektes. 380 // Action vor dem Replace an der ObjList konstruieren. 381 // 382 //************************************************************ 383 384 class SVX_DLLPUBLIC SdrUndoReplaceObj : public SdrUndoObj 385 { 386 bool bOldOwner; 387 bool bNewOwner; 388 389 protected: 390 SdrObjList* pObjList; 391 sal_uInt32 nOrdNum; 392 SdrObject* pNewObj; 393 394 public: 395 SdrUndoReplaceObj(SdrObject& rOldObj1, SdrObject& rNewObj1, bool bOrdNumDirect = false); 396 virtual ~SdrUndoReplaceObj(); 397 398 virtual void Undo(); 399 virtual void Redo(); 400 401 bool IsNewOwner() { return bNewOwner; } 402 void SetNewOwner(bool bNew); 403 404 bool IsOldOwner() { return bOldOwner; } 405 void SetOldOwner(bool bNew); 406 }; 407 408 //************************************************************ 409 // SdrUndoCopyObj 410 // 411 // Kopieren eines Objekts 412 // Action nach dem einfügen in die ObjList konstruieren. 413 // 414 //************************************************************ 415 416 class SdrUndoCopyObj : public SdrUndoNewObj 417 { 418 public: 419 SdrUndoCopyObj(SdrObject& rNewObj, FASTBOOL bOrdNumDirect=sal_False) 420 : SdrUndoNewObj(rNewObj,bOrdNumDirect) {} 421 virtual ~SdrUndoCopyObj() {} 422 423 virtual String GetComment() const; 424 }; 425 426 //************************************************************ 427 // SdrUndoObjOrdNum 428 //************************************************************ 429 430 class SdrUndoObjOrdNum : public SdrUndoObj 431 { 432 protected: 433 sal_uInt32 nOldOrdNum; 434 sal_uInt32 nNewOrdNum; 435 436 public: 437 SdrUndoObjOrdNum(SdrObject& rNewObj, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1); 438 virtual ~SdrUndoObjOrdNum() {} 439 440 virtual void Undo(); 441 virtual void Redo(); 442 443 virtual String GetComment() const; 444 }; 445 446 ////////////////////////////////////////////////////////////////////////////// 447 // #i11702# 448 449 class SVX_DLLPUBLIC SdrUndoObjectLayerChange : public SdrUndoObj 450 { 451 protected: 452 SdrLayerID maOldLayer; 453 SdrLayerID maNewLayer; 454 455 public: 456 SdrUndoObjectLayerChange(SdrObject& rObj, SdrLayerID aOldLayer, SdrLayerID aNewLayer); 457 virtual ~SdrUndoObjectLayerChange() {} 458 459 virtual void Undo(); 460 virtual void Redo(); 461 }; 462 463 //************************************************************ 464 // SdrUndoObjSetText 465 //************************************************************ 466 467 class SVX_DLLPUBLIC SdrUndoObjSetText : public SdrUndoObj 468 { 469 protected: 470 OutlinerParaObject* pOldText; 471 OutlinerParaObject* pNewText; 472 FASTBOOL bNewTextAvailable; 473 sal_Bool bEmptyPresObj; 474 sal_Int32 mnText; 475 476 public: 477 SdrUndoObjSetText(SdrObject& rNewObj, sal_Int32 nText ); 478 virtual ~SdrUndoObjSetText(); 479 480 FASTBOOL IsDifferent() const { return pOldText!=pNewText; } 481 void AfterSetText(); 482 483 virtual void Undo(); 484 virtual void Redo(); 485 486 virtual String GetComment() const; 487 virtual String GetSdrRepeatComment(SdrView& rView) const; 488 489 virtual void SdrRepeat(SdrView& rView); 490 virtual bool CanSdrRepeat(SdrView& rView) const; 491 }; 492 493 // --> OD 2009-07-09 #i73249# 494 class SdrUndoObjStrAttr : public SdrUndoObj 495 { 496 public: 497 enum ObjStrAttrType 498 { 499 OBJ_NAME, 500 OBJ_TITLE, 501 OBJ_DESCRIPTION 502 }; 503 504 protected: 505 const ObjStrAttrType meObjStrAttr; 506 const String msOldStr; 507 const String msNewStr; 508 509 public: 510 SdrUndoObjStrAttr( SdrObject& rNewObj, 511 const ObjStrAttrType eObjStrAttr, 512 const String& sOldStr, 513 const String& sNewStr); 514 virtual ~SdrUndoObjStrAttr() {} 515 516 virtual void Undo(); 517 virtual void Redo(); 518 519 virtual String GetComment() const; 520 }; 521 // <-- 522 523 //////////////////////////////////////////////////////////////////////////////////////////////////// 524 // LAYER 525 //////////////////////////////////////////////////////////////////////////////////////////////////// 526 527 //************************************************************ 528 // SdrUndoLayer 529 // 530 // Abstrakte Basisklasse für alle UndoActions die mit SdrLayer zu tun haben. 531 // 532 //************************************************************ 533 534 class SdrUndoLayer : public SdrUndoAction 535 { 536 protected: 537 SdrLayer* pLayer; 538 SdrLayerAdmin* pLayerAdmin; 539 sal_uInt16 nNum; 540 FASTBOOL bItsMine; 541 542 protected: 543 SdrUndoLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel); 544 public: 545 virtual ~SdrUndoLayer(); 546 }; 547 548 //************************************************************ 549 // SdrUndoNewLayer 550 // 551 // Einfügen eines neuen Layer. Action nach dem Einfügen konstruieren. 552 // 553 //************************************************************ 554 555 class SdrUndoNewLayer : public SdrUndoLayer 556 { 557 public: 558 SdrUndoNewLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel) 559 : SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel) {} 560 virtual ~SdrUndoNewLayer() {} 561 562 virtual void Undo(); 563 virtual void Redo(); 564 565 virtual String GetComment() const; 566 }; 567 568 //************************************************************ 569 // SdrUndoDelLayer 570 // 571 // Löschen eines Layer. Action vor dem Remove konstruieren 572 // 573 //************************************************************ 574 575 class SdrUndoDelLayer : public SdrUndoLayer 576 { 577 public: 578 SdrUndoDelLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel) 579 : SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel) { bItsMine=sal_True; } 580 virtual ~SdrUndoDelLayer() {} 581 582 virtual void Undo(); 583 virtual void Redo(); 584 585 virtual String GetComment() const; 586 }; 587 588 //************************************************************ 589 // SdrUndoMoveLayer 590 // 591 // Verschieben eines Layer. Action vor dem Verschieben konstruieren. 592 // 593 //************************************************************ 594 595 class SdrUndoMoveLayer : public SdrUndoLayer 596 { 597 sal_uInt16 nNewPos; 598 599 public: 600 SdrUndoMoveLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel, sal_uInt16 nNewPos1) 601 : SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel), nNewPos(nNewPos1) {} 602 virtual ~SdrUndoMoveLayer() {} 603 604 virtual void Undo(); 605 virtual void Redo(); 606 607 virtual String GetComment() const; 608 }; 609 610 //////////////////////////////////////////////////////////////////////////////////////////////////// 611 // PAGES 612 //////////////////////////////////////////////////////////////////////////////////////////////////// 613 614 //************************************************************ 615 // SdrUndoPage 616 // 617 // Abstrakte Basisklasse für alle UndoActions die mit SdrPages zu tun haben. 618 // 619 //************************************************************ 620 621 class SVX_DLLPUBLIC SdrUndoPage : public SdrUndoAction 622 { 623 protected: 624 SdrPage& mrPage; 625 626 protected: 627 void ImpInsertPage(sal_uInt16 nNum); 628 void ImpRemovePage(sal_uInt16 nNum); 629 void ImpMovePage(sal_uInt16 nOldNum, sal_uInt16 nNewNum); 630 631 protected: 632 SdrUndoPage(SdrPage& rNewPg); 633 virtual ~SdrUndoPage() {} 634 635 void ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, String& rStr, sal_uInt16 n=0, FASTBOOL bRepeat=sal_False) const; 636 }; 637 638 //************************************************************ 639 // SdrUndoPageList 640 // 641 // Manipulationen an einer PageList: Neue Page, DeletePage, MovePage(ChangePageNum) 642 // Abstrakte Basisklasse. 643 // 644 //************************************************************ 645 646 class SVX_DLLPUBLIC SdrUndoPageList : public SdrUndoPage 647 { 648 protected: 649 sal_uInt16 nPageNum; 650 651 // Bei einem Undo/Redo findet möglicherweise Übereignung der Page 652 // statt. Im Dtor wird die Page deleted, wenn bItsMine==TRUE 653 FASTBOOL bItsMine; 654 655 protected: 656 SdrUndoPageList(SdrPage& rNewPg); 657 virtual ~SdrUndoPageList(); 658 }; 659 660 //************************************************************ 661 // SdrUndoDelPage 662 // 663 // Löschen einer Page. 664 // Action vor dem entfernen aus der List konstruieren. 665 // 666 //************************************************************ 667 668 class SVX_DLLPUBLIC SdrUndoDelPage : public SdrUndoPageList 669 { 670 // Beim loeschen einer MasterPage merke ich mir in dieser UndoGroup 671 // alle Beziehungen der Zeichenseiten zu der geloeschten MasterPage 672 SdrUndoGroup* pUndoGroup; 673 674 public: 675 SdrUndoDelPage(SdrPage& rNewPg); 676 virtual ~SdrUndoDelPage(); 677 678 virtual void Undo(); 679 virtual void Redo(); 680 681 virtual String GetComment() const; 682 virtual String GetSdrRepeatComment(SdrView& rView) const; 683 684 virtual void SdrRepeat(SdrView& rView); 685 virtual bool CanSdrRepeat(SdrView& rView) const; 686 }; 687 688 //************************************************************ 689 // SdrUndoNewPage 690 // 691 // Einfügen einer neuen Page. 692 // Action nach dem einfügen in die Liste konstruieren. 693 // 694 //************************************************************ 695 696 class SVX_DLLPUBLIC SdrUndoNewPage : public SdrUndoPageList 697 { 698 public: 699 SdrUndoNewPage(SdrPage& rNewPg): SdrUndoPageList(rNewPg) {} 700 virtual ~SdrUndoNewPage() {} 701 702 virtual void Undo(); 703 virtual void Redo(); 704 705 virtual String GetComment() const; 706 }; 707 708 //************************************************************ 709 // SdrUndoCopyPage 710 // 711 // Kopieren einer Page 712 // Action nach dem einfügen in die Liste konstruieren. 713 // 714 //************************************************************ 715 716 class SdrUndoCopyPage : public SdrUndoNewPage 717 { 718 public: 719 SdrUndoCopyPage(SdrPage& rNewPg): SdrUndoNewPage(rNewPg) {} 720 virtual ~SdrUndoCopyPage() {} 721 722 virtual String GetComment() const; 723 virtual String GetSdrRepeatComment(SdrView& rView) const; 724 725 virtual void SdrRepeat(SdrView& rView); 726 virtual bool CanSdrRepeat(SdrView& rView) const; 727 }; 728 729 //************************************************************ 730 // SdrUndoSetPageNum 731 // 732 // Verschieben der Page innerhalb der Liste 733 // Action vor dem Verschieben der Page konstruieren. 734 // 735 //************************************************************ 736 737 class SVX_DLLPUBLIC SdrUndoSetPageNum : public SdrUndoPage 738 { 739 protected: 740 sal_uInt16 nOldPageNum; 741 sal_uInt16 nNewPageNum; 742 743 public: 744 SdrUndoSetPageNum(SdrPage& rNewPg, sal_uInt16 nOldPageNum1, sal_uInt16 nNewPageNum1) 745 : SdrUndoPage(rNewPg),nOldPageNum(nOldPageNum1),nNewPageNum(nNewPageNum1) {} 746 virtual ~SdrUndoSetPageNum() {} 747 748 virtual void Undo(); 749 virtual void Redo(); 750 751 virtual String GetComment() const; 752 }; 753 754 //////////////////////////////////////////////////////////////////////////////////////////////////// 755 // MASTERPAGES 756 //////////////////////////////////////////////////////////////////////////////////////////////////// 757 758 //************************************************************ 759 // SdrUndoPageMasterPage 760 // 761 // Abstrakte Basisklasse fuer alle UndoActions die mit 762 // MasterPage-Beziehungen zu tun haben. 763 // 764 //************************************************************ 765 766 class SdrUndoPageMasterPage : public SdrUndoPage 767 { 768 protected: 769 sal_Bool mbOldHadMasterPage; 770 SetOfByte maOldSet; 771 sal_uInt16 maOldMasterPageNumber; 772 773 protected: 774 SdrUndoPageMasterPage(SdrPage& rChangedPage); 775 776 public: 777 SVX_DLLPUBLIC virtual ~SdrUndoPageMasterPage(); 778 }; 779 780 //************************************************************ 781 // SdrUndoPageRemoveMasterPage 782 // 783 // Entfernen einer MasterPage von einer Zeichenseite. 784 // Action vor dem Entfernen des MasterPageDescriptors erzeugen. 785 // 786 //************************************************************ 787 788 class SdrUndoPageRemoveMasterPage : public SdrUndoPageMasterPage 789 { 790 public: 791 SdrUndoPageRemoveMasterPage(SdrPage& rChangedPage); 792 793 virtual void Undo(); 794 virtual void Redo(); 795 796 virtual String GetComment() const; 797 }; 798 799 //************************************************************ 800 // SdrUndoPageChangeMasterPage 801 // 802 // Änderung des MasterPageDescriptors (z.B. ändern der VisibleLayer). 803 // Action vor der Änderung am MasterPageDescriptor erzeugen. 804 // 805 //************************************************************ 806 807 class SVX_DLLPUBLIC SdrUndoPageChangeMasterPage : public SdrUndoPageMasterPage 808 { 809 protected: 810 sal_Bool mbNewHadMasterPage; 811 SetOfByte maNewSet; 812 sal_uInt16 maNewMasterPageNumber; 813 814 public: 815 SdrUndoPageChangeMasterPage(SdrPage& rChangedPage); 816 virtual ~SdrUndoPageChangeMasterPage() {} 817 818 virtual void Undo(); 819 virtual void Redo(); 820 821 virtual String GetComment() const; 822 }; 823 824 /////////////////////////////////////////////////////////////////////// 825 826 /** the SdrUndoFactory can be set and retrieved from the SdrModel. 827 It is used by the drawing layer implementations to create undo actions. 828 It can be used by applications to create application specific undo actions. 829 */ 830 class SVX_DLLPUBLIC SdrUndoFactory 831 { 832 public: 833 // shapes 834 virtual ~SdrUndoFactory(); 835 virtual SdrUndoAction* CreateUndoMoveObject( SdrObject& rObject ); 836 virtual SdrUndoAction* CreateUndoMoveObject( SdrObject& rObject, const Size& rDist ); 837 virtual SdrUndoAction* CreateUndoGeoObject( SdrObject& rObject ); 838 virtual SdrUndoAction* CreateUndoAttrObject( SdrObject& rObject, bool bStyleSheet1 = false, bool bSaveText = false ); 839 virtual SdrUndoAction* CreateUndoRemoveObject( SdrObject& rObject, bool bOrdNumDirect = false); 840 virtual SdrUndoAction* CreateUndoInsertObject( SdrObject& rObject, bool bOrdNumDirect = false); 841 virtual SdrUndoAction* CreateUndoDeleteObject( SdrObject& rObject, bool bOrdNumDirect = false); 842 virtual SdrUndoAction* CreateUndoNewObject( SdrObject& rObject, bool bOrdNumDirect = false); 843 virtual SdrUndoAction* CreateUndoCopyObject( SdrObject& rObject, bool bOrdNumDirect = false); 844 845 virtual SdrUndoAction* CreateUndoObjectOrdNum( SdrObject& rObject, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1); 846 847 virtual SdrUndoAction* CreateUndoReplaceObject( SdrObject& rOldObject, SdrObject& rNewObject, bool bOrdNumDirect = false ); 848 virtual SdrUndoAction* CreateUndoObjectLayerChange( SdrObject& rObject, SdrLayerID aOldLayer, SdrLayerID aNewLayer ); 849 virtual SdrUndoAction* CreateUndoObjectSetText( SdrObject& rNewObj, sal_Int32 nText ); 850 851 // --> OD 2009-07-09 #i73249# 852 virtual SdrUndoAction* CreateUndoObjectStrAttr( SdrObject& rObject, 853 SdrUndoObjStrAttr::ObjStrAttrType eObjStrAttrType, 854 String sOldStr, 855 String sNewStr ); 856 // <-- 857 858 // layer 859 virtual SdrUndoAction* CreateUndoNewLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel); 860 virtual SdrUndoAction* CreateUndoDeleteLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel); 861 virtual SdrUndoAction* CreateUndoMoveLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel, sal_uInt16 nNewPos1); 862 863 // page 864 virtual SdrUndoAction* CreateUndoDeletePage(SdrPage& rPage); 865 virtual SdrUndoAction* CreateUndoNewPage(SdrPage& rPage); 866 virtual SdrUndoAction* CreateUndoCopyPage(SdrPage& rPage); 867 virtual SdrUndoAction* CreateUndoSetPageNum(SdrPage& rNewPg, sal_uInt16 nOldPageNum1, sal_uInt16 nNewPageNum1); 868 869 // master page 870 virtual SdrUndoAction* CreateUndoPageRemoveMasterPage(SdrPage& rChangedPage); 871 virtual SdrUndoAction* CreateUndoPageChangeMasterPage(SdrPage& rChangedPage); 872 }; 873 874 //////////////////////////////////////////////////////////////////////////////////////////////////// 875 876 #endif //_SVDUNDO_HXX 877 878 /* vim: set noet sw=4 ts=4: */ 879