TimeSyncModel.hpp

#pragma once
#include <State/Expression.hpp>
 
#include <Process/Dataflow/TimeSignature.hpp>
#include <Process/TimeValue.hpp>
 
#include <Scenario/Document/Event/ExecutionStatus.hpp>
#include <Scenario/Document/Metatypes.hpp>
#include <Scenario/Document/VerticalExtent.hpp>
 
#include <score/model/Component.hpp>
#include <score/model/EntityImpl.hpp>
#include <score/model/IdentifiedObject.hpp>
#include <score/model/Identifier.hpp>
#include <score/selection/Selectable.hpp>
#include <score/tools/Metadata.hpp>
#include <score/tools/std/Optional.hpp>
 
#include <QObject>
 
#include <score_plugin_scenario_export.h>
 
#include <verdigris>
class DataStream;
class JSONObject;
 
namespace Scenario
{
class EventModel;
class ScenarioInterface;
 
class SCORE_PLUGIN_SCENARIO_EXPORT TimeSyncModel final
    : public score::Entity<TimeSyncModel>
{
  W_OBJECT(TimeSyncModel)
 
  SCORE_SERIALIZE_FRIENDS
 
public:
  Selectable selection{this};
 
  TimeSyncModel(const Id<TimeSyncModel>& id, const TimeVal& date, QObject* parent);
 
  template <typename DeserializerVisitor>
  TimeSyncModel(DeserializerVisitor&& vis, QObject* parent)
      : Entity{vis, parent}
  {
    vis.writeTo(*this);
  }
 
  // Data of the TimeSync
  const TimeVal& date() const noexcept;
  double dateInFlicks() const noexcept { return date().impl; }
  void setDate(const TimeVal&);
 
  void addEvent(const Id<EventModel>&);
  bool removeEvent(const Id<EventModel>&);
  void clearEvents();
 
  using EventIdVec = ossia::small_vector<Id<EventModel>, 2>;
  const EventIdVec& events() const noexcept;
  void setEvents(const TimeSyncModel::EventIdVec& events);
 
  State::Expression expression() const noexcept { return m_expression; }
  void setExpression(const State::Expression& expression);
 
  bool active() const noexcept;
  void setActive(bool active);
 
  bool autotrigger() const noexcept;
  void setAutotrigger(bool t);
 
  bool isStartPoint() const noexcept;
  void setStartPoint(bool t);
 
  ossia::musical_sync musicalSync() const noexcept;
  void setMusicalSync(ossia::musical_sync sig);
 
  void setWaiting(bool);
  bool waiting() const noexcept;
 
  bool scriptable() const noexcept { return m_scriptable; }
  void setScriptable(bool b);
 
public:
  void dateChanged(const TimeVal& arg_1)
      E_SIGNAL(SCORE_PLUGIN_SCENARIO_EXPORT, dateChanged, arg_1)
 
  void newEvent(const Id<Scenario::EventModel>& eventId)
      E_SIGNAL(SCORE_PLUGIN_SCENARIO_EXPORT, newEvent, eventId)
  void eventRemoved(const Id<Scenario::EventModel>& eventId)
      E_SIGNAL(SCORE_PLUGIN_SCENARIO_EXPORT, eventRemoved, eventId)
 
  void triggerChanged(const State::Expression& arg_1)
      E_SIGNAL(SCORE_PLUGIN_SCENARIO_EXPORT, triggerChanged, arg_1)
  void activeChanged() E_SIGNAL(SCORE_PLUGIN_SCENARIO_EXPORT, activeChanged)
 
  void autotriggerChanged(bool b)
      E_SIGNAL(SCORE_PLUGIN_SCENARIO_EXPORT, autotriggerChanged, b)
  void startPointChanged(bool b)
      E_SIGNAL(SCORE_PLUGIN_SCENARIO_EXPORT, startPointChanged, b)
  void scriptableChanged(bool b)
      E_SIGNAL(SCORE_PLUGIN_SCENARIO_EXPORT, scriptableChanged, b)
 
  void triggeredByGui() const E_SIGNAL(SCORE_PLUGIN_SCENARIO_EXPORT, triggeredByGui)
 
  void waitingChanged(bool b) const
      E_SIGNAL(SCORE_PLUGIN_SCENARIO_EXPORT, waitingChanged, b)
 
  double musicalSyncChanged(ossia::musical_sync sync)
      E_SIGNAL(SCORE_PLUGIN_SCENARIO_EXPORT, musicalSyncChanged, sync)
 
  PROPERTY(
      ossia::musical_sync,
      musicalSync READ musicalSync WRITE setMusicalSync NOTIFY musicalSyncChanged)
  PROPERTY(double, date READ dateInFlicks NOTIFY dateChanged)
  PROPERTY(bool, active READ active WRITE setActive NOTIFY activeChanged)
  PROPERTY(
      bool, autotrigger READ autotrigger WRITE setAutotrigger NOTIFY autotriggerChanged)
  PROPERTY(
      bool, startPoint READ isStartPoint WRITE setStartPoint NOTIFY startPointChanged)
  PROPERTY(bool, scriptable READ scriptable WRITE setScriptable NOTIFY scriptableChanged)
  PROPERTY(
      State::Expression,
      expression READ expression WRITE setExpression NOTIFY triggerChanged)
 
private:
  TimeVal m_date{};
  State::Expression m_expression;
 
  EventIdVec m_events;
  ossia::musical_sync m_musicalSync{-1.};
  bool m_active{false};
  bool m_autotrigger{false};
  bool m_startPoint{false};
  bool m_scriptable{false};
  bool m_waiting{false};
};
}
 
DEFAULT_MODEL_METADATA(Scenario::TimeSyncModel, "Sync")
TR_TEXT_METADATA(, Scenario::TimeSyncModel, PrettyName_k, "Sync")