office-gobmx/sc/inc/chgtrack.hxx
2012-02-13 15:58:48 +00:00

1290 lines
49 KiB
C++

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#ifndef SC_CHGTRACK_HXX
#define SC_CHGTRACK_HXX
#include <deque>
#include <map>
#include <set>
#include <stack>
#include <tools/string.hxx>
#include <tools/datetime.hxx>
#include <tools/mempool.hxx>
#include <unotools/options.hxx>
#include "global.hxx"
#include "bigrange.hxx"
#include "scdllapi.h"
#ifdef SC_CHGTRACK_CXX
// core/inc
#include "refupdat.hxx"
#endif
class ScBaseCell;
class ScDocument;
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_COPY,
SC_CACM_PASTE
};
class SvStream;
// --- ScChangeActionLinkEntry ---------------------------------------------
// Inserts itself as the head of a chain (better: linked list?), or before a LinkEntry
// on delete: automatically remove of what is linked (German original was strange...)
// ppPrev == &previous->pNext oder address of pointer to head of linked list,
// *ppPrev == this
class ScChangeAction;
class ScChangeActionLinkEntry
{
// not implemented, prevent usage
ScChangeActionLinkEntry( const ScChangeActionLinkEntry& );
ScChangeActionLinkEntry& operator=( const ScChangeActionLinkEntry& );
protected:
ScChangeActionLinkEntry* pNext;
ScChangeActionLinkEntry** ppPrev;
ScChangeAction* pAction;
ScChangeActionLinkEntry* pLink;
public:
DECL_FIXEDMEMPOOL_NEWDEL( ScChangeActionLinkEntry )
ScChangeActionLinkEntry(
ScChangeActionLinkEntry** ppPrevP,
ScChangeAction* pActionP )
: pNext( *ppPrevP ),
ppPrev( ppPrevP ),
pAction( pActionP ),
pLink( NULL )
{
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 = NULL;
pLink = NULL;
}
}
void Remove()
{
if ( ppPrev )
{
if ( ( *ppPrev = pNext ) != NULL )
pNext->ppPrev = ppPrev;
ppPrev = NULL; // not inserted
}
}
void Insert( ScChangeActionLinkEntry** ppPrevP )
{
if ( !ppPrev )
{
ppPrev = ppPrevP;
if ( (pNext = *ppPrevP) )
pNext->ppPrev = &pNext;
*ppPrevP = this;
}
}
const ScChangeActionLinkEntry* GetLink() const { return pLink; }
ScChangeActionLinkEntry* GetLink() { return pLink; }
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 ScChangeActionCellListEntry
{
friend class ScChangeAction;
friend class ScChangeActionDel;
friend class ScChangeActionMove;
friend class ScChangeTrack;
ScChangeActionCellListEntry* pNext;
ScChangeActionContent* pContent;
ScChangeActionCellListEntry(
ScChangeActionContent* pContentP,
ScChangeActionCellListEntry* pNextP )
: pNext( pNextP ),
pContent( pContentP )
{}
public:
const ScChangeActionCellListEntry* GetNext() const { return pNext; } // this is only for the XML Export public
const ScChangeActionContent* GetContent() const { return pContent; } // this is only for the XML Export public
DECL_FIXEDMEMPOOL_NEWDEL( ScChangeActionCellListEntry )
};
// --- ScChangeAction -------------------------------------------------------
class ScChangeTrack;
class ScChangeActionIns;
class ScChangeActionDel;
class ScChangeActionContent;
class ScChangeAction
{
friend class ScChangeTrack;
friend class ScChangeActionIns;
friend class ScChangeActionDel;
friend class ScChangeActionMove;
friend class ScChangeActionContent;
// not implemented, prevent usage
ScChangeAction( const ScChangeAction& );
ScChangeAction& operator=( const ScChangeAction& );
protected:
ScBigRange aBigRange; // Ins/Del/MoveTo/ContentPos
DateTime aDateTime; //! UTC
rtl::OUString aUser; // who?
rtl::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 rtl::OUString& aUser,
const rtl::OUString& aComment );
// only to be used in the XML import
ScChangeAction( ScChangeActionType, const ScBigRange&, const sal_uLong nAction);
virtual ~ScChangeAction();
rtl::OUString GetRefString(
const ScBigRange& rRange, ScDocument* pDoc, bool bFlag3D = false) const;
void SetActionNumber( sal_uLong n ) { nAction = n; }
void SetRejectAction( sal_uLong n ) { nRejectAction = n; }
void SetUser( const rtl::OUString& r );
void SetType( ScChangeActionType e ) { eType = e; }
void SetState( ScChangeActionState e ) { eState = e; }
void SetRejected();
ScBigRange& GetBigRange() { return aBigRange; }
ScChangeActionLinkEntry* AddLink(
ScChangeAction* p, ScChangeActionLinkEntry* pL )
{
ScChangeActionLinkEntry* pLnk =
new ScChangeActionLinkEntry(
&pLinkAny, p );
pLnk->SetLink( pL );
return pLnk;
}
void RemoveAllAnyLinks();
virtual ScChangeActionLinkEntry* GetDeletedIn() const
{ return pLinkDeletedIn; }
virtual ScChangeActionLinkEntry** GetDeletedInAddress()
{ return &pLinkDeletedIn; }
ScChangeActionLinkEntry* AddDeletedIn( ScChangeAction* p )
{
return new ScChangeActionLinkEntry(
GetDeletedInAddress(), p );
}
bool RemoveDeletedIn( const ScChangeAction* );
void SetDeletedIn( ScChangeAction* );
ScChangeActionLinkEntry* AddDeleted( ScChangeAction* p )
{
return new ScChangeActionLinkEntry(&pLinkDeleted, p);
}
void RemoveAllDeleted();
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* pDoc) = 0;
void RejectRestoreContents( ScChangeTrack*, SCsCOL nDx, SCsROW 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:
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 void GetDescription(
rtl::OUString& rStr, ScDocument* pDoc,
bool bSplitRange = false, bool bWarning = true ) const;
virtual void GetRefString(
rtl::OUString& rStr, ScDocument* pDoc, bool bFlag3D = false ) const;
// for DocumentMerge set old date of the other
// action, fetched by GetDateTimeUTC
void SetDateTimeUTC( const DateTime& rDT )
{ aDateTime = rDT; }
SC_DLLPUBLIC const rtl::OUString& GetUser() const;
const rtl::OUString& GetComment() const;
// set user comment
void SetComment( const rtl::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 ScChangeActionIns : public ScChangeAction
{
friend class ScChangeTrack;
ScChangeActionIns( const ScRange& rRange );
virtual ~ScChangeActionIns();
virtual void AddContent( ScChangeActionContent* ) {}
virtual void DeleteCellEntries() {}
virtual bool Reject(ScDocument* pDoc);
virtual const ScChangeTrack* GetChangeTrack() const { return 0; }
public:
ScChangeActionIns(const sal_uLong nActionNumber,
const ScChangeActionState eState,
const sal_uLong nRejectingNumber,
const ScBigRange& aBigRange,
const rtl::OUString& aUser,
const DateTime& aDateTime,
const rtl::OUString &sComment,
const ScChangeActionType eType); // only to use in the XML import
virtual void GetDescription(
rtl::OUString& rStr, ScDocument* pDoc, bool bSplitRange = false, bool bWarning = true) const;
};
// --- ScChangeActionDel ----------------------------------------------------
class ScChangeActionMove;
class ScChangeActionDelMoveEntry : public ScChangeActionLinkEntry
{
friend class ScChangeActionDel;
friend class ScChangeTrack;
short nCutOffFrom;
short nCutOffTo;
ScChangeActionDelMoveEntry(
ScChangeActionDelMoveEntry** ppPrevP,
ScChangeActionMove* pMove,
short nFrom, short nTo )
: ScChangeActionLinkEntry(
(ScChangeActionLinkEntry**)
ppPrevP,
(ScChangeAction*) pMove ),
nCutOffFrom( nFrom ),
nCutOffTo( nTo )
{}
ScChangeActionDelMoveEntry* GetNext()
{
return (ScChangeActionDelMoveEntry*)
ScChangeActionLinkEntry::GetNext();
}
ScChangeActionMove* GetMove()
{
return (ScChangeActionMove*)
ScChangeActionLinkEntry::GetAction();
}
public:
const ScChangeActionDelMoveEntry* GetNext() const
{
return (const ScChangeActionDelMoveEntry*)
ScChangeActionLinkEntry::GetNext();
}
const ScChangeActionMove* GetMove() const
{
return (const ScChangeActionMove*)
ScChangeActionLinkEntry::GetAction();
}
short GetCutOffFrom() const { return nCutOffFrom; }
short GetCutOffTo() const { return nCutOffTo; }
};
class ScChangeActionDel : public ScChangeAction
{
friend class ScChangeTrack;
friend void ScChangeAction::Accept();
ScChangeTrack* pTrack;
ScChangeActionCellListEntry* pFirstCell;
ScChangeActionIns* pCutOff; // cut insert
short nCutOff; // +: start -: end
ScChangeActionDelMoveEntry* pLinkMove;
SCsCOL nDx;
SCsROW nDy;
ScChangeActionDel( const ScRange& rRange, SCsCOL nDx, SCsROW nDy, ScChangeTrack* );
virtual ~ScChangeActionDel();
ScChangeActionIns* GetCutOffInsert() { return pCutOff; }
virtual void AddContent( ScChangeActionContent* );
virtual void DeleteCellEntries();
void UndoCutOffMoves();
void UndoCutOffInsert();
virtual void UpdateReference( const ScChangeTrack*,
UpdateRefMode, const ScBigRange&,
sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz );
virtual bool Reject(ScDocument* pDoc);
virtual const ScChangeTrack* GetChangeTrack() const { return pTrack; }
public:
ScChangeActionDel(
const sal_uLong nActionNumber, const ScChangeActionState eState,
const sal_uLong nRejectingNumber, const ScBigRange& aBigRange,
const rtl::OUString& aUser, const DateTime& aDateTime,
const rtl::OUString &sComment, const ScChangeActionType eType,
const SCsCOLROW nD, ScChangeTrack* pTrack); // only to use in the XML import
// which of nDx and nDy is set is dependend on the type
// 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;
SCsCOL GetDx() const;
SCsROW GetDy() const;
ScBigRange GetOverAllRange() const; // BigRange + (nDx, nDy)
const ScChangeActionCellListEntry* GetFirstCellEntry() const
{ return pFirstCell; }
const ScChangeActionDelMoveEntry* GetFirstMoveEntry() const
{ return pLinkMove; }
const ScChangeActionIns* GetCutOffInsert() const { return pCutOff; }
short GetCutOffCount() const { return nCutOff; }
virtual void GetDescription(
rtl::OUString& rStr, ScDocument* pDoc, bool bSplitRange = false, bool bWarning = true ) const;
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 : public ScChangeAction
{
friend class ScChangeTrack;
friend class ScChangeActionDel;
ScBigRange aFromRange;
ScChangeTrack* pTrack;
ScChangeActionCellListEntry* pFirstCell;
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 ),
pFirstCell( NULL ),
nStartLastCut(0),
nEndLastCut(0)
{}
virtual ~ScChangeActionMove();
virtual void AddContent( ScChangeActionContent* );
virtual void DeleteCellEntries();
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 );
virtual bool Reject(ScDocument* pDoc);
virtual const ScChangeTrack* GetChangeTrack() const { return pTrack; }
protected:
using ScChangeAction::GetRefString;
public:
ScChangeActionMove(const sal_uLong nActionNumber,
const ScChangeActionState eState,
const sal_uLong nRejectingNumber,
const ScBigRange& aToBigRange,
const rtl::OUString& aUser,
const DateTime& aDateTime,
const rtl::OUString &sComment,
const ScBigRange& aFromBigRange,
ScChangeTrack* pTrack); // only to use in the XML import
const ScChangeActionCellListEntry* GetFirstCellEntry() const
{ return pFirstCell; } // only to use in the XML export
const ScBigRange& GetFromRange() const { return aFromRange; }
SC_DLLPUBLIC void GetDelta( sal_Int32& nDx, sal_Int32& nDy, sal_Int32& nDz ) const;
virtual void GetDescription(
rtl::OUString& rStr, ScDocument* pDoc, bool bSplitRange = false,
bool bWarning = true ) const;
virtual void GetRefString(
rtl::OUString& rStr, ScDocument* pDoc, bool bFlag3D = false ) const;
};
// --- ScChangeActionContent ------------------------------------------------
enum ScChangeActionContentCellType
{
SC_CACCT_NONE = 0,
SC_CACCT_NORMAL,
SC_CACCT_MATORG,
SC_CACCT_MATREF
};
class ScChangeActionContent : public ScChangeAction
{
friend class ScChangeTrack;
rtl::OUString aOldValue;
rtl::OUString aNewValue;
ScBaseCell* pOldCell;
ScBaseCell* pNewCell;
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 ) != NULL )
pNextInSlot->ppPrevInSlot = &pNextInSlot;
*pp = this;
}
}
void RemoveFromSlot()
{
if ( ppPrevInSlot )
{
if ( ( *ppPrevInSlot = pNextInSlot ) != NULL )
pNextInSlot->ppPrevInSlot = ppPrevInSlot;
ppPrevInSlot = NULL; // not inserted
}
}
ScChangeActionContent* GetNextInSlot() { return pNextInSlot; }
void ClearTrack();
static void GetStringOfCell( rtl::OUString& rStr, const ScBaseCell* pCell,
const ScDocument* pDoc, const ScAddress& rPos );
static void GetStringOfCell( rtl::OUString& rStr, const ScBaseCell* pCell,
const ScDocument* pDoc, sal_uLong nFormat );
static void SetValue( rtl::OUString& rStr, ScBaseCell*& pCell, const ScAddress& rPos,
const ScBaseCell* pOrgCell, const ScDocument* pFromDoc,
ScDocument* pToDoc );
static void SetValue( rtl::OUString& rStr, ScBaseCell*& pCell, sal_uLong nFormat,
const ScBaseCell* pOrgCell, const ScDocument* pFromDoc,
ScDocument* pToDoc );
static void SetCell( rtl::OUString& rStr, ScBaseCell* pCell,
sal_uLong nFormat, const ScDocument* pDoc );
static bool NeedsNumberFormat( const ScBaseCell* );
void SetValueString( rtl::OUString& rValue, ScBaseCell*& pCell,
const rtl::OUString& rStr, ScDocument* pDoc );
void GetValueString( rtl::OUString& rStr, const rtl::OUString& rValue,
const ScBaseCell* pCell ) const;
void GetFormulaString( rtl::OUString& rStr, const ScFormulaCell* pCell ) const;
virtual void AddContent( ScChangeActionContent* ) {}
virtual void DeleteCellEntries() {}
virtual void UpdateReference( const ScChangeTrack*,
UpdateRefMode, const ScBigRange&,
sal_Int32 nDx, sal_Int32 nDy, sal_Int32 nDz );
virtual bool Reject(ScDocument* pDoc);
virtual const ScChangeTrack* GetChangeTrack() const { return 0; }
// pRejectActions!=NULL: reject actions get
// stacked, no SetNewValue, no Append
bool Select( ScDocument*, ScChangeTrack*,
bool bOldest, ::std::stack<ScChangeActionContent*>* pRejectActions );
void PutValueToDoc(
ScBaseCell* pCell, const rtl::OUString& rValue, ScDocument* pDoc,
SCsCOL nDx, SCsROW nDy ) const;
protected:
using ScChangeAction::GetRefString;
public:
DECL_FIXEDMEMPOOL_NEWDEL( ScChangeActionContent )
ScChangeActionContent( const ScRange& rRange )
: ScChangeAction( SC_CAT_CONTENT, rRange ),
pOldCell( NULL ),
pNewCell( NULL ),
pNextContent( NULL ),
pPrevContent( NULL ),
pNextInSlot( NULL ),
ppPrevInSlot( NULL )
{}
ScChangeActionContent(
const sal_uLong nActionNumber, const ScChangeActionState eState,
const sal_uLong nRejectingNumber, const ScBigRange& aBigRange,
const rtl::OUString& aUser, const DateTime& aDateTime,
const rtl::OUString &sComment, ScBaseCell* pOldCell,
ScDocument* pDoc, const rtl::OUString& sOldValue); // to use for XML Import
ScChangeActionContent(
const sal_uLong nActionNumber, ScBaseCell* pNewCell,
const ScBigRange& aBigRange, ScDocument* pDoc,
const rtl::OUString& sNewValue); // to use for XML Import of Generated Actions
virtual ~ScChangeActionContent();
ScChangeActionContent* GetNextContent() const { return pNextContent; }
ScChangeActionContent* GetPrevContent() const { return pPrevContent; }
ScChangeActionContent* GetTopContent() const;
bool IsTopContent() const { return pNextContent == NULL; }
virtual ScChangeActionLinkEntry* GetDeletedIn() const;
virtual ScChangeActionLinkEntry** GetDeletedInAddress();
void PutOldValueToDoc( ScDocument*,
SCsCOL nDx, SCsROW nDy ) const;
void PutNewValueToDoc( ScDocument*,
SCsCOL nDx, SCsROW nDy ) const;
void SetOldValue( const ScBaseCell*,
const ScDocument* pFromDoc,
ScDocument* pToDoc,
sal_uLong nFormat );
void SetOldValue( const ScBaseCell*,
const ScDocument* pFromDoc,
ScDocument* pToDoc );
void SetNewValue( const ScBaseCell*, ScDocument* );
// Used in import filter AppendContentOnTheFly,
// takes ownership of cells.
void SetOldNewCells( ScBaseCell* pOldCell,
sal_uLong nOldFormat, ScBaseCell* pNewCell,
sal_uLong nNewFormat, ScDocument* pDoc );
// Use this only in the XML import,
// takes ownership of cell.
void SetNewCell(
ScBaseCell* pCell, ScDocument* pDoc, const rtl::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 forumula cell
void SetOldValue( const rtl::OUString& rOld, ScDocument* pDoc );
void SetNewValue( const rtl::OUString& rNew, ScDocument* pDoc );
void GetOldString( rtl::OUString& rStr ) const;
void GetNewString( rtl::OUString& rStr ) const;
const ScBaseCell* GetOldCell() const { return pOldCell; }
const ScBaseCell* GetNewCell() const { return pNewCell; }
virtual void GetDescription(
rtl::OUString& rStr, ScDocument* pDoc, bool bSplitRange = false, bool bWarning = true ) const;
virtual void GetRefString(
rtl::OUString& rStr, ScDocument* pDoc, bool bFlag3D = false ) const;
static ScChangeActionContentCellType GetContentCellType( const ScBaseCell* );
// NewCell
bool IsMatrixOrigin() const;
// OldCell
bool IsOldMatrixReference() const;
};
// --- ScChangeActionReject -------------------------------------------------
class ScChangeActionReject : public ScChangeAction
{
friend class ScChangeTrack;
friend class ScChangeActionContent;
ScChangeActionReject( sal_uLong nReject ) :
ScChangeAction( SC_CAT_REJECT, ScRange() )
{
SetRejectAction( nReject );
SetState( SC_CAS_ACCEPTED );
}
virtual void AddContent( ScChangeActionContent* ) {}
virtual void DeleteCellEntries() {}
virtual bool Reject(ScDocument* pDoc);
virtual const ScChangeTrack* GetChangeTrack() const { return 0; }
public:
ScChangeActionReject(const sal_uLong nActionNumber,
const ScChangeActionState eState,
const sal_uLong nRejectingNumber,
const ScBigRange& aBigRange,
const rtl::OUString& aUser,
const DateTime& aDateTime,
const rtl::OUString &sComment); // only to use in the XML import
};
// --- ScChangeTrack --------------------------------------------------------
enum ScChangeTrackMsgType
{
SC_CTM_NONE,
SC_CTM_APPEND, // Actions appended
SC_CTM_REMOVE, // Actions removed
SC_CTM_CHANGE, // Actions changed
SC_CTM_PARENT // became a parent (and wasn't before)
};
struct ScChangeTrackMsgInfo
{
DECL_FIXEDMEMPOOL_NEWDEL( ScChangeTrackMsgInfo )
ScChangeTrackMsgType eMsgType;
sal_uLong nStartAction;
sal_uLong nEndAction;
};
// MsgQueue for notification via ModifiedLink
typedef std::deque<ScChangeTrackMsgInfo*> ScChangeTrackMsgQueue;
typedef std::stack<ScChangeTrackMsgInfo*> ScChangeTrackMsgStack;
typedef std::map<sal_uLong, ScChangeAction*> 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 seperated from "normal" actions.
#define SC_CHGTRACK_GENERATED_START ((sal_uInt32) 0xfffffff0)
class ScChangeTrack : public utl::ConfigurationListener
{
friend void ScChangeAction::RejectRestoreContents( ScChangeTrack*, SCsCOL, SCsROW );
friend bool ScChangeActionDel::Reject( ScDocument* pDoc );
friend void ScChangeActionDel::DeleteCellEntries();
friend void ScChangeActionMove::DeleteCellEntries();
friend bool ScChangeActionMove::Reject( ScDocument* pDoc );
static const SCROW nContentRowsPerSlot;
static const SCSIZE nContentSlots;
com::sun::star::uno::Sequence< sal_Int8 > aProtectPass;
ScChangeActionMap aMap;
ScChangeActionMap aGeneratedMap;
ScChangeActionMap aPasteCutMap;
ScChangeTrackMsgQueue aMsgQueue;
ScChangeTrackMsgStack aMsgStackTmp;
ScChangeTrackMsgStack aMsgStackFinal;
std::set<rtl::OUString> maUserCollection;
rtl::OUString maUser;
Link aModifiedLink;
ScRange aInDeleteRange;
DateTime aFixDateTime;
ScChangeAction* pFirst;
ScChangeAction* pLast;
ScChangeActionContent* pFirstGeneratedDelContent;
ScChangeActionContent** ppContentSlots;
ScChangeActionMove* pLastCutMove;
ScChangeActionLinkEntry* pLinkInsertCol;
ScChangeActionLinkEntry* pLinkInsertRow;
ScChangeActionLinkEntry* pLinkInsertTab;
ScChangeActionLinkEntry* pLinkMove;
ScChangeTrackMsgInfo* pBlockModifyMsg;
ScDocument* pDoc;
sal_uLong nActionMax;
sal_uLong nGeneratedMin;
sal_uLong nMarkLastSaved;
sal_uLong nStartLastCut;
sal_uLong nEndLastCut;
sal_uLong nLastMerge;
ScChangeTrackMergeState eMergeState;
sal_uInt16 nLoadedFileFormatVersion;
bool bLoadSave:1;
bool bInDelete:1;
bool bInDeleteUndo:1;
bool bInDeleteTop:1;
bool bInPasteCut:1;
bool bUseFixDateTime:1;
bool bTime100thSeconds:1;
// not implemented, prevent usage
ScChangeTrack( const ScChangeTrack& );
ScChangeTrack& operator=( const ScChangeTrack& );
#ifdef SC_CHGTRACK_CXX
static SCROW InitContentRowsPerSlot();
// true if one is MM_FORMULA and the other is
// not, or if both are and range differs
static bool IsMatrixFormulaRangeDifferent(
const ScBaseCell* pOldCell, const ScBaseCell* pNewCell );
void Init();
void DtorClear();
void SetLoadSave( bool bVal ) { bLoadSave = bVal; }
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, SCsTAB nDz,
sal_uLong nRejectingInsert );
void AppendOneDeleteRange( const ScRange& rOrgRange,
ScDocument* pRefDoc,
SCsCOL nDx, SCsROW nDy, SCsTAB nDz,
sal_uLong nRejectingInsert );
void LookUpContents( const ScRange& rOrgRange,
ScDocument* pRefDoc,
SCsCOL nDx, SCsROW nDy, SCsTAB nDz );
void Remove( ScChangeAction* );
void MasterLinks( ScChangeAction* );
// Content on top an Position
ScChangeActionContent* SearchContentAt( const ScBigAddress&,
ScChangeAction* pButNotThis ) const;
void DeleteGeneratedDelContent(
ScChangeActionContent* );
ScChangeActionContent* GenerateDelContent( const ScAddress&,
const ScBaseCell*,
const ScDocument* pFromDoc );
void DeleteCellEntries(
ScChangeActionCellListEntry*&,
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 );
#endif // SC_CHGTRACK_CXX
void ClearMsgQueue();
virtual void ConfigurationChanged( utl::ConfigurationBroadcaster*, sal_uInt32 );
public:
static SCSIZE ComputeContentSlot( sal_Int32 nRow )
{
if ( nRow < 0 || nRow > MAXROW )
return nContentSlots - 1;
return static_cast< SCSIZE >( nRow / nContentRowsPerSlot );
}
SC_DLLPUBLIC ScChangeTrack( ScDocument* );
ScChangeTrack(ScDocument* pDocP, const std::set<rtl::OUString>& aTempUserCollection); // only to use in the XML import
SC_DLLPUBLIC virtual ~ScChangeTrack();
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
{ return nAction >= nGeneratedMin; }
ScChangeAction* GetAction( sal_uLong nAction ) const
{
ScChangeActionMap::const_iterator it = aMap.find( nAction );
if( it != aMap.end() )
return it->second;
else
return NULL;
}
ScChangeAction* GetGenerated( sal_uLong nGenerated ) const
{
ScChangeActionMap::const_iterator it = aGeneratedMap.find( nGenerated );
if( it != aGeneratedMap.end() )
return it->second;
else
return NULL;
}
ScChangeAction* GetActionOrGenerated( sal_uLong nAction ) const
{
return IsGenerated( nAction ) ?
GetGenerated( nAction ) :
GetAction( nAction );
}
sal_uLong GetLastSavedActionNumber() const
{ return nMarkLastSaved; }
void SetLastSavedActionNumber(sal_uLong nNew)
{ nMarkLastSaved = nNew; }
ScChangeAction* GetLastSaved() const
{
ScChangeActionMap::const_iterator it = aMap.find( nMarkLastSaved );
if( it != aMap.end() )
return it->second;
else
return NULL;
}
ScChangeActionContent** GetContentSlots() const { return ppContentSlots; }
bool IsLoadSave() const { return bLoadSave; }
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 rtl::OUString& rUser );
SC_DLLPUBLIC const rtl::OUString& GetUser() const;
SC_DLLPUBLIC const std::set<rtl::OUString>& GetUserCollection() const;
ScDocument* GetDocument() const { return pDoc; }
// 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,
SCsTAB 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,
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 ScBaseCell* pOldCell,
sal_uLong nOldFormat, ScDocument* pRefDoc = NULL );
// after new value was set in the document,
// old value from pOldCell, format from Doc
void AppendContent( const ScAddress& rPos,
const ScBaseCell* pOldCell );
// after new values were set in the document,
// old values from RefDoc/UndoDoc.
// All contents with a cell in RefDoc
void AppendContentsIfInRefDoc( ScDocument* pRefDoc,
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,
ScBaseCell* pOldCell,
ScBaseCell* pNewCell,
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& );
// 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;
if ( pLastCutMove )
{
delete pLastCutMove;
pLastCutMove = NULL;
}
}
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( ScChangeAction* pFirstMerge, bool bShared = false );
void MergeOwn( ScChangeAction* pAct, sal_uLong nFirstMerge, bool bShared = false );
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(); }
const Link& GetModifiedLink() const { return aModifiedLink; }
ScChangeTrackMsgQueue& GetMsgQueue() { return aMsgQueue; }
void NotifyModified( ScChangeTrackMsgType eMsgType,
sal_uLong nStartAction, sal_uLong nEndAction );
sal_uInt16 GetLoadedFileFormatVersion() const
{ return nLoadedFileFormatVersion; }
sal_uLong AddLoadedGenerated(
ScBaseCell* pOldCell, const ScBigRange& aBigRange, const rtl::OUString& sNewValue ); // only to use in the XML import
void AppendLoaded( ScChangeAction* 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 com::sun::star::uno::Sequence< sal_Int8 >& rPass )
{ aProtectPass = rPass; }
com::sun::star::uno::Sequence< sal_Int8 > GetProtection() const
{ return aProtectPass; }
bool IsProtected() const { return aProtectPass.getLength() != 0; }
// If time stamps of actions of this
// ChangeTrack and a second one are to be
// compared including 100th seconds.
void SetTime100thSeconds( bool bVal ) { bTime100thSeconds = bVal; }
bool IsTime100thSeconds() const { return bTime100thSeconds; }
void AppendCloned( ScChangeAction* pAppend );
SC_DLLPUBLIC ScChangeTrack* Clone( ScDocument* pDocument ) const;
void MergeActionState( ScChangeAction* pAct, const ScChangeAction* pOtherAct );
};
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */