[ScenarioComponent] current issue with inheriting base_widget virtauly

CMakeLists.txt

@@ -23,7 +23,10 @@ set(HDRS
     "Hardware/DocumentPlugin.hpp"
     "Hardware/ApplicationPlugin.hpp"
 
+    "Hardware/Widgets/ScenarioComponent.hpp"
     "Hardware/Widgets/ScenarioWidget.hpp"
+    "Hardware/Widgets/TimeSyncWidget.hpp"
+    "Hardware/Widgets/EventWidget.hpp"
     "Hardware/Widgets/StateWidget.hpp"
     "Hardware/Widgets/IntervalWidget.hpp"
 
@@ -40,6 +43,8 @@ set(SRCS
     "${CMAKE_CURRENT_SOURCE_DIR}/Hardware/ApplicationPlugin.cpp"
 
     "${CMAKE_CURRENT_SOURCE_DIR}/Hardware/Widgets/ScenarioWidget.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/Hardware/Widgets/TimeSyncWidget.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/Hardware/Widgets/EventWidget.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/Hardware/Widgets/StateWidget.cpp"
     "${CMAKE_CURRENT_SOURCE_DIR}/Hardware/Widgets/IntervalWidget.cpp"
 

Hardware/3rdparty/bugui

@@ -1 +1 @@
-Subproject commit 6beac152a93db4887435abdf2712e89ff32f7c35
+Subproject commit 08fcc660909bfb688156904cf520d150e3b426f6

Hardware/Widgets/EventWidget.cpp

@@ -0,0 +1,54 @@
+#include <Scenario/Document/Event/EventModel.hpp>
+
+#include "EventWidget.hpp"
+
+namespace Hardware
+{
+EventWidget::EventWidget(Scenario::EventModel& event,
+                         bugui::container_widget* parent)
+    : ScenarioComponentSpec<Scenario::EventModel>{event, parent}
+    , bugui::container_widget{parent}
+{ }
+
+int EventWidget::x() const
+{
+  return model.date().sec();
+}
+
+int EventWidget::y() const
+{
+  return 0;
+}
+
+int EventWidget::height() const
+{
+  return 1;
+}
+
+void EventWidget::paint(bugui::painter& painter) const
+{
+  // const auto col = skin.StateDot().color();
+  // painter.set_color(col.red(), col.green(), col.blue(), col.alpha());
+
+  // painter.draw_cell(0, 0);
+}
+
+bool EventWidget::contains(int px, int py) const
+{
+  if (px == x() && py == y())
+    return true;
+
+  return false;
+}
+
+void EventWidget::on_press(int x, int y, bool pressed)
+{
+  qDebug() << "is inside!";
+}
+
+const Scenario::EventModel& EventWidget::get_model() const
+{
+  return model;
+}
+
+}

Hardware/Widgets/EventWidget.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <widgets/container_widget.hpp>
+#include "ScenarioComponent.hpp"
+
+namespace Hardware
+{
+struct EventWidget final : virtual bugui::container_widget
+                         , ScenarioComponentSpec<Scenario::EventModel>
+
+{
+  explicit EventWidget(Scenario::EventModel& event,
+                       bugui::container_widget* parent);
+
+  void paint(bugui::painter& painter) const override;
+  void on_press(int x, int y, bool pressed) override;
+
+  int x() const override;
+  int y() const override;
+  int height() const override;
+
+  const Scenario::EventModel& get_model() const;
+
+protected:
+  bool contains(int px, int py) const override;
+};
+
+} //namespace Hardware
+

Hardware/Widgets/IntervalWidget.cpp

@@ -6,9 +6,7 @@ namespace Hardware
 {
 IntervalWidget::IntervalWidget(Scenario::IntervalModel& interval,
                                bugui::container_widget* parent)
-    : bugui::base_widget{parent}
+    : ScenarioComponentSpec<Scenario::IntervalModel>{interval, parent}
-    , model{interval}
-    , skin{Process::Style::instance()}
 { }
 
 int IntervalWidget::x() const
@@ -32,7 +30,7 @@ void IntervalWidget::paint(bugui::painter& painter) const
   const auto col = skin.IntervalBase().color();
   painter.set_color(col.red(), col.green(), col.blue(), col.alpha());
 
-  painter.draw_line({0, 0}, {width(), 0});
+  painter.draw_line(0, 0, width(), 0);
 }
 
 bool IntervalWidget::contains(int px, int py) const

Hardware/Widgets/IntervalWidget.hpp

@@ -1,12 +1,13 @@
 #pragma once
 
-#include <Scenario/Document/Interval/IntervalModel.hpp>
 #include <Process/Style/ScenarioStyle.hpp>
 #include <widgets/base_widget.hpp>
 
+#include "ScenarioComponent.hpp"
+
 namespace Hardware
 {
-struct IntervalWidget final : bugui::base_widget
+struct IntervalWidget final : ScenarioComponentSpec<Scenario::IntervalModel>
 {
   explicit IntervalWidget(Scenario::IntervalModel& interval,
                           bugui::container_widget* parent);
@@ -24,10 +25,6 @@ struct IntervalWidget final : bugui::base_widget
 
 protected:
   bool contains(int px, int py) const override;
-
-private:
-  Scenario::IntervalModel& model;
-  const Process::Style& skin;
 };
 
 } // namespace Hardware

Hardware/Widgets/ScenarioComponent.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "widgets/base_widget.hpp"
+#include <Process/Style/ScenarioStyle.hpp>
+#include <Scenario/Document/Interval/IntervalModel.hpp>
+
+namespace Hardware
+{
+struct ScenarioComponent : bugui::base_widget
+{
+  virtual bool this_model(const Scenario::IntervalModel&) const { return false; };
+  virtual bool this_model(const Scenario::TimeSyncModel&) const { return false; };
+  virtual bool this_model(const Scenario::EventModel&) const { return false; };
+  virtual bool this_model(const Scenario::StateModel&) const { return false; };
+
+protected:
+  explicit ScenarioComponent(bugui::container_widget* parent)
+      : bugui::base_widget{parent}
+  { }
+};
+
+template <typename T>
+  requires (std::same_as<T, Scenario::IntervalModel> ||
+           std::same_as<T, Scenario::TimeSyncModel> ||
+           std::same_as<T, Scenario::EventModel> ||
+           std::same_as<T, Scenario::StateModel>)
+struct ScenarioComponentSpec : ScenarioComponent
+{
+  bool this_model(const T& m) const override { return m.id() == model.id(); };
+
+protected:
+  explicit ScenarioComponentSpec(T& m,
+                                 bugui::container_widget* parent)
+      : ScenarioComponent{parent}
+      , model{m}
+      , skin{Process::Style::instance()}
+  { }
+
+  T& model;
+  const Process::Style& skin;
+};
+
+} // hardware

Hardware/Widgets/ScenarioWidget.cpp

@@ -1,5 +1,7 @@
 #include "ScenarioWidget.hpp"
+
 #include <Hardware/Widgets/IntervalWidget.hpp>
+#include <Hardware/Widgets/TimeSyncWidget.hpp>
 
 namespace Hardware
 {
@@ -15,8 +17,14 @@ ScenarioWidget::ScenarioWidget(Scenario::ProcessModel* scenario,
           &Scenario::ProcessModel::intervalMoved,
           [this] { update(); });
 
-  for(Scenario::IntervalModel& s : model->intervals)
+  for(Scenario::IntervalModel& i : model->intervals)
-    add_widget<IntervalWidget>(s);
+    add_widget<IntervalWidget>(i);
+
+  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);
 }
 
 int ScenarioWidget::x() const
@@ -31,7 +39,7 @@ int ScenarioWidget::y() const
 
 int ScenarioWidget::width() const
 {
-  return bugui::base_widget::parent->width();
+  return std::numeric_limits<int>::max();
 }
 
 int ScenarioWidget::height() const
@@ -49,19 +57,31 @@ void ScenarioWidget::on_interval_removed(const Scenario::IntervalModel& interval
 {
   remove_widget([&interval]
                 (const auto& w)
-  {
+  { return static_cast<ScenarioComponent*>(w.get())->this_model(interval); });
-    auto ntrvl = static_cast<IntervalWidget*>(w.get());
-    return ntrvl->get_model().id() == interval.id();
-  });
 
   update();
 }
 
-void ScenarioWidget::on_interval_changed(const Scenario::IntervalModel &)
+void ScenarioWidget::on_interval_changed(const Scenario::IntervalModel&)
 {
   update();
 }
 
+void ScenarioWidget::on_time_sync_added(Scenario::TimeSyncModel& timeSync)
+{
+  add_widget<TimeSyncWidget>(timeSync);
+  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();
+}
+
 } // namespace Hardware
 
 #include "wobjectimpl.h"

