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

#include "ScenarioWidget.hpp"

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

namespace Hardware
{
ScenarioWidget::ScenarioWidget(Scenario::ProcessModel* scenario,
                               bugui::container_widget* parent)
    : bugui::container_widget{parent}
    , model{scenario}
    , skin{Process::Style::instance()}
{
  model->intervals.mutable_added.connect<&ScenarioWidget::on_interval_added>(this);
  model->intervals.removed.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.removed.connect<&ScenarioWidget::on_time_sync_removed>(this);

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

int ScenarioWidget::x() const
{
  return bugui::base_widget::parent->x();
}

int ScenarioWidget::y() const
{
  return bugui::base_widget::parent->y();
}

int ScenarioWidget::width() const
{
  return std::numeric_limits<int>::max();
}

int ScenarioWidget::height() const
{
  return 15;
}

Scenario::ProcessModel *ScenarioWidget::get_model() const
{
  return model;
}

void ScenarioWidget::paint(bugui::painter& painter) const
{
  const auto col = skin.IntervalBase().color();
  painter.set_color(col.red(), col.green(), col.blue(), col.alpha());

  for (const auto& i : model->intervals)
  {
    int y{static_cast<int>(i.heightPercentage() * height())};
    int st{static_cast<int>(i.date().sec())};

    painter.draw_line(st, y, st + i.duration.defaultDuration().sec(), y);
  }
}

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

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

  update();
}

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

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); });
}

} // namespace Hardware