Action.hpp

Go to the documentation of this file.

#pragma once
#include <score/document/DocumentContext.hpp>
#include <score/plugins/StringFactoryKey.hpp>
 
#include <QAction>
#include <QPointer>
#include <QString>
 
#include <memory>
 
class IdentifiedObjectAbstract;
namespace score
{
struct DocumentContext;
class ActionGroup;
class ActionManager;
using ActionGroupKey = StringKey<ActionGroup>;
 
class SCORE_LIB_BASE_EXPORT ActionGroup
{
public:
  ActionGroup(QString prettyName, ActionGroupKey key);
 
  QString prettyName() const;
 
  ActionGroupKey key() const;
 
private:
  QString m_name;
  ActionGroupKey m_key;
};
class Action;
using ActionKey = StringKey<Action>;
 
class SCORE_LIB_BASE_EXPORT Action
{
public:
  Action(
      QAction* act, QString text, ActionKey key, ActionGroupKey k,
      const QKeySequence& defaultShortcut);
  Action(
      QAction* act, QString text, ActionKey key, ActionGroupKey k,
      const QKeySequence& defaultShortcut, const QKeySequence& defaultShortcut2);
 
  Action(
      QAction* act, QString text, const char* key, const char* group_key,
      const QKeySequence& defaultShortcut);
 
  ActionKey key() const;
 
  QAction* action() const;
 
  QKeySequence shortcut();
  void setShortcut(const QKeySequence& shortcut);
 
  QKeySequence defaultShortcut();
 
private:
  void updateTexts();
 
  QPointer<QAction> m_impl{};
  QString m_text;
  ActionKey m_key;
  ActionGroupKey m_groupKey;
  QKeySequence m_default;
  QKeySequence m_current;
};
 
template <typename Action_T>
struct MetaAction
{
};
 
struct ActionContainer
{
private:
  inline bool canAddAction(const ActionKey& other) const noexcept
  {
    for(auto& act : container)
      if(act.key() == other)
        return false;
    return true;
  }
 
public:
  std::vector<Action> container;
 
  template <typename Action_T>
  void add(QAction* ptr)
  {
    SCORE_ASSERT(canAddAction(MetaAction<Action_T>::key()));
    container.emplace_back(MetaAction<Action_T>::make(ptr));
  }
};
 
struct SCORE_LIB_BASE_EXPORT ActionCondition
{
  ActionCondition(StringKey<ActionCondition> k);
 
  virtual ~ActionCondition();
 
  virtual void action(ActionManager& mgr, MaybeDocument);
 
  void setEnabled(score::ActionManager& mgr, bool b);
 
  template <typename Action_T>
  void add()
  {
    SCORE_ASSERT(canAddAction(MetaAction<Action_T>::key()));
    m_actions.emplace_back(MetaAction<Action_T>::key());
  }
 
  StringKey<ActionCondition> key() const;
 
private:
  inline bool canAddAction(const ActionKey& other) const noexcept
  {
    for(const auto& act : m_actions)
      if(act == other)
        return false;
    return true;
  }
  StringKey<ActionCondition> m_key;
  std::vector<ActionKey> m_actions;
};
 
struct SCORE_LIB_BASE_EXPORT DocumentActionCondition : public ActionCondition
{
  using ActionCondition::ActionCondition;
  ~DocumentActionCondition();
};
 
struct SCORE_LIB_BASE_EXPORT EnableActionIfDocument final
    : public DocumentActionCondition
{
  EnableActionIfDocument()
      : DocumentActionCondition{static_key()}
  {
  }
 
  ~EnableActionIfDocument();
 
  static StringKey<ActionCondition> static_key()
  {
    return StringKey<ActionCondition>{"EnableActionIfDocument"};
  }
 
  void action(ActionManager& mgr, MaybeDocument doc) override;
};
 
struct SCORE_LIB_BASE_EXPORT FocusActionCondition : public ActionCondition
{
  using ActionCondition::ActionCondition;
  ~FocusActionCondition();
};
 
struct SCORE_LIB_BASE_EXPORT SelectionActionCondition : public ActionCondition
{
  using ActionCondition::ActionCondition;
  ~SelectionActionCondition();
};
 
struct SCORE_LIB_BASE_EXPORT CustomActionCondition
    : public QObject
    , public ActionCondition
{
  W_OBJECT(CustomActionCondition)
 
public:
  using ActionCondition::ActionCondition;
  ~CustomActionCondition();
 
  void changed(bool b) E_SIGNAL(SCORE_LIB_BASE_EXPORT, changed, b)
};
 
using ActionConditionKey = StringKey<score::ActionCondition>;
 
template <typename T>
class EnableWhenSelectionContains;
template <typename T>
class EnableWhenFocusedObjectIs;
template <typename T>
class EnableWhenDocumentIs;
 
#define SCORE_DECLARE_SELECTED_OBJECT_CONDITION(Type)                                 \
  namespace score                                                                     \
  {                                                                                   \
  template <>                                                                         \
  class EnableWhenSelectionContains<Type> final                                       \
      : public score::SelectionActionCondition                                        \
  {                                                                                   \
  public:                                                                             \
    EnableWhenSelectionContains()                                                     \
        : score::SelectionActionCondition{static_key()}                               \
    {                                                                                 \
    }                                                                                 \
                                                                                      \
    static score::ActionConditionKey static_key()                                     \
    {                                                                                 \
      return score::ActionConditionKey{"SelectedObjectIs" #Type};                     \
    }                                                                                 \
                                                                                      \
  private:                                                                            \
    void action(score::ActionManager& mgr, score::MaybeDocument doc) override         \
    {                                                                                 \
      if(!doc)                                                                        \
      {                                                                               \
        setEnabled(mgr, false);                                                       \
        return;                                                                       \
      }                                                                               \
                                                                                      \
      const auto& sel = doc->selectionStack.currentSelection();                       \
      auto res = ossia::any_of(                                                       \
          sel, [](auto obj) { return bool(dynamic_cast<const Type*>(obj.data())); }); \
                                                                                      \
      setEnabled(mgr, res);                                                           \
    }                                                                                 \
  };                                                                                  \
  }
 
#define SCORE_DECLARE_FOCUSED_OBJECT_CONDITION(Type)                               \
  namespace score                                                                  \
  {                                                                                \
  template <>                                                                      \
  class EnableWhenFocusedObjectIs<Type> final : public score::FocusActionCondition \
  {                                                                                \
  public:                                                                          \
    static score::ActionConditionKey static_key()                                  \
    {                                                                              \
      return score::ActionConditionKey{"FocusedObjectIs" #Type};                   \
    }                                                                              \
                                                                                   \
    EnableWhenFocusedObjectIs()                                                    \
        : score::FocusActionCondition{static_key()}                                \
    {                                                                              \
    }                                                                              \
                                                                                   \
  private:                                                                         \
    void action(score::ActionManager& mgr, score::MaybeDocument doc) override      \
    {                                                                              \
      if(!doc)                                                                     \
      {                                                                            \
        setEnabled(mgr, false);                                                    \
        return;                                                                    \
      }                                                                            \
                                                                                   \
      auto obj = doc->focus.get();                                                 \
      if(!obj)                                                                     \
      {                                                                            \
        setEnabled(mgr, false);                                                    \
        return;                                                                    \
      }                                                                            \
                                                                                   \
      if(dynamic_cast<const Type*>(obj))                                           \
      {                                                                            \
        setEnabled(mgr, true);                                                     \
      }                                                                            \
    }                                                                              \
  };                                                                               \
  }
 
#define SCORE_DECLARE_DOCUMENT_CONDITION(Type)                                   \
  namespace score                                                                \
  {                                                                              \
  template <>                                                                    \
  class EnableWhenDocumentIs<Type> final : public score::DocumentActionCondition \
  {                                                                              \
  public:                                                                        \
    static score::ActionConditionKey static_key()                                \
    {                                                                            \
      return score::ActionConditionKey{"DocumentIs" #Type};                      \
    }                                                                            \
    EnableWhenDocumentIs()                                                       \
        : score::DocumentActionCondition{static_key()}                           \
    {                                                                            \
    }                                                                            \
                                                                                 \
  private:                                                                       \
    void action(score::ActionManager& mgr, score::MaybeDocument doc) override    \
    {                                                                            \
      if(!doc)                                                                   \
      {                                                                          \
        setEnabled(mgr, false);                                                  \
        return;                                                                  \
      }                                                                          \
      auto model = score::IDocument::try_get<Type>(doc->document);               \
      setEnabled(mgr, bool(model));                                              \
    }                                                                            \
  };                                                                             \
  }
}
 
#define SCORE_DECLARE_ACTION(ActionName, Text, Group, Shortcut)                    \
  namespace Actions                                                                \
  {                                                                                \
  struct ActionName;                                                               \
  }                                                                                \
  namespace score                                                                  \
  {                                                                                \
  template <>                                                                      \
  struct MetaAction<Actions::ActionName>                                           \
  {                                                                                \
    static score::Action make(QAction* ptr)                                        \
    {                                                                              \
      return score::Action{                                                        \
          ptr, QObject::tr(Text), key(), score::ActionGroupKey{#Group}, Shortcut}; \
    }                                                                              \
                                                                                   \
    static score::ActionKey key()                                                  \
    {                                                                              \
      return score::ActionKey{#ActionName};                                        \
    }                                                                              \
  };                                                                               \
  }
 
#define SCORE_DECLARE_ACTION_2S(ActionName, Text, Group, Shortcut1, Shortcut2) \
  namespace Actions                                                            \
  {                                                                            \
  struct ActionName;                                                           \
  }                                                                            \
  namespace score                                                              \
  {                                                                            \
  template <>                                                                  \
  struct MetaAction<Actions::ActionName>                                       \
  {                                                                            \
    static score::Action make(QAction* ptr)                                    \
    {                                                                          \
      return score::Action{ptr,       QObject::tr(Text),                       \
                           key(),     score::ActionGroupKey{#Group},           \
                           Shortcut1, Shortcut2};                              \
    }                                                                          \
                                                                               \
    static score::ActionKey key()                                              \
    {                                                                          \
      return score::ActionKey{#ActionName};                                    \
    }                                                                          \
  };                                                                           \
  }