OngoingCommandDispatcher.hpp

#pragma once
#include <score/command/Dispatchers/ICommandDispatcher.hpp>
#include <score/command/Dispatchers/SendStrategy.hpp>
#include <score/plugins/StringFactoryKey.hpp>
#include <score/tools/Debug.hpp>
#include <score/tools/SafeCast.hpp>
 
#include <QObject>
 
#include <memory>
 
class SCORE_LIB_BASE_EXPORT OngoingCommandDispatcher final : public ICommandDispatcher
{
public:
  explicit OngoingCommandDispatcher(const score::CommandStackFacade& stack);
  ~OngoingCommandDispatcher();
 
  // In Document.cpp
  void watch(const QObject* obj);
  void unwatch(const QObject* obj);
 
  bool watching(const QObject* obj) const noexcept { return m_watched == obj; }
 
  template <typename TheCommand, typename Watched, typename... Args>
  void submit(Watched&& watched, Args&&... args)
  {
    using decayed = std::remove_cvref_t<Watched>;
    const QObject* target{};
    if constexpr(std::is_pointer_v<decayed>)
    {
      static_assert(std::is_base_of_v<QObject, std::remove_cvref_t<decltype(*watched)>>);
      target = watched;
    }
    else
    {
      static_assert(std::is_base_of_v<QObject, decayed>);
      target = &watched;
    }
 
    // An interaction that never got its end -- a drag whose mouse grab the
    // scene took away without delivering the release, a widget hidden
    // mid-edit -- leaves its command sitting here. update() only refreshes a
    // command's parameters and not what it points at, so carrying that one
    // over would send this interaction's edits to the *previous* object: the
    // widget under the mouse would move while the value went somewhere else.
    // The stale command has already been redone, so close it properly.
    if(m_cmd && (m_watched != target || m_cmd->key() != TheCommand::static_key()))
    {
      // A different command type means the two interactions are unrelated, so
      // whoever owned the first one never finished it. That used to throw;
      // closing it is friendlier, but it is still worth saying out loud.
      if(m_cmd->key() != TheCommand::static_key())
      {
        qDebug() << "OngoingCommandDispatcher: closing unfinished"
                 << m_cmd->key().toString().c_str() << "to start"
                 << TheCommand::static_key().toString().c_str();
      }
      commit();
    }
 
    watch(target);
 
    if(!m_cmd)
    {
      stack().disableActions();
      m_cmd = std::make_unique<TheCommand>(watched, std::forward<Args>(args)...);
    }
    else
    {
      safe_cast<TheCommand*>(m_cmd.get())->update(watched, std::forward<Args>(args)...);
    }
    redo();
  }
 
  void commit();
 
  void rollback();
  void rollback_without_undo();
 
private:
  void redo();
 
  std::unique_ptr<score::Command> m_cmd;
  const QObject* m_watched{};
};