/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed * with this work for additional information regarding copyright * ownership. The ASF licenses this file to you under the Apache * License, Version 2.0 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.apache.org/licenses/LICENSE-2.0 . */ #pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include "global.hxx" #include "bigrange.hxx" #include "scdllapi.h" #include "cellvalue.hxx" class ScDocument; class ScFormulaCell; class ScChangeAction; class ScChangeTrack; class ScAppOptions; namespace tools { class JsonWriter; } class ScActionColorChanger { private: const ScAppOptions& rOpt; const std::set& rUsers; OUString aLastUserName; sal_uInt16 nLastUserIndex; Color nColor; public: ScActionColorChanger( const ScChangeTrack& rTrack ); void Update( const ScChangeAction& rAction ); Color GetColor() const { return nColor; } }; enum ScChangeActionType { SC_CAT_NONE, SC_CAT_INSERT_COLS, SC_CAT_INSERT_ROWS, SC_CAT_INSERT_TABS, SC_CAT_DELETE_COLS, SC_CAT_DELETE_ROWS, SC_CAT_DELETE_TABS, SC_CAT_MOVE, SC_CAT_CONTENT, SC_CAT_REJECT }; enum ScChangeActionState { SC_CAS_VIRGIN, SC_CAS_ACCEPTED, SC_CAS_REJECTED }; enum ScChangeActionClipMode { SC_CACM_NONE, SC_CACM_CUT, SC_CACM_PASTE }; /** A link/connection/dependency between change actions. Upon construction inserts itself as the head of a chain / linked list, respectively between existing link entries. Upon destruction removes itself from the list and connects the previous and next entry, if it was the first entry automatically maintaining the head pointer to the list. ppPrev == &previous->pNext or address of pointer to head of linked list, *ppPrev == this */ class ScChangeActionLinkEntry { ScChangeActionLinkEntry( const ScChangeActionLinkEntry& ) = delete; ScChangeActionLinkEntry& operator=( const ScChangeActionLinkEntry& ) = delete; protected: ScChangeActionLinkEntry* pNext; ScChangeActionLinkEntry** ppPrev; ScChangeAction* pAction; ScChangeActionLinkEntry* pLink; public: ScChangeActionLinkEntry( ScChangeActionLinkEntry** ppPrevP, ScChangeAction* pActionP ) : pNext( *ppPrevP ), ppPrev( ppPrevP ), pAction( pActionP ), pLink( nullptr ) { if ( pNext ) pNext->ppPrev = &pNext; *ppPrevP = this; } virtual ~ScChangeActionLinkEntry() { ScChangeActionLinkEntry* p = pLink; UnLink(); Remove(); if ( p ) delete p; } void SetLink( ScChangeActionLinkEntry* pLinkP ) { UnLink(); if ( pLinkP ) { pLink = pLinkP; pLinkP->pLink = this; } } void UnLink() { if ( pLink ) { pLink->pLink = nullptr; pLink = nullptr; } } void Remove() { if ( ppPrev ) { if ( ( *ppPrev = pNext ) != nullptr ) pNext->ppPrev = ppPrev; ppPrev = nullptr; // not inserted } } const ScChangeActionLinkEntry* GetNext() const { return pNext; } ScChangeActionLinkEntry* GetNext() { return pNext; } const ScChangeAction* GetAction() const { return pAction; } ScChangeAction* GetAction() { return pAction; } }; // ScChangeActionCellListEntry // this is only for the XML Export in the hxx class ScChangeActionContent; class SAL_DLLPUBLIC_RTTI ScChangeAction { friend class ScChangeTrack; friend class ScChangeActionIns; friend class ScChangeActionDel; friend class ScChangeActionMove; friend class ScChangeActionContent; ScChangeAction( const ScChangeAction& ) = delete; ScChangeAction& operator=( const ScChangeAction& ) = delete; protected: ScBigRange aBigRange; // Ins/Del/MoveTo/ContentPos DateTime aDateTime; //! UTC OUString aUser; // who? OUString aComment; // user comment ScChangeAction* pNext; // next in linked list ScChangeAction* pPrev; // previous in linked list ScChangeActionLinkEntry* pLinkAny; // arbitrary links ScChangeActionLinkEntry* pLinkDeletedIn; // access to insert areas which were // deleted or moved or rejected ScChangeActionLinkEntry* pLinkDeleted; // links to deleted ScChangeActionLinkEntry* pLinkDependent; // links to dependent sal_uLong nAction; sal_uLong nRejectAction; ScChangeActionType eType; ScChangeActionState eState; ScChangeAction( ScChangeActionType, const ScRange& ); // only to be used in the XML import ScChangeAction( ScChangeActionType, const ScBigRange&, const sal_uLong nAction, const sal_uLong nRejectAction, const ScChangeActionState eState, const DateTime& aDateTime, const OUString& aUser, const OUString& aComment ); // only to be used in the XML import ScChangeAction( ScChangeActionType, const ScBigRange&, const sal_uLong nAction); OUString GetRefString( const ScBigRange& rRange, const ScDocument& rDoc, bool bFlag3D = false) const; void SetActionNumber( sal_uLong n ) { nAction = n; } void SetRejectAction( sal_uLong n ) { nRejectAction = n; } void SetUser( const OUString& r ); void SetType( ScChangeActionType e ) { eType = e; } void SetState( ScChangeActionState e ) { eState = e; } void SetRejected(); ScBigRange& GetBigRange() { return aBigRange; } void AddLink( ScChangeAction* p, ScChangeActionLinkEntry* pL ) { ScChangeActionLinkEntry* pLnk = new ScChangeActionLinkEntry( &pLinkAny, p ); pLnk->SetLink( pL ); } virtual ScChangeActionLinkEntry* GetDeletedIn() const { return pLinkDeletedIn; } virtual ScChangeActionLinkEntry** GetDeletedInAddress() { return &pLinkDeletedIn; } bool RemoveDeletedIn( const ScChangeAction* ); void SetDeletedIn( ScChangeAction* ); ScChangeActionLinkEntry* AddDeleted( ScChangeAction* p ) { return new ScChangeActionLinkEntry(&pLinkDeleted, p); } ScChangeActionLinkEntry* AddDependent( ScChangeAction* p ) { return new ScChangeActionLinkEntry(&pLinkDependent, p); } void RemoveAllDependent(); void RemoveAllLinks(); virtual void AddContent( ScChangeActionContent* ) = 0; virtual void DeleteCellEntries() = 0; virtual void UpdateReference( const ScChangeTrack*, UpdateRefMode, const ScBigRange&, sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz ); void Accept(); virtual bool Reject(ScDocument& rDoc) = 0; void RejectRestoreContents( ScChangeTrack*, SCCOL nDx, SCROW nDy ); // used in Reject() instead of IsRejectable() bool IsInternalRejectable() const; // Derived classes that hold a pointer to the // ChangeTrack must return that. Otherwise NULL. virtual const ScChangeTrack* GetChangeTrack() const = 0; public: virtual ~ScChangeAction(); bool IsInsertType() const; bool IsDeleteType() const; bool IsVirgin() const; SC_DLLPUBLIC bool IsAccepted() const; bool IsRejected() const; // Action rejects another Action bool IsRejecting() const; // if action is visible in the document bool IsVisible() const; // if action if touchable bool IsTouchable() const; // if action is an entry in dialog root bool IsDialogRoot() const; // if an entry in a dialog shall be a drop down entry bool IsDialogParent() const; // if action is a delete with subdeletes (aufgeklappt = open ?) bool IsMasterDelete() const; // if action is acceptable/selectable/rejectable bool IsClickable() const; // if action is rejectable bool IsRejectable() const; const ScBigRange& GetBigRange() const { return aBigRange; } SC_DLLPUBLIC DateTime GetDateTime() const; // local time const DateTime& GetDateTimeUTC() const // UTC time { return aDateTime; } ScChangeActionType GetType() const { return eType; } ScChangeActionState GetState() const { return eState; } sal_uLong GetActionNumber() const { return nAction; } sal_uLong GetRejectAction() const { return nRejectAction; } ScChangeAction* GetNext() const { return pNext; } ScChangeAction* GetPrev() const { return pPrev; } bool IsDeletedIn() const; bool IsDeletedIn( const ScChangeAction* ) const; bool IsDeletedInDelType( ScChangeActionType ) const; void RemoveAllDeletedIn(); const ScChangeActionLinkEntry* GetFirstDeletedEntry() const { return pLinkDeleted; } const ScChangeActionLinkEntry* GetFirstDependentEntry() const { return pLinkDependent; } bool HasDependent() const; bool HasDeleted() const; // description will be appended to string // with bSplitRange only one column/row will be considered for delete // (for a listing of entries) virtual OUString GetDescription( ScDocument& rDoc, bool bSplitRange = false, bool bWarning = true ) const; virtual OUString GetRefString( ScDocument& rDoc, bool bFlag3D = false ) const; // for DocumentMerge set old date of the other // action, fetched by GetDateTimeUTC void SetDateTimeUTC( const DateTime& rDT ) { aDateTime = rDT; } const OUString& GetUser() const { return aUser;} const OUString& GetComment() const { return aComment;} // set user comment void SetComment( const OUString& rStr ); // only to be used in the XML import void SetDeletedInThis( sal_uLong nActionNumber, const ScChangeTrack* pTrack ); // only to be used in the XML import void AddDependent( sal_uLong nActionNumber, const ScChangeTrack* pTrack ); }; // ScChangeActionIns class SAL_DLLPUBLIC_RTTI ScChangeActionIns final : public ScChangeAction { friend class ScChangeTrack; bool mbEndOfList; /// whether or not a row was auto-inserted at the bottom. ScChangeActionIns( const ScDocument* pDoc, const ScRange& rRange, bool bEndOfList = false ); virtual void AddContent( ScChangeActionContent* ) override {} virtual void DeleteCellEntries() override {} virtual bool Reject(ScDocument& rDoc) override; virtual const ScChangeTrack* GetChangeTrack() const override { return nullptr; } public: virtual ~ScChangeActionIns() override; ScChangeActionIns( const sal_uLong nActionNumber, const ScChangeActionState eState, const sal_uLong nRejectingNumber, const ScBigRange& aBigRange, const OUString& aUser, const DateTime& aDateTime, const OUString &sComment, const ScChangeActionType eType, bool bEndOfList = false ); virtual OUString GetDescription( ScDocument& rDoc, bool bSplitRange = false, bool bWarning = true) const override; SC_DLLPUBLIC bool IsEndOfList() const; }; // ScChangeActionDel class SAL_DLLPUBLIC_RTTI ScChangeActionMove; class ScChangeActionDelMoveEntry final : public ScChangeActionLinkEntry { friend class ScChangeActionDel; friend class ScChangeTrack; short nCutOffFrom; short nCutOffTo; inline ScChangeActionDelMoveEntry( ScChangeActionDelMoveEntry** ppPrevP, ScChangeActionMove* pMove, short nFrom, short nTo ); inline ScChangeActionMove* GetMove(); public: const ScChangeActionDelMoveEntry* GetNext() const { return static_cast( ScChangeActionLinkEntry::GetNext()); } inline const ScChangeActionMove* GetMove() const; short GetCutOffFrom() const { return nCutOffFrom; } short GetCutOffTo() const { return nCutOffTo; } }; class ScChangeActionDel final : public ScChangeAction { friend class ScChangeTrack; friend void ScChangeAction::Accept(); ScChangeTrack* pTrack; std::vector mvCells; ScChangeActionIns* pCutOff; // cut insert short nCutOff; // +: start -: end ScChangeActionDelMoveEntry* pLinkMove; SCCOL nDx; SCROW nDy; ScChangeActionDel( const ScDocument* pDoc, const ScRange& rRange, SCCOL nDx, SCROW nDy, ScChangeTrack* ); virtual void AddContent( ScChangeActionContent* ) override; virtual void DeleteCellEntries() override; void UndoCutOffMoves(); void UndoCutOffInsert(); virtual void UpdateReference( const ScChangeTrack*, UpdateRefMode, const ScBigRange&, sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz ) override; virtual bool Reject(ScDocument& rDoc) override; virtual const ScChangeTrack* GetChangeTrack() const override { return pTrack; } public: ScChangeActionDel( const sal_uLong nActionNumber, const ScChangeActionState eState, const sal_uLong nRejectingNumber, const ScBigRange& aBigRange, const OUString& aUser, const DateTime& aDateTime, const OUString &sComment, const ScChangeActionType eType, const SCCOLROW nD, ScChangeTrack* pTrack); // only to use in the XML import // which of nDx and nDy is set is dependent on the type virtual ~ScChangeActionDel() override; // is the last in a row (or single) bool IsBaseDelete() const; // is the first in a row (or single) bool IsTopDelete() const; // is part of a row bool IsMultiDelete() const; // is col, belonging to a TabDelete bool IsTabDeleteCol() const; SCCOL GetDx() const { return nDx; } SCROW GetDy() const { return nDy; } ScBigRange GetOverAllRange() const; // BigRange + (nDx, nDy) const ScChangeActionDelMoveEntry* GetFirstMoveEntry() const { return pLinkMove; } const ScChangeActionIns* GetCutOffInsert() const { return pCutOff; } short GetCutOffCount() const { return nCutOff; } virtual OUString GetDescription( ScDocument& rDoc, bool bSplitRange = false, bool bWarning = true ) const override; void SetCutOffInsert( ScChangeActionIns* p, short n ) { pCutOff = p; nCutOff = n; } // only to use in the XML import // this should be protected, but for the XML import it is public // only to use in the XML import // this should be protected, but for the XML import it is public ScChangeActionDelMoveEntry* AddCutOffMove( ScChangeActionMove* pMove, short nFrom, short nTo ); }; // ScChangeActionMove class ScChangeActionMove final : public ScChangeAction { friend class ScChangeTrack; friend struct std::default_delete; // for std::unique_ptr friend class ScChangeActionDel; ScBigRange aFromRange; ScChangeTrack* pTrack; std::vector mvCells; sal_uLong nStartLastCut; // for PasteCut undo sal_uLong nEndLastCut; ScChangeActionMove( const ScRange& rFromRange, const ScRange& rToRange, ScChangeTrack* pTrackP ) : ScChangeAction( SC_CAT_MOVE, rToRange ), aFromRange( rFromRange ), pTrack( pTrackP ), nStartLastCut(0), nEndLastCut(0) {} virtual ~ScChangeActionMove() override; virtual void AddContent( ScChangeActionContent* ) override; virtual void DeleteCellEntries() override; ScBigRange& GetFromRange() { return aFromRange; } void SetStartLastCut( sal_uLong nVal ) { nStartLastCut = nVal; } sal_uLong GetStartLastCut() const { return nStartLastCut; } void SetEndLastCut( sal_uLong nVal ) { nEndLastCut = nVal; } sal_uLong GetEndLastCut() const { return nEndLastCut; } virtual void UpdateReference( const ScChangeTrack*, UpdateRefMode, const ScBigRange&, sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz ) override; virtual bool Reject(ScDocument& rDoc) override; virtual const ScChangeTrack* GetChangeTrack() const override { return pTrack; } protected: using ScChangeAction::GetRefString; public: ScChangeActionMove(const sal_uLong nActionNumber, const ScChangeActionState eState, const sal_uLong nRejectingNumber, const ScBigRange& aToBigRange, const OUString& aUser, const DateTime& aDateTime, const OUString &sComment, const ScBigRange& aFromBigRange, ScChangeTrack* pTrack); // only to use in the XML import const ScBigRange& GetFromRange() const { return aFromRange; } SC_DLLPUBLIC void GetDelta( sal_Int32& nDx, sal_Int32& nDy, sal_Int32& nDz ) const; virtual OUString GetDescription( ScDocument& rDoc, bool bSplitRange = false, bool bWarning = true ) const override; virtual OUString GetRefString( ScDocument& rDoc, bool bFlag3D = false ) const override; }; ScChangeActionDelMoveEntry::ScChangeActionDelMoveEntry( ScChangeActionDelMoveEntry** ppPrevP, ScChangeActionMove* pMove, short nFrom, short nTo ) : ScChangeActionLinkEntry( reinterpret_cast( ppPrevP), static_cast(pMove) ), nCutOffFrom( nFrom ), nCutOffTo( nTo ) {} inline ScChangeActionMove* ScChangeActionDelMoveEntry::GetMove() { return static_cast( ScChangeActionLinkEntry::GetAction()); } inline const ScChangeActionMove* ScChangeActionDelMoveEntry::GetMove() const { return static_cast( ScChangeActionLinkEntry::GetAction()); } // ScChangeActionContent enum ScChangeActionContentCellType { SC_CACCT_NONE = 0, SC_CACCT_NORMAL, SC_CACCT_MATORG, SC_CACCT_MATREF }; class SAL_DLLPUBLIC_RTTI ScChangeActionContent final : public ScChangeAction { friend class ScChangeTrack; ScCellValue maOldCell; ScCellValue maNewCell; OUString maOldValue; OUString maNewValue; ScChangeActionContent* pNextContent; // at the same position ScChangeActionContent* pPrevContent; ScChangeActionContent* pNextInSlot; // in the same slot ScChangeActionContent** ppPrevInSlot; void InsertInSlot( ScChangeActionContent** pp ) { if ( !ppPrevInSlot ) { ppPrevInSlot = pp; if ( ( pNextInSlot = *pp ) != nullptr ) pNextInSlot->ppPrevInSlot = &pNextInSlot; *pp = this; } } void RemoveFromSlot() { if ( ppPrevInSlot ) { if ( ( *ppPrevInSlot = pNextInSlot ) != nullptr ) pNextInSlot->ppPrevInSlot = ppPrevInSlot; ppPrevInSlot = nullptr; // not inserted } } ScChangeActionContent* GetNextInSlot() { return pNextInSlot; } void ClearTrack(); static OUString GetStringOfCell( const ScCellValue& rCell, const ScDocument* pDoc, const ScAddress& rPos ); static OUString GetStringOfCell( const ScCellValue& rCell, const ScDocument* pDoc, sal_uLong nFormat ); static void SetValue( OUString& rStr, ScCellValue& rCell, const ScAddress& rPos, const ScCellValue& rOrgCell, const ScDocument* pFromDoc, ScDocument* pToDoc ); static void SetValue( OUString& rStr, ScCellValue& rCell, sal_uLong nFormat, const ScCellValue& rOrgCell, const ScDocument* pFromDoc, ScDocument* pToDoc ); static void SetCell( OUString& rStr, ScCellValue& rCell, sal_uLong nFormat, const ScDocument* pDoc ); static bool NeedsNumberFormat( const ScCellValue& rVal ); void SetValueString( OUString& rValue, ScCellValue& rCell, const OUString& rStr, ScDocument* pDoc ); OUString GetValueString( const OUString& rValue, const ScCellValue& rCell, const ScDocument* pDoc ) const; OUString GetFormulaString( const ScFormulaCell* pCell ) const; virtual void AddContent( ScChangeActionContent* ) override {} virtual void DeleteCellEntries() override {} virtual void UpdateReference( const ScChangeTrack*, UpdateRefMode, const ScBigRange&, sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz ) override; virtual bool Reject(ScDocument& rDoc) override; virtual const ScChangeTrack* GetChangeTrack() const override { return nullptr; } // pRejectActions!=NULL: reject actions get // stacked, no SetNewValue, no Append bool Select( ScDocument&, ScChangeTrack*, bool bOldest, ::std::stack* pRejectActions ); void PutValueToDoc( const ScCellValue& rCell, const OUString& rValue, ScDocument* pDoc, SCCOL nDx, SCROW nDy ) const; protected: using ScChangeAction::GetRefString; public: ScChangeActionContent( const ScRange& rRange ); ScChangeActionContent( const sal_uLong nActionNumber, const ScChangeActionState eState, const sal_uLong nRejectingNumber, const ScBigRange& aBigRange, const OUString& aUser, const DateTime& aDateTime, const OUString &sComment, const ScCellValue& rOldCell, const ScDocument* pDoc, const OUString& sOldValue ); // to use for XML Import ScChangeActionContent( const sal_uLong nActionNumber, const ScCellValue& rNewCell, const ScBigRange& aBigRange, const ScDocument* pDoc, const OUString& sNewValue ); // to use for XML Import of Generated Actions virtual ~ScChangeActionContent() override; ScChangeActionContent* GetNextContent() const { return pNextContent; } ScChangeActionContent* GetPrevContent() const { return pPrevContent; } ScChangeActionContent* GetTopContent() const; bool IsTopContent() const { return pNextContent == nullptr; } virtual ScChangeActionLinkEntry* GetDeletedIn() const override; virtual ScChangeActionLinkEntry** GetDeletedInAddress() override; void PutOldValueToDoc( ScDocument*, SCCOL nDx, SCROW nDy ) const; void PutNewValueToDoc( ScDocument*, SCCOL nDx, SCROW nDy ) const; void SetOldValue( const ScCellValue& rCell, const ScDocument* pFromDoc, ScDocument* pToDoc, sal_uLong nFormat ); void SetOldValue( const ScCellValue& rCell, const ScDocument* pFromDoc, ScDocument* pToDoc ); void SetNewValue( const ScCellValue& rCell, ScDocument* pDoc ); // Used in import filter AppendContentOnTheFly, void SetOldNewCells( const ScCellValue& rOldCell, sal_uLong nOldFormat, const ScCellValue& rNewCell, sal_uLong nNewFormat, const ScDocument* pDoc ); // Use this only in the XML import, // takes ownership of cell. void SetNewCell( const ScCellValue& rCell, const ScDocument* pDoc, const OUString& rFormatted ); // These functions should be protected but for // the XML import they are public. void SetNextContent( ScChangeActionContent* p ) { pNextContent = p; } void SetPrevContent( ScChangeActionContent* p ) { pPrevContent = p; } // don't use: // assigns string / creates formula cell void SetOldValue( const OUString& rOld, ScDocument* pDoc ); OUString GetOldString( const ScDocument* pDoc ) const; OUString GetNewString( const ScDocument* pDoc ) const; const ScCellValue& GetOldCell() const { return maOldCell;} const ScCellValue& GetNewCell() const { return maNewCell;} virtual OUString GetDescription( ScDocument& rDoc, bool bSplitRange = false, bool bWarning = true ) const override; virtual OUString GetRefString( ScDocument& rDoc, bool bFlag3D = false ) const override; static ScChangeActionContentCellType GetContentCellType( const ScCellValue& rCell ); static ScChangeActionContentCellType GetContentCellType( const ScRefCellValue& rIter ); // NewCell bool IsMatrixOrigin() const; // OldCell bool IsOldMatrixReference() const; }; // ScChangeActionReject class ScChangeActionReject final : public ScChangeAction { friend class ScChangeTrack; friend class ScChangeActionContent; virtual void AddContent( ScChangeActionContent* ) override {} virtual void DeleteCellEntries() override {} virtual bool Reject(ScDocument& rDoc) override; virtual const ScChangeTrack* GetChangeTrack() const override { return nullptr; } public: ScChangeActionReject(const sal_uLong nActionNumber, const ScChangeActionState eState, const sal_uLong nRejectingNumber, const ScBigRange& aBigRange, const OUString& aUser, const DateTime& aDateTime, const OUString &sComment); // only to use in the XML import }; // ScChangeTrack enum class ScChangeTrackMsgType { NONE, Append, // Actions appended Remove, // Actions removed Change, // Actions changed Parent // became a parent (and wasn't before) }; struct ScChangeTrackMsgInfo { ScChangeTrackMsgType eMsgType; sal_uLong nStartAction; sal_uLong nEndAction; }; // MsgQueue for notification via ModifiedLink typedef std::vector ScChangeTrackMsgQueue; typedef std::vector ScChangeTrackMsgStack; typedef std::map ScChangeActionMap; enum ScChangeTrackMergeState { SC_CTMS_NONE, SC_CTMS_PREPARE, SC_CTMS_OWN, SC_CTMS_UNDO, SC_CTMS_OTHER }; // Internally generated actions start at this value (nearly all bits set) // and are decremented, to keep values in a table separated from "normal" actions. #define SC_CHGTRACK_GENERATED_START (sal_uInt32(0xfffffff0)) class SAL_DLLPUBLIC_RTTI ScChangeTrack final : public utl::ConfigurationListener { friend void ScChangeAction::RejectRestoreContents( ScChangeTrack*, SCCOL, SCROW ); friend bool ScChangeActionDel::Reject( ScDocument& pDoc ); friend void ScChangeActionDel::DeleteCellEntries(); friend void ScChangeActionMove::DeleteCellEntries(); friend bool ScChangeActionMove::Reject( ScDocument& pDoc ); SCROW mnContentRowsPerSlot; SCSIZE mnContentSlots; css::uno::Sequence< sal_Int8 > aProtectPass; ScChangeActionMap aMap; ScChangeActionMap aGeneratedMap; ScChangeActionMap aPasteCutMap; ScChangeTrackMsgQueue aMsgQueue; ScChangeTrackMsgStack aMsgStackTmp; ScChangeTrackMsgStack aMsgStackFinal; std::set maUserCollection; OUString maUser; Link aModifiedLink; ScRange aInDeleteRange; DateTime aFixDateTime; ScChangeAction* pFirst; ScChangeAction* pLast; ScChangeActionContent* pFirstGeneratedDelContent; std::unique_ptr ppContentSlots; std::unique_ptr pLastCutMove; ScChangeActionLinkEntry* pLinkInsertCol; ScChangeActionLinkEntry* pLinkInsertRow; ScChangeActionLinkEntry* pLinkInsertTab; ScChangeActionLinkEntry* pLinkMove; std::optional xBlockModifyMsg; ScDocument& rDoc; sal_uLong nActionMax; sal_uLong nGeneratedMin; sal_uLong nMarkLastSaved; sal_uLong nStartLastCut; sal_uLong nEndLastCut; sal_uLong nLastMerge; ScChangeTrackMergeState eMergeState; bool bInDelete:1; bool bInDeleteUndo:1; bool bInDeleteTop:1; bool bInPasteCut:1; bool bUseFixDateTime:1; bool bTimeNanoSeconds:1; ScChangeTrack( const ScChangeTrack& ) = delete; ScChangeTrack& operator=( const ScChangeTrack& ) = delete; SCROW InitContentRowsPerSlot(); // true if one is ScMatrixMode::Formula and the other is // not, or if both are and range differs static bool IsMatrixFormulaRangeDifferent( const ScCellValue& rOldCell, const ScCellValue& rNewCell ); void Init(); void DtorClear(); void SetInDeleteRange( const ScRange& rRange ) { aInDeleteRange = rRange; } void SetInDelete( bool bVal ) { bInDelete = bVal; } void SetInDeleteTop( bool bVal ) { bInDeleteTop = bVal; } void SetInDeleteUndo( bool bVal ) { bInDeleteUndo = bVal; } void SetInPasteCut( bool bVal ) { bInPasteCut = bVal; } void SetMergeState( ScChangeTrackMergeState eState ) { eMergeState = eState; } ScChangeTrackMergeState GetMergeState() const { return eMergeState; } void SetLastMerge( sal_uLong nVal ) { nLastMerge = nVal; } sal_uLong GetLastMerge() const { return nLastMerge; } void SetLastCutMoveRange( const ScRange&, ScDocument* ); // create block of ModifyMsg void StartBlockModify( ScChangeTrackMsgType, sal_uLong nStartAction ); void EndBlockModify( sal_uLong nEndAction ); void AddDependentWithNotify( ScChangeAction* pParent, ScChangeAction* pDependent ); void Dependencies( ScChangeAction* ); void UpdateReference( ScChangeAction*, bool bUndo ); void UpdateReference( ScChangeAction** ppFirstAction, ScChangeAction* pAct, bool bUndo ); void Append( ScChangeAction* pAppend, sal_uLong nAction ); SC_DLLPUBLIC void AppendDeleteRange( const ScRange&, ScDocument* pRefDoc, SCTAB nDz, sal_uLong nRejectingInsert ); void AppendOneDeleteRange( const ScRange& rOrgRange, ScDocument* pRefDoc, SCCOL nDx, SCROW nDy, SCTAB nDz, sal_uLong nRejectingInsert ); void LookUpContents( const ScRange& rOrgRange, ScDocument* pRefDoc, SCCOL nDx, SCROW nDy, SCTAB nDz ); void Remove( ScChangeAction* ); void MasterLinks( ScChangeAction* ); // Content on top at Position ScChangeActionContent* SearchContentAt( const ScBigAddress&, const ScChangeAction* pButNotThis ) const; void DeleteGeneratedDelContent( ScChangeActionContent* ); ScChangeActionContent* GenerateDelContent( const ScAddress& rPos, const ScCellValue& rCell, const ScDocument* pFromDoc ); void DeleteCellEntries( std::vector&, const ScChangeAction* pDeletor ); // Reject action and all dependent actions, // Table stems from previous GetDependents, // only needed for Insert and Move (MasterType), // is NULL otherwise. // bRecursion == called from reject with table bool Reject( ScChangeAction*, ScChangeActionMap*, bool bRecursion ); bool IsLastAction( sal_uLong nNum ) const; void ClearMsgQueue(); virtual void ConfigurationChanged( utl::ConfigurationBroadcaster*, ConfigurationHints ) override; public: SCSIZE ComputeContentSlot( sal_Int32 nRow ) const; SC_DLLPUBLIC ScChangeTrack( ScDocument& ); ScChangeTrack(ScDocument& rDocP, std::set&& aTempUserCollection); // only to use in the XML import SC_DLLPUBLIC virtual ~ScChangeTrack() override; void Clear(); ScChangeActionContent* GetFirstGenerated() const { return pFirstGeneratedDelContent; } ScChangeAction* GetFirst() const { return pFirst; } ScChangeAction* GetLast() const { return pLast; } sal_uLong GetActionMax() const { return nActionMax; } bool IsGenerated( sal_uLong nAction ) const; SC_DLLPUBLIC ScChangeAction* GetAction( sal_uLong nAction ) const; ScChangeAction* GetGenerated( sal_uLong nGenerated ) const; ScChangeAction* GetActionOrGenerated( sal_uLong nAction ) const; sal_uLong GetLastSavedActionNumber() const; void SetLastSavedActionNumber(sal_uLong nNew); ScChangeAction* GetLastSaved() const; ScChangeActionContent** GetContentSlots() const { return ppContentSlots.get(); } const ScRange& GetInDeleteRange() const { return aInDeleteRange; } bool IsInDelete() const { return bInDelete; } bool IsInDeleteTop() const { return bInDeleteTop; } bool IsInDeleteUndo() const { return bInDeleteUndo; } bool IsInPasteCut() const { return bInPasteCut; } SC_DLLPUBLIC void SetUser( const OUString& rUser ); const OUString& GetUser() const { return maUser;} const std::set& GetUserCollection() const { return maUserCollection;} ScDocument& GetDocument() const { return rDoc; } // for import filter const DateTime& GetFixDateTime() const { return aFixDateTime; } // set this if the date/time set with // SetFixDateTime...() shall be applied to // appended actions void SetUseFixDateTime( bool bVal ) { bUseFixDateTime = bVal; } // for MergeDocument, apply original date/time as UTC void SetFixDateTimeUTC( const DateTime& rDT ) { aFixDateTime = rDT; } // for import filter, apply original date/time as local time void SetFixDateTimeLocal( const DateTime& rDT ) { aFixDateTime = rDT; aFixDateTime.ConvertToUTC(); } void Append( ScChangeAction* ); // pRefDoc may be NULL => no lookup of contents // => no generation of deleted contents SC_DLLPUBLIC void AppendDeleteRange( const ScRange&, ScDocument* pRefDoc, sal_uLong& nStartAction, sal_uLong& nEndAction, SCTAB nDz = 0 ); // nDz: multi TabDel, LookUpContent must be searched // with an offset of -nDz // after new value was set in the document, // old value from RefDoc/UndoDoc void AppendContent( const ScAddress& rPos, const ScDocument* pRefDoc ); // after new values were set in the document, // old values from RefDoc/UndoDoc void AppendContentRange( const ScRange& rRange, ScDocument* pRefDoc, sal_uLong& nStartAction, sal_uLong& nEndAction, ScChangeActionClipMode eMode = SC_CACM_NONE ); // after new value was set in the document, // old value from pOldCell, nOldFormat, // RefDoc==NULL => Doc void AppendContent( const ScAddress& rPos, const ScCellValue& rOldCell, sal_uLong nOldFormat, ScDocument* pRefDoc = nullptr ); // after new value was set in the document, // old value from pOldCell, format from Doc SC_DLLPUBLIC void AppendContent( const ScAddress& rPos, const ScCellValue& rOldCell ); // after new values were set in the document, // old values from RefDoc/UndoDoc. // All contents with a cell in RefDoc void AppendContentsIfInRefDoc( ScDocument& rRefDoc, sal_uLong& nStartAction, sal_uLong& nEndAction ); // Meant for import filter, creates and inserts // an unconditional content action of the two // cells without querying the document, not // even for number formats (though the number // formatter of the document may be used). // The action is returned and may be used to // set user name, description, date/time et al. // Takes ownership of the cells! SC_DLLPUBLIC ScChangeActionContent* AppendContentOnTheFly( const ScAddress& rPos, const ScCellValue& rOldCell, const ScCellValue& rNewCell, sal_uLong nOldFormat = 0, sal_uLong nNewFormat = 0 ); // Only use the following two if there is no different solution! (Assign // string for NewValue or creation of a formula respectively) SC_DLLPUBLIC void AppendInsert( const ScRange& rRange, bool bEndOfList = false ); // pRefDoc may be NULL => no lookup of contents // => no generation of deleted contents SC_DLLPUBLIC void AppendMove( const ScRange& rFromRange, const ScRange& rToRange, ScDocument* pRefDoc ); // Cut to Clipboard void ResetLastCut() { nStartLastCut = nEndLastCut = 0; pLastCutMove.reset(); } bool HasLastCut() const { return nEndLastCut > 0 && nStartLastCut <= nEndLastCut && pLastCutMove; } SC_DLLPUBLIC void Undo( sal_uLong nStartAction, sal_uLong nEndAction, bool bMerge = false ); // adjust references for MergeDocument //! may only be used in a temporary opened document. //! the Track (?) is unclean afterwards void MergePrepare( const ScChangeAction* pFirstMerge, bool bShared ); void MergeOwn( ScChangeAction* pAct, sal_uLong nFirstMerge, bool bShared ); static bool MergeIgnore( const ScChangeAction&, sal_uLong nFirstMerge ); // This comment was already really strange in German. // Tried to structure it a little. Hope no information got lost... // // Insert dependents into table. // ScChangeAction is // - "Insert": really dependents // - "Move": dependent contents in FromRange / // deleted contents in ToRange // OR inserts in FromRange or ToRange // - "Delete": a list of deleted (what?) // OR for content, different contents at the same position // OR MatrixReferences belonging to MatrixOrigin // With bListMasterDelete (==TRUE ?) all Deletes of a row belonging // to a MasterDelete are listed (possibly it is // "all Deletes belonging...are listed in a row?) // With bAllFlat (==TRUE ?) all dependents of dependents // will be inserted flatly. SC_DLLPUBLIC void GetDependents( ScChangeAction*, ScChangeActionMap&, bool bListMasterDelete = false, bool bAllFlat = false ) const; // Reject visible action (and dependents) bool Reject( ScChangeAction*, bool bShared = false ); // Accept visible action (and dependents) SC_DLLPUBLIC bool Accept( ScChangeAction* ); void AcceptAll(); // all Virgins bool RejectAll(); // all Virgins // Selects a content of several contents at the same // position and accepts this one and // the older ones, rejects the more recent ones. // If bOldest==TRUE then the first OldValue // of a Virgin-Content-List will be restored. bool SelectContent( ScChangeAction*, bool bOldest = false ); // If ModifiedLink is set, changes go to // ScChangeTrackMsgQueue void SetModifiedLink( const Link& r ) { aModifiedLink = r; ClearMsgQueue(); } ScChangeTrackMsgQueue& GetMsgQueue(); void NotifyModified( ScChangeTrackMsgType eMsgType, sal_uLong nStartAction, sal_uLong nEndAction ); sal_uLong AddLoadedGenerated( const ScCellValue& rNewCell, const ScBigRange& aBigRange, const OUString& sNewValue ); // only to use in the XML import void AppendLoaded( std::unique_ptr pAppend ); // this is only for the XML import public, it should be protected void SetActionMax(sal_uLong nTempActionMax) { nActionMax = nTempActionMax; } // only to use in the XML import void SetProtection( const css::uno::Sequence< sal_Int8 >& rPass ) { aProtectPass = rPass; } const css::uno::Sequence< sal_Int8 >& GetProtection() const { return aProtectPass; } bool IsProtected() const { return aProtectPass.hasElements(); } // If time stamps of actions of this // ChangeTrack and a second one are to be // compared including nanoseconds. void SetTimeNanoSeconds( bool bVal ) { bTimeNanoSeconds = bVal; } bool IsTimeNanoSeconds() const { return bTimeNanoSeconds; } void AppendCloned( ScChangeAction* pAppend ); SC_DLLPUBLIC ScChangeTrack* Clone( ScDocument* pDocument ) const; static void MergeActionState( ScChangeAction* pAct, const ScChangeAction* pOtherAct ); /// Get info about all ScChangeAction elements. void GetChangeTrackInfo(tools::JsonWriter&); }; /* vim:set shiftwidth=4 softtabstop=4 expandtab: */