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