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