sc/source/ui/inc/undoblk.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 #ifndef INCLUDED_SC_SOURCE_UI_INC_UNDOBLK_HXX
  20 #define INCLUDED_SC_SOURCE_UI_INC_UNDOBLK_HXX
  21
  22 #include "undobase.hxx"
  23 #include "markdata.hxx"
  24 #include "viewutil.hxx"
  25 #include "spellparam.hxx"
  26 #include "cellmergeoption.hxx"
  27 #include "paramisc.hxx"
  28
  29 #include <boost/shared_ptr.hpp>
  30 #include <boost/scoped_ptr.hpp>
  31
  32 class ScDocShell;
  33 class ScDocument;
  34 class ScOutlineTable;
  35 class ScRangeList;
  36 class ScPatternAttr;
  37 class SvxBoxItem;
  38 class SvxBoxInfoItem;
  39 class SvxSearchItem;
  40 class SdrUndoAction;
  41 class ScEditDataArray;
  42
  43 class ScUndoInsertCells: public ScMoveUndo
  44 {
  45 public:
  46                     TYPEINFO_OVERRIDE();
  47                     ScUndoInsertCells( ScDocShell* pNewDocShell,
  48                                        const ScRange& rRange, SCTAB nNewCount, SCTAB* pNewTabs, SCTAB* pNewScenarios,
  49                                        InsCellCmd eNewCmd, ScDocument* pUndoDocument, ScRefUndoData* pRefData,
  50                                        bool bNewPartOfPaste );
  51     virtual         ~ScUndoInsertCells();
  52
  53     virtual void    Undo() SAL_OVERRIDE;
  54     virtual void    Redo() SAL_OVERRIDE;
  55     virtual void    Repeat( SfxRepeatTarget& rTarget ) SAL_OVERRIDE;
  56     virtual bool    CanRepeat( SfxRepeatTarget& rTarget ) const SAL_OVERRIDE;
  57
  58     virtual OUString GetComment() const SAL_OVERRIDE;
  59
  60     virtual bool    Merge( SfxUndoAction *pNextAction ) SAL_OVERRIDE;
  61
  62 private:
  63     ScRange         aEffRange;
  64     SCTAB           nCount;
  65     SCTAB*          pTabs;
  66     SCTAB*          pScenarios;
  67     sal_uLong       nEndChangeAction;
  68     InsCellCmd      eCmd;
  69     bool            bPartOfPaste;
  70     SfxUndoAction*  pPasteUndo;
  71
  72     void            DoChange ( const bool bUndo );
  73     void            SetChangeTrack();
  74 };
  75
  76 class ScUndoDeleteCells: public ScMoveUndo
  77 {
  78 public:
  79                     TYPEINFO_OVERRIDE();
  80                     ScUndoDeleteCells( ScDocShell* pNewDocShell,
  81                                        const ScRange& rRange, SCTAB nNewCount, SCTAB* pNewTabs, SCTAB* pNewScenarios,
  82                                        DelCellCmd eNewCmd, ScDocument* pUndoDocument, ScRefUndoData* pRefData );
  83     virtual         ~ScUndoDeleteCells();
  84
  85     virtual void    Undo() SAL_OVERRIDE;
  86     virtual void    Redo() SAL_OVERRIDE;
  87     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
  88     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
  89
  90     virtual OUString GetComment() const SAL_OVERRIDE;
  91
  92 private:
  93     ScRange         aEffRange;
  94     SCTAB           nCount;
  95     SCTAB*          pTabs;
  96     SCTAB*          pScenarios;
  97     sal_uLong       nStartChangeAction;
  98     sal_uLong       nEndChangeAction;
  99     DelCellCmd      eCmd;
 100
 101     void            DoChange ( const bool bUndo );
 102     void            SetChangeTrack();
 103 };
 104
 105 class ScUndoDeleteMulti: public ScMoveUndo
 106 {
 107 public:
 108                     TYPEINFO_OVERRIDE();
 109
 110     ScUndoDeleteMulti( ScDocShell* pNewDocShell,
 111                        bool bNewRows, bool bNeedsRefresh, SCTAB nNewTab,
 112                        const std::vector<sc::ColRowSpan>& rSpans,
 113                        ScDocument* pUndoDocument, ScRefUndoData* pRefData );
 114
 115     virtual         ~ScUndoDeleteMulti();
 116
 117     virtual void    Undo() SAL_OVERRIDE;
 118     virtual void    Redo() SAL_OVERRIDE;
 119     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 120     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 121
 122     virtual OUString GetComment() const SAL_OVERRIDE;
 123
 124 private:
 125     bool mbRows:1;
 126     bool mbRefresh:1;
 127     SCTAB           nTab;
 128     std::vector<sc::ColRowSpan> maSpans;
 129     sal_uLong           nStartChangeAction;
 130     sal_uLong           nEndChangeAction;
 131
 132     void            DoChange() const;
 133     void            SetChangeTrack();
 134 };
 135
 136 class ScUndoCut: public ScBlockUndo
 137 {
 138 public:
 139                     TYPEINFO_OVERRIDE();
 140                     ScUndoCut( ScDocShell* pNewDocShell,
 141                                ScRange aRange,              // adjusted for merged cells
 142                                ScAddress aOldEnd,           // end position without adjustment
 143                                const ScMarkData& rMark,     // selected sheets
 144                                ScDocument* pNewUndoDoc );
 145     virtual         ~ScUndoCut();
 146
 147     virtual void    Undo() SAL_OVERRIDE;
 148     virtual void    Redo() SAL_OVERRIDE;
 149     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 150     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 151
 152     virtual OUString GetComment() const SAL_OVERRIDE;
 153
 154 private:
 155     ScMarkData      aMarkData;
 156     ScDocument*     pUndoDoc;
 157     ScRange         aExtendedRange;
 158     sal_uLong           nStartChangeAction;
 159     sal_uLong           nEndChangeAction;
 160
 161     void            DoChange( const bool bUndo );
 162     void            SetChangeTrack();
 163 };
 164
 165 struct ScUndoPasteOptions
 166 {
 167     sal_uInt16 nFunction;
 168     bool       bSkipEmpty;
 169     bool       bTranspose;
 170     bool       bAsLink;
 171     InsCellCmd eMoveMode;
 172
 173     ScUndoPasteOptions() :
 174         nFunction( PASTE_NOFUNC ),
 175         bSkipEmpty( false ),
 176         bTranspose( false ),
 177         bAsLink( false ),
 178         eMoveMode( INS_NONE )
 179     {}
 180 };
 181
 182 class ScUndoPaste: public ScMultiBlockUndo
 183 {
 184 public:
 185     TYPEINFO_OVERRIDE();
 186     ScUndoPaste(ScDocShell* pNewDocShell, const ScRangeList& rRanges,
 187                 const ScMarkData& rMark,
 188                 ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc,
 189                 InsertDeleteFlags nNewFlags,
 190                 ScRefUndoData* pRefData,
 191                 bool bRedoIsFilled = true,
 192                 const ScUndoPasteOptions* pOptions = NULL);
 193     virtual ~ScUndoPaste();
 194
 195     virtual void Undo() SAL_OVERRIDE;
 196     virtual void Redo() SAL_OVERRIDE;
 197     virtual void Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 198     virtual bool CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 199
 200     virtual OUString GetComment() const SAL_OVERRIDE;
 201
 202 private:
 203     ScMarkData      aMarkData;
 204     ScDocument*     pUndoDoc;
 205     ScDocument*     pRedoDoc;
 206     InsertDeleteFlags nFlags;
 207     ScRefUndoData*  pRefUndoData;
 208     ScRefUndoData*  pRefRedoData;
 209     sal_uLong       nStartChangeAction;
 210     sal_uLong       nEndChangeAction;
 211     bool            bRedoFilled;
 212     ScUndoPasteOptions aPasteOptions;
 213
 214     void DoChange(bool bUndo);
 215     void SetChangeTrack();
 216 };
 217
 218 class ScUndoDragDrop: public ScMoveUndo
 219 {
 220 public:
 221                     TYPEINFO_OVERRIDE();
 222                     ScUndoDragDrop( ScDocShell* pNewDocShell,
 223                                     const ScRange& rRange, ScAddress aNewDestPos, bool bNewCut,
 224                                     ScDocument* pUndoDocument, ScRefUndoData* pRefData,
 225                                     bool bScenario );
 226     virtual         ~ScUndoDragDrop();
 227
 228     virtual void    Undo() SAL_OVERRIDE;
 229     virtual void    Redo() SAL_OVERRIDE;
 230     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 231     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 232
 233     virtual OUString GetComment() const SAL_OVERRIDE;
 234
 235 private:
 236     sal_uInt16 mnPaintExtFlags;
 237     ScRangeList maPaintRanges;
 238
 239     ScRange         aSrcRange;
 240     ScRange         aDestRange;
 241     sal_uLong       nStartChangeAction;
 242     sal_uLong       nEndChangeAction;
 243     bool            bCut;
 244     bool            bKeepScenarioFlags;
 245
 246     void            PaintArea( ScRange aRange, sal_uInt16 nExtFlags ) const;
 247     void DoUndo( ScRange aRange );
 248
 249     void            SetChangeTrack();
 250 };
 251
 252 class ScUndoDeleteContents: public ScSimpleUndo
 253 {
 254 public:
 255                     TYPEINFO_OVERRIDE();
 256                     ScUndoDeleteContents( ScDocShell* pNewDocShell,
 257                                           const ScMarkData& rMark,
 258                                           const ScRange& rRange,
 259                                           ScDocument* pNewUndoDoc, bool bNewMulti,
 260                                           InsertDeleteFlags nNewFlags, bool bObjects );
 261     virtual         ~ScUndoDeleteContents();
 262
 263     virtual void    Undo() SAL_OVERRIDE;
 264     virtual void    Redo() SAL_OVERRIDE;
 265     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 266     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 267
 268     virtual OUString GetComment() const SAL_OVERRIDE;
 269
 270     void SetDataSpans( const boost::shared_ptr<DataSpansType>& pSpans );
 271
 272 private:
 273     boost::shared_ptr<DataSpansType> mpDataSpans; // Spans of non-empty cells.
 274
 275     ScRange         aRange;
 276     ScMarkData      aMarkData;
 277     ScDocument*     pUndoDoc;       // Block mark and deleted data
 278     SdrUndoAction*  pDrawUndo;      // Deleted objects
 279     sal_uLong       nStartChangeAction;
 280     sal_uLong       nEndChangeAction;
 281     InsertDeleteFlags nFlags;
 282     bool            bMulti;         // Multi selection
 283
 284     void            DoChange( const bool bUndo );
 285     void            SetChangeTrack();
 286 };
 287
 288 class ScUndoFillTable: public ScSimpleUndo
 289 {
 290 public:
 291                     TYPEINFO_OVERRIDE();
 292                     ScUndoFillTable( ScDocShell* pNewDocShell,
 293                                      const ScMarkData& rMark,
 294                                      SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
 295                                      SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
 296                                      ScDocument* pNewUndoDoc, bool bNewMulti, SCTAB nSrc,
 297                                      InsertDeleteFlags nFlg, sal_uInt16 nFunc, bool bSkip, bool bLink );
 298     virtual         ~ScUndoFillTable();
 299
 300     virtual void    Undo() SAL_OVERRIDE;
 301     virtual void    Redo() SAL_OVERRIDE;
 302     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 303     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 304
 305     virtual OUString GetComment() const SAL_OVERRIDE;
 306
 307 private:
 308     ScRange         aRange;
 309     ScMarkData      aMarkData;
 310     ScDocument*     pUndoDoc;       // Block mark and deleted data
 311     sal_uLong       nStartChangeAction;
 312     sal_uLong       nEndChangeAction;
 313     InsertDeleteFlags nFlags;
 314     sal_uInt16      nFunction;
 315     SCTAB           nSrcTab;
 316     bool            bMulti;         // Multi selection
 317     bool            bSkipEmpty;
 318     bool            bAsLink;
 319
 320     void            DoChange( const bool bUndo );
 321     void            SetChangeTrack();
 322 };
 323
 324 class ScUndoSelectionAttr: public ScSimpleUndo
 325 {
 326 public:
 327                     TYPEINFO_OVERRIDE();
 328                     ScUndoSelectionAttr( ScDocShell* pNewDocShell,
 329                                          const ScMarkData& rMark,
 330                                          SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
 331                                          SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
 332                                          ScDocument* pNewUndoDoc, bool bNewMulti,
 333                                          const ScPatternAttr* pNewApply,
 334                                          const SvxBoxItem* pNewOuter = NULL,
 335                                          const SvxBoxInfoItem* pNewInner = NULL );
 336     virtual         ~ScUndoSelectionAttr();
 337
 338     virtual void    Undo() SAL_OVERRIDE;
 339     virtual void    Redo() SAL_OVERRIDE;
 340     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 341     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 342
 343     virtual OUString GetComment() const SAL_OVERRIDE;
 344
 345     ScEditDataArray*    GetDataArray();
 346 private:
 347     ScMarkData      aMarkData;
 348     ScRange         aRange;
 349     boost::scoped_ptr<ScEditDataArray> mpDataArray;
 350     ScDocument*     pUndoDoc;
 351     bool            bMulti;
 352     ScPatternAttr*  pApplyPattern;
 353     SvxBoxItem*     pLineOuter;
 354     SvxBoxInfoItem* pLineInner;
 355
 356     void            DoChange( const bool bUndo );
 357     void            ChangeEditData( const bool bUndo );
 358 };
 359
 360 class ScUndoWidthOrHeight: public ScSimpleUndo
 361 {
 362 public:
 363                     TYPEINFO_OVERRIDE();
 364                     ScUndoWidthOrHeight( ScDocShell* pNewDocShell,
 365                                          const ScMarkData& rMark,
 366                                          SCCOLROW nNewStart, SCTAB nNewStartTab,
 367                                          SCCOLROW nNewEnd, SCTAB nNewEndTab,
 368                                          ScDocument* pNewUndoDoc,
 369                                          const std::vector<sc::ColRowSpan>& rRanges,
 370                                          ScOutlineTable* pNewUndoTab,
 371                                          ScSizeMode eNewMode, sal_uInt16 nNewSizeTwips,
 372                                          bool bNewWidth );
 373     virtual         ~ScUndoWidthOrHeight();
 374
 375     virtual void    Undo() SAL_OVERRIDE;
 376     virtual void    Redo() SAL_OVERRIDE;
 377     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 378     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 379
 380     virtual OUString GetComment() const SAL_OVERRIDE;
 381
 382 private:
 383     ScMarkData      aMarkData;
 384     SCCOLROW        nStart;
 385     SCCOLROW        nEnd;
 386     SCTAB           nStartTab;
 387     SCTAB           nEndTab;
 388     ScDocument*     pUndoDoc;
 389     ScOutlineTable* pUndoTab;
 390     std::vector<sc::ColRowSpan> maRanges;
 391     sal_uInt16      nNewSize;
 392     bool            bWidth;
 393     ScSizeMode      eMode;
 394     SdrUndoAction*  pDrawUndo;
 395 };
 396
 397 class ScUndoAutoFill: public ScBlockUndo
 398 {
 399 public:
 400                     TYPEINFO_OVERRIDE();
 401                     ScUndoAutoFill( ScDocShell* pNewDocShell,
 402                                     const ScRange& rRange, const ScRange& rSourceArea,
 403                                     ScDocument* pNewUndoDoc, const ScMarkData& rMark,
 404                                     FillDir eNewFillDir,
 405                                     FillCmd eNewFillCmd, FillDateCmd eNewFillDateCmd,
 406                                     double fNewStartValue, double fNewStepValue, double fNewMaxValue );
 407     virtual         ~ScUndoAutoFill();
 408
 409     virtual void    Undo() SAL_OVERRIDE;
 410     virtual void    Redo() SAL_OVERRIDE;
 411     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 412     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 413
 414     virtual OUString GetComment() const SAL_OVERRIDE;
 415
 416 private:
 417     ScRange         aSource;
 418     ScMarkData      aMarkData;
 419     ScDocument*     pUndoDoc;
 420     FillDir         eFillDir;
 421     FillCmd         eFillCmd;
 422     FillDateCmd     eFillDateCmd;
 423     double          fStartValue;
 424     double          fStepValue;
 425     double          fMaxValue;
 426     sal_uLong           nStartChangeAction;
 427     sal_uLong           nEndChangeAction;
 428
 429     void            SetChangeTrack();
 430 };
 431
 432 class ScUndoMerge: public ScSimpleUndo
 433 {
 434 public:
 435                     TYPEINFO_OVERRIDE();
 436                     ScUndoMerge( ScDocShell* pNewDocShell, const ScCellMergeOption& rOption,
 437                                  bool bMergeContents, ScDocument* pUndoDoc, SdrUndoAction* pDrawUndo);
 438     virtual         ~ScUndoMerge();
 439
 440     virtual void    Undo() SAL_OVERRIDE;
 441     virtual void    Redo() SAL_OVERRIDE;
 442     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 443     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 444
 445     virtual OUString GetComment() const SAL_OVERRIDE;
 446
 447 private:
 448     ScCellMergeOption maOption;
 449     bool            mbMergeContents;        // Merge contents in Redo().
 450     ScDocument*     mpUndoDoc;              // when data is merged
 451     SdrUndoAction*  mpDrawUndo;
 452
 453     void            DoChange( bool bUndo ) const;
 454 };
 455
 456 class ScUndoAutoFormat: public ScBlockUndo
 457 {
 458 public:
 459                     TYPEINFO_OVERRIDE();
 460                     ScUndoAutoFormat( ScDocShell* pNewDocShell,
 461                                       const ScRange& rRange, ScDocument* pNewUndoDoc,
 462                                       const ScMarkData& rMark,
 463                                       bool bNewSize, sal_uInt16 nNewFormatNo );
 464     virtual         ~ScUndoAutoFormat();
 465
 466     virtual void    Undo() SAL_OVERRIDE;
 467     virtual void    Redo() SAL_OVERRIDE;
 468     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 469     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 470
 471     virtual OUString GetComment() const SAL_OVERRIDE;
 472
 473 private:
 474     ScDocument*     pUndoDoc;       // deleted data
 475     ScMarkData      aMarkData;
 476     bool            bSize;
 477     sal_uInt16      nFormatNo;
 478 };
 479
 480 class ScUndoReplace: public ScSimpleUndo
 481 {
 482 public:
 483                     TYPEINFO_OVERRIDE();
 484                     ScUndoReplace( ScDocShell* pNewDocShell,
 485                                    const ScMarkData& rMark,
 486                                    SCCOL nCurX, SCROW nCurY, SCTAB nCurZ,
 487                                    const OUString& rNewUndoStr, ScDocument* pNewUndoDoc,
 488                                    const SvxSearchItem* pItem );
 489     virtual         ~ScUndoReplace();
 490
 491     virtual void    Undo() SAL_OVERRIDE;
 492     virtual void    Redo() SAL_OVERRIDE;
 493     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 494     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 495
 496     virtual OUString GetComment() const SAL_OVERRIDE;
 497
 498 private:
 499     ScAddress       aCursorPos;
 500     ScMarkData      aMarkData;
 501     OUString        aUndoStr;           // Data at single selection
 502     ScDocument*     pUndoDoc;           // Block mark and deleted data
 503     SvxSearchItem*  pSearchItem;
 504     sal_uLong           nStartChangeAction;
 505     sal_uLong           nEndChangeAction;
 506
 507             void    SetChangeTrack();
 508 };
 509
 510 class ScUndoTabOp: public ScSimpleUndo
 511 {
 512 public:
 513                     TYPEINFO_OVERRIDE();
 514                     ScUndoTabOp( ScDocShell* pNewDocShell,
 515                                  SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
 516                                  SCCOL nEndX,   SCROW nEndY,   SCTAB nEndZ,
 517                                  ScDocument* pNewUndoDoc,
 518                                  const ScRefAddress& rFormulaCell,
 519                                  const ScRefAddress& rFormulaEnd,
 520                                  const ScRefAddress& rRowCell,
 521                                  const ScRefAddress& rColCell,
 522                                  ScTabOpParam::Mode eMode );
 523     virtual         ~ScUndoTabOp();
 524
 525     virtual void    Undo() SAL_OVERRIDE;
 526     virtual void    Redo() SAL_OVERRIDE;
 527     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 528     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 529
 530     virtual OUString GetComment() const SAL_OVERRIDE;
 531
 532 private:
 533     ScRange         aRange;
 534     ScDocument*     pUndoDoc;       // Deleted data
 535     ScRefAddress    theFormulaCell;
 536     ScRefAddress    theFormulaEnd;
 537     ScRefAddress    theRowCell;
 538     ScRefAddress    theColCell;
 539     ScTabOpParam::Mode meMode;
 540 };
 541
 542 class ScUndoConversion : public ScSimpleUndo
 543 {
 544 public:
 545                     TYPEINFO_OVERRIDE();
 546
 547                     ScUndoConversion( ScDocShell* pNewDocShell, const ScMarkData& rMark,
 548                                       SCCOL nCurX, SCROW nCurY, SCTAB nCurZ, ScDocument* pNewUndoDoc,
 549                                       SCCOL nNewX, SCROW nNewY, SCTAB nNewZ, ScDocument* pNewRedoDoc,
 550                                       const ScConversionParam& rConvParam );
 551     virtual         ~ScUndoConversion();
 552
 553     virtual void    Undo() SAL_OVERRIDE;
 554     virtual void    Redo() SAL_OVERRIDE;
 555     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 556     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 557
 558     virtual OUString GetComment() const SAL_OVERRIDE;
 559
 560 private:
 561     ScMarkData      aMarkData;
 562     ScAddress       aCursorPos;
 563     ScDocument*     pUndoDoc;           // Block mark and deleted data
 564     ScAddress       aNewCursorPos;
 565     ScDocument*     pRedoDoc;           // Block mark and new data
 566     sal_uLong       nStartChangeAction;
 567     sal_uLong       nEndChangeAction;
 568     ScConversionParam maConvParam;        /// Conversion type and parameters.
 569
 570     void            DoChange( ScDocument* pRefDoc, const ScAddress& rCursorPos );
 571     void            SetChangeTrack();
 572 };
 573
 574 class ScUndoRefConversion: public ScSimpleUndo
 575 {
 576 public:
 577                     TYPEINFO_OVERRIDE();
 578                     ScUndoRefConversion( ScDocShell* pNewDocShell,
 579                                          const ScRange& aMarkRange, const ScMarkData& rMark,
 580                                          ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc, bool bNewMulti, InsertDeleteFlags nNewFlag);
 581     virtual         ~ScUndoRefConversion();
 582
 583     virtual void    Undo() SAL_OVERRIDE;
 584     virtual void    Redo() SAL_OVERRIDE;
 585     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 586     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 587
 588     virtual OUString GetComment() const SAL_OVERRIDE;
 589
 590 private:
 591     ScMarkData          aMarkData;
 592     ScDocument*         pUndoDoc;
 593     ScDocument*         pRedoDoc;
 594     ScRange             aRange;
 595     bool                bMulti;
 596     InsertDeleteFlags   nFlags;
 597     sal_uLong           nStartChangeAction;
 598     sal_uLong           nEndChangeAction;
 599
 600     void                DoChange( ScDocument* pRefDoc);
 601     void                SetChangeTrack();
 602 };
 603
 604 class ScUndoListNames: public ScBlockUndo
 605 {
 606 public:
 607                     TYPEINFO_OVERRIDE();
 608                     ScUndoListNames( ScDocShell* pNewDocShell,
 609                                      const ScRange& rRange,
 610                                      ScDocument* pNewUndoDoc, ScDocument* pNewRedoDoc );
 611     virtual         ~ScUndoListNames();
 612
 613     virtual void    Undo() SAL_OVERRIDE;
 614     virtual void    Redo() SAL_OVERRIDE;
 615     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 616     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 617
 618     virtual OUString GetComment() const SAL_OVERRIDE;
 619
 620 private:
 621     ScDocument*     pUndoDoc;
 622     ScDocument*     pRedoDoc;
 623
 624     void            DoChange( ScDocument* pSrcDoc ) const;
 625 };
 626
 627 class ScUndoConditionalFormat : public ScSimpleUndo
 628 {
 629 public:
 630     TYPEINFO_OVERRIDE();
 631     ScUndoConditionalFormat( ScDocShell* pNewDocShell,
 632             ScDocument* pUndoDoc, ScDocument* pRedoDoc, const ScRange& rRange);
 633     virtual         ~ScUndoConditionalFormat();
 634
 635     virtual void    Undo() SAL_OVERRIDE;
 636     virtual void    Redo() SAL_OVERRIDE;
 637     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 638     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 639
 640     virtual OUString GetComment() const SAL_OVERRIDE;
 641
 642 private:
 643     void DoChange(ScDocument* pDoc);
 644     boost::scoped_ptr<ScDocument> mpUndoDoc;
 645     boost::scoped_ptr<ScDocument> mpRedoDoc;
 646     ScRange maRange;
 647 };
 648
 649 class ScUndoUseScenario: public ScSimpleUndo
 650 {
 651 public:
 652                     TYPEINFO_OVERRIDE();
 653                     ScUndoUseScenario( ScDocShell* pNewDocShell,
 654                                        const ScMarkData& rMark,
 655                                        const ScArea& rDestArea, ScDocument* pNewUndoDoc,
 656                                        const OUString& rNewName );
 657     virtual         ~ScUndoUseScenario();
 658
 659     virtual void    Undo() SAL_OVERRIDE;
 660     virtual void    Redo() SAL_OVERRIDE;
 661     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 662     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 663
 664     virtual OUString GetComment() const SAL_OVERRIDE;
 665
 666 private:
 667     ScDocument*     pUndoDoc;
 668     ScRange         aRange;
 669     ScMarkData      aMarkData;
 670     OUString        aName;
 671 };
 672
 673 class ScUndoSelectionStyle: public ScSimpleUndo
 674 {
 675 public:
 676                     TYPEINFO_OVERRIDE();
 677                     ScUndoSelectionStyle( ScDocShell* pNewDocShell,
 678                                           const ScMarkData& rMark,
 679                                           const ScRange& rRange,
 680                                           const OUString& rName,
 681                                           ScDocument* pNewUndoDoc );
 682     virtual         ~ScUndoSelectionStyle();
 683
 684     virtual void    Undo() SAL_OVERRIDE;
 685     virtual void    Redo() SAL_OVERRIDE;
 686     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 687     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 688
 689     virtual OUString GetComment() const SAL_OVERRIDE;
 690     virtual sal_uInt16  GetId() const SAL_OVERRIDE;
 691
 692 private:
 693     ScMarkData      aMarkData;
 694     ScDocument*     pUndoDoc;
 695     OUString        aStyleName;
 696     ScRange         aRange;
 697
 698     void            DoChange( const bool bUndo );
 699 };
 700
 701 class ScUndoRefreshLink: public ScSimpleUndo
 702 {
 703 public:
 704                     TYPEINFO_OVERRIDE();
 705                     ScUndoRefreshLink( ScDocShell* pNewDocShell,
 706                                        ScDocument* pNewUndoDoc );
 707     virtual         ~ScUndoRefreshLink();
 708
 709     virtual void    Undo() SAL_OVERRIDE;
 710     virtual void    Redo() SAL_OVERRIDE;
 711     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 712     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 713
 714     virtual OUString GetComment() const SAL_OVERRIDE;
 715
 716 private:
 717     ScDocument*     pUndoDoc;
 718     ScDocument*     pRedoDoc;
 719 };
 720
 721 class ScUndoEnterMatrix: public ScBlockUndo
 722 {
 723 public:
 724                     TYPEINFO_OVERRIDE();
 725                     ScUndoEnterMatrix( ScDocShell* pNewDocShell,
 726                                        const ScRange& rArea,
 727                                        ScDocument* pNewUndoDoc,
 728                                        const OUString& rForm );
 729     virtual         ~ScUndoEnterMatrix();
 730
 731     virtual void    Undo() SAL_OVERRIDE;
 732     virtual void    Redo() SAL_OVERRIDE;
 733     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 734     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 735
 736     virtual OUString GetComment() const SAL_OVERRIDE;
 737
 738 private:
 739     ScDocument*     pUndoDoc;
 740     OUString        aFormula;
 741     sal_uLong       nStartChangeAction;
 742     sal_uLong       nEndChangeAction;
 743
 744     void            SetChangeTrack();
 745 };
 746
 747 class ScUndoInsertAreaLink : public ScSimpleUndo
 748 {
 749 public:
 750                     TYPEINFO_OVERRIDE();
 751                     ScUndoInsertAreaLink( ScDocShell* pShell,
 752                                           const OUString& rDocName,
 753                                           const OUString& rFltName, const OUString& rOptions,
 754                                           const OUString& rAreaName, const ScRange& rDestRange,
 755                                           sal_uLong nRefreshDelay );
 756     virtual         ~ScUndoInsertAreaLink();
 757
 758     virtual void    Undo() SAL_OVERRIDE;
 759     virtual void    Redo() SAL_OVERRIDE;
 760     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 761     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 762
 763     virtual OUString GetComment() const SAL_OVERRIDE;
 764
 765 private:
 766     OUString        aDocName;
 767     OUString        aFltName;
 768     OUString        aOptions;
 769     OUString        aAreaName;
 770     ScRange         aRange;
 771     sal_uLong           nRefreshDelay;
 772 };
 773
 774 class ScUndoRemoveAreaLink : public ScSimpleUndo
 775 {
 776 public:
 777                     TYPEINFO_OVERRIDE();
 778                     ScUndoRemoveAreaLink( ScDocShell* pShell,
 779                                           const OUString& rDocName,
 780                                           const OUString& rFltName, const OUString& rOptions,
 781                                           const OUString& rAreaName, const ScRange& rDestRange,
 782                                           sal_uLong nRefreshDelay );
 783     virtual         ~ScUndoRemoveAreaLink();
 784
 785     virtual void    Undo() SAL_OVERRIDE;
 786     virtual void    Redo() SAL_OVERRIDE;
 787     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 788     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 789
 790     virtual OUString GetComment() const SAL_OVERRIDE;
 791
 792 private:
 793     OUString        aDocName;
 794     OUString        aFltName;
 795     OUString        aOptions;
 796     OUString        aAreaName;
 797     ScRange         aRange;
 798     sal_uLong           nRefreshDelay;
 799 };
 800
 801 class ScUndoUpdateAreaLink : public ScSimpleUndo        //! also change BlockUndo?
 802 {
 803 public:
 804                     TYPEINFO_OVERRIDE();
 805                     ScUndoUpdateAreaLink( ScDocShell* pShell,
 806                                           const OUString& rOldD,
 807                                           const OUString& rOldF, const OUString& rOldO,
 808                                           const OUString& rOldA, const ScRange& rOldR,
 809                                           sal_uLong nOldRD,
 810                                           const OUString& rNewD,
 811                                           const OUString& rNewF, const OUString& rNewO,
 812                                           const OUString& rNewA, const ScRange& rNewR,
 813                                           sal_uLong nNewRD,
 814                                           ScDocument* pUndo, ScDocument* pRedo,
 815                                           bool bDoInsert );
 816     virtual         ~ScUndoUpdateAreaLink();
 817
 818     virtual void    Undo() SAL_OVERRIDE;
 819     virtual void    Redo() SAL_OVERRIDE;
 820     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 821     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 822
 823     virtual OUString GetComment() const SAL_OVERRIDE;
 824
 825 private:
 826     OUString        aOldDoc;
 827     OUString        aOldFlt;
 828     OUString        aOldOpt;
 829     OUString        aOldArea;
 830     ScRange         aOldRange;
 831     OUString        aNewDoc;
 832     OUString        aNewFlt;
 833     OUString        aNewOpt;
 834     OUString        aNewArea;
 835     ScRange         aNewRange;
 836     ScDocument*     pUndoDoc;
 837     ScDocument*     pRedoDoc;
 838     sal_uLong       nOldRefresh;
 839     sal_uLong       nNewRefresh;
 840     bool            bWithInsert;
 841
 842     void            DoChange( const bool bUndo ) const;
 843 };
 844
 845 class ScUndoIndent: public ScBlockUndo
 846 {
 847 public:
 848                     TYPEINFO_OVERRIDE();
 849                     ScUndoIndent( ScDocShell* pNewDocShell, const ScMarkData& rMark,
 850                                     ScDocument* pNewUndoDoc, bool bIncrement );
 851     virtual         ~ScUndoIndent();
 852
 853     virtual void    Undo() SAL_OVERRIDE;
 854     virtual void    Redo() SAL_OVERRIDE;
 855     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 856     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 857
 858     virtual OUString GetComment() const SAL_OVERRIDE;
 859
 860 private:
 861     ScMarkData      aMarkData;
 862     ScDocument*     pUndoDoc;
 863     bool            bIsIncrement;
 864 };
 865
 866 class ScUndoTransliterate: public ScBlockUndo
 867 {
 868 public:
 869                     TYPEINFO_OVERRIDE();
 870                     ScUndoTransliterate( ScDocShell* pNewDocShell, const ScMarkData& rMark,
 871                                         ScDocument* pNewUndoDoc, sal_Int32 nType );
 872     virtual         ~ScUndoTransliterate();
 873
 874     virtual void    Undo() SAL_OVERRIDE;
 875     virtual void    Redo() SAL_OVERRIDE;
 876     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 877     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 878
 879     virtual OUString GetComment() const SAL_OVERRIDE;
 880
 881 private:
 882     ScMarkData      aMarkData;
 883     ScDocument*     pUndoDoc;
 884     sal_Int32       nTransliterationType;
 885 };
 886
 887 class ScUndoClearItems: public ScBlockUndo
 888 {
 889 public:
 890                     TYPEINFO_OVERRIDE();
 891                     ScUndoClearItems( ScDocShell* pNewDocShell, const ScMarkData& rMark,
 892                                         ScDocument* pNewUndoDoc, const sal_uInt16* pW );
 893     virtual         ~ScUndoClearItems();
 894
 895     virtual void    Undo() SAL_OVERRIDE;
 896     virtual void    Redo() SAL_OVERRIDE;
 897     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 898     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 899
 900     virtual OUString GetComment() const SAL_OVERRIDE;
 901
 902 private:
 903     ScMarkData      aMarkData;
 904     ScDocument*     pUndoDoc;
 905     sal_uInt16*         pWhich;
 906 };
 907
 908 class ScUndoRemoveBreaks: public ScSimpleUndo
 909 {
 910 public:
 911                     TYPEINFO_OVERRIDE();
 912                     ScUndoRemoveBreaks( ScDocShell* pNewDocShell,
 913                                     SCTAB nNewTab, ScDocument* pNewUndoDoc );
 914     virtual         ~ScUndoRemoveBreaks();
 915
 916     virtual void    Undo() SAL_OVERRIDE;
 917     virtual void    Redo() SAL_OVERRIDE;
 918     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 919     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 920
 921     virtual OUString GetComment() const SAL_OVERRIDE;
 922
 923 private:
 924     SCTAB           nTab;
 925     ScDocument*     pUndoDoc;
 926 };
 927
 928 class ScUndoRemoveMerge: public ScBlockUndo
 929 {
 930 public:
 931                     TYPEINFO_OVERRIDE();
 932                     ScUndoRemoveMerge( ScDocShell* pNewDocShell,
 933                                        const ScCellMergeOption& rOption,
 934                                        ScDocument* pNewUndoDoc );
 935     virtual         ~ScUndoRemoveMerge();
 936
 937     virtual void    Undo() SAL_OVERRIDE;
 938     virtual void    Redo() SAL_OVERRIDE;
 939     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 940     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 941
 942     virtual OUString GetComment() const SAL_OVERRIDE;
 943
 944 private:
 945     void            SetCurTab();
 946
 947     ScCellMergeOption maOption;
 948     ScDocument*     pUndoDoc;
 949 };
 950
 951 class ScUndoBorder: public ScBlockUndo
 952 {
 953 public:
 954                     TYPEINFO_OVERRIDE();
 955                     ScUndoBorder( ScDocShell* pNewDocShell,
 956                                     const ScRangeList& rRangeList,
 957                                     ScDocument* pNewUndoDoc,
 958                                     const SvxBoxItem& rNewOuter,
 959                                     const SvxBoxInfoItem& rNewInner );
 960     virtual         ~ScUndoBorder();
 961
 962     virtual void    Undo() SAL_OVERRIDE;
 963     virtual void    Redo() SAL_OVERRIDE;
 964     virtual void    Repeat(SfxRepeatTarget& rTarget) SAL_OVERRIDE;
 965     virtual bool    CanRepeat(SfxRepeatTarget& rTarget) const SAL_OVERRIDE;
 966
 967     virtual OUString GetComment() const SAL_OVERRIDE;
 968
 969 private:
 970     ScDocument*     pUndoDoc;
 971     ScRangeList*    pRanges;
 972     SvxBoxItem*     pOuter;
 973     SvxBoxInfoItem* pInner;
 974 };
 975
 976 #endif
 977
 978 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */