CommandHistory.h

#pragma once
 
#include <Foundation/Types/RefCounted.h>
#include <Foundation/Types/SharedPtr.h>
#include <ToolsFoundation/Command/Command.h>
#include <ToolsFoundation/ToolsFoundationDLL.h>
 
class plCommandHistory;
 
class PL_TOOLSFOUNDATION_DLL plCommandTransaction : public plCommand
{
  PL_ADD_DYNAMIC_REFLECTION(plCommandTransaction, plCommand);
 
public:
  plCommandTransaction();
  ~plCommandTransaction();
 
  plString m_sDisplayString;
 
private:
  virtual plStatus DoInternal(bool bRedo) override;
  virtual plStatus UndoInternal(bool bFireEvents) override;
  virtual void CleanupInternal(CommandState state) override;
  plStatus AddCommandTransaction(plCommand* command);
 
private:
  friend class plCommandHistory;
};
 
struct plCommandHistoryEvent
{
  enum class Type
  {
    UndoStarted,
    UndoEnded,
    RedoStarted,
    RedoEnded,
    TransactionStarted,        
    BeforeTransactionEnded,    
    BeforeTransactionCanceled, 
    TransactionEnded,          
    TransactionCanceled,       
    HistoryChanged,
  };
 
  Type m_Type;
  const plDocument* m_pDocument;
};
 
class PL_TOOLSFOUNDATION_DLL plCommandHistory
{
public:
  plEvent<const plCommandHistoryEvent&, plMutex> m_Events;
 
  // \brief Storage for the command history so it can be swapped when using multiple sub documents.
  class Storage : public plRefCounted
  {
  public:
    plHybridArray<plCommandTransaction*, 4> m_TransactionStack;
    plHybridArray<plCommand*, 4> m_ActiveCommandStack;
    plDeque<plCommandTransaction*> m_UndoHistory;
    plDeque<plCommandTransaction*> m_RedoHistory;
    plDocument* m_pDocument = nullptr;
    plEvent<const plCommandHistoryEvent&, plMutex> m_Events;
  };
 
public:
  plCommandHistory(plDocument* pDocument);
  ~plCommandHistory();
 
  const plDocument* GetDocument() const { return m_pHistoryStorage->m_pDocument; }
 
  plStatus Undo(plUInt32 uiNumEntries = 1);
  plStatus Redo(plUInt32 uiNumEntries = 1);
 
  bool CanUndo() const;
  bool CanRedo() const;
 
  plStringView GetUndoDisplayString() const;
  plStringView GetRedoDisplayString() const;
 
  void StartTransaction(const plFormatString& displayString);
  void CancelTransaction() { EndTransaction(true); }
  void FinishTransaction() { EndTransaction(false); }
 
  bool IsInTransaction() const { return !m_pHistoryStorage->m_TransactionStack.IsEmpty(); }
  bool IsInUndoRedo() const { return m_bIsInUndoRedo; }
 
  void BeginTemporaryCommands(plStringView sDisplayString, bool bFireEventsWhenUndoingTempCommands = false);
  void CancelTemporaryCommands();
  void FinishTemporaryCommands();
 
  bool InTemporaryTransaction() const;
  void SuspendTemporaryTransaction();
  void ResumeTemporaryTransaction();
 
  plStatus AddCommand(plCommand& ref_command);
 
  void ClearUndoHistory();
  void ClearRedoHistory();
 
  void MergeLastTwoTransactions();
 
  plUInt32 GetUndoStackSize() const;
  plUInt32 GetRedoStackSize() const;
  const plCommandTransaction* GetUndoStackEntry(plUInt32 uiIndex) const;
  const plCommandTransaction* GetRedoStackEntry(plUInt32 uiIndex) const;
 
  plSharedPtr<plCommandHistory::Storage> SwapStorage(plSharedPtr<plCommandHistory::Storage> pNewStorage);
  plSharedPtr<plCommandHistory::Storage> GetStorage() { return m_pHistoryStorage; }
 
private:
  friend class plCommand;
 
  plStatus UndoInternal();
  plStatus RedoInternal();
 
  void EndTransaction(bool bCancel);
  void EndTemporaryCommands(bool bCancel);
 
  plSharedPtr<plCommandHistory::Storage> m_pHistoryStorage;
 
  plEvent<const plCommandHistoryEvent&, plMutex>::Unsubscriber m_EventsUnsubscriber;
 
  bool m_bFireEventsWhenUndoingTempCommands = false;
  bool m_bTemporaryMode = false;
  plInt32 m_iTemporaryDepth = -1;
  plInt32 m_iPreSuspendTemporaryDepth = -1;
  bool m_bIsInUndoRedo = false;
};