Hardware/Widgets/ScenarioWidget.hpp

@@ -3,6 +3,7 @@
 #include <wobjectdefs.h>
 
 #include <Scenario/Process/ScenarioModel.hpp>
+
 #include <widgets/container_widget.hpp>
 
 namespace Hardware
@@ -27,6 +28,9 @@ private:
   void on_interval_removed(const Scenario::IntervalModel& interval);
   void on_interval_changed(const Scenario::IntervalModel&);
 
+  void on_time_sync_added(Scenario::TimeSyncModel& timeSync);
+  void on_time_sync_removed(const Scenario::TimeSyncModel& timeSync);
+
   Scenario::ProcessModel* model;
 };
 

Hardware/Widgets/StateWidget.cpp

@@ -1,12 +1,12 @@
+#include <Scenario/Document/State/StateModel.hpp>
+
 #include "StateWidget.hpp"
 
 namespace Hardware
 {
 StateWidget::StateWidget(Scenario::StateModel& state,
-                         container_widget* parent)
+                         bugui::container_widget* parent)
-    : bugui::container_widget{parent}
+    : ScenarioComponentSpec<Scenario::StateModel>{state, parent}
-    , model{state}
-    , skin{Process::Style::instance()}
 { }
 
 int StateWidget::x() const
@@ -21,18 +21,15 @@ int StateWidget::y() const
 
 void StateWidget::paint(bugui::painter& painter) const
 {
-  // Copied from MiniscenarioView
+  const auto col = skin.StateDot().color();
-  const auto col = skin.IntervalBase().color();
   painter.set_color(col.red(), col.green(), col.blue(), col.alpha());
 
-  painter.draw_line({x(), y()}, {x() + width(), y()});
+  painter.draw_cell(0, 0);
 }
 
 bool StateWidget::contains(int px, int py) const
 {
-  if (px >= x() &&
+  if (px == x() && py == y())
-     px <= (x() + width()) &&
-     py == y())
     return true;
 
   return false;

Hardware/Widgets/StateWidget.hpp

@@ -1,15 +1,14 @@
 #pragma once
 
-#include <Scenario/Document/State/StateModel.hpp>
-#include <Process/Style/ScenarioStyle.hpp>
 #include <widgets/container_widget.hpp>
+#include "ScenarioComponent.hpp"
 
 namespace Hardware
 {
-struct StateWidget final : bugui::container_widget
+struct StateWidget final : ScenarioComponentSpec<Scenario::StateModel>
 {
   explicit StateWidget(Scenario::StateModel& state,
-                       container_widget* parent);
+                       bugui::container_widget* parent);
 
   void paint(bugui::painter& painter) const override;
   void on_press(int x, int y, bool pressed) override;
@@ -23,10 +22,6 @@ struct StateWidget final : bugui::container_widget
 
 protected:
   bool contains(int px, int py) const override;
-
-private:
-  Scenario::StateModel& model;
-  const Process::Style& skin;
 };
 
 } //namespace Hardware

