CommandStack.hpp

#pragma once
#include <score/tools/Debug.hpp>
#include <score/command/Command.hpp>
#include <score/command/Validity/ValidityChecker.hpp>
 
#include <QObject>
#include <QStack>
#include <QString>
 
#include <verdigris>
 
namespace score
{
class Document;
 
class SCORE_LIB_BASE_EXPORT CommandStack final : public QObject
{
  W_OBJECT(CommandStack)
 
  friend class CommandBackupFile;
  friend struct CommandStackBackup;
 
public:
  explicit CommandStack(const score::Document& ctx, QObject* parent = nullptr);
  ~CommandStack();
 
  void enableActions();
 
  void disableActions();
 
  bool canUndo() const;
 
  bool canRedo() const;
 
  QString undoText() const;
 
  QString redoText() const;
 
  int size() const;
 
  const score::Command* command(int index) const;
  int currentIndex() const;
 
  void markCurrentIndexAsSaved();
 
  bool isAtSavedIndex() const;
 
  QStack<score::Command*>& undoable() { return m_undoable; }
  QStack<score::Command*>& redoable() { return m_redoable; }
  const QStack<score::Command*>& undoable() const { return m_undoable; }
  const QStack<score::Command*>& redoable() const { return m_redoable; }
 
  const score::DocumentContext& context() const { return m_ctx; }
 
  void localCommand(score::Command* cmd)
      E_SIGNAL(SCORE_LIB_BASE_EXPORT, localCommand, cmd)
 
  
  void localUndo() E_SIGNAL(SCORE_LIB_BASE_EXPORT, localUndo)
 
  void localRedo() E_SIGNAL(SCORE_LIB_BASE_EXPORT, localRedo)
 
  void localIndexChanged(int v) E_SIGNAL(SCORE_LIB_BASE_EXPORT, localIndexChanged, v)
 
  void canUndoChanged(bool b) E_SIGNAL(SCORE_LIB_BASE_EXPORT, canUndoChanged, b)
  void canRedoChanged(bool b) E_SIGNAL(SCORE_LIB_BASE_EXPORT, canRedoChanged, b)
 
  void undoTextChanged(QString b) E_SIGNAL(SCORE_LIB_BASE_EXPORT, undoTextChanged, b)
  void redoTextChanged(QString b) E_SIGNAL(SCORE_LIB_BASE_EXPORT, redoTextChanged, b)
 
  void indexChanged(int b) E_SIGNAL(SCORE_LIB_BASE_EXPORT, indexChanged, b)
 
  void stackChanged() E_SIGNAL(SCORE_LIB_BASE_EXPORT, stackChanged)
 
  void saveIndexChanged(bool b) E_SIGNAL(SCORE_LIB_BASE_EXPORT, saveIndexChanged, b)
 
  // These signals are low-level and are sent on each operation that
  // affects the stacks
  void sig_undo() E_SIGNAL(SCORE_LIB_BASE_EXPORT, sig_undo)
  void sig_redo() E_SIGNAL(SCORE_LIB_BASE_EXPORT, sig_redo)
  void sig_push() E_SIGNAL(SCORE_LIB_BASE_EXPORT, sig_push)
  void sig_indexChanged() E_SIGNAL(SCORE_LIB_BASE_EXPORT, sig_indexChanged)
 
  void setIndex(int index);
  W_INVOKABLE(setIndex)
  void setIndexQuiet(int index);
  W_INVOKABLE(setIndexQuiet)
 
  // These ones do not send signals
  void undoQuiet();
  W_INVOKABLE(undoQuiet)
  void redoQuiet();
  W_INVOKABLE(redoQuiet)
 
  void redoAndPush(score::Command* cmd);
  W_INVOKABLE(redoAndPush)
 
  void push(score::Command* cmd);
  W_INVOKABLE(push)
 
  void redoAndPushQuiet(score::Command* cmd);
  W_INVOKABLE(redoAndPushQuiet)
  void pushQuiet(score::Command* cmd);
  W_INVOKABLE(pushQuiet)
 
  void undo()
  {
    SCORE_ASSERT(canUndo());
    undoQuiet();
    localUndo();
  }
  W_INVOKABLE(undo)
 
  void redo()
  {
    SCORE_ASSERT(canRedo());
    redoQuiet();
    localRedo();
  }
  W_INVOKABLE(redo)
 
public:
  template <typename Callable>
  void updateStack(Callable&& c)
  {
    bool pre_canUndo{canUndo()}, pre_canRedo{canRedo()};
 
    m_checker();
    c();
    m_checker();
 
    if(pre_canUndo != canUndo())
      canUndoChanged(canUndo());
 
    if(pre_canRedo != canRedo())
      canRedoChanged(canRedo());
 
    if(canUndo())
      undoTextChanged(m_undoable.top()->description());
    else
      undoTextChanged("");
 
    if(canRedo())
      redoTextChanged(m_redoable.top()->description());
    else
      redoTextChanged("");
 
    indexChanged(m_undoable.size() - 1);
    stackChanged();
  }
 
  void setSavedIndex(int index);
 
  void validateDocument() const;
 
private:
  QStack<score::Command*> m_undoable;
  QStack<score::Command*> m_redoable;
 
  int m_savedIndex{};
 
  DocumentValidator m_checker;
  const score::DocumentContext& m_ctx;
};
}
W_REGISTER_ARGTYPE(score::Command*)