score-addon-hardware/Hardware/Widgets/ScenarioWidget.cpp

#include "ScenarioWidget.hpp"

#include <Hardware/Widgets/IntervalWidget.hpp>
#include <Hardware/Widgets/TimeSyncWidget.hpp>
#include <Hardware/Widgets/StateWidget.hpp>

namespace Hardware
{
ScenarioWidget::ScenarioWidget(Scenario::ProcessModel* scenario,
                               bugui::container_widget* parent)
    : bugui::container_widget{parent}
    , model{scenario}
{
  model->intervals.mutable_added.connect<&ScenarioWidget::on_interval_added>(this);
  model->intervals.removing.connect<&ScenarioWidget::on_interval_removed>(this);

  for(Scenario::IntervalModel& i : model->intervals)
    add_widget<IntervalWidget>(i, this);

  model->timeSyncs.mutable_added.connect<&ScenarioWidget::on_time_sync_added>(this);
  model->timeSyncs.removing.connect<&ScenarioWidget::on_time_sync_removed>(this);

  for(Scenario::TimeSyncModel& t : model->timeSyncs)
    add_widget<TimeSyncWidget>(t, this);
}

void ScenarioWidget::add_proxy(StateWidget* sw)
{
  states_proxy.push_back(sw);
}

void ScenarioWidget::remove_proxy(StateWidget* sw)
{
  std::erase_if(states_proxy,
                [sw] (StateWidget* w) { return w == sw; });
}

void ScenarioWidget::on_interval_added(Scenario::IntervalModel& interval)
{
  add_widget<IntervalWidget>(interval, this);
}

void ScenarioWidget::on_interval_removed(const Scenario::IntervalModel& interval)
{
  remove_widget([&interval]
                (const auto& w)
  { return static_cast<ScenarioComponent<>*>(w.get())->this_model(interval); });
}

void ScenarioWidget::on_time_sync_added(Scenario::TimeSyncModel& timeSync)
{
  add_widget<TimeSyncWidget>(timeSync, this);

  update();
}

void ScenarioWidget::on_time_sync_removed(const Scenario::TimeSyncModel& timeSync)
{
  remove_widget([&timeSync]
                (const auto& w)
  { return static_cast<ScenarioComponent<>*>(w.get())->this_model(timeSync); });

  update();
}

void ScenarioWidget::recursive_change(const Scenario::StateModel& state)
{
  change_previous(state);
  change_next(state);
}

void ScenarioWidget::recursive_change(const Scenario::IntervalModel& interval)
{
  change_previous(interval);
  change_next(interval);
}

void ScenarioWidget::time_propagate(const Scenario::StateModel& state, const TimeVal& t)
{
  auto interval{state.previousInterval()};

  if (interval.has_value())
  {
    auto& v{interval.value()};

    for (const auto& c : children)
    {
      ScenarioComponent<>* s{static_cast<ScenarioComponent<>*>(c.get())};

      if (s->this_model(v))
      {
        static_cast<IntervalWidget*>(s)->set_duration(t);
        break;
      }
    }
  }

  interval = state.nextInterval();

  if (interval.has_value())
  {
    auto& v{interval.value()};

    for (const auto& c : children)
    {
      ScenarioComponent<>* s{static_cast<ScenarioComponent<>*>(c.get())};

      if (s->this_model(v))
      {
        static_cast<IntervalWidget*>(s)->time_propagate(t);
        break;
      }
    }
  }
}

void ScenarioWidget::time_propagate(const Scenario::IntervalModel& interval, const TimeVal& t)
{
  auto& es{interval.endState()};

  for (const auto& s : states_proxy)
  {
    if (s->this_model(es))
    {
      s->time_propagate(t);
      break;
    }
  }
}

void ScenarioWidget::change_previous(const Scenario::IntervalModel& interval)
{
  auto& es{interval.startState()};

  for (const auto& s : states_proxy)
  {
    if (s->this_model(es))
    {
      s->change_previous(interval);
      break;
    }
  }
}

void ScenarioWidget::change_next(const Scenario::IntervalModel& interval)
{
  auto& es{interval.endState()};

  for (const auto& s : states_proxy)
  {
    if (s->this_model(es))
    {
      s->change_next(interval);
      break;
    }
  }
}

void ScenarioWidget::change_previous(const Scenario::StateModel& state)
{
  auto& pi{state.previousInterval()};

  if (pi)
  {
    auto& v{pi.value()};

    for (const auto& c : children)
    {
      ScenarioComponent<>* s{static_cast<ScenarioComponent<>*>(c.get())};

      if (s->this_model(v))
      {
        static_cast<IntervalWidget*>(s)->change_previous(state);
        break;
      }
    }
  }
}

void ScenarioWidget::change_next(const Scenario::StateModel& state)
{
  auto& ni{state.nextInterval()};

  if (ni)
  {
    auto& v{ni.value()};

    for (const auto& c : children)
    {
      ScenarioComponent<>* s{static_cast<ScenarioComponent<>*>(c.get())};

      if (s->this_model(v))
      {
        static_cast<IntervalWidget*>(s)->change_next(state);
        break;
      }
    }
  }
}

} // namespace Hardware