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

#include <Scenario/Document/State/StateModel.hpp>

#include "ScenarioWidget.hpp"
#include "TimeSyncWidget.hpp"
#include "EventWidget.hpp"
#include "StateWidget.hpp"

namespace Hardware
{
StateWidget::StateWidget(Scenario::StateModel& state,
                         ScenarioWidget* scenario,
                         bugui::container_widget* parent)
    : ScenarioComponentSpec<Scenario::StateModel>{state, scenario, parent}
{
  set_absolute_y();

  con = connect(&model,
                &Scenario::StateModel::heightPercentageChanged,
                this,
                [scenario, this]
  {
    if (scenario->changing) return;

    set_absolute_y();
    set_span_recursive();
    scenario->update();
  });

  scenario->add_proxy(this);
}

StateWidget::~StateWidget()
{
  disconnect(con);
  scenario->remove_proxy(this);
}

void StateWidget::set_absolute_y()
{
  m_absolute_y = model.heightPercentage() * scenario->height();
}

void StateWidget::set_y()
{
  m_y = m_absolute_y -
        bugui::base_widget::parent->y() -
        bugui::base_widget::parent->get_parent()->y();
}

void StateWidget::set_span_recursive()
{
  static_cast<EventWidget*>(bugui::base_widget::parent)
  ->set_span_recursive();
}

void StateWidget::change_previous(const Scenario::IntervalModel& interval)
{
  model.setHeightPercentage(interval.heightPercentage());
  set_absolute_y();
  set_span_recursive();
  scenario->change_previous(model);
}
void StateWidget::change_next(const Scenario::IntervalModel& interval)
{
  model.setHeightPercentage(interval.heightPercentage());
  set_absolute_y();
  set_span_recursive();
  scenario->change_next(model);
}

void StateWidget::time_propagate(const TimeVal& t)
{
  static_cast<TimeSyncWidget*>(
      bugui::base_widget::parent->get_parent())
      ->time_propagate(t);
}

void StateWidget::paint(bugui::painter& painter) const
{
  const auto col{model.metadata().getColor().getBrush().color()};
  // const auto col = skin.StateSelected().color();
  painter.set_color(col.red(), col.green(), col.blue(), col.alpha());
  // painter.set_color(255, 255, 255, 255);

  painter.draw_cell(0, 0);
}

bool StateWidget::contains(int px, int py) const
{
  if (px == 0 && py == 0)
    return true;

  return false;
}

void StateWidget::on_press(int x, int y, bool pressed)
{
  // update();
}

void StateWidget::on_double_press(int x, int y)
{
  qDebug() << "state double pressed";
}

void StateWidget::on_drag(int from_x, int from_y, int to_x, int to_y)
{
  bool update{false};

  // handle vertical drag
  if (from_y != to_y)
  {
    double new_height{model.heightPercentage() +
                      to_y / static_cast<double>(scenario->height())};

    // prevent dragging out of scenario
    if (new_height >= 0 && new_height <= 1)
    {
      scenario->changing = true;
      model.setHeightPercentage(new_height);
      scenario->recursive_change(model);
      set_absolute_y();
      set_span_recursive();
      scenario->changing = false;
      update = true;
    }
  }

  if (from_x != to_x)
  {
    scenario->changing = true;
    TimeSyncWidget* sync{static_cast<TimeSyncWidget*>(
        bugui::base_widget::parent->get_parent())};
    auto d{sync->get_model().date()};
    d.setMSecs(d.msec() + to_x * 1000);
    sync->time_propagate(d);
    scenario->changing = false;
    update = true;
  }

  if (update) scenario->update();
}

} // namespace Hardware

#include <wobjectimpl.h>
W_OBJECT_IMPL(Hardware::StateWidget)