sc/inc/chgtrack.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SC_INC_CHGTRACK_HXX
  21 #define INCLUDED_SC_INC_CHGTRACK_HXX
  22
  23 #include <deque>
  24 #include <map>
  25 #include <set>
  26 #include <stack>
  27
  28 #include <tools/color.hxx>
  29 #include <tools/datetime.hxx>
  30 #include <tools/link.hxx>
  31 #include <tools/mempool.hxx>
  32 #include <unotools/options.hxx>
  33 #include "global.hxx"
  34 #include "bigrange.hxx"
  35 #include "scdllapi.h"
  36 #include "cellvalue.hxx"
  37
  38 class ScDocument;
  39 class ScFormulaCell;
  40 class ScChangeAction;
  41 class ScChangeTrack;
  42 class ScAppOptions;
  43
  44 class ScActionColorChanger
  45 {
  46 private:
  47     const ScAppOptions&     rOpt;
  48     const std::set<OUString>& rUsers;
  49     OUString                aLastUserName;
  50     sal_uInt16              nLastUserIndex;
  51     ColorData               nColor;
  52
  53 public:
  54     ScActionColorChanger( const ScChangeTrack& rTrack );
  55     ~ScActionColorChanger() {}
  56     void        Update( const ScChangeAction& rAction );
  57     ColorData   GetColor() const    { return nColor; }
  58 };
  59
  60 enum ScChangeActionType
  61 {
  62     SC_CAT_NONE,
  63     SC_CAT_INSERT_COLS,
  64     SC_CAT_INSERT_ROWS,
  65     SC_CAT_INSERT_TABS,
  66     SC_CAT_DELETE_COLS,
  67     SC_CAT_DELETE_ROWS,
  68     SC_CAT_DELETE_TABS,
  69     SC_CAT_MOVE,
  70     SC_CAT_CONTENT,
  71     SC_CAT_REJECT
  72 };
  73
  74 enum ScChangeActionState
  75 {
  76     SC_CAS_VIRGIN,
  77     SC_CAS_ACCEPTED,
  78     SC_CAS_REJECTED
  79 };
  80
  81 enum ScChangeActionClipMode
  82 {
  83     SC_CACM_NONE,
  84     SC_CACM_CUT,
  85     SC_CACM_COPY,
  86     SC_CACM_PASTE
  87 };
  88
  89 //  ScChangeActionLinkEntry
  90 // Inserts itself as the head of a chain (better: linked list?), or before a LinkEntry
  91 // on delete: automatically remove of what is linked (German original was strange...)
  92 // ppPrev == &previous->pNext oder address of pointer to head of linked list,
  93 // *ppPrev == this
  94
  95 class ScChangeAction;
  96
  97 class ScChangeActionLinkEntry
  98 {
  99     ScChangeActionLinkEntry( const ScChangeActionLinkEntry& ) = delete;
 100     ScChangeActionLinkEntry& operator=( const ScChangeActionLinkEntry& ) = delete;
 101
 102 protected:
 103
 104     ScChangeActionLinkEntry*    pNext;
 105     ScChangeActionLinkEntry**   ppPrev;
 106     ScChangeAction*             pAction;
 107     ScChangeActionLinkEntry*    pLink;
 108
 109 public:
 110
 111     DECL_FIXEDMEMPOOL_NEWDEL( ScChangeActionLinkEntry )
 112
 113     ScChangeActionLinkEntry(
 114             ScChangeActionLinkEntry** ppPrevP,
 115             ScChangeAction* pActionP )
 116         :   pNext( *ppPrevP ),
 117             ppPrev( ppPrevP ),
 118             pAction( pActionP ),
 119             pLink( nullptr )
 120         {
 121             if ( pNext )
 122                 pNext->ppPrev = &pNext;
 123             *ppPrevP = this;
 124         }
 125
 126     virtual ~ScChangeActionLinkEntry()
 127     {
 128         ScChangeActionLinkEntry* p = pLink;
 129         UnLink();
 130         Remove();
 131         if ( p )
 132             delete p;
 133     }
 134
 135     void SetLink( ScChangeActionLinkEntry* pLinkP )
 136     {
 137         UnLink();
 138         if ( pLinkP )
 139         {
 140             pLink = pLinkP;
 141             pLinkP->pLink = this;
 142         }
 143     }
 144
 145     void UnLink()
 146     {
 147         if ( pLink )
 148         {
 149             pLink->pLink = nullptr;
 150             pLink = nullptr;
 151         }
 152     }
 153
 154     void Remove()
 155     {
 156         if ( ppPrev )
 157         {
 158             if ( ( *ppPrev = pNext ) != nullptr )
 159                 pNext->ppPrev = ppPrev;
 160             ppPrev = nullptr;  // not inserted
 161         }
 162     }
 163
 164     const ScChangeActionLinkEntry*  GetNext() const     { return pNext; }
 165     ScChangeActionLinkEntry*        GetNext()           { return pNext; }
 166     const ScChangeAction*           GetAction() const   { return pAction; }
 167     ScChangeAction*                 GetAction()         { return pAction; }
 168 };
 169
 170 // ScChangeActionCellListEntry
 171 // this is only for the XML Export in the hxx
 172 class ScChangeActionContent;
 173
 174 class ScChangeActionCellListEntry
 175 {
 176     friend class ScChangeAction;
 177     friend class ScChangeActionDel;
 178     friend class ScChangeActionMove;
 179     friend class ScChangeTrack;
 180
 181     ScChangeActionCellListEntry*    pNext;
 182     ScChangeActionContent*          pContent;
 183
 184     ScChangeActionCellListEntry(
 185         ScChangeActionContent* pContentP,
 186         ScChangeActionCellListEntry* pNextP )
 187         :   pNext( pNextP ),
 188             pContent( pContentP )
 189         {}
 190
 191 public:
 192     DECL_FIXEDMEMPOOL_NEWDEL( ScChangeActionCellListEntry )
 193 };
 194
 195 //  ScChangeAction
 196 class ScChangeTrack;
 197 class ScChangeActionIns;
 198 class ScChangeActionDel;
 199 class ScChangeActionContent;
 200
 201 class ScChangeAction
 202 {
 203     friend class ScChangeTrack;
 204     friend class ScChangeActionIns;
 205     friend class ScChangeActionDel;
 206     friend class ScChangeActionMove;
 207     friend class ScChangeActionContent;
 208
 209     ScChangeAction( const ScChangeAction& ) = delete;
 210     ScChangeAction& operator=( const ScChangeAction& ) = delete;
 211
 212 protected:
 213
 214     ScBigRange          aBigRange;          // Ins/Del/MoveTo/ContentPos
 215     DateTime            aDateTime;          //! UTC
 216     OUString       aUser;              // who?
 217     OUString       aComment;           // user comment
 218     ScChangeAction*     pNext;              // next in linked list
 219     ScChangeAction*     pPrev;              // previous in linked list
 220     ScChangeActionLinkEntry*    pLinkAny;   // arbitrary links
 221     ScChangeActionLinkEntry*    pLinkDeletedIn; // access to insert areas which were
 222                                             // deleted or moved or rejected
 223     ScChangeActionLinkEntry*    pLinkDeleted;   // links to deleted
 224     ScChangeActionLinkEntry*    pLinkDependent; // links to dependent
 225     sal_uLong               nAction;
 226     sal_uLong               nRejectAction;
 227     ScChangeActionType  eType;
 228     ScChangeActionState eState;
 229
 230     ScChangeAction( ScChangeActionType, const ScRange& );
 231
 232     // only to be used in the XML import
 233     ScChangeAction( ScChangeActionType,
 234                     const ScBigRange&,
 235                     const sal_uLong nAction,
 236                     const sal_uLong nRejectAction,
 237                     const ScChangeActionState eState,
 238                     const DateTime& aDateTime,
 239                     const OUString& aUser,
 240                     const OUString& aComment );
 241
 242     // only to be used in the XML import
 243     ScChangeAction( ScChangeActionType, const ScBigRange&, const sal_uLong nAction);
 244
 245     virtual ~ScChangeAction();
 246
 247     OUString GetRefString(
 248         const ScBigRange& rRange, ScDocument* pDoc, bool bFlag3D = false) const;
 249
 250     void SetActionNumber( sal_uLong n ) { nAction = n; }
 251     void SetRejectAction( sal_uLong n ) { nRejectAction = n; }
 252     void SetUser( const OUString& r );
 253     void SetType( ScChangeActionType e ) { eType = e; }
 254     void SetState( ScChangeActionState e ) { eState = e; }
 255     void SetRejected();
 256
 257     ScBigRange& GetBigRange() { return aBigRange; }
 258
 259     void AddLink( ScChangeAction* p, ScChangeActionLinkEntry* pL )
 260     {
 261         ScChangeActionLinkEntry* pLnk =
 262             new ScChangeActionLinkEntry(
 263             &pLinkAny, p );
 264         pLnk->SetLink( pL );
 265     }
 266
 267     void RemoveAllAnyLinks();
 268
 269     virtual ScChangeActionLinkEntry*    GetDeletedIn() const
 270                                             { return pLinkDeletedIn; }
 271     virtual ScChangeActionLinkEntry**   GetDeletedInAddress()
 272                                             { return &pLinkDeletedIn; }
 273     ScChangeActionLinkEntry* AddDeletedIn( ScChangeAction* p )
 274     {
 275         return new ScChangeActionLinkEntry(
 276             GetDeletedInAddress(), p );
 277     }
 278
 279     bool RemoveDeletedIn( const ScChangeAction* );
 280     void SetDeletedIn( ScChangeAction* );
 281
 282     ScChangeActionLinkEntry* AddDeleted( ScChangeAction* p )
 283     {
 284         return new ScChangeActionLinkEntry(&pLinkDeleted, p);
 285     }
 286
 287     void RemoveAllDeleted();
 288
 289     ScChangeActionLinkEntry* AddDependent( ScChangeAction* p )
 290     {
 291         return new ScChangeActionLinkEntry(&pLinkDependent, p);
 292     }
 293
 294     void                RemoveAllDependent();
 295
 296     void                RemoveAllLinks();
 297
 298     virtual void AddContent( ScChangeActionContent* ) = 0;
 299     virtual void DeleteCellEntries() = 0;
 300
 301     virtual void UpdateReference( const ScChangeTrack*,
 302                      UpdateRefMode, const ScBigRange&,
 303                      sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz );
 304
 305     void Accept();
 306     virtual bool Reject(ScDocument* pDoc) = 0;
 307     void RejectRestoreContents( ScChangeTrack*, SCsCOL nDx, SCsROW nDy );
 308
 309     // used in Reject() instead of IsRejectable()
 310     bool IsInternalRejectable() const;
 311
 312     // Derived classes that hold a pointer to the
 313     // ChangeTrack must return that. Otherwise NULL.
 314     virtual const ScChangeTrack* GetChangeTrack() const = 0;
 315
 316 public:
 317     bool IsInsertType() const;
 318     bool IsDeleteType() const;
 319     bool IsVirgin() const;
 320     SC_DLLPUBLIC bool IsAccepted() const;
 321     bool IsRejected() const;
 322
 323     // Action rejects another Action
 324     bool IsRejecting() const;
 325
 326     // if action is visible in the document
 327     bool IsVisible() const;
 328
 329     // if action if touchable
 330     bool IsTouchable() const;
 331
 332     // if action is an entry in dialog root
 333     bool IsDialogRoot() const;
 334
 335     // if an entry in a dialog shall be a drop down entry
 336     bool IsDialogParent() const;
 337
 338     // if action is a delete with subdeletes (aufgeklappt = open ?)
 339     bool IsMasterDelete() const;
 340
 341     // if action is acceptable/selectable/rejectable
 342     bool IsClickable() const;
 343
 344     // if action is rejectable
 345     bool IsRejectable() const;
 346
 347     const ScBigRange& GetBigRange() const { return aBigRange; }
 348     SC_DLLPUBLIC DateTime GetDateTime() const;        // local time
 349     const DateTime&     GetDateTimeUTC() const      // UTC time
 350                             { return aDateTime; }
 351     ScChangeActionType  GetType() const { return eType; }
 352     ScChangeActionState GetState() const { return eState; }
 353     sal_uLong               GetActionNumber() const { return nAction; }
 354     sal_uLong               GetRejectAction() const { return nRejectAction; }
 355
 356     ScChangeAction*     GetNext() const { return pNext; }
 357     ScChangeAction*     GetPrev() const { return pPrev; }
 358
 359     bool IsDeletedIn() const;
 360     bool IsDeletedIn( const ScChangeAction* ) const;
 361     bool IsDeletedInDelType( ScChangeActionType ) const;
 362     void RemoveAllDeletedIn();
 363
 364     const ScChangeActionLinkEntry* GetFirstDeletedEntry() const
 365                             { return pLinkDeleted; }
 366     const ScChangeActionLinkEntry* GetFirstDependentEntry() const
 367                             { return pLinkDependent; }
 368     bool HasDependent() const;
 369     bool HasDeleted() const;
 370                                 // description will be appended to string
 371                                 // with bSplitRange only one column/row will be considered for delete
 372                                 // (for a listing of entries)
 373     virtual void GetDescription(
 374         OUString& rStr, ScDocument* pDoc,
 375         bool bSplitRange = false, bool bWarning = true ) const;
 376
 377     virtual void GetRefString(
 378         OUString& rStr, ScDocument* pDoc, bool bFlag3D = false ) const;
 379
 380                         // for DocumentMerge set old date of the other
 381                         // action, fetched by GetDateTimeUTC
 382     void                SetDateTimeUTC( const DateTime& rDT )
 383                             { aDateTime = rDT; }
 384
 385     const OUString& GetUser() const { return aUser;}
 386     const OUString& GetComment() const { return aComment;}
 387
 388     // set user comment
 389     void SetComment( const OUString& rStr );
 390
 391                         // only to be used in the XML import
 392     void                SetDeletedInThis( sal_uLong nActionNumber,
 393                                 const ScChangeTrack* pTrack );
 394                         // only to be used in the XML import
 395     void                AddDependent( sal_uLong nActionNumber,
 396                                 const ScChangeTrack* pTrack );
 397 };
 398
 399 //  ScChangeActionIns
 400 class ScChangeActionIns : public ScChangeAction
 401 {
 402     friend class ScChangeTrack;
 403
 404     bool mbEndOfList; /// whether or not a row was auto-inserted at the bottom.
 405
 406     ScChangeActionIns( const ScRange& rRange, bool bEndOfList = false );
 407     virtual                     ~ScChangeActionIns();
 408
 409     virtual void                AddContent( ScChangeActionContent* ) override {}
 410     virtual void                DeleteCellEntries() override {}
 411
 412     virtual bool Reject(ScDocument* pDoc) override;
 413
 414     virtual const ScChangeTrack*    GetChangeTrack() const override { return nullptr; }
 415
 416 public:
 417     ScChangeActionIns(
 418         const sal_uLong nActionNumber,
 419         const ScChangeActionState eState,
 420         const sal_uLong nRejectingNumber,
 421         const ScBigRange& aBigRange,
 422         const OUString& aUser,
 423         const DateTime& aDateTime,
 424         const OUString &sComment,
 425         const ScChangeActionType eType,
 426         bool bEndOfList = false );
 427
 428     virtual void GetDescription(
 429         OUString& rStr, ScDocument* pDoc, bool bSplitRange = false, bool bWarning = true) const override;
 430
 431     SC_DLLPUBLIC bool IsEndOfList() const;
 432 };
 433
 434 //  ScChangeActionDel
 435 class ScChangeActionMove;
 436
 437 class ScChangeActionDelMoveEntry : public ScChangeActionLinkEntry
 438 {
 439     friend class ScChangeActionDel;
 440     friend class ScChangeTrack;
 441
 442     short               nCutOffFrom;
 443     short               nCutOffTo;
 444
 445     inline ScChangeActionDelMoveEntry(
 446         ScChangeActionDelMoveEntry** ppPrevP,
 447         ScChangeActionMove* pMove,
 448         short nFrom, short nTo );
 449
 450     inline ScChangeActionMove* GetMove();
 451
 452 public:
 453     const ScChangeActionDelMoveEntry*   GetNext() const
 454                             {
 455                                 return static_cast<const ScChangeActionDelMoveEntry*>(
 456                                     ScChangeActionLinkEntry::GetNext());
 457                             }
 458     inline const ScChangeActionMove*   GetMove() const;
 459     short               GetCutOffFrom() const { return nCutOffFrom; }
 460     short               GetCutOffTo() const { return nCutOffTo; }
 461 };
 462
 463 class ScChangeActionDel : public ScChangeAction
 464 {
 465     friend class ScChangeTrack;
 466     friend void ScChangeAction::Accept();
 467
 468     ScChangeTrack*      pTrack;
 469     ScChangeActionCellListEntry* pFirstCell;
 470     ScChangeActionIns*  pCutOff;        // cut insert
 471     short               nCutOff;        // +: start  -: end
 472     ScChangeActionDelMoveEntry* pLinkMove;
 473     SCsCOL              nDx;
 474     SCsROW              nDy;
 475
 476     ScChangeActionDel( const ScRange& rRange, SCsCOL nDx, SCsROW nDy, ScChangeTrack* );
 477     virtual ~ScChangeActionDel();
 478
 479     virtual void                AddContent( ScChangeActionContent* ) override;
 480     virtual void                DeleteCellEntries() override;
 481
 482             void                UndoCutOffMoves();
 483             void                UndoCutOffInsert();
 484
 485     virtual void                UpdateReference( const ScChangeTrack*,
 486                                     UpdateRefMode, const ScBigRange&,
 487                                     sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz ) override;
 488
 489     virtual bool Reject(ScDocument* pDoc) override;
 490
 491     virtual const ScChangeTrack*    GetChangeTrack() const override { return pTrack; }
 492
 493 public:
 494     ScChangeActionDel(
 495         const sal_uLong nActionNumber, const ScChangeActionState eState,
 496         const sal_uLong nRejectingNumber, const ScBigRange& aBigRange,
 497         const OUString& aUser, const DateTime& aDateTime,
 498         const OUString &sComment, const ScChangeActionType eType,
 499         const SCsCOLROW nD, ScChangeTrack* pTrack); // only to use in the XML import
 500                                             // which of nDx and nDy is set is dependent on the type
 501
 502     // is the last in a row (or single)
 503     bool IsBaseDelete() const;
 504
 505     // is the first in a row (or single)
 506     bool IsTopDelete() const;
 507
 508     // is part of a row
 509     bool IsMultiDelete() const;
 510
 511     // is col, belonging to a TabDelete
 512     bool IsTabDeleteCol() const;
 513
 514     SCsCOL GetDx() const { return nDx; }
 515     SCsROW GetDy() const { return nDy; }
 516     ScBigRange          GetOverAllRange() const;    // BigRange + (nDx, nDy)
 517
 518     const ScChangeActionDelMoveEntry* GetFirstMoveEntry() const
 519                             { return pLinkMove; }
 520     const ScChangeActionIns*    GetCutOffInsert() const { return pCutOff; }
 521     short               GetCutOffCount() const { return nCutOff; }
 522
 523     virtual void GetDescription(
 524         OUString& rStr, ScDocument* pDoc, bool bSplitRange = false, bool bWarning = true ) const override;
 525
 526     void                SetCutOffInsert( ScChangeActionIns* p, short n )
 527                             { pCutOff = p; nCutOff = n; }   // only to use in the XML import
 528                                                                     // this should be protected, but for the XML import it is public
 529     // only to use in the XML import
 530     // this should be protected, but for the XML import it is public
 531     ScChangeActionDelMoveEntry* AddCutOffMove(
 532         ScChangeActionMove* pMove, short nFrom, short nTo );
 533 };
 534
 535 //  ScChangeActionMove
 536 class ScChangeActionMove : public ScChangeAction
 537 {
 538     friend class ScChangeTrack;
 539     friend class ScChangeActionDel;
 540
 541     ScBigRange          aFromRange;
 542     ScChangeTrack*      pTrack;
 543     ScChangeActionCellListEntry* pFirstCell;
 544     sal_uLong               nStartLastCut;  // for PasteCut undo
 545     sal_uLong               nEndLastCut;
 546
 547     ScChangeActionMove( const ScRange& rFromRange,
 548         const ScRange& rToRange,
 549         ScChangeTrack* pTrackP )
 550         : ScChangeAction( SC_CAT_MOVE, rToRange ),
 551             aFromRange( rFromRange ),
 552             pTrack( pTrackP ),
 553             pFirstCell( nullptr ),
 554             nStartLastCut(0),
 555             nEndLastCut(0)
 556         {}
 557     virtual ~ScChangeActionMove();
 558
 559     virtual void                AddContent( ScChangeActionContent* ) override;
 560     virtual void                DeleteCellEntries() override;
 561
 562             ScBigRange&         GetFromRange() { return aFromRange; }
 563
 564             void                SetStartLastCut( sal_uLong nVal ) { nStartLastCut = nVal; }
 565             sal_uLong               GetStartLastCut() const { return nStartLastCut; }
 566             void                SetEndLastCut( sal_uLong nVal ) { nEndLastCut = nVal; }
 567             sal_uLong               GetEndLastCut() const { return nEndLastCut; }
 568
 569     virtual void                UpdateReference( const ScChangeTrack*,
 570                                     UpdateRefMode, const ScBigRange&,
 571                                     sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz ) override;
 572
 573     virtual bool Reject(ScDocument* pDoc) override;
 574
 575     virtual const ScChangeTrack*    GetChangeTrack() const override { return pTrack; }
 576
 577 protected:
 578     using ScChangeAction::GetRefString;
 579
 580 public:
 581     ScChangeActionMove(const sal_uLong nActionNumber,
 582                     const ScChangeActionState eState,
 583                     const sal_uLong nRejectingNumber,
 584                     const ScBigRange& aToBigRange,
 585                     const OUString& aUser,
 586                     const DateTime& aDateTime,
 587                     const OUString &sComment,
 588                     const ScBigRange& aFromBigRange,
 589                     ScChangeTrack* pTrack); // only to use in the XML import
 590
 591     const ScBigRange&   GetFromRange() const { return aFromRange; }
 592     SC_DLLPUBLIC        void                GetDelta( sal_Int32& nDx, sal_Int32& nDy, sal_Int32& nDz ) const;
 593
 594     virtual void GetDescription(
 595         OUString& rStr, ScDocument* pDoc, bool bSplitRange = false,
 596         bool bWarning = true ) const override;
 597
 598     virtual void GetRefString(
 599         OUString& rStr, ScDocument* pDoc, bool bFlag3D = false ) const override;
 600 };
 601
 602 ScChangeActionDelMoveEntry::ScChangeActionDelMoveEntry(
 603     ScChangeActionDelMoveEntry** ppPrevP,
 604     ScChangeActionMove* pMove,
 605     short nFrom, short nTo )
 606     :   ScChangeActionLinkEntry(
 607             reinterpret_cast<ScChangeActionLinkEntry**>(
 608                 ppPrevP),
 609             static_cast<ScChangeAction*>(pMove) ),
 610         nCutOffFrom( nFrom ),
 611         nCutOffTo( nTo )
 612 {}
 613
 614 inline ScChangeActionMove* ScChangeActionDelMoveEntry::GetMove()
 615                            {
 616                                return static_cast<ScChangeActionMove*>(
 617                                    ScChangeActionLinkEntry::GetAction());
 618                            }
 619
 620 inline const ScChangeActionMove* ScChangeActionDelMoveEntry::GetMove() const
 621                           {
 622                               return static_cast<const ScChangeActionMove*>(
 623                                   ScChangeActionLinkEntry::GetAction());
 624                           }
 625 //  ScChangeActionContent
 626 enum ScChangeActionContentCellType
 627 {
 628     SC_CACCT_NONE = 0,
 629     SC_CACCT_NORMAL,
 630     SC_CACCT_MATORG,
 631     SC_CACCT_MATREF
 632 };
 633
 634 class ScChangeActionContent : public ScChangeAction
 635 {
 636     friend class ScChangeTrack;
 637
 638     ScCellValue maOldCell;
 639     ScCellValue maNewCell;
 640
 641     OUString maOldValue;
 642     OUString maNewValue;
 643     ScChangeActionContent*  pNextContent;   // at the same position
 644     ScChangeActionContent*  pPrevContent;
 645     ScChangeActionContent*  pNextInSlot;    // in the same slot
 646     ScChangeActionContent** ppPrevInSlot;
 647
 648     void InsertInSlot( ScChangeActionContent** pp )
 649     {
 650         if ( !ppPrevInSlot )
 651         {
 652             ppPrevInSlot = pp;
 653             if ( ( pNextInSlot = *pp ) != nullptr )
 654                 pNextInSlot->ppPrevInSlot = &pNextInSlot;
 655             *pp = this;
 656         }
 657     }
 658
 659     void RemoveFromSlot()
 660     {
 661         if ( ppPrevInSlot )
 662         {
 663             if ( ( *ppPrevInSlot = pNextInSlot ) != nullptr )
 664                 pNextInSlot->ppPrevInSlot = ppPrevInSlot;
 665             ppPrevInSlot = nullptr;    // not inserted
 666         }
 667     }
 668
 669     ScChangeActionContent*  GetNextInSlot() { return pNextInSlot; }
 670
 671     void ClearTrack();
 672
 673     static void GetStringOfCell(
 674         OUString& rStr, const ScCellValue& rCell, const ScDocument* pDoc, const ScAddress& rPos );
 675
 676     static void GetStringOfCell(
 677         OUString& rStr, const ScCellValue& rCell, const ScDocument* pDoc, sal_uLong nFormat );
 678
 679     static void SetValue( OUString& rStr, ScCellValue& rCell, const ScAddress& rPos,
 680                           const ScCellValue& rOrgCell, const ScDocument* pFromDoc,
 681                           ScDocument* pToDoc );
 682
 683     static void SetValue( OUString& rStr, ScCellValue& rCell, sal_uLong nFormat,
 684                           const ScCellValue& rOrgCell, const ScDocument* pFromDoc,
 685                           ScDocument* pToDoc );
 686
 687     static void SetCell( OUString& rStr, ScCellValue& rCell, sal_uLong nFormat, const ScDocument* pDoc );
 688
 689     static bool NeedsNumberFormat( const ScCellValue& rVal );
 690
 691     void SetValueString( OUString& rValue, ScCellValue& rCell, const OUString& rStr, ScDocument* pDoc );
 692
 693     void GetValueString( OUString& rStr, const OUString& rValue, const ScCellValue& rCell,
 694                          const ScDocument* pDoc ) const;
 695
 696     void GetFormulaString( OUString& rStr, const ScFormulaCell* pCell ) const;
 697
 698     virtual void                AddContent( ScChangeActionContent* ) override {}
 699     virtual void                DeleteCellEntries() override {}
 700
 701     virtual void                UpdateReference( const ScChangeTrack*,
 702                                     UpdateRefMode, const ScBigRange&,
 703                                     sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz ) override;
 704
 705     virtual bool Reject(ScDocument* pDoc) override;
 706
 707     virtual const ScChangeTrack*    GetChangeTrack() const override { return nullptr; }
 708
 709     // pRejectActions!=NULL: reject actions get
 710     // stacked, no SetNewValue, no Append
 711     bool Select( ScDocument*, ScChangeTrack*,
 712                  bool bOldest, ::std::stack<ScChangeActionContent*>* pRejectActions );
 713
 714     void PutValueToDoc(
 715         const ScCellValue& rCell, const OUString& rValue, ScDocument* pDoc, SCsCOL nDx, SCsROW nDy ) const;
 716
 717 protected:
 718     using ScChangeAction::GetRefString;
 719
 720 public:
 721
 722     DECL_FIXEDMEMPOOL_NEWDEL( ScChangeActionContent )
 723
 724     ScChangeActionContent( const ScRange& rRange );
 725
 726     ScChangeActionContent(
 727         const sal_uLong nActionNumber,  const ScChangeActionState eState,
 728         const sal_uLong nRejectingNumber, const ScBigRange& aBigRange,
 729         const OUString& aUser, const DateTime& aDateTime,
 730         const OUString &sComment, const ScCellValue& rOldCell,
 731         ScDocument* pDoc, const OUString& sOldValue ); // to use for XML Import
 732
 733     ScChangeActionContent(
 734         const sal_uLong nActionNumber, const ScCellValue& rNewCell,
 735         const ScBigRange& aBigRange, ScDocument* pDoc,
 736         const OUString& sNewValue ); // to use for XML Import of Generated Actions
 737
 738     virtual ~ScChangeActionContent();
 739
 740     ScChangeActionContent*  GetNextContent() const { return pNextContent; }
 741     ScChangeActionContent*  GetPrevContent() const { return pPrevContent; }
 742     ScChangeActionContent*  GetTopContent() const;
 743     bool IsTopContent() const { return pNextContent == nullptr; }
 744
 745     virtual ScChangeActionLinkEntry*    GetDeletedIn() const override;
 746     virtual ScChangeActionLinkEntry**   GetDeletedInAddress() override;
 747
 748     void                PutOldValueToDoc( ScDocument*,
 749                             SCsCOL nDx, SCsROW nDy ) const;
 750     void                PutNewValueToDoc( ScDocument*,
 751                             SCsCOL nDx, SCsROW nDy ) const;
 752
 753     void SetOldValue( const ScCellValue& rCell, const ScDocument* pFromDoc, ScDocument* pToDoc, sal_uLong nFormat );
 754
 755     void SetOldValue( const ScCellValue& rCell, const ScDocument* pFromDoc, ScDocument* pToDoc );
 756
 757     void SetNewValue( const ScCellValue& rCell, ScDocument* pDoc );
 758
 759     // Used in import filter AppendContentOnTheFly,
 760     void SetOldNewCells(
 761         const ScCellValue& rOldCell, sal_uLong nOldFormat,
 762         const ScCellValue& rNewCell, sal_uLong nNewFormat, ScDocument* pDoc );
 763
 764     // Use this only in the XML import,
 765     // takes ownership of cell.
 766     void SetNewCell(
 767         const ScCellValue& rCell, ScDocument* pDoc, const OUString& rFormatted );
 768
 769                         // These functions should be protected but for
 770                         // the XML import they are public.
 771     void                SetNextContent( ScChangeActionContent* p )
 772                             { pNextContent = p; }
 773     void                SetPrevContent( ScChangeActionContent* p )
 774                             { pPrevContent = p; }
 775
 776     // don't use:
 777     // assigns string / creates formula cell
 778     void SetOldValue( const OUString& rOld, ScDocument* pDoc );
 779
 780     void GetOldString( OUString& rStr, const ScDocument* pDoc ) const;
 781     void GetNewString( OUString& rStr, const ScDocument* pDoc ) const;
 782     const ScCellValue& GetOldCell() const { return maOldCell;}
 783     const ScCellValue& GetNewCell() const { return maNewCell;}
 784     virtual void GetDescription(
 785         OUString& rStr, ScDocument* pDoc, bool bSplitRange = false, bool bWarning = true ) const override;
 786
 787     virtual void GetRefString(
 788         OUString& rStr, ScDocument* pDoc, bool bFlag3D = false ) const override;
 789
 790     static ScChangeActionContentCellType GetContentCellType( const ScCellValue& rCell );
 791     static ScChangeActionContentCellType GetContentCellType( const ScRefCellValue& rIter );
 792
 793     // NewCell
 794     bool IsMatrixOrigin() const;
 795     // OldCell
 796     bool IsOldMatrixReference() const;
 797 };
 798
 799 //  ScChangeActionReject
 800 class ScChangeActionReject : public ScChangeAction
 801 {
 802     friend class ScChangeTrack;
 803     friend class ScChangeActionContent;
 804
 805     virtual void AddContent( ScChangeActionContent* ) override {}
 806     virtual void DeleteCellEntries() override {}
 807
 808     virtual bool Reject(ScDocument* pDoc) override;
 809
 810     virtual const ScChangeTrack* GetChangeTrack() const override { return nullptr; }
 811
 812 public:
 813     ScChangeActionReject(const sal_uLong nActionNumber,
 814                     const ScChangeActionState eState,
 815                     const sal_uLong nRejectingNumber,
 816                     const ScBigRange& aBigRange,
 817                     const OUString& aUser,
 818                     const DateTime& aDateTime,
 819                     const OUString &sComment); // only to use in the XML import
 820 };
 821
 822 //  ScChangeTrack
 823 enum ScChangeTrackMsgType
 824 {
 825     SC_CTM_NONE,
 826     SC_CTM_APPEND,      // Actions appended
 827     SC_CTM_REMOVE,      // Actions removed
 828     SC_CTM_CHANGE,      // Actions changed
 829     SC_CTM_PARENT       // became a parent (and wasn't before)
 830 };
 831
 832 struct ScChangeTrackMsgInfo
 833 {
 834     DECL_FIXEDMEMPOOL_NEWDEL( ScChangeTrackMsgInfo )
 835
 836     ScChangeTrackMsgType    eMsgType;
 837     sal_uLong                   nStartAction;
 838     sal_uLong                   nEndAction;
 839 };
 840
 841 // MsgQueue for notification via ModifiedLink
 842 typedef std::deque<ScChangeTrackMsgInfo*> ScChangeTrackMsgQueue;
 843 typedef std::stack<ScChangeTrackMsgInfo*> ScChangeTrackMsgStack;
 844 typedef std::map<sal_uLong, ScChangeAction*> ScChangeActionMap;
 845
 846 enum ScChangeTrackMergeState
 847 {
 848     SC_CTMS_NONE,
 849     SC_CTMS_PREPARE,
 850     SC_CTMS_OWN,
 851     SC_CTMS_UNDO,
 852     SC_CTMS_OTHER
 853 };
 854
 855 // Internally generated actions start at this value (nearly all bits set)
 856 // and are decremented, to keep values in a table separated from "normal" actions.
 857 #define SC_CHGTRACK_GENERATED_START ((sal_uInt32) 0xfffffff0)
 858
 859 class ScChangeTrack : public utl::ConfigurationListener
 860 {
 861     friend void ScChangeAction::RejectRestoreContents( ScChangeTrack*, SCsCOL, SCsROW );
 862     friend bool ScChangeActionDel::Reject( ScDocument* pDoc );
 863     friend void ScChangeActionDel::DeleteCellEntries();
 864     friend void ScChangeActionMove::DeleteCellEntries();
 865     friend bool ScChangeActionMove::Reject( ScDocument* pDoc );
 866
 867     static  const SCROW         nContentRowsPerSlot;
 868     static  const SCSIZE        nContentSlots;
 869
 870     css::uno::Sequence< sal_Int8 >   aProtectPass;
 871     ScChangeActionMap   aMap;
 872     ScChangeActionMap   aGeneratedMap;
 873     ScChangeActionMap   aPasteCutMap;
 874     ScChangeTrackMsgQueue   aMsgQueue;
 875     ScChangeTrackMsgStack   aMsgStackTmp;
 876     ScChangeTrackMsgStack   aMsgStackFinal;
 877     std::set<OUString> maUserCollection;
 878     OUString maUser;
 879     Link<ScChangeTrack&,void> aModifiedLink;
 880     ScRange             aInDeleteRange;
 881     DateTime            aFixDateTime;
 882     ScChangeAction*     pFirst;
 883     ScChangeAction*     pLast;
 884     ScChangeActionContent*  pFirstGeneratedDelContent;
 885     ScChangeActionContent** ppContentSlots;
 886     ScChangeActionMove*     pLastCutMove;
 887     ScChangeActionLinkEntry*    pLinkInsertCol;
 888     ScChangeActionLinkEntry*    pLinkInsertRow;
 889     ScChangeActionLinkEntry*    pLinkInsertTab;
 890     ScChangeActionLinkEntry*    pLinkMove;
 891     ScChangeTrackMsgInfo*   pBlockModifyMsg;
 892     ScDocument*         pDoc;
 893     sal_uLong               nActionMax;
 894     sal_uLong               nGeneratedMin;
 895     sal_uLong               nMarkLastSaved;
 896     sal_uLong               nStartLastCut;
 897     sal_uLong               nEndLastCut;
 898     sal_uLong               nLastMerge;
 899     ScChangeTrackMergeState eMergeState;
 900     bool bLoadSave:1;
 901     bool bInDelete:1;
 902     bool bInDeleteUndo:1;
 903     bool bInDeleteTop:1;
 904     bool bInPasteCut:1;
 905     bool bUseFixDateTime:1;
 906     bool bTimeNanoSeconds:1;
 907
 908     ScChangeTrack( const ScChangeTrack& ) = delete;
 909     ScChangeTrack& operator=( const ScChangeTrack& ) = delete;
 910
 911     static  SCROW               InitContentRowsPerSlot();
 912
 913     // true if one is MM_FORMULA and the other is
 914     // not, or if both are and range differs
 915     static bool IsMatrixFormulaRangeDifferent(
 916         const ScCellValue& rOldCell, const ScCellValue& rNewCell );
 917
 918     void                Init();
 919     void                DtorClear();
 920     void                SetInDeleteRange( const ScRange& rRange )
 921                             { aInDeleteRange = rRange; }
 922     void                SetInDelete( bool bVal )
 923                             { bInDelete = bVal; }
 924     void                SetInDeleteTop( bool bVal )
 925                             { bInDeleteTop = bVal; }
 926     void                SetInDeleteUndo( bool bVal )
 927                             { bInDeleteUndo = bVal; }
 928     void                SetInPasteCut( bool bVal )
 929                             { bInPasteCut = bVal; }
 930     void                SetMergeState( ScChangeTrackMergeState eState )
 931                             { eMergeState = eState; }
 932     ScChangeTrackMergeState GetMergeState() const { return eMergeState; }
 933     void                SetLastMerge( sal_uLong nVal ) { nLastMerge = nVal; }
 934     sal_uLong               GetLastMerge() const { return nLastMerge; }
 935
 936     void                SetLastCutMoveRange( const ScRange&, ScDocument* );
 937
 938                         // create block of ModifyMsg
 939     void                StartBlockModify( ScChangeTrackMsgType,
 940                             sal_uLong nStartAction );
 941     void                EndBlockModify( sal_uLong nEndAction );
 942
 943     void                AddDependentWithNotify( ScChangeAction* pParent,
 944                             ScChangeAction* pDependent );
 945
 946     void                Dependencies( ScChangeAction* );
 947     void UpdateReference( ScChangeAction*, bool bUndo );
 948     void UpdateReference( ScChangeAction** ppFirstAction, ScChangeAction* pAct, bool bUndo );
 949     void                Append( ScChangeAction* pAppend, sal_uLong nAction );
 950     SC_DLLPUBLIC        void                AppendDeleteRange( const ScRange&,
 951                                     ScDocument* pRefDoc, SCsTAB nDz,
 952                                     sal_uLong nRejectingInsert );
 953     void                AppendOneDeleteRange( const ScRange& rOrgRange,
 954                             ScDocument* pRefDoc,
 955                             SCsCOL nDx, SCsROW nDy, SCsTAB nDz,
 956                             sal_uLong nRejectingInsert );
 957     void                LookUpContents( const ScRange& rOrgRange,
 958                             ScDocument* pRefDoc,
 959                             SCsCOL nDx, SCsROW nDy, SCsTAB nDz );
 960     void                Remove( ScChangeAction* );
 961     void                MasterLinks( ScChangeAction* );
 962
 963                                 // Content on top an Position
 964     ScChangeActionContent*  SearchContentAt( const ScBigAddress&,
 965                                     ScChangeAction* pButNotThis ) const;
 966     void                DeleteGeneratedDelContent(
 967                                     ScChangeActionContent* );
 968
 969     ScChangeActionContent* GenerateDelContent(
 970         const ScAddress& rPos, const ScCellValue& rCell, const ScDocument* pFromDoc );
 971
 972     void                DeleteCellEntries(
 973                                     ScChangeActionCellListEntry*&,
 974                                     ScChangeAction* pDeletor );
 975
 976                                 // Reject action and all dependent actions,
 977                                 // Table stems from previous GetDependents,
 978                                 // only needed for Insert and Move (MasterType),
 979                                 // is NULL otherwise.
 980                                 // bRecursion == called from reject with table
 981     bool Reject( ScChangeAction*, ScChangeActionMap*, bool bRecursion );
 982
 983     bool IsLastAction( sal_uLong nNum ) const;
 984
 985             void                ClearMsgQueue();
 986     virtual void                ConfigurationChanged( utl::ConfigurationBroadcaster*, sal_uInt32 ) override;
 987
 988 public:
 989
 990     static  SCSIZE              ComputeContentSlot( sal_Int32 nRow )
 991                                     {
 992                                         if ( nRow < 0 || nRow > MAXROW )
 993                                             return nContentSlots - 1;
 994                                         return static_cast< SCSIZE >( nRow / nContentRowsPerSlot );
 995                                     }
 996
 997     SC_DLLPUBLIC ScChangeTrack( ScDocument* );
 998     ScChangeTrack(ScDocument* pDocP, const std::set<OUString>& aTempUserCollection); // only to use in the XML import
 999     SC_DLLPUBLIC virtual ~ScChangeTrack();
1000     void Clear();
1001
1002     ScChangeActionContent*  GetFirstGenerated() const { return pFirstGeneratedDelContent; }
1003     ScChangeAction*     GetFirst() const { return pFirst; }
1004     ScChangeAction*     GetLast() const { return pLast; }
1005     sal_uLong               GetActionMax() const { return nActionMax; }
1006     bool IsGenerated( sal_uLong nAction ) const;
1007     SC_DLLPUBLIC ScChangeAction* GetAction( sal_uLong nAction ) const;
1008     ScChangeAction* GetGenerated( sal_uLong nGenerated ) const;
1009     ScChangeAction* GetActionOrGenerated( sal_uLong nAction ) const;
1010     sal_uLong GetLastSavedActionNumber() const;
1011     void SetLastSavedActionNumber(sal_uLong nNew);
1012     ScChangeAction* GetLastSaved() const;
1013     ScChangeActionContent** GetContentSlots() const { return ppContentSlots; }
1014
1015     bool IsLoadSave() const { return bLoadSave; }
1016     const ScRange&      GetInDeleteRange() const
1017                             { return aInDeleteRange; }
1018     bool IsInDelete() const { return bInDelete; }
1019     bool IsInDeleteTop() const { return bInDeleteTop; }
1020     bool IsInDeleteUndo() const { return bInDeleteUndo; }
1021     bool IsInPasteCut() const { return bInPasteCut; }
1022     SC_DLLPUBLIC void SetUser( const OUString& rUser );
1023     const OUString& GetUser() const { return maUser;}
1024     const std::set<OUString>& GetUserCollection() const { return maUserCollection;}
1025     ScDocument*         GetDocument() const { return pDoc; }
1026                         // for import filter
1027     const DateTime&     GetFixDateTime() const { return aFixDateTime; }
1028
1029                         // set this if the date/time set with
1030                         // SetFixDateTime...() shall be applied to
1031                         // appended actions
1032     void                SetUseFixDateTime( bool bVal )
1033                             { bUseFixDateTime = bVal; }
1034                         // for MergeDocument, apply original date/time as UTC
1035     void                SetFixDateTimeUTC( const DateTime& rDT )
1036                             { aFixDateTime = rDT; }
1037                         // for import filter, apply original date/time as local time
1038     void                SetFixDateTimeLocal( const DateTime& rDT )
1039                             { aFixDateTime = rDT; aFixDateTime.ConvertToUTC(); }
1040
1041     void                Append( ScChangeAction* );
1042
1043                                 // pRefDoc may be NULL => no lookup of contents
1044                                 // => no generation of deleted contents
1045     SC_DLLPUBLIC void AppendDeleteRange( const ScRange&,
1046                                     ScDocument* pRefDoc,
1047                                     sal_uLong& nStartAction, sal_uLong& nEndAction,
1048                                     SCsTAB nDz = 0 );
1049                                     // nDz: multi TabDel, LookUpContent must be searched
1050                                     // with an offset of -nDz
1051
1052                         // after new value was set in the document,
1053                         // old value from RefDoc/UndoDoc
1054     void                AppendContent( const ScAddress& rPos,
1055                             ScDocument* pRefDoc );
1056                         // after new values were set in the document,
1057                         // old values from RefDoc/UndoDoc
1058     void                AppendContentRange( const ScRange& rRange,
1059                             ScDocument* pRefDoc,
1060                             sal_uLong& nStartAction, sal_uLong& nEndAction,
1061                             ScChangeActionClipMode eMode = SC_CACM_NONE );
1062                         // after new value was set in the document,
1063                         // old value from pOldCell, nOldFormat,
1064                         // RefDoc==NULL => Doc
1065     void AppendContent( const ScAddress& rPos, const ScCellValue& rOldCell,
1066                         sal_uLong nOldFormat, ScDocument* pRefDoc = nullptr );
1067                         // after new value was set in the document,
1068                         // old value from pOldCell, format from Doc
1069     SC_DLLPUBLIC void AppendContent( const ScAddress& rPos, const ScCellValue& rOldCell );
1070                         // after new values were set in the document,
1071                         // old values from RefDoc/UndoDoc.
1072                         // All contents with a cell in RefDoc
1073     void                AppendContentsIfInRefDoc( ScDocument* pRefDoc,
1074                             sal_uLong& nStartAction, sal_uLong& nEndAction );
1075
1076                         // Meant for import filter, creates and inserts
1077                         // an unconditional content action of the two
1078                         // cells without querying the document, not
1079                         // even for number formats (though the number
1080                         // formatter of the document may be used).
1081                         // The action is returned and may be used to
1082                         // set user name, description, date/time et al.
1083                         // Takes ownership of the cells!
1084     SC_DLLPUBLIC ScChangeActionContent* AppendContentOnTheFly(
1085         const ScAddress& rPos, const ScCellValue& rOldCell, const ScCellValue& rNewCell,
1086         sal_uLong nOldFormat = 0, sal_uLong nNewFormat = 0 );
1087
1088     // Only use the following two if there is no different solution! (Assign
1089     // string for NewValue or creation of a formula respectively)
1090
1091     SC_DLLPUBLIC void AppendInsert( const ScRange& rRange, bool bEndOfList = false );
1092
1093                                 // pRefDoc may be NULL => no lookup of contents
1094                                 // => no generation of deleted contents
1095     SC_DLLPUBLIC void AppendMove( const ScRange& rFromRange, const ScRange& rToRange,
1096                                   ScDocument* pRefDoc );
1097
1098                                 // Cut to Clipboard
1099     void ResetLastCut()
1100     {
1101         nStartLastCut = nEndLastCut = 0;
1102         if ( pLastCutMove )
1103         {
1104             delete pLastCutMove;
1105             pLastCutMove = nullptr;
1106         }
1107     }
1108     bool HasLastCut() const
1109     {
1110         return nEndLastCut > 0 &&
1111             nStartLastCut <= nEndLastCut &&
1112             pLastCutMove;
1113     }
1114
1115     SC_DLLPUBLIC void Undo( sal_uLong nStartAction, sal_uLong nEndAction, bool bMerge = false );
1116
1117                         // adjust references for MergeDocument
1118                         //! may only be used in a temporary opened document.
1119                         //! the Track (?) is unclean afterwards
1120     void                MergePrepare( ScChangeAction* pFirstMerge, bool bShared = false );
1121     void                MergeOwn( ScChangeAction* pAct, sal_uLong nFirstMerge, bool bShared = false );
1122     static bool MergeIgnore( const ScChangeAction&, sal_uLong nFirstMerge );
1123
1124                                 // This comment was already really strange in German.
1125                                 // Tried to structure it a little. Hope no information got lost...
1126                                 //
1127                                 // Insert dependents into table.
1128                                 // ScChangeAction is
1129                                 // - "Insert": really dependents
1130                                 // - "Move": dependent contents in FromRange /
1131                                 //           deleted contents in ToRange
1132                                 //      OR   inserts in FromRange or ToRange
1133                                 // - "Delete": a list of deleted (what?)
1134                                 //      OR     for content, different contents at the same position
1135                                 //      OR     MatrixReferences belonging to MatrixOrigin
1136
1137                                 // With bListMasterDelete (==TRUE ?) all Deletes of a row belonging
1138                                 // to a MasterDelete are listed (possibly it is
1139                                 // "all Deletes belonging...are listed in a row?)
1140
1141                                 // With bAllFlat (==TRUE ?) all dependents of dependents
1142                                 // will be inserted flatly.
1143
1144     SC_DLLPUBLIC void GetDependents(
1145         ScChangeAction*, ScChangeActionMap&, bool bListMasterDelete = false, bool bAllFlat = false ) const;
1146
1147     // Reject visible action (and dependents)
1148     bool Reject( ScChangeAction*, bool bShared = false );
1149
1150     // Accept visible action (and dependents)
1151     SC_DLLPUBLIC bool Accept( ScChangeAction* );
1152
1153     void                AcceptAll();    // all Virgins
1154     bool                RejectAll();    // all Virgins
1155
1156     // Selects a content of several contents at the same
1157     // position and accepts this one and
1158     // the older ones, rejects the more recent ones.
1159     // If bOldest==TRUE then the first OldValue
1160     // of a Virgin-Content-List will be restored.
1161     bool SelectContent( ScChangeAction*, bool bOldest = false );
1162
1163                         // If ModifiedLink is set, changes go to
1164                         // ScChangeTrackMsgQueue
1165     void                SetModifiedLink( const Link<ScChangeTrack&,void>& r )
1166                             { aModifiedLink = r; ClearMsgQueue(); }
1167     ScChangeTrackMsgQueue& GetMsgQueue();
1168
1169     void                NotifyModified( ScChangeTrackMsgType eMsgType,
1170                             sal_uLong nStartAction, sal_uLong nEndAction );
1171
1172     sal_uLong           AddLoadedGenerated( const ScCellValue& rNewCell,
1173                             const ScBigRange& aBigRange, const OUString& sNewValue ); // only to use in the XML import
1174     void                AppendLoaded( ScChangeAction* pAppend ); // this is only for the XML import public, it should be protected
1175     void                SetActionMax(sal_uLong nTempActionMax)
1176                             { nActionMax = nTempActionMax; } // only to use in the XML import
1177
1178     void                SetProtection( const css::uno::Sequence< sal_Int8 >& rPass )
1179                             { aProtectPass = rPass; }
1180     const css::uno::Sequence< sal_Int8 >& GetProtection() const
1181                                     { return aProtectPass; }
1182     bool IsProtected() const { return aProtectPass.getLength() != 0; }
1183
1184                                 // If time stamps of actions of this
1185                                 // ChangeTrack and a second one are to be
1186                                 // compared including nanoseconds.
1187     void SetTimeNanoSeconds( bool bVal ) { bTimeNanoSeconds = bVal; }
1188     bool IsTimeNanoSeconds() const { return bTimeNanoSeconds; }
1189
1190     void AppendCloned( ScChangeAction* pAppend );
1191     SC_DLLPUBLIC ScChangeTrack* Clone( ScDocument* pDocument ) const;
1192     static void MergeActionState( ScChangeAction* pAct, const ScChangeAction* pOtherAct );
1193 };
1194
1195 #endif
1196
1197 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */