include/svx/svdundo.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SVX_SVDUNDO_HXX
  21 #define INCLUDED_SVX_SVDUNDO_HXX
  22
  23 #include <svl/solar.hrc>
  24 #include <svl/undo.hxx>
  25 #include <svl/style.hxx>
  26 #include <tools/gen.hxx>
  27 #include <svx/svdtypes.hxx>
  28 #include <svx/svdsob.hxx>
  29 #include <svx/svxdllapi.h>
  30
  31 class SfxItemSet;
  32 class SfxStyleSheet;
  33 class SdrView;
  34 class SdrPageView;
  35 class SdrModel;
  36 class SdrObject;
  37 class SdrPage;
  38 class SdrObjList;
  39 class SdrLayer;
  40 class SdrLayerAdmin;
  41 class SdrObjGeoData;
  42 class OutlinerParaObject;
  43
  44 /**
  45  * Abstract base class (ABC) for all UndoActions of DrawingEngine
  46  */
  47
  48 class SVX_DLLPUBLIC SdrUndoAction : public SfxUndoAction
  49 {
  50 protected:
  51     SdrModel&                   rMod;
  52
  53 protected:
  54     SdrUndoAction(SdrModel& rNewMod)
  55     :   rMod(rNewMod)
  56     {}
  57
  58 public:
  59     TYPEINFO();
  60     virtual ~SdrUndoAction();
  61
  62     virtual bool CanRepeat(SfxRepeatTarget& rView) const;
  63     virtual void Repeat(SfxRepeatTarget& rView);
  64
  65     virtual OUString GetRepeatComment(SfxRepeatTarget& rView) const;
  66     virtual OUString GetSdrRepeatComment(SdrView& rView) const;
  67
  68     virtual bool CanSdrRepeat(SdrView& rView) const;
  69     virtual void SdrRepeat(SdrView& rView);
  70 };
  71
  72 /**
  73  * Aggregation of arbitrarily many UndoActions to a single UndoAction.
  74  * Undo() executes the single UndoActions backwards (LIFO, first the last
  75  * ones attached), Redo() executes the UndoActions in the order they were
  76  * added (FIFO).
  77  */
  78
  79 class SVX_DLLPUBLIC SdrUndoGroup : public SdrUndoAction
  80 {
  81 protected:
  82     std::vector<SdrUndoAction*> aBuf;
  83
  84     // No expanded description of the Action (contains %O)
  85     OUString                    aComment;
  86     OUString                    aObjDescription;
  87
  88     SdrRepeatFunc               eFunction;
  89
  90 public:
  91     SdrUndoGroup(SdrModel& rNewMod);
  92     virtual ~SdrUndoGroup();
  93
  94     void Clear();
  95     sal_uIntPtr GetActionCount() const { return aBuf.size(); }
  96     SdrUndoAction* GetAction(sal_uIntPtr nNum) const { return aBuf[nNum]; }
  97     void AddAction(SdrUndoAction* pAct);
  98
  99     void SetComment(const OUString& rStr) { aComment=rStr; }
 100     void SetObjDescription(const OUString& rStr) { aObjDescription=rStr; }
 101     virtual OUString GetComment() const;
 102     virtual OUString GetSdrRepeatComment(SdrView& rView) const;
 103
 104     virtual void Undo();
 105     virtual void Redo();
 106
 107     virtual bool CanSdrRepeat(SdrView& rView) const;
 108     virtual void SdrRepeat(SdrView& rView);
 109     void SetRepeatFunction(SdrRepeatFunc eFunc) { eFunction=eFunc; }
 110     SdrRepeatFunc GetRepeatFunction() const { return eFunction; }
 111 };
 112
 113 /**
 114  * Abstract base class for all UndoActions that handle objects.
 115  */
 116
 117 class SVX_DLLPUBLIC SdrUndoObj : public SdrUndoAction
 118 {
 119 protected:
 120     SdrObject*                  pObj;
 121
 122 protected:
 123     SdrUndoObj(SdrObject& rNewObj);
 124
 125     void ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, OUString& rStr, bool bRepeat = false) const;
 126
 127     static SAL_WARN_UNUSED_RESULT OUString GetDescriptionStringForObject( const SdrObject& _rForObject, sal_uInt16 nStrCacheID, bool bRepeat = false );
 128
 129     // #94278# new method for evtl. PageChange at UNDO/REDO
 130     void ImpShowPageOfThisObject();
 131 };
 132
 133 /**
 134  * Changing the object attributes.
 135  * Create Action right before setting the new attributes.
 136  * Also for StyleSheets.
 137  */
 138
 139 class SVX_DLLPUBLIC SdrUndoAttrObj : public SdrUndoObj
 140 {
 141 protected:
 142     SfxItemSet*                 pUndoSet;
 143     SfxItemSet*                 pRedoSet;
 144     SfxItemSet*                 pRepeatSet;
 145
 146     // FIXME: Or should we better remember the StyleSheetNames?
 147     rtl::Reference< SfxStyleSheetBase > mxUndoStyleSheet;
 148     rtl::Reference< SfxStyleSheetBase > mxRedoStyleSheet;
 149     bool                        bStyleSheet;
 150     bool                        bHaveToTakeRedoSet;
 151
 152     // When assigning TextItems to a drawing object with text:
 153     OutlinerParaObject*         pTextUndo;
 154     // #i8508#
 155     // The text rescue mechanism needs also to be implemented for redo actions.
 156     OutlinerParaObject*         pTextRedo;
 157
 158     // If we have a group object:
 159     SdrUndoGroup*               pUndoGroup;
 160
 161     // Helper to ensure StyleSheet is in pool (provided by SdrModel from SdrObject)
 162     void ensureStyleSheetInStyleSheetPool(SfxStyleSheetBasePool& rStyleSheetPool, SfxStyleSheet& rSheet);
 163
 164 public:
 165     SdrUndoAttrObj(SdrObject& rNewObj, bool bStyleSheet1 = false, bool bSaveText = false);
 166     virtual ~SdrUndoAttrObj();
 167     virtual void Undo();
 168     virtual void Redo();
 169
 170     virtual OUString GetComment() const;
 171     virtual OUString GetSdrRepeatComment(SdrView& rView) const;
 172
 173     virtual void SdrRepeat(SdrView& rView);
 174     virtual bool CanSdrRepeat(SdrView& rView) const;
 175 };
 176
 177 /**
 178  * Only moving of an object.
 179  * Create Action right before moving.
 180  */
 181
 182 class SVX_DLLPUBLIC SdrUndoMoveObj : public SdrUndoObj
 183 {
 184 protected:
 185     Size                        aDistance;     // Distance by which we move
 186
 187 public:
 188     SdrUndoMoveObj(SdrObject& rNewObj): SdrUndoObj(rNewObj) {}
 189     SdrUndoMoveObj(SdrObject& rNewObj, const Size& rDist): SdrUndoObj(rNewObj),aDistance(rDist) {}
 190     virtual ~SdrUndoMoveObj();
 191
 192     void SetDistance(const Size& rDist) { aDistance=rDist; }
 193     const Size& GetDistance() const { return aDistance; }
 194
 195     virtual void Undo();
 196     virtual void Redo();
 197
 198     virtual OUString GetComment() const;
 199     virtual OUString GetSdrRepeatComment(SdrView& rView) const;
 200
 201     virtual void SdrRepeat(SdrView& rView);
 202     virtual bool CanSdrRepeat(SdrView& rView) const;
 203 };
 204
 205 /**
 206  * Changing the geometry of an object.
 207  * Create Action right before the geometric transformation.
 208  */
 209
 210 class SVX_DLLPUBLIC SdrUndoGeoObj : public SdrUndoObj
 211 {
 212 protected:
 213     SdrObjGeoData*              pUndoGeo;
 214     SdrObjGeoData*              pRedoGeo;
 215     // If we have a group object:
 216     SdrUndoGroup*               pUndoGroup;
 217
 218 public:
 219     SdrUndoGeoObj(SdrObject& rNewObj);
 220     virtual ~SdrUndoGeoObj();
 221
 222     virtual void Undo();
 223     virtual void Redo();
 224
 225     virtual OUString GetComment() const;
 226 };
 227
 228 /**
 229  * Manipulation of an ObjList: New Object, DeleteObj, SetObjZLevel, Grouping, ...
 230  * Abstract base class.
 231  */
 232
 233 class SVX_DLLPUBLIC SdrUndoObjList : public SdrUndoObj {
 234     class ObjListListener;
 235     friend class ObjListListener;
 236
 237 private:
 238     bool                        bOwner;
 239
 240 protected:
 241     SdrObjList*                 pObjList;
 242     SdrView*                    pView;      // To be able to re-create the selection for a
 243     SdrPageView*                pPageView;  // for a ObjDel, Undo
 244     sal_uInt32                      nOrdNum;
 245     // It's possible that the object is re-assigned during a Undo/Redo.
 246     // The object is deleted in the dtor, if bOwner==TRUE
 247     ObjListListener*            m_pListener;
 248
 249 protected:
 250     SdrUndoObjList(SdrObject& rNewObj, bool bOrdNumDirect = false);
 251     virtual ~SdrUndoObjList();
 252
 253     void SetView(SdrView* pView1, SdrPageView* pPageView1) { pView=pView1; pPageView=pPageView1; }
 254     bool IsOwner() { return bOwner; }
 255     void SetOwner(bool bNew);
 256
 257 private:
 258     sal_uInt32 GetOrdNum() const;
 259     void SetOrdNum(sal_uInt32 nOrdNum_);
 260 };
 261
 262 /**
 263  * Removing an Object from an ObjectList.
 264  * To be used with corresponding Inserts within a UndoGroup.
 265  *
 266  * Create Action before removing from the ObjList.
 267  */
 268
 269 class SVX_DLLPUBLIC SdrUndoRemoveObj : public SdrUndoObjList
 270 {
 271 public:
 272     SdrUndoRemoveObj(SdrObject& rNewObj, bool bOrdNumDirect = false)
 273     : SdrUndoObjList(rNewObj,bOrdNumDirect) {}
 274
 275     virtual void Undo();
 276     virtual void Redo();
 277
 278     virtual ~SdrUndoRemoveObj();
 279 };
 280
 281 /**
 282  * Inserting Objects into a ObjectList.
 283  * Use with corresponding Removes within an UndoGroup.
 284  * Create Action before removal from ObjList.
 285  */
 286
 287 class SVX_DLLPUBLIC SdrUndoInsertObj : public SdrUndoObjList
 288 {
 289 public:
 290     SdrUndoInsertObj(SdrObject& rNewObj, bool bOrdNumDirect = false)
 291     :   SdrUndoObjList(rNewObj,bOrdNumDirect) {}
 292
 293     virtual void Undo();
 294     virtual void Redo();
 295 };
 296
 297 /**
 298  * Deleting an Object.
 299  * Create Action before removing from ObjList.
 300  */
 301
 302 class SVX_DLLPUBLIC SdrUndoDelObj : public SdrUndoRemoveObj
 303 {
 304 private:
 305     void TryToFlushGraphicContent();
 306
 307 public:
 308     SdrUndoDelObj(SdrObject& rNewObj, bool bOrdNumDirect = false);
 309
 310     virtual void Undo();
 311     virtual void Redo();
 312
 313     virtual OUString GetComment() const;
 314     virtual OUString GetSdrRepeatComment(SdrView& rView) const;
 315
 316     virtual void SdrRepeat(SdrView& rView);
 317     virtual bool CanSdrRepeat(SdrView& rView) const;
 318 };
 319
 320 /**
 321  * Inserting a NEW Object.
 322  * Create Actio after insertion into the ObjList.
 323  */
 324
 325 class SVX_DLLPUBLIC SdrUndoNewObj : public SdrUndoInsertObj
 326 {
 327 public:
 328     SdrUndoNewObj(SdrObject& rNewObj, bool bOrdNumDirect = false)
 329     :   SdrUndoInsertObj(rNewObj,bOrdNumDirect) {}
 330
 331     virtual void Undo();
 332     virtual void Redo();
 333
 334     virtual OUString GetComment() const;
 335
 336     static  OUString GetComment(const SdrObject& _rForObject);
 337 };
 338
 339 /**
 340  * Replacing an Object.
 341  * Create Action before Replace in ObjList.
 342  */
 343
 344 class SVX_DLLPUBLIC SdrUndoReplaceObj : public SdrUndoObj
 345 {
 346     bool                        bOldOwner;
 347     bool                        bNewOwner;
 348
 349 protected:
 350     SdrObjList*                 pObjList;
 351     sal_uInt32                      nOrdNum;
 352     SdrObject*                  pNewObj;
 353
 354 public:
 355     SdrUndoReplaceObj(SdrObject& rOldObj1, SdrObject& rNewObj1, bool bOrdNumDirect = false);
 356     virtual ~SdrUndoReplaceObj();
 357
 358     virtual void Undo();
 359     virtual void Redo();
 360
 361     bool IsNewOwner() { return bNewOwner; }
 362     void SetNewOwner(bool bNew);
 363
 364     bool IsOldOwner() { return bOldOwner; }
 365     void SetOldOwner(bool bNew);
 366 };
 367
 368 /**
 369  * Copying an Object.
 370  * Create Action before inserting into the ObjList.
 371  */
 372
 373 class SdrUndoCopyObj : public SdrUndoNewObj
 374 {
 375 public:
 376     SdrUndoCopyObj(SdrObject& rNewObj, bool bOrdNumDirect = false)
 377     :   SdrUndoNewObj(rNewObj,bOrdNumDirect) {}
 378
 379     virtual OUString GetComment() const;
 380 };
 381
 382 class SdrUndoObjOrdNum : public SdrUndoObj
 383 {
 384 protected:
 385     sal_uInt32                      nOldOrdNum;
 386     sal_uInt32                      nNewOrdNum;
 387
 388 public:
 389     SdrUndoObjOrdNum(SdrObject& rNewObj, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1);
 390
 391     virtual void Undo();
 392     virtual void Redo();
 393
 394     virtual OUString GetComment() const;
 395 };
 396
 397 //////////////////////////////////////////////////////////////////////////////
 398 // #i11702#
 399
 400 class SVX_DLLPUBLIC SdrUndoObjectLayerChange : public SdrUndoObj
 401 {
 402 protected:
 403     SdrLayerID                  maOldLayer;
 404     SdrLayerID                  maNewLayer;
 405
 406 public:
 407     SdrUndoObjectLayerChange(SdrObject& rObj, SdrLayerID aOldLayer, SdrLayerID aNewLayer);
 408
 409     virtual void Undo();
 410     virtual void Redo();
 411 };
 412
 413 class SVX_DLLPUBLIC SdrUndoObjSetText : public SdrUndoObj
 414 {
 415 protected:
 416     OutlinerParaObject*         pOldText;
 417     OutlinerParaObject*         pNewText;
 418     bool                        bNewTextAvailable;
 419     sal_Bool                        bEmptyPresObj;
 420     sal_Int32                   mnText;
 421
 422 public:
 423     SdrUndoObjSetText(SdrObject& rNewObj, sal_Int32 nText );
 424     virtual ~SdrUndoObjSetText();
 425
 426     bool IsDifferent() const { return pOldText!=pNewText; }
 427     void AfterSetText();
 428
 429     virtual void Undo();
 430     virtual void Redo();
 431
 432     virtual OUString GetComment() const;
 433     virtual OUString GetSdrRepeatComment(SdrView& rView) const;
 434
 435     virtual void SdrRepeat(SdrView& rView);
 436     virtual bool CanSdrRepeat(SdrView& rView) const;
 437 };
 438
 439 /**
 440  * Implement Title/Description Elements UI for Writer
 441  * text frames, graphics and embedded objects (#i73249#)
 442  */
 443 class SdrUndoObjStrAttr : public SdrUndoObj
 444 {
 445 public:
 446     enum ObjStrAttrType
 447     {
 448         OBJ_NAME,
 449         OBJ_TITLE,
 450         OBJ_DESCRIPTION
 451     };
 452
 453 protected:
 454     const ObjStrAttrType meObjStrAttr;
 455     const OUString msOldStr;
 456     const OUString msNewStr;
 457
 458 public:
 459     SdrUndoObjStrAttr( SdrObject& rNewObj,
 460                        const ObjStrAttrType eObjStrAttr,
 461                        const OUString& sOldStr,
 462                        const OUString& sNewStr);
 463
 464     virtual void Undo();
 465     virtual void Redo();
 466
 467     virtual OUString GetComment() const;
 468 };
 469
 470
 471 /*
 472  * Layer
 473  */
 474
 475 /**
 476  * Abstract base class for all UndoActions that have something to do with SdrLayer.
 477  */
 478
 479 class SdrUndoLayer : public SdrUndoAction
 480 {
 481 protected:
 482     SdrLayer*                   pLayer;
 483     SdrLayerAdmin*              pLayerAdmin;
 484     sal_uInt16                      nNum;
 485     bool                        bItsMine;
 486
 487 protected:
 488     SdrUndoLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel);
 489     virtual ~SdrUndoLayer();
 490 };
 491
 492 /**
 493  * Inserting a new Layer.
 494  * Create Action after Insertion.
 495  */
 496
 497 class SdrUndoNewLayer : public SdrUndoLayer
 498 {
 499 public:
 500     SdrUndoNewLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
 501     : SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel) {}
 502
 503     virtual void Undo();
 504     virtual void Redo();
 505
 506     virtual OUString GetComment() const;
 507 };
 508
 509 /**
 510  * Deleting a Layer.
 511  * Create Action before the Remove.
 512  */
 513
 514 class SdrUndoDelLayer : public SdrUndoLayer
 515 {
 516 public:
 517     SdrUndoDelLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel)
 518     : SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel) { bItsMine=sal_True; }
 519
 520     virtual void Undo();
 521     virtual void Redo();
 522
 523     virtual OUString GetComment() const;
 524 };
 525
 526 /**
 527  * Moving a Layer.
 528  * Create Action before the Move.
 529  */
 530
 531 class SdrUndoMoveLayer : public SdrUndoLayer
 532 {
 533     sal_uInt16                      nNeuPos;
 534
 535 public:
 536     SdrUndoMoveLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel, sal_uInt16 nNeuPos1)
 537     :   SdrUndoLayer(nLayerNum,rNewLayerAdmin,rNewModel), nNeuPos(nNeuPos1) {}
 538
 539     virtual void Undo();
 540     virtual void Redo();
 541
 542     virtual OUString GetComment() const;
 543 };
 544
 545
 546 /*
 547  * Pages
 548  */
 549
 550 /**
 551  * ABC for all UndoActions that have something to do with SdrPages.
 552  */
 553
 554 class SVX_DLLPUBLIC SdrUndoPage : public SdrUndoAction
 555 {
 556 protected:
 557     SdrPage&                    mrPage;
 558
 559 protected:
 560     void ImpInsertPage(sal_uInt16 nNum);
 561     void ImpRemovePage(sal_uInt16 nNum);
 562     void ImpMovePage(sal_uInt16 nOldNum, sal_uInt16 nNewNum);
 563
 564 protected:
 565     SdrUndoPage(SdrPage& rNewPg);
 566
 567     void ImpTakeDescriptionStr(sal_uInt16 nStrCacheID, OUString& rStr, sal_uInt16 n=0, bool bRepeat = false) const;
 568 };
 569
 570 /**
 571  * ABC for manipulation of a PageList: New Page, DeletePage, MovePage (ChangePageNum).
 572  */
 573
 574 class SVX_DLLPUBLIC SdrUndoPageList : public SdrUndoPage
 575 {
 576 protected:
 577     sal_uInt16                      nPageNum;
 578
 579     // It's possible that the object is re-assigned during a Undo/Redo.
 580     // The Page is deleted in the dtor, if bItsMine==TRUE
 581     bool                        bItsMine;
 582
 583 protected:
 584     SdrUndoPageList(SdrPage& rNewPg);
 585     virtual ~SdrUndoPageList();
 586 };
 587
 588 /**
 589  * Deleting a Page.
 590  * Create Action before removing from the List.
 591  */
 592
 593 class SVX_DLLPUBLIC SdrUndoDelPage : public SdrUndoPageList
 594 {
 595     // When deleting a MasterPage, we remember all relations of the
 596     // Character Page with the MasterPage in this UndoGroup.
 597     SdrUndoGroup*               pUndoGroup;
 598
 599 public:
 600     SdrUndoDelPage(SdrPage& rNewPg);
 601     virtual ~SdrUndoDelPage();
 602
 603     virtual void Undo();
 604     virtual void Redo();
 605
 606     virtual OUString GetComment() const;
 607     virtual OUString GetSdrRepeatComment(SdrView& rView) const;
 608
 609     virtual void SdrRepeat(SdrView& rView);
 610     virtual bool CanSdrRepeat(SdrView& rView) const;
 611 };
 612
 613 /**
 614  * Inserting a new Page.
 615  * Create Action after inserting into the List.
 616  */
 617
 618 class SVX_DLLPUBLIC SdrUndoNewPage : public SdrUndoPageList
 619 {
 620 public:
 621     SdrUndoNewPage(SdrPage& rNewPg): SdrUndoPageList(rNewPg) {}
 622
 623     virtual void Undo();
 624     virtual void Redo();
 625
 626     virtual OUString GetComment() const;
 627 };
 628
 629 /**
 630  * Copying a Page.
 631  * Create Action after inserting into the List.
 632  */
 633
 634 class SdrUndoCopyPage : public SdrUndoNewPage
 635 {
 636 public:
 637     SdrUndoCopyPage(SdrPage& rNewPg): SdrUndoNewPage(rNewPg) {}
 638
 639     virtual OUString GetComment() const;
 640     virtual OUString GetSdrRepeatComment(SdrView& rView) const;
 641
 642     virtual void SdrRepeat(SdrView& rView);
 643     virtual bool CanSdrRepeat(SdrView& rView) const;
 644 };
 645
 646 /**
 647  * Moving a Page within the List.
 648  * Create Action before moving the Page.
 649  */
 650
 651 class SVX_DLLPUBLIC SdrUndoSetPageNum : public SdrUndoPage
 652 {
 653 protected:
 654     sal_uInt16                      nOldPageNum;
 655     sal_uInt16                      nNewPageNum;
 656
 657 public:
 658     SdrUndoSetPageNum(SdrPage& rNewPg, sal_uInt16 nOldPageNum1, sal_uInt16 nNewPageNum1)
 659     :   SdrUndoPage(rNewPg),nOldPageNum(nOldPageNum1),nNewPageNum(nNewPageNum1) {}
 660
 661     virtual void Undo();
 662     virtual void Redo();
 663
 664     virtual OUString GetComment() const;
 665 };
 666
 667
 668 /*
 669  * Masterpages
 670  */
 671
 672 /**
 673  * ABC for all UndoActions that have something to do with
 674  * MasterPage relationships.
 675  */
 676
 677 class SdrUndoPageMasterPage : public SdrUndoPage
 678 {
 679 protected:
 680     sal_Bool                    mbOldHadMasterPage;
 681     SetOfByte                   maOldSet;
 682     sal_uInt16                  maOldMasterPageNumber;
 683
 684 protected:
 685     SdrUndoPageMasterPage(SdrPage& rChangedPage);
 686
 687 public:
 688     SVX_DLLPUBLIC virtual ~SdrUndoPageMasterPage();
 689 };
 690
 691 /**
 692  * Removal of a MasterPage from a Character Page.
 693  * Create Action before removing the MasterPageDescriptor.
 694  */
 695
 696 class SdrUndoPageRemoveMasterPage : public SdrUndoPageMasterPage
 697 {
 698 public:
 699     SdrUndoPageRemoveMasterPage(SdrPage& rChangedPage);
 700
 701     virtual void Undo();
 702     virtual void Redo();
 703
 704     virtual OUString GetComment() const;
 705 };
 706
 707 /**
 708  * Changing the MasterPageDescriptor (e.g. change of the VisibleLayer).
 709  * Create Action before changing the MasterPageDescriptors.
 710  */
 711
 712 class SVX_DLLPUBLIC SdrUndoPageChangeMasterPage : public SdrUndoPageMasterPage
 713 {
 714 protected:
 715     sal_Bool                    mbNewHadMasterPage;
 716     SetOfByte                   maNewSet;
 717     sal_uInt16                  maNewMasterPageNumber;
 718
 719 public:
 720     SdrUndoPageChangeMasterPage(SdrPage& rChangedPage);
 721
 722     virtual void Undo();
 723     virtual void Redo();
 724
 725     virtual OUString GetComment() const;
 726 };
 727
 728 ///////////////////////////////////////////////////////////////////////
 729
 730 /**
 731  * The SdrUndoFactory can be set and retrieved from the SdrModel.
 732  * It is used by the drawing layer implementations to create undo actions.
 733  * It can be used by applications to create application specific undo actions.
 734  */
 735 class SVX_DLLPUBLIC SdrUndoFactory
 736 {
 737 public:
 738     // Shapes
 739     virtual ~SdrUndoFactory();
 740     virtual SdrUndoAction* CreateUndoMoveObject( SdrObject& rObject );
 741     virtual SdrUndoAction* CreateUndoMoveObject( SdrObject& rObject, const Size& rDist );
 742     virtual SdrUndoAction* CreateUndoGeoObject( SdrObject& rObject );
 743     virtual SdrUndoAction* CreateUndoAttrObject( SdrObject& rObject, bool bStyleSheet1 = false, bool bSaveText = false );
 744     virtual SdrUndoAction* CreateUndoRemoveObject( SdrObject& rObject, bool bOrdNumDirect = false);
 745     virtual SdrUndoAction* CreateUndoInsertObject( SdrObject& rObject, bool bOrdNumDirect = false);
 746     virtual SdrUndoAction* CreateUndoDeleteObject( SdrObject& rObject, bool bOrdNumDirect = false);
 747     virtual SdrUndoAction* CreateUndoNewObject( SdrObject& rObject, bool bOrdNumDirect = false);
 748     virtual SdrUndoAction* CreateUndoCopyObject( SdrObject& rObject, bool bOrdNumDirect = false);
 749
 750     virtual SdrUndoAction* CreateUndoObjectOrdNum( SdrObject& rObject, sal_uInt32 nOldOrdNum1, sal_uInt32 nNewOrdNum1);
 751
 752     virtual SdrUndoAction* CreateUndoReplaceObject( SdrObject& rOldObject, SdrObject& rNewObject, bool bOrdNumDirect = false );
 753     virtual SdrUndoAction* CreateUndoObjectLayerChange( SdrObject& rObject, SdrLayerID aOldLayer, SdrLayerID aNewLayer );
 754     virtual SdrUndoAction* CreateUndoObjectSetText( SdrObject& rNewObj, sal_Int32 nText );
 755
 756     // Implement Title/Description Elements UI for Writer text frames, graphics and embedded objects (#i73249#)
 757     virtual SdrUndoAction* CreateUndoObjectStrAttr( SdrObject& rObject,
 758                                                     SdrUndoObjStrAttr::ObjStrAttrType eObjStrAttrType,
 759                                                     const OUString& sOldStr,
 760                                                     const OUString& sNewStr );
 761
 762     // Layer
 763     virtual SdrUndoAction* CreateUndoNewLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel);
 764     virtual SdrUndoAction* CreateUndoDeleteLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel);
 765     virtual SdrUndoAction* CreateUndoMoveLayer(sal_uInt16 nLayerNum, SdrLayerAdmin& rNewLayerAdmin, SdrModel& rNewModel, sal_uInt16 nNeuPos1);
 766
 767     // Page
 768     virtual SdrUndoAction*  CreateUndoDeletePage(SdrPage& rPage);
 769     virtual SdrUndoAction* CreateUndoNewPage(SdrPage& rPage);
 770     virtual SdrUndoAction* CreateUndoCopyPage(SdrPage& rPage);
 771     virtual SdrUndoAction* CreateUndoSetPageNum(SdrPage& rNewPg, sal_uInt16 nOldPageNum1, sal_uInt16 nNewPageNum1);
 772
 773     // Master page
 774     virtual SdrUndoAction* CreateUndoPageRemoveMasterPage(SdrPage& rChangedPage);
 775     virtual SdrUndoAction* CreateUndoPageChangeMasterPage(SdrPage& rChangedPage);
 776 };
 777
 778 #endif // INCLUDED_SVX_SVDUNDO_HXX
 779
 780 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */