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