Changeset f2d5ce

Timestamp:

Dec 26, 2025, 9:40:14 PM (43 hours 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.

Location:

src/UIElements

Files:

• Makefile.am (modified) (2 diffs)
• Qt4/InstanceBoard/ObservedMaximumAtomTrajectorySize.cpp (added)
• Qt4/InstanceBoard/ObservedMaximumAtomTrajectorySize.hpp (added)
• Qt4/InstanceBoard/QtObservedInstanceBoard.cpp (modified) (9 diffs)
• Qt4/InstanceBoard/QtObservedInstanceBoard.hpp (modified) (6 diffs)
• Qt4/QtMainWindow.cpp (modified) (1 diff)
• Views/Qt4/QtTimeLine.cpp (modified) (5 diffs)
• Views/Qt4/QtTimeLine.hpp (modified) (2 diffs)

src/UIElements/Makefile.am

@@ -144 +144 @@
   UIElements/GlobalListOfParameterQueries.hpp \
   UIElements/MainWindow.hpp \
+  UIElements/Qt4/InstanceBoard/ObservedMaximumAtomTrajectorySize.hpp \
   UIElements/Qt4/InstanceBoard/ObservedValue_types.hpp \
   UIElements/Qt4/InstanceBoard/ObservedValuesContainer.hpp \
@@ -150 +151 @@
 
 QTUISOURCE = \
+  UIElements/Qt4/InstanceBoard/ObservedMaximumAtomTrajectorySize.cpp \
   UIElements/Qt4/InstanceBoard/QtObservedAtom.cpp \
   UIElements/Qt4/InstanceBoard/QtObservedBond.cpp \

src/UIElements/Qt4/InstanceBoard/QtObservedInstanceBoard.cpp

@@ -51 +51 @@
 #include "Descriptors/MoleculeIdDescriptor.hpp"
 #include "molecule.hpp"
+#include "UIElements/Qt4/InstanceBoard/ObservedMaximumAtomTrajectorySize.hpp"
 #include "UIElements/Qt4/InstanceBoard/ObservedValuesContainer_impl.hpp"
 #include "World.hpp"
+#include "WorldTime.hpp"
+
+// static entities
+const Observable::channels_t
+WorldTimeChannels(1, WorldTime::TimeChanged);
+
+const Observable::channels_t
+MaximumTrajectorySizeChannels(1, ObservedMaximumAtomTrajectorySize::MaximumChanged);
 
 QtObservedInstanceBoard::QtObservedInstanceBoard(QWidget * _parent) :
@@ -58 +67 @@
   Observer("QtObservedInstanceBoard"),
   WorldSignedOn(false),
+  WorldTimeSignedOn(false),
+  MaximumAtomTrajectorySizeSignedOn(false),
   atomObservedValues(
       "atom",
@@ -69 +80 @@
       "molecule",
       *this,
-      boost::bind(&QtObservedInstanceBoard::moleculecountsubjectKilled, this, _1))
+      boost::bind(&QtObservedInstanceBoard::moleculecountsubjectKilled, this, _1)),
+  worldTime(
+    WorldTime::getPointer(),
+    WorldTime::getTime,
+    "WorldTime",
+    0,
+    WorldTimeChannels),
+  maximumAtomTrajectorySize(
+    ObservedMaximumAtomTrajectorySize::getPointer(),
+    boost::bind(
+      &ObservedMaximumAtomTrajectorySize::GetMaximumAtomTrajectorySize, 
+      boost::cref(ObservedMaximumAtomTrajectorySize::getConstInstance())
+    ),
+    "MaximumAtomTrajectorySize",
+    0,
+    MaximumTrajectorySizeChannels)
 {
   qRegisterMetaType<ObservedValue_Index_t>("ObservedValue_Index_t");
@@ -80 +106 @@
   World::getInstance().signOn(this, World::MoleculeInserted, GlobalObservableInfo::PriorityLevel(int(-10)));
   WorldSignedOn = true;
+  WorldTime::getInstance().signOn(this, WorldTime::TimeChanged);
+  WorldTimeSignedOn = true;
+  ObservedMaximumAtomTrajectorySize::getInstance().signOn(this, ObservedMaximumAtomTrajectorySize::MaximumChanged);
+  MaximumAtomTrajectorySizeSignedOn = true;
 }
 
