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