Hardware/Widgets/TimeSyncWidget.cpp

@@ -0,0 +1,54 @@
+#include <Scenario/Document/TimeSync/TimeSyncModel.hpp>
+
+#include "TimeSyncWidget.hpp"
+
+namespace Hardware
+{
+TimeSyncWidget::TimeSyncWidget(Scenario::TimeSyncModel& timeSync,
+                               bugui::container_widget* parent)
+    : ScenarioComponentSpec<Scenario::TimeSyncModel>{timeSync, parent}
+    // , bugui::container_widget{parent}
+{ }
+
+int TimeSyncWidget::x() const
+{
+  return model.date().sec();
+}
+
+int TimeSyncWidget::y() const
+{
+  return 0;
+}
+
+int TimeSyncWidget::height() const
+{
+  return 1;
+}
+
+void TimeSyncWidget::paint(bugui::painter& painter) const
+{
+  // const auto col = skin.StateDot().color();
+  // painter.set_color(col.red(), col.green(), col.blue(), col.alpha());
+
+  // painter.draw_cell(0, 0);
+}
+
+bool TimeSyncWidget::contains(int px, int py) const
+{
+  if (px == x() && py == y())
+    return true;
+
+  return false;
+}
+
+void TimeSyncWidget::on_press(int x, int y, bool pressed)
+{
+  qDebug() << "is inside!";
+}
+
+const Scenario::TimeSyncModel& TimeSyncWidget::get_model() const
+{
+  return model;
+}
+
+}

Hardware/Widgets/TimeSyncWidget.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "Hardware/Widgets/ScenarioComponent.hpp"
+#include "Scenario/Document/TimeSync/TimeSyncModel.hpp"
+#include <widgets/container_widget.hpp>
+
+namespace Hardware
+{
+struct TimeSyncWidget final : ScenarioComponentSpec<Scenario::TimeSyncModel>
+                            // , virtual bugui::container_widget
+{
+  explicit TimeSyncWidget(Scenario::TimeSyncModel& timeSync,
+                          bugui::container_widget* parent);
+
+  void paint(bugui::painter& painter) const override;
+  void on_press(int x, int y, bool pressed) override;
+
+  int x() const override;
+  int y() const override;
+  int height() const override;
+
+  const Scenario::TimeSyncModel& get_model() const;
+
+protected:
+  bool contains(int px, int py) const override;
+};
+
+} //namespace Hardware
+