diff options
Diffstat (limited to 'hammer/history.h')
| -rw-r--r-- | hammer/history.h | 211 |
1 files changed, 211 insertions, 0 deletions
diff --git a/hammer/history.h b/hammer/history.h new file mode 100644 index 0000000..c0d1912 --- /dev/null +++ b/hammer/history.h @@ -0,0 +1,211 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Defines the interface to the Undo system. +// +//=============================================================================// + +#ifndef HISTORY_H +#define HISTORY_H +#ifdef _WIN32 +#pragma once +#endif + +#include "MapClass.h" // For CMapObjectList + +class CMapClass; +class CMapDoc; +class CHistory; + +// +// Holds undo information for a single object, due to a single operation. Held by a CHistoryTrack. +// +class CTrackEntry +{ + public: + + enum TrackType_t + { + ttNone = -1, + ttCopy, + ttDelete, + ttCreate, + }; + + CTrackEntry(); + CTrackEntry(TrackType_t eType, ...); + ~CTrackEntry(); + + void Undo(CHistory *Opposite); + void DispatchUndoNotify(void); + + void SetKeptChildren(bool bSet); + + inline int GetSize(void) { return(m_nDataSize); } + + void OnRemoveVisGroup(CVisGroup *pGroup); + + bool m_bAutoDestruct; + + protected: + + size_t m_nDataSize; + + TrackType_t m_eType; // What type of event this entry can undo. + + // + // Based on the event type, one of these structs will be filled out: + // + union + { + struct + { + CMapClass *pCurrent; // Pointer to the object as it currently exists in the world. + CMapClass *pKeptObject; // Pointer to a copy of the object at the time it was kept. + } m_Copy; + + struct + { + CMapClass *pDeleted; // Pointer to the object that was deleted from the world. + CMapClass *pKeptParent; // Pointer to the object's parent at the time of deletion. + } m_Delete; + + struct + { + CMapClass *pCreated; // Pointer to the object that was created and added to the world. + } m_Create; + }; + + bool m_bKeptChildren; + bool m_bUndone; // Set to true after this entry is undone. +}; + + +// +// Tracks all the objects changed by a single operation, such as "Nudge Objects" or "Delete". Each +// track contains one track entry per object affected by the operation. +// +class CHistoryTrack +{ +public: + CHistoryTrack(CHistory *pParent, const CMapObjectList *pSelection); + ~CHistoryTrack(); + + void Keep(CMapClass *pObject, bool bKeepChildren); + void KeepForDestruction(CMapClass *pObject); + void KeepNew(CMapClass *pObject); + + void Undo(); + + void SetName(LPCTSTR pszName) { if(pszName) strcpy(szName, pszName); } + + void OnRemoveVisGroup(CVisGroup *pGroup); + +private: + + BOOL CheckObjectFlag(CMapClass *pObject, int iFlag); + + CUtlVector<CTrackEntry> Data; + + CHistory *Parent; + DWORD dwID; // id of this tracker.. + char szName[128]; + CMapObjectList Selected; + bool m_bAutoDestruct; + size_t uDataSize; // approx + +friend class CHistory; +}; + + +class CHistory +{ +public: + CHistory(); + ~CHistory(); + + static void SetHistory(CHistory *pHistory); + + void SetOpposite(BOOL bUndo, CHistory*); + inline void SetDocument(CMapDoc *pDoc); + inline CMapDoc *GetDocument(void); + + // mark undo position: + void MarkUndoPosition(const CMapObjectList* pSelection = NULL, LPCTSTR pszName = NULL, BOOL = FALSE); + + // + // Keep this object so we can undo changes to it: + // + void Keep(CMapClass *pObject); + void KeepNoChildren(CMapClass *pObject); + void Keep(const CMapObjectList *pList); + + // + // Store this pointer for destruction if it cycles off the undo stack: + // + void KeepForDestruction(CMapClass *pObject); + + // + // Store this object for destruction if 'undone': + // + void KeepNew(CMapClass *pObject, bool bKeepChildren = true); + void KeepNew(const CMapObjectList *pList, bool bKeepChildren = true); + + void Undo(CMapObjectList *pNewSelection); + + BOOL IsUndoable(); // anything to undo? + + void OnRemoveVisGroup(CVisGroup *pVisGroup); + + // returns current name + LPCTSTR GetCurTrackName() { return CurTrack ? CurTrack->szName : ""; } + + // total override: + void SetActive(BOOL bActive); + BOOL IsActive() { return m_bActive; } + + // temporary shutdown/resume: + inline void Pause() { bPaused = TRUE; } + inline void Resume() { if(bPaused == TRUE) bPaused = FALSE; } + inline BOOL IsPaused() { return bPaused || !IsActive(); } + +private: + + CHistoryTrack *CurTrack; + CUtlVector<CHistoryTrack*> Tracks; + + CMapDoc *m_pDoc; // Associated document. + + // opposite tracker: + CHistory *Opposite; + BOOL bUndo; // is this the undo tracker? + + BOOL bPaused; + size_t uDataSize; + BOOL m_bActive; // veto control + +friend class CHistoryTrack; +}; + + +//----------------------------------------------------------------------------- +// Purpose: Sets the document that this undo history belongs to. +//----------------------------------------------------------------------------- +void CHistory::SetDocument(CMapDoc *pDoc) +{ + m_pDoc = pDoc; +} + + +//----------------------------------------------------------------------------- +// Purpose: Returns the document that this undo history belongs to. +//----------------------------------------------------------------------------- +CMapDoc *CHistory::GetDocument(void) +{ + return(m_pDoc); +} + + +CHistory *GetHistory(); + + +#endif // HISTORY_H |