@@ -87 +117 @@
     World::getInstance().signOff(this, World::AtomInserted);
     World::getInstance().signOff(this, World::MoleculeInserted);
+  }
+  if (WorldTimeSignedOn) {
+    WorldTime::getInstance().signOff(this, WorldTime::TimeChanged);
+  }
+  if (MaximumAtomTrajectorySizeSignedOn) {
+    ObservedMaximumAtomTrajectorySize::getInstance().signOff(this, ObservedMaximumAtomTrajectorySize::MaximumChanged);
   }
   // sign off from all remaining molecules, bonds, and atoms
@@ -121 +157 @@
       MoleculeSignedOn.erase(iter);
     } else {
-      ASSERT(0,
-          "QtObservedInstanceBoard::subjectKilled() - could not find signedOn for atom/molecule "+toString(publisher));
+      if (static_cast<World *>(publisher) == World::getPointer()) {
+        WorldSignedOn = false;
+      } else if (static_cast<WorldTime *>(publisher) == WorldTime::getPointer()) {
+        WorldTimeSignedOn = false;
+      } else if (static_cast<ObservedMaximumAtomTrajectorySize *>(publisher) == ObservedMaximumAtomTrajectorySize::getPointer()) {
+        MaximumAtomTrajectorySizeSignedOn = false;
+      } else {
+        ASSERT(0,
+            "QtObservedInstanceBoard::subjectKilled() - could not find signedOn for atom/molecule "+toString(publisher));
+      }
     }
   }
@@ -217 +261 @@
       }
       default:
-        ASSERT(0, "QtObservedInstanceBoard::recieveNotification() - we cannot get here.");
+        ASSERT(0, "QtObservedInstanceBoard::recieveNotification() - we cannot get here for Molecule.");
         break;
     }
@@ -277 +321 @@
       }
       default:
-        ASSERT(0, "QtObservedInstanceBoard::recieveNotification() - we cannot get here.");
-        break;
+        ASSERT(0, "QtObservedInstanceBoard::recieveNotification() - we cannot get here for Atom.");
+        break;
+    }
+  } else if (static_cast<ObservedMaximumAtomTrajectorySize *>(publisher) == ObservedMaximumAtomTrajectorySize::getPointer()) {
+    switch (notification->getChannelNo()) {
+      case ObservedMaximumAtomTrajectorySize::MaximumChanged:
+      {
+#ifdef LOG_OBSERVER
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that maximum atom tractory size has changed.";
+#endif
+        LOG(3, "DEBUG: InformationBoard got MaximumChanged signal from ObservedMaximumAtomTrajectorySize.");
+        emit MaximumAtomTrajectoryChanged();
+        break;
+      }
+      default:
+      {
+        ASSERT(0, "QtObservedInstanceBoard::recieveNotification() - we cannot get here for ObservedMaximumAtomTrajectorySize.");
+        break;
+      }
+    }
+  } else if (static_cast<WorldTime *>(publisher) == WorldTime::getPointer()) {
+    switch (notification->getChannelNo()) {
+      case WorldTime::TimeChanged:
+      {
+#ifdef LOG_OBSERVER
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that WorldTime has changed.";
+#endif
+        LOG(3, "DEBUG: InformationBoard got TimeChanged signal from WorldTime.");
+        emit WorldTimeChanged();
+        break;
+      }
+      default:
+      {
+        ASSERT(0, "QtObservedInstanceBoard::recieveNotification() - we cannot get here for WorldTime.");
+        break;
+      }
     }
   } else {
@@ -373 +451 @@
 }
 
+const ObservedValue<unsigned int>& QtObservedInstanceBoard::getObservedWorldTime()
+{
+  return worldTime;
+}
+
+const ObservedValue<int>& QtObservedInstanceBoard::getObservedMaximumAtomTrajectorySize()
+{
+  return maximumAtomTrajectorySize;
+}
+
 void QtObservedInstanceBoard::markObservedAtomAsConnected(ObservedValue_Index_t _id)
 {

src/UIElements/Qt4/InstanceBoard/QtObservedInstanceBoard.hpp

@@ -25 +25 @@
 #include <boost/function.hpp>
 
+#include "CodePatterns/ObservedValue.hpp"
 #include "CodePatterns/Observer/Observer.hpp"
 
@@ -94 +95 @@
   QtObservedMolecule::ptr getObservedMolecule(const moleculeId_t _id);
   QtObservedMolecule::ptr getObservedMolecule(ObservedValue_Index_t _id);
+  const ObservedValue<unsigned int>& getObservedWorldTime();
+  const ObservedValue<int>& getObservedMaximumAtomTrajectorySize();
   void markObservedAtomAsConnected(ObservedValue_Index_t _id);
   void markObservedAtomAsDisconnected(ObservedValue_Index_t _id);
@@ -114 +117 @@
   void moleculeRemoved(ObservedValue_Index_t _molid);
   void moleculeIndexChanged(const moleculeId_t _oldid, const moleculeId_t _newid);
+  void WorldTimeChanged();
+  void MaximumAtomTrajectoryChanged();
 
 private:
@@ -124 +129 @@
   bool WorldSignedOn;
 
+  //!> indicating whether we are still signedOn to World or not
+  bool WorldTimeSignedOn;
+  
+  //!> indicating whether we are still signedOn to MaximumAtomTrajectorySize observable
+  bool MaximumAtomTrajectorySizeSignedOn;
+
   typedef std::multiset<Observable *> SignedOn_t;
   //!> map indicating to which atom we are currently signed on
@@ -129 +140 @@
   //!> map indicating to which molecule we are currently signed on
   SignedOn_t MoleculeSignedOn;
+
 
   //!> "templated typedef" for an id to index map.
@@ -173 +185 @@
   //!> container with all ObservedValues for each molecule, associated by id
   ObservedValuesContainer<QtObservedMolecule, ObservedValue_Index_t> moleculeObservedValues;
+  //!> observed value for the world's time
+  ObservedValue<unsigned int> worldTime;
+  //!> observed value for the largest atom trajectory siye (i.e., current number of world time steps)
+  ObservedValue<int> maximumAtomTrajectorySize;
 };
 

src/UIElements/Qt4/QtMainWindow.cpp

@@ -120 +120 @@
   shapeController = new QtShapeController(worldTab);
 
-  timeline = new QtTimeLine(this);
+  timeline = new QtTimeLine(InstanceBoard, this);
 
   infoBox = new QtInfoBox(InstanceBoard);

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

src/UIElements/Views/Qt4/QtTimeLine.hpp

@@ -20 +20 @@
 #include <boost/thread/recursive_mutex.hpp>
 
-#include "CodePatterns/Observer/Observer.hpp"
+class QtObservedInstanceBoard;
 
-class QtTimeLine : public QWidget, public Observer
+class QtTimeLine : public QWidget
 {
   Q_OBJECT
 
 public:
-  QtTimeLine(QWidget * _parent=0);
+  QtTimeLine(QtObservedInstanceBoard *_instanceBoard, QWidget * _parent=0);
   virtual ~QtTimeLine();
 
 protected:
-  virtual void update(Observable *publisher);
-  virtual void recieveNotification(Observable *publisher, Notification_ptr notification);
-  virtual void subjectKilled(Observable *publisher);
   virtual void paintEvent(QPaintEvent * event);
 
@@ -39 +36 @@
   void StepUpdate(int position);
 
+public slots:
+  void WorldTimeChanged();
+  void MaximumAtomTrajectoryChanged();
+
 private:
-  //!> whether AtomObserver knows about us or not
-  bool atomobserver_enlisted;
-  //!> whether WorldTime knows about us or not
-  bool worldtime_enlisted;
-
   QSlider *slider;
   QSpinBox *spinbox;
   QHBoxLayout *layout;
+
+  //!> instance board with observed world time
+  QtObservedInstanceBoard *instanceBoard;
 
   //!> states whether we are expecting a notification from the worldtime