Changeset f2d5ce for src/UIElements/Views/Qt4/QtTimeLine.cpp

Timestamp:

Dec 26, 2025, 9:40:14 PM (2 days ago)

Author:

Frederik Heber <frederik.heber@…>

Branches:

Candidate_v1.7.1, stable

Children:

c8cb0d

Parents:

bdd1d0

git-author:

Frederik Heber <frederik.heber@…> (12/10/25 10:20:56)

git-committer:

Frederik Heber <frederik.heber@…> (12/26/25 21:40:14)

Message:

QtTimeLine no longers queries WorldTime directly.

• This was slightly prone to race conditions when manipulating the slider in the UI while stuff was going on in the background. Instead, we query the QtObservedInstanceBoard.
• QtObservedInstanceBoard has ObservedValue for WorldTime.
• introduces ObservedMaximumAtomTrajectorySize that aggregates the maximum trajectory size over all atoms and provides it as an Observable. We need this value in QtTimeLine only right now.

File:

• src/UIElements/Views/Qt4/QtTimeLine.cpp (modified) (5 diffs)

src/UIElements/Views/Qt4/QtTimeLine.cpp

@@ -46 +46 @@
 #include "WorldTime.hpp"
 
-QtTimeLine::QtTimeLine(QWidget * _parent) :
+#include "UIElements/Qt4/InstanceBoard/QtObservedInstanceBoard.hpp"
+
+QtTimeLine::QtTimeLine(QtObservedInstanceBoard *_instanceBoard, QWidget * _parent) :
     QWidget(_parent),
-    Observer("QtTimeLine"),
-    atomobserver_enlisted(false),
-    worldtime_enlisted(false),
+    instanceBoard(_instanceBoard),
     SetWorldTime_called(false)
 {
@@ -71 +71 @@
   layout->addWidget(spinbox);
 
-  // sign on to observable
-  WorldTime::getInstance().signOn(this, WorldTime::TimeChanged);
-  worldtime_enlisted = true;
-  AtomObserver::getInstance().signOn(this, AtomObservable::TrajectoryChanged);
-  atomobserver_enlisted = true;
-
   // connect to QSlider's valueChanged() signal
   bool result = connect(slider,SIGNAL(valueChanged(int)),this,SLOT(StepUpdate(int)));
@@ -82 +76 @@
   if (!result)
     ELOG(0, "Could not connect to QSlider::valueChanged.");
+
+  connect(instanceBoard, SIGNAL(WorldTimeChanged()), this, SLOT(WorldTimeChanged()));
+  connect(instanceBoard, SIGNAL(MaximumAtomTrajectoryChanged()), this, SLOT(MaximumAtomTrajectoryChanged()));
 }
 
 QtTimeLine::~QtTimeLine()
-{
-  if (worldtime_enlisted)
-    WorldTime::getInstance().signOff(this, WorldTime::TimeChanged);
-  if (atomobserver_enlisted)
-    AtomObserver::getInstance().signOff(this, AtomObservable::TrajectoryChanged);
-}
+{}
 
 void QtTimeLine::paintEvent(QPaintEvent * event)
@@ -99 +91 @@
 }
 
-void QtTimeLine::subjectKilled(Observable *publisher)
-{
-  // as long as we are enlisted to only one channel, we have nothing to worry.
-  // Otherwise we should also signOn to global changes for subjectKilled() and
-  // sign off from the channels
-  if (static_cast<AtomObserver *>(publisher) == AtomObserver::getPointer()) {
-    atomobserver_enlisted = false;
-  } else if (static_cast<WorldTime *>(publisher) == WorldTime::getPointer()) {
-    worldtime_enlisted = false;
- }
-}
-
-void QtTimeLine::update(Observable *publisher)
-{
-  ELOG(0, "We are not enlisted for general updates.");
-}
-
-void QtTimeLine::recieveNotification(Observable *publisher, Notification_ptr notification)
+void QtTimeLine::WorldTimeChanged()
 {
   boost::recursive_mutex::scoped_lock lock(refill_mutex);
 
-  if (static_cast<WorldTime *>(publisher) == WorldTime::getPointer()) {
-    SetWorldTime_called = false;
-    const int timestep = WorldTime::getTime();
-    // check whether we are beyond maximum
-    if (timestep > slider->maximum()) {
-      slider->setMaximum(timestep);
-      spinbox->setMaximum(timestep);
-    }
-    // set slider position to new time step
-    slider->setValue( timestep );
-    spinbox->setValue( timestep );
-  } else
-    //if (static_cast<AtomObserver *>(publisher) == AtomObserver::getPointer())
-  {
-    // calculate max trajectory (need dynamic_cast due to virtual base)
-    const atom *_atom = dynamic_cast<const atom *>(publisher);
-    const int MaxTrajectory = _atom->getTrajectorySize()-1;
-    if (MaxTrajectory > slider->maximum()) {
-      slider->setMaximum(MaxTrajectory);
-      spinbox->setMaximum(MaxTrajectory);
-    }
+  SetWorldTime_called = false;
+  const int timestep = instanceBoard->getObservedWorldTime().get();
+  // check whether we are beyond maximum
+  if (timestep > slider->maximum()) {
+    slider->setMaximum(timestep);
+    spinbox->setMaximum(timestep);
+  }
+  // set slider position to new time step
+  slider->setValue( timestep );
+  spinbox->setValue( timestep );
+}
+
+void QtTimeLine::MaximumAtomTrajectoryChanged()
+{
+  boost::recursive_mutex::scoped_lock lock(refill_mutex);
+
+  // calculate max trajectory (need dynamic_cast due to virtual base)
+  const int MaxTrajectory = instanceBoard->getObservedMaximumAtomTrajectorySize().get();
+  if (MaxTrajectory > slider->maximum()) {
+    slider->setMaximum(MaxTrajectory);
+    spinbox->setMaximum(MaxTrajectory);
   }
 }
@@ -149 +124 @@
 
   if (!SetWorldTime_called) {
-    if (WorldTime::getTime() != (unsigned int)position) {
+    if (instanceBoard->getObservedWorldTime().get() != (unsigned int)position) {
       SetWorldTime_called = true;
       MoleCuilder::WorldSetWorldTime(position);