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