Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp	(revision e254484494f1093b5f83e79385d6f87cc3ea6588)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp	(revision 7c7c4adf3a00ea2410433016fef5f193bab8b957)
@@ -57,4 +57,6 @@
 #include "WorldTime.hpp"
 
+#include "ObservedValue_wCallback.hpp"
+
 using namespace boost::assign;
 
@@ -80,30 +82,10 @@
   Observer(std::string("GLMoleculeObject_atom")+toString(_id)),
   atomref(getAtom(_id)),
-  AtomIndex(
-      atomref,
-      boost::bind(&GLMoleculeObject_atom::updateIndex, this),
-      "AtomIndex_"+toString(_id),
-      _id,
-      AtomIndexChannels),
-  AtomPosition(
-      atomref,
-      boost::bind(&GLMoleculeObject_atom::updatePosition, this),
-      "AtomPosition_"+toString(_id),
-      updatePosition(),
-      AtomPositionChannels),
-  AtomElement(
-      atomref,
-      boost::bind(&GLMoleculeObject_atom::updateElement, this),
-      "AtomElement"+toString(_id),
-      updateElement(),
-      AtomElementChannels),
-  AtomBonds(
-      atomref,
-      boost::bind(&GLMoleculeObject_atom::updateBonds, this),
-      "AtomBonds_"+toString(_id),
-      updateBonds(),
-      AtomBondsChannels),
+  ObservedValues(MAX_ObservedTypes),
+  subjectKilledCount(0),
   owner(NULL)
 {
+  initObservedValues(_id);
+
   setObjectId(_id);
   resetPosition();
@@ -154,9 +136,10 @@
 {
   deactivateObserver();
+  destroyObservedValues();
 }
 
 void GLMoleculeObject_atom::resetIndex()
 {
-  const atomId_t newId = AtomIndex.get();
+  const atomId_t newId = getAtomIndex();
   const size_t oldId = objectId();
   ASSERT( newId != oldId,
@@ -170,5 +153,5 @@
 void GLMoleculeObject_atom::resetPosition()
 {
-  const Vector Position = AtomPosition.get();
+  const Vector Position = getAtomPosition();
   LOG(4, "INFO: GLMoleculeObject_atom::resetIndex() - new position is "+toString(Position)+".");
   setPosition(QVector3D(Position[0], Position[1], Position[2]));
@@ -179,5 +162,5 @@
   size_t elementno = 0;
   const element * const _type = World::getInstance().
-      getPeriode()->FindElement(AtomElement.get());
+      getPeriode()->FindElement(getAtomElement());
   if (_type != NULL) {
     elementno = _type->getAtomicNumber();
@@ -205,5 +188,5 @@
 void GLMoleculeObject_atom::resetBonds()
 {
-  ListOfBonds_t ListOfBonds_new = AtomBonds.get();
+  ListOfBonds_t ListOfBonds_new = getAtomBonds();
   std::sort(ListOfBonds_new.begin(), ListOfBonds_new.end());
   ListOfBonds_t BondsToAdd;
@@ -220,5 +203,5 @@
       iter != BondsToAdd.end();
       ++iter) {
-    const GLMoleculeObject_bond::SideOfBond side = (iter->first == AtomIndex.get()) ?
+    const GLMoleculeObject_bond::SideOfBond side = (iter->first == getAtomIndex()) ?
         GLMoleculeObject_bond::left : GLMoleculeObject_bond::right;
     emit BondsAdded(iter->first, iter->second, side);
@@ -259,6 +242,6 @@
 void GLMoleculeObject_atom::wasClicked()
 {
-  LOG(4, "INFO: GLMoleculeObject_atom: atom " << AtomIndex.get() << " has been clicked");
-  emit clicked(AtomIndex.get());
+  LOG(4, "INFO: GLMoleculeObject_atom: atom " << getAtomIndex() << " has been clicked");
+  emit clicked(getAtomIndex());
 }
 
@@ -283,5 +266,5 @@
 Vector GLMoleculeObject_atom::updatePosition() const
 {
-  const atom * const _atom = getAtom(AtomIndex.get());
+  const atom * const _atom = getAtom(getAtomIndex());
   if (_atom != NULL) {
     return _atom->getPosition();
@@ -293,5 +276,5 @@
 atomicNumber_t GLMoleculeObject_atom::updateElement() const
 {
-  const atom * const _atom = getAtom(AtomIndex.get());
+  const atom * const _atom = getAtom(getAtomIndex());
   if (_atom != NULL) {
     return _atom->getElementNo();
@@ -304,5 +287,5 @@
 {
   ListOfBonds_t ListOfBonds;
-  const atom * const _atom = getAtom(AtomIndex.get());
+  const atom * const _atom = getAtom(getAtomIndex());
   if (_atom != NULL) {
     // make sure position is up-to-date
@@ -315,5 +298,5 @@
           (*iter)->rightatom->getId()) );
   } else {
-    ELOG(2, "Atom with id "+toString(AtomIndex.get())+" is already gone.");
+    ELOG(2, "Atom with id "+toString(getAtomIndex())+" is already gone.");
   }
   return ListOfBonds;
@@ -328,4 +311,6 @@
 {
   deactivateObserver();
+
+  countsubjectKilled();
 }
 
@@ -357,2 +342,74 @@
     ASSERT(0, "GLMoleculeObject_atom::recieveNotification() - received notification from unexpected source.");
 }
+
+void GLMoleculeObject_atom::countsubjectKilled()
+{
+  ++subjectKilledCount;
+
+  if (subjectKilledCount > ObservedValues.size())
+    emit InstanceRemoved(getAtomIndex());
+}
+
+void GLMoleculeObject_atom::initObservedValues(const atomId_t _id)
+{
+  // fill ObservedValues
+  boost::function<void()> subjectKilled =
+      boost::bind(&GLMoleculeObject_atom::countsubjectKilled, this);
+  ObservedValues[AtomIndex] = new ObservedValue_wCallback<atomId_t>(
+      atomref,
+      boost::bind(&GLMoleculeObject_atom::updateIndex, this),
+      "AtomIndex_"+toString(_id),
+      _id,
+      AtomIndexChannels,
+      subjectKilled);
+  ObservedValues[AtomPosition] = new ObservedValue_wCallback<Vector>(
+      atomref,
+      boost::bind(&GLMoleculeObject_atom::updatePosition, this),
+      "AtomPosition_"+toString(_id),
+      updatePosition(),
+      AtomPositionChannels,
+      subjectKilled);
+  ObservedValues[AtomElement] = new ObservedValue_wCallback<atomicNumber_t>(
+      atomref,
+      boost::bind(&GLMoleculeObject_atom::updateElement, this),
+      "AtomElement"+toString(_id),
+      updateElement(),
+      AtomElementChannels,
+      subjectKilled);
+  ObservedValues[AtomBonds] = new ObservedValue_wCallback<ListOfBonds_t>(
+      atomref,
+      boost::bind(&GLMoleculeObject_atom::updateBonds, this),
+      "AtomBonds_"+toString(_id),
+      updateBonds(),
+      AtomBondsChannels,
+      subjectKilled);
+}
+
+void GLMoleculeObject_atom::destroyObservedValues()
+{
+  delete boost::any_cast<ObservedValue_wCallback<atomId_t> *>(ObservedValues[AtomIndex]);
+  delete boost::any_cast<ObservedValue_wCallback<Vector> *>(ObservedValues[AtomPosition]);
+  delete boost::any_cast<ObservedValue_wCallback<atomicNumber_t> *>(ObservedValues[AtomElement]);
+  delete boost::any_cast<ObservedValue_wCallback<ListOfBonds_t> *>(ObservedValues[AtomBonds]);
+  ObservedValues.clear();
+}
+
+atomId_t GLMoleculeObject_atom::getAtomIndex() const
+{
+  return boost::any_cast<ObservedValue_wCallback<atomId_t> *>(ObservedValues[AtomIndex])->get();
+}
+
+Vector GLMoleculeObject_atom::getAtomPosition() const
+{
+  return boost::any_cast<ObservedValue_wCallback<Vector> *>(ObservedValues[AtomPosition])->get();
+}
+
+atomicNumber_t GLMoleculeObject_atom::getAtomElement() const
+{
+  return boost::any_cast<ObservedValue_wCallback<atomicNumber_t> *>(ObservedValues[AtomElement])->get();
+}
+
+GLMoleculeObject_atom::ListOfBonds_t GLMoleculeObject_atom::getAtomBonds() const
+{
+  return boost::any_cast<ObservedValue_wCallback<ListOfBonds_t> *>(ObservedValues[AtomBonds])->get();
+}
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision e254484494f1093b5f83e79385d6f87cc3ea6588)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 7c7c4adf3a00ea2410433016fef5f193bab8b957)
@@ -15,4 +15,7 @@
 
 #include "GLMoleculeObject.hpp"
+
+#include <vector>
+#include <boost/any.hpp>
 
 #include "CodePatterns/ObservedValue.hpp"
@@ -61,4 +64,5 @@
   void elementChanged();
   void bondsChanged();
+  void InstanceRemoved(const atomId_t);
 
 private:
@@ -88,12 +92,72 @@
   atom * const atomref;
 
-  //!> cached value of the atom's id
-  ObservedValue<atomId_t> AtomIndex;
-  //!> cached value of the atom's position
-  ObservedValue<Vector> AtomPosition;
-  //!> cached value of the atom's element
-  ObservedValue<atomicNumber_t> AtomElement;
-  //!> cached value of the atom's id
-  ObservedValue<ListOfBonds_t> AtomBonds;
+private:
+  /** Observed Values **/
+
+  //!> enumeration of observed values to match with entries in ObservedValues
+  enum ObservedTypes {
+    //!> contains the current atom index
+    AtomIndex,
+    //!> contains the current atom position
+    AtomPosition,
+    //!> contains the current atom element
+    AtomElement,
+    //!> contains the current set of bonds atoms fort the atom
+    AtomBonds,
+    //!> gives the size of the enumeration
+    MAX_ObservedTypes
+  };
+
+  //!> vector with all observed values
+  std::vector<boost::any> ObservedValues;
+
+  /** Initializes all \a ObservedValues entries.
+   *
+   * \param _id atom id
+   */
+  void initObservedValues(const atomId_t _id);
+
+  /** Destroys all \a ObservedValues entries.
+   *
+   */
+  void destroyObservedValues();
+
+  /** Getter to atom index contained in \a ObservedValues.
+   *
+   * \return atom's index
+   */
+  atomId_t getAtomIndex() const;
+
+  /** Getter to atom position contained in \a ObservedValues.
+   *
+   * \return atom's position
+   */
+  Vector getAtomPosition() const;
+
+  /** Getter to atom element contained in \a ObservedValues.
+   *
+   * \return atom's elemnt
+   */
+  atomicNumber_t getAtomElement() const;
+
+  /** Getter to atom bonds contained in \a ObservedValues.
+   *
+   * \return atom's bonds
+   */
+  ListOfBonds_t getAtomBonds() const;
+
+  /** Counts how many ObservedValues got subjectKilled.
+   *
+   * This is used to give InstanceRemoved() signal only when each and every
+   * ObservedValue (and the instance itself) has been subjectKilled by the
+   * monitored Observable. Only then can we safely remove the instance.
+   *
+   */
+  void countsubjectKilled();
+
+  //!> counts how many ObservedValues have already been subjectKilled()
+  mutable size_t subjectKilledCount;
+
+private:
 
   //!> list of channels when index needs to update
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.cpp	(revision e254484494f1093b5f83e79385d6f87cc3ea6588)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.cpp	(revision 7c7c4adf3a00ea2410433016fef5f193bab8b957)
@@ -57,4 +57,6 @@
 #include "World.hpp"
 
+#include "ObservedValue_wCallback.hpp"
+
 
 // static entities
@@ -82,37 +84,11 @@
   bondowner(getAtom(leftatomId)->getBond(getAtom(rightatomId)).get()),
   BondSide(side),
-  leftPosition(
-      leftowner,
-      boost::bind(&GLMoleculeObject_bond::updateLeftPosition, this),
-      "BondleftPosition_"+toString(leftatomId),
-      updateLeftPosition(),
-      BondPositionChannels),
-  rightPosition(
-      rightowner,
-      boost::bind(&GLMoleculeObject_bond::updateRightPosition, this),
-      "BondrightPosition_"+toString(rightatomId),
-      updateRightPosition(),
-      BondPositionChannels),
-  leftElement(
-      leftowner,
-      boost::bind(&GLMoleculeObject_bond::updateLeftElement, this),
-      "BondleftElement"+toString(leftatomId),
-      updateLeftElement(),
-      BondElementChannels),
-  rightElement(
-      rightowner,
-      boost::bind(&GLMoleculeObject_bond::updateRightElement, this),
-      "BondrightElement"+toString(rightatomId),
-      updateRightElement(),
-      BondElementChannels),
-  Degree(
-      bondowner,
-      boost::bind(&GLMoleculeObject_bond::updateDegree, this),
-      "BondDegree"+toString(leftatomId)+"_"+toString(rightatomId),
-      updateDegree(),
-      BondDegreeChannels),
+  ObservedValues(MAX_ObservedTypes),
+  subjectKilledCount(0),
   leftobservable_enabled(false),
   rightobservable_enabled(false)
 {
+  initObservedValues();
+
   // sign on as observer (obtain non-const instance before)
   bondowner->signOn(this, BondObservable::BondRemoved);
@@ -141,4 +117,5 @@
   // signOff() if not already done
   removeChannels();
+  destroyObservedValues();
 }
 
@@ -170,10 +147,4 @@
 }
 
-void GLMoleculeObject_bond::removeMe()
-{
-  // sign off
-  emit BondRemoved(leftatomId, rightatomId);
-}
-
 void GLMoleculeObject_bond::update(Observable *publisher)
 {
@@ -185,6 +156,6 @@
   // we signOff from all other sources
   removeChannels();
-  // then indicate to remove us
-  removeMe();
+  // check whether we should be removed
+  countsubjectKilled();
 }
 
@@ -278,5 +249,5 @@
 void GLMoleculeObject_bond::resetElement()
 {
-  size_t elementno = rightElement.get();
+  size_t elementno = getrightElement();
   QGLMaterial *elementmaterial = getMaterial(elementno);
   setMaterial(elementmaterial);
@@ -285,5 +256,5 @@
 void GLMoleculeObject_bond::resetWidth()
 {
-  const double factor = 1.0f+.5f*(Degree.get()-1);
+  const double factor = 1.0f+.5f*(getDegree()-1);
   LOG(2, "DEBUG: GLMoleculeObject_bond::resetWidth() - setting bond's width to " << factor << ".");
   setScaleX(factor);
@@ -295,6 +266,6 @@
 void GLMoleculeObject_bond::resetPosition()
 {
-  Vector Position = leftPosition.get();
-  Vector OtherPosition = rightPosition.get();
+  Vector Position = getleftPosition();
+  Vector OtherPosition = getrightPosition();
   const double distance =
       Position.distance(OtherPosition)/2.;
@@ -346,2 +317,87 @@
   return _atom;
 }
+
+void GLMoleculeObject_bond::countsubjectKilled()
+{
+  ++subjectKilledCount;
+
+  if (subjectKilledCount > ObservedValues.size())
+    emit BondRemoved(leftatomId, rightatomId);
+}
+
+void GLMoleculeObject_bond::initObservedValues()
+{
+  // fill ObservedValues
+  boost::function<void()> subjectKilled =
+      boost::bind(&GLMoleculeObject_bond::countsubjectKilled, this);
+  ObservedValues[leftPosition] = new ObservedValue_wCallback<Vector>(
+      leftowner,
+      boost::bind(&GLMoleculeObject_bond::updateLeftPosition, this),
+      "BondleftPosition_"+toString(leftatomId),
+      updateLeftPosition(),
+      BondPositionChannels,
+      subjectKilled);
+  ObservedValues[rightPosition] = new ObservedValue_wCallback<Vector>(
+      rightowner,
+      boost::bind(&GLMoleculeObject_bond::updateRightPosition, this),
+      "BondrightPosition_"+toString(rightatomId),
+      updateRightPosition(),
+      BondPositionChannels,
+      subjectKilled);
+  ObservedValues[leftElement] = new ObservedValue_wCallback<atomicNumber_t>(
+      leftowner,
+      boost::bind(&GLMoleculeObject_bond::updateLeftElement, this),
+      "BondleftElement"+toString(leftatomId),
+      updateLeftElement(),
+      BondElementChannels,
+      subjectKilled);
+  ObservedValues[rightElement] = new ObservedValue_wCallback<atomicNumber_t>(
+      rightowner,
+      boost::bind(&GLMoleculeObject_bond::updateRightElement, this),
+      "BondrightElement"+toString(rightatomId),
+      updateRightElement(),
+      BondElementChannels,
+      subjectKilled);
+  ObservedValues[Degree] = new ObservedValue_wCallback<int>(
+      bondowner,
+      boost::bind(&GLMoleculeObject_bond::updateDegree, this),
+      "BondDegree"+toString(leftatomId)+"_"+toString(rightatomId),
+      updateDegree(),
+      BondDegreeChannels,
+      subjectKilled);
+}
+
+void GLMoleculeObject_bond::destroyObservedValues()
+{
+  delete boost::any_cast<ObservedValue_wCallback<Vector> *>(ObservedValues[leftPosition]);
+  delete boost::any_cast<ObservedValue_wCallback<Vector> *>(ObservedValues[rightPosition]);
+  delete boost::any_cast<ObservedValue_wCallback<atomicNumber_t> *>(ObservedValues[leftElement]);
+  delete boost::any_cast<ObservedValue_wCallback<atomicNumber_t> *>(ObservedValues[rightElement]);
+  delete boost::any_cast<ObservedValue_wCallback<int> *>(ObservedValues[Degree]);
+  ObservedValues.clear();
+}
+
+Vector GLMoleculeObject_bond::getleftPosition() const
+{
+  return boost::any_cast<ObservedValue_wCallback<Vector> *>(ObservedValues[leftPosition])->get();
+}
+
+Vector GLMoleculeObject_bond::getrightPosition() const
+{
+  return boost::any_cast<ObservedValue_wCallback<Vector> *>(ObservedValues[rightPosition])->get();
+}
+
+atomicNumber_t GLMoleculeObject_bond::getleftElement() const
+{
+  return boost::any_cast<ObservedValue_wCallback<atomicNumber_t> *>(ObservedValues[leftElement])->get();
+}
+
+atomicNumber_t GLMoleculeObject_bond::getrightElement() const
+{
+  return boost::any_cast<ObservedValue_wCallback<atomicNumber_t> *>(ObservedValues[rightElement])->get();
+}
+
+int GLMoleculeObject_bond::getDegree() const
+{
+  return boost::any_cast<ObservedValue_wCallback<int> *>(ObservedValues[Degree])->get();
+}
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp	(revision e254484494f1093b5f83e79385d6f87cc3ea6588)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp	(revision 7c7c4adf3a00ea2410433016fef5f193bab8b957)
@@ -15,4 +15,7 @@
 
 #include "GLMoleculeObject.hpp"
+
+#include <vector>
+#include <boost/any.hpp>
 
 #include "CodePatterns/Observer/Observer.hpp"
@@ -70,13 +73,4 @@
 
 private:
-  /** This must be called from subjectKilled() only.
-   *
-   * We remove from all other Observables in a controlled manner.
-   *
-   * removeBond(), and removeChannels() must have been called before (or one of
-   * the subjects has been killed).
-   *
-   */
-  void removeMe();
   void removeChannels();
 
@@ -105,9 +99,80 @@
   const enum SideOfBond BondSide;
 
-  ObservedValue<Vector> leftPosition;
-  ObservedValue<Vector> rightPosition;
-  ObservedValue<atomicNumber_t> leftElement;
-  ObservedValue<atomicNumber_t> rightElement;
-  ObservedValue<int> Degree;
+
+private:
+  /** Observed Values **/
+
+  //!> enumeration of observed values to match with entries in ObservedValues
+  enum ObservedTypes {
+    //!> contains the position of the left atom
+    leftPosition,
+    //!> contains the position of the right atom
+    rightPosition,
+    //!> contains the element of the left atom
+    leftElement,
+    //!> contains the element of the right atom
+    rightElement,
+    //!> contains the degree of the bond
+    Degree,
+    //!> gives the size of the enumeration
+    MAX_ObservedTypes
+  };
+
+  //!> vector with all observed values
+  std::vector<boost::any> ObservedValues;
+
+  /** Initializes all \a ObservedValues entries.
+   *
+   */
+  void initObservedValues();
+
+  /** Destroys all \a ObservedValues entries.
+   *
+   */
+  void destroyObservedValues();
+
+  /** Getter to left atom's position contained in \a ObservedValues.
+   *
+   * \return left atom's position
+   */
+  Vector getleftPosition() const;
+
+  /** Getter to right atom's position contained in \a ObservedValues.
+   *
+   * \return right atom's position
+   */
+  Vector getrightPosition() const;
+
+  /** Getter to left atom's element contained in \a ObservedValues.
+   *
+   * \return left atom's element
+   */
+  atomicNumber_t getleftElement() const;
+
+  /** Getter to rightatom's element contained in \a ObservedValues.
+   *
+   * \return right atom's element
+   */
+  atomicNumber_t getrightElement() const;
+
+  /** Getter to bond's degree contained in \a ObservedValues.
+   *
+   * \return bond's degree
+   */
+  int getDegree() const;
+
+  /** Counts how many ObservedValues got subjectKilled.
+   *
+   * This is used to give InstanceRemoved() signal only when each and every
+   * ObservedValue (and the instance itself) has been subjectKilled by the
+   * monitored Observable. Only then can we safely remove the instance.
+   *
+   */
+  void countsubjectKilled();
+
+  //!> counts how many ObservedValues have already been subjectKilled()
+  mutable size_t subjectKilledCount;
+
+private:
 
   //!> indicate whether we are signed in to leftobservable
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp	(revision e254484494f1093b5f83e79385d6f87cc3ea6588)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp	(revision 7c7c4adf3a00ea2410433016fef5f193bab8b957)
@@ -63,4 +63,6 @@
 #include "Atom/TesselPoint.hpp"
 #include "World.hpp"
+
+#include "ObservedValue_wCallback.hpp"
 
 using namespace boost::assign;
@@ -122,16 +124,6 @@
       boost::bind(&GLMoleculeObject_molecule::updateAtoms, this)
       ),
-  MolIndex(
-      molref,
-      MolIndexUpdater,
-      "MoleculeIndex_"+toString(_molid),
-      _molid,
-      IndexChannels),
-  MolName(
-      molref,
-      MolNameUpdater,
-      "MoleculeName_"+toString(_molid),
-      updateName(),
-      NameChannels),
+  ObservedValues(MAX_ObservedTypes),
+  subjectKilledCount(0),
   TesselationHull(
       molref,
@@ -139,18 +131,8 @@
       "MoleculeTesselationHull_"+toString(_molid),
       HullChannels),
-  BoundingBox(
-      molref,
-      BoundingBoxUpdater,
-      "MoleculeBoundingBox_"+toString(_molid),
-      initBoundingBox(),
-      BoundingBoxChannels),
-  PresentAtoms(
-      molref,
-      PresentAtomsUpdater,
-      "MoleculeAtoms_"+toString(_molid),
-      updateAtoms(),
-      AtomsChannels),
   hoverAtomId(-1)
 {
+  initObservedValues(_molid);
+
   setObjectId(_molid);
   setMaterial(getMaterial(1));
@@ -199,16 +181,6 @@
       boost::bind(&GLMoleculeObject_molecule::updateAtoms, this)
       ),
-  MolIndex(
-      molref,
-      MolIndexUpdater,
-      "MoleculeIndex_"+toString(_molid),
-      _molid,
-      IndexChannels),
-  MolName(
-      molref,
-      MolNameUpdater,
-      "MoleculeName_"+toString(_molid),
-      updateName(),
-      NameChannels),
+  ObservedValues(MAX_ObservedTypes),
+  subjectKilledCount(0),
   TesselationHull(
       molref,
@@ -216,18 +188,8 @@
       "MoleculeTesselationHull_"+toString(_molid),
       HullChannels),
-  BoundingBox(
-      molref,
-      BoundingBoxUpdater,
-      "MoleculeBoundingBox_"+toString(_molid),
-      initBoundingBox(),
-      BoundingBoxChannels),
-  PresentAtoms(
-      molref,
-      PresentAtomsUpdater,
-      "MoleculeAtoms_"+toString(_molid),
-      atoms_t(),
-      AtomsChannels),
   hoverAtomId(-1)
 {
+  initObservedValues(_molid);
+
   setObjectId(_molid);
   setMaterial(getMaterial(1));
@@ -254,4 +216,5 @@
 {
   deactivateObserver();
+  destroyObservedValues();
 }
 
@@ -270,5 +233,5 @@
 {
   // sign on as observer (obtain non-const instance before)
-  const molecule * const _molecule = getMolecule(MolIndex.get());
+  const molecule * const _molecule = getMolecule(getMolIndex());
   if (_molecule != NULL) {
     owner = static_cast<const Observable *>(_molecule);
@@ -278,5 +241,5 @@
     owner->signOn(this, molecule::IndexChanged);
   } else {
-    ELOG(1, "GLMoleculeObject_molecule() - added null object for not present mol id " << MolIndex.get());
+    ELOG(1, "GLMoleculeObject_molecule() - added null object for not present mol id " << getMolIndex());
   }
 
@@ -332,7 +295,7 @@
   QGeometryData geo;
 
-  const molecule * const molref = getMolecule(MolIndex.get());
+  const molecule * const molref = getMolecule(getMolIndex());
   if (molref == NULL) {
-    ELOG(1, "Could not createMoleculeMesh, molecule with id " << MolIndex.get() << " already gone.");
+    ELOG(1, "Could not createMoleculeMesh, molecule with id " << getMolIndex() << " already gone.");
     return geo;
   }
@@ -353,8 +316,8 @@
 
   // we need at least three points for tesselation
-  if (PresentAtoms.get().size() >= 3) {
+  if (getPresentAtoms().size() >= 3) {
     // Tesselate the points.
     Tesselation T;
-    PointCloudAdaptor<molecule> cloud(const_cast<molecule *>(molref), MolName.get());
+    PointCloudAdaptor<molecule> cloud(const_cast<molecule *>(molref), getMolName());
     T(cloud, minradius);
 
@@ -413,10 +376,10 @@
 molecule::BoundingBoxInfo GLMoleculeObject_molecule::updateBoundingBox() const
 {
-  return BoundingBox.get();
+  return getBoundingBox();
 }
 
 GLMoleculeObject_molecule::atoms_t GLMoleculeObject_molecule::updateAtoms()
 {
-  const molecule * const mol = getMolecule(MolIndex.get());
+  const molecule * const mol = getMolecule(getMolIndex());
   if (mol != NULL) {
     const atomId_t id = mol->lastChangedAtomId();
@@ -436,5 +399,5 @@
 std::string GLMoleculeObject_molecule::updateName() const
 {
-  const molecule * const mol = getMolecule(MolIndex.get());
+  const molecule * const mol = getMolecule(getMolIndex());
   return mol->getName();
 }
@@ -448,5 +411,5 @@
 void GLMoleculeObject_molecule::resetBoundingBox()
 {
-  molecule::BoundingBoxInfo info = BoundingBox.get();
+  molecule::BoundingBoxInfo info = getBoundingBox();
   setPosition(QVector3D(info.position[0], info.position[1], info.position[2]));
   setScale(info.radius + 0.3); // getBoundingSphere() only sees atoms as points, so make the box a bit bigger
@@ -455,5 +418,5 @@
 void GLMoleculeObject_molecule::resetAtoms()
 {
-  const atoms_t atoms = PresentAtoms.get();
+  const atoms_t atoms = getPresentAtoms();
   std::vector<atomId_t> InsertedAtoms;
   std::vector<atomId_t> RemovedAtoms;
@@ -479,5 +442,5 @@
 void GLMoleculeObject_molecule::resetIndex()
 {
-  const atomId_t newId = MolIndex.get();
+  const atomId_t newId = getMolIndex();
   const size_t oldId = objectId();
   ASSERT( newId != oldId,
@@ -544,9 +507,11 @@
   // remove owner: no more signOff needed
   owner = NULL;
+
+  countsubjectKilled();
 }
 
 void GLMoleculeObject_molecule::recieveNotification(Observable *publisher, Notification_ptr notification)
 {
-  const molecule * const _molecule = getMolecule(MolIndex.get());
+  const molecule * const _molecule = getMolecule(getMolIndex());
   // when molecule is NULL we will soon get destroyed anyway
   if (_molecule == NULL)
@@ -556,5 +521,5 @@
 #ifdef LOG_OBSERVER
     observerLog().addMessage() << "++ Update of Observer "<< observerLog().getName(static_cast<Observer *>(this))
-          << " received notification from molecule " << MolIndex.get() << " for channel "
+          << " received notification from molecule " << getMolIndex() << " for channel "
           << notification->getChannelNo() << ".";
 #endif
@@ -577,5 +542,4 @@
         observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that atom "+toString(_id)+" has been removed.";
   #endif
-        emit AtomRemoved(_id);
         emit TesselationHullChanged();
         emit BoundingBoxChanged();
@@ -719,4 +683,5 @@
   connect (atomObject, SIGNAL(BondsRemoved(const atomId_t, const atomId_t)), this, SLOT(bondRemoved(const atomId_t, const atomId_t)));
   connect (atomObject, SIGNAL(indexChanged(GLMoleculeObject_atom*, const atomId_t, const atomId_t)), this, SLOT(changeAtomId(GLMoleculeObject_atom*, const atomId_t, const atomId_t)));
+  connect (atomObject, SIGNAL(InstanceRemoved(const atomId_t)), this, SIGNAL(AtomRemoved(const atomId_t)));
 
   if (m_objectId  == -1)
@@ -773,5 +738,5 @@
     if (moleculeObject == this){
       // Propagate signal.
-      emit hoverChanged(MolIndex.get(), 0);
+      emit hoverChanged(getMolIndex(), 0);
     }
   }
@@ -871,6 +836,6 @@
 void GLMoleculeObject_molecule::wasClicked()
 {
-  LOG(4, "INFO: GLMoleculeObject_molecule: atom " << MolIndex.get() << " has been clicked");
-  emit moleculeClicked(MolIndex.get());
+  LOG(4, "INFO: GLMoleculeObject_molecule: atom " << getMolIndex() << " has been clicked");
+  emit moleculeClicked(getMolIndex());
 }
 
@@ -906,2 +871,74 @@
   return mol;
 }
+
+void GLMoleculeObject_molecule::countsubjectKilled()
+{
+  ++subjectKilledCount;
+
+  if (subjectKilledCount > ObservedValues.size())
+    emit InstanceRemoved(getMolIndex());
+}
+
+void GLMoleculeObject_molecule::initObservedValues(const moleculeId_t _molid)
+{
+  // fill ObservedValues
+  boost::function<void()> subjectKilled =
+      boost::bind(&GLMoleculeObject_molecule::countsubjectKilled, this);
+  ObservedValues[MolIndex] = new ObservedValue_wCallback<moleculeId_t>(
+      molref,
+      MolIndexUpdater,
+      "MoleculeIndex_"+toString(_molid),
+      _molid,
+      IndexChannels,
+      subjectKilled);
+  ObservedValues[MolName] = new ObservedValue_wCallback<std::string>(
+      molref,
+      MolNameUpdater,
+      "MoleculeName_"+toString(_molid),
+      updateName(),
+      NameChannels,
+      subjectKilled);
+  ObservedValues[BoundingBox] = new ObservedValue_wCallback<molecule::BoundingBoxInfo>(
+      molref,
+      BoundingBoxUpdater,
+      "MoleculeBoundingBox_"+toString(_molid),
+      initBoundingBox(),
+      BoundingBoxChannels,
+      subjectKilled);
+  ObservedValues[PresentAtoms] = new ObservedValue_wCallback<atoms_t>(
+      molref,
+      PresentAtomsUpdater,
+      "MoleculeAtoms_"+toString(_molid),
+      updateAtoms(),
+      AtomsChannels,
+      subjectKilled);
+}
+
+void GLMoleculeObject_molecule::destroyObservedValues()
+{
+  delete boost::any_cast<ObservedValue_wCallback<moleculeId_t> *>(ObservedValues[MolIndex]);
+  delete boost::any_cast<ObservedValue_wCallback<std::string> *>(ObservedValues[MolName]);
+  delete boost::any_cast<ObservedValue_wCallback<molecule::BoundingBoxInfo> *>(ObservedValues[BoundingBox]);
+  delete boost::any_cast<ObservedValue_wCallback<atoms_t> *>(ObservedValues[PresentAtoms]);
+  ObservedValues.clear();
+}
+
+moleculeId_t GLMoleculeObject_molecule::getMolIndex() const
+{
+  return boost::any_cast<ObservedValue_wCallback<moleculeId_t> *>(ObservedValues[MolIndex])->get();
+}
+
+std::string GLMoleculeObject_molecule::getMolName() const
+{
+  return boost::any_cast<ObservedValue_wCallback<std::string> *>(ObservedValues[MolName])->get();
+}
+
+molecule::BoundingBoxInfo GLMoleculeObject_molecule::getBoundingBox() const
+{
+  return boost::any_cast<ObservedValue_wCallback<molecule::BoundingBoxInfo> *>(ObservedValues[BoundingBox])->get();
+}
+
+GLMoleculeObject_molecule::atoms_t GLMoleculeObject_molecule::getPresentAtoms() const
+{
+  return boost::any_cast<ObservedValue_wCallback<atoms_t> *>(ObservedValues[PresentAtoms])->get();
+}
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp	(revision e254484494f1093b5f83e79385d6f87cc3ea6588)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp	(revision 7c7c4adf3a00ea2410433016fef5f193bab8b957)
@@ -17,4 +17,7 @@
 
 #include <Qt3D/qgeometrydata.h>
+
+#include <vector>
+#include <boost/any.hpp>
 
 #include "CodePatterns/Cacheable.hpp"
@@ -68,4 +71,5 @@
   void AtomRemoved(const atomId_t _id);
   void IdChanged();
+  void InstanceRemoved(const moleculeId_t);
 
 private slots:
@@ -141,15 +145,75 @@
   boost::function<atoms_t ()> PresentAtomsUpdater;
 
-  //!> contains the current molecule index
-  ObservedValue<moleculeId_t> MolIndex;
-  //!> contains the current molecule name
-  ObservedValue<std::string> MolName;
+private:
+  /** Observed Values **/
+
+  //!> enumeration of observed values to match with entries in ObservedValues
+  enum ObservedTypes {
+    //!> contains the current molecule index
+    MolIndex,
+    //!> contains the current molecule name
+    MolName,
+    //!> contains newest version of the bounding box on request
+    BoundingBox,
+    //!> contains the current live set of atoms for the molecule
+    PresentAtoms,
+    //!> gives the size of the enumeration
+    MAX_ObservedTypes
+  };
+
+  //!> vector with all observed values
+  std::vector<boost::any> ObservedValues;
+
+  /** Initializes all \a ObservedValues entries.
+   *
+   * \param _moid molecule id
+   */
+  void initObservedValues(const moleculeId_t _molid);
+
+  /** Destroys all \a ObservedValues entries.
+   *
+   */
+  void destroyObservedValues();
+
+  /** Getter to molecule index contained in \a ObservedValues.
+   *
+   * \return molecule's index
+   */
+  moleculeId_t getMolIndex() const;
+
+  /** Getter to molecule name contained in \a ObservedValues.
+   *
+   * \return molecule's name
+   */
+  std::string getMolName() const;
+
+  /** Getter to molecule's bounding box contained in \a ObservedValues.
+   *
+   * \return molecule's bounding box
+   */
+  molecule::BoundingBoxInfo getBoundingBox() const;
+
+  /** Getter to contained atoms contained in \a ObservedValues.
+   *
+   * \return molecule's contained atoms
+   */
+  atoms_t getPresentAtoms() const;
+
+  /** Counts how many ObservedValues got subjectKilled.
+   *
+   * This is used to give InstanceRemoved() signal only when each and every
+   * ObservedValue (and the instance itself) has been subjectKilled by the
+   * monitored Observable. Only then can we safely remove the instance.
+   *
+   */
+  void countsubjectKilled();
+
+  //!> counts how many ObservedValues have already been subjectKilled()
+  mutable size_t subjectKilledCount;
+
   //!> contains current version of the tesselation hull on request
   Cacheable<QGeometryData> TesselationHull;
-  //!> contains newest version of the bounding box on request
-  ObservedValue<molecule::BoundingBoxInfo> BoundingBox;
-  //!> contains the current live set of atoms for the molecule
-  ObservedValue<atoms_t> PresentAtoms;
-
+
+private:
   //!> contains the set of atoms displayed
   atoms_t DisplayedAtoms;
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision e254484494f1093b5f83e79385d6f87cc3ea6588)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 7c7c4adf3a00ea2410433016fef5f193bab8b957)
@@ -91,5 +91,4 @@
   }
   connect(this, SIGNAL(moleculePreparedInserted(const moleculeId_t)), this, SLOT(moleculeInserted(const moleculeId_t)));
-  connect(this, SIGNAL(moleculePreparedRemoved(const moleculeId_t)), this, SLOT(moleculeRemoved(const moleculeId_t)));
 
 //  connect(this, SIGNAL(updated()), this, SLOT(update()));
@@ -116,4 +115,5 @@
 //      moliter != molecules.end();
 //      moliter++) {
+//    boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
 //    // check whether molecule already exists
 //    const moleculeId_t molid = (*moliter)->getId();
@@ -123,4 +123,5 @@
 //  }
 //
+//  boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
 //  MoleculeNodeMap::iterator iter = MoleculesinSceneMap.begin();
 //  for (;iter != MoleculesinSceneMap.end();) {
@@ -182,7 +183,7 @@
 void GLWorldScene::atomInserted(const moleculeId_t _molid, const atomId_t _atomid)
 {
+  boost::recursive_mutex::scoped_lock lock(MoleculeMissedStateMap_mutex);
+
   LOG(3, "INFO: GLWorldScene: Received signal atomInserted for atom "+toString(_atomid)+".");
-
-  boost::recursive_mutex::scoped_lock lock(MoleculeMissedStateMap_mutex);
 
   // check of molecule is already present
@@ -268,4 +269,5 @@
 
   // add new object
+  LOG(1, "DEBUG: Adding GLMoleculeObject_molecule to id " << _id);
   GLMoleculeObject_molecule *molObject =
       new GLMoleculeObject_molecule(GLMoleculeObject::meshEmpty, this, _id);
@@ -344,5 +346,6 @@
   connect (molObject, SIGNAL(hoverChanged(const atomId_t)), this, SIGNAL(hoverChanged(const atomId_t)));
   connect (molObject, SIGNAL(hoverChanged(const moleculeId_t, int)), this, SIGNAL(hoverChanged(const moleculeId_t, int)));
-  connect (molObject, SIGNAL(indexChanged(GLMoleculeObject_molecule *, const moleculeId_t, const moleculeId_t)), this, SLOT(changeMoleculeId(GLMoleculeObject_molecule *, const moleculeId_t, const moleculeId_t)));
+  connect (molObject, SIGNAL(hoverChanged(const moleculeId_t, int)), this, SIGNAL(hoverChanged(const moleculeId_t, int)));
+  connect (molObject, SIGNAL(InstanceRemoved(const moleculeId_t)), this, SLOT(moleculeRemoved(const moleculeId_t)));
 
   emit changed();
@@ -350,11 +353,11 @@
 }
 
-/** Prepares removing a molecule from the scene.
- *
- * \sa moleculePrepareInserted()
+/** Removes a molecule from the scene.
+ *
+ * * \sa moleculePrepareRemoved()
  *
  * @param _id id of molecule to remove
  */
-void GLWorldScene::moleculePrepareRemoved(const moleculeId_t _id)
+void GLWorldScene::moleculeRemoved(const moleculeId_t _id)
 {
   LOG(3, "INFO: GLWorldScene: Received signal moleculePrepareRemoved for molecule "+toString(_id)+".");
@@ -363,25 +366,13 @@
 
   MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_id);
-  if ( iter == MoleculesinSceneMap.end())
+  if ( iter == MoleculesinSceneMap.end()) {
     RemovalMolecules.insert(_id);
-
-  emit moleculePreparedRemoved(_id);
-}
-
-/** Removes a molecule from the scene.
- *
- * * \sa moleculePrepareRemoved()
- *
- * @param _id id of molecule to remove
- */
-void GLWorldScene::moleculeRemoved(const moleculeId_t _id)
-{
-  boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
-
-  MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_id);
-  GLMoleculeObject_molecule *molObject = iter->second;
-  molObject->disconnect();
-  MoleculesinSceneMap.erase(iter);
-  delete molObject;
+  } else {
+    LOG(1, "DEBUG: Removing GLMoleculeObject_molecule to id " << _id);
+    GLMoleculeObject_molecule *molObject = iter->second;
+    molObject->disconnect();
+    MoleculesinSceneMap.erase(iter);
+    delete molObject;
+  }
 
   // remove any possible state changes left
@@ -397,4 +388,5 @@
 void GLWorldScene::moleculesVisibilityChanged(const moleculeId_t _id, bool _visible)
 {
+  boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
   MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_id);
   ASSERT( iter != MoleculesinSceneMap.end(),
@@ -506,4 +498,5 @@
 
   {
+    boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
     // Remove from map.
     MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(oldId);
@@ -525,4 +518,5 @@
 
   {
+    boost::recursive_mutex::scoped_lock lock(MoleculeMissedStateMap_mutex);
     // Remove and re-insert from map if present.
     MoleculeMissedStateMap_t::iterator iter = MoleculeMissedStateMap.find(oldId);
@@ -537,4 +531,5 @@
 void GLWorldScene::AtomSelected(const moleculeId_t _molid, const atomId_t _id)
 {
+  boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
   MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_molid);
   if (iter != MoleculesinSceneMap.end())
@@ -550,4 +545,5 @@
 void GLWorldScene::AtomUnselected(const moleculeId_t _molid, const atomId_t _id)
 {
+  boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
   MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_molid);
   if (iter != MoleculesinSceneMap.end())
@@ -563,5 +559,6 @@
 void GLWorldScene::MoleculeSelected(const moleculeId_t _molid)
 {
-  MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_molid);
+  boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
+MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_molid);
   if (iter != MoleculesinSceneMap.end())
     QMetaObject::invokeMethod(iter->second,        // pointer to a QObject
@@ -575,4 +572,5 @@
 void GLWorldScene::MoleculeUnselected(const moleculeId_t _molid)
 {
+  boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
   MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_molid);
   if (iter != MoleculesinSceneMap.end())
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision e254484494f1093b5f83e79385d6f87cc3ea6588)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision 7c7c4adf3a00ea2410433016fef5f193bab8b957)
@@ -83,10 +83,8 @@
   void hoverChanged(const moleculeId_t, int);
   void moleculePreparedInserted(const moleculeId_t _id);
-  void moleculePreparedRemoved(const moleculeId_t _id);
 
 private slots:
   void atomClicked(atomId_t no);
   void moleculeClicked(moleculeId_t no);
-  void moleculePrepareRemoved(const moleculeId_t _id);
   void moleculePrepareInserted(const moleculeId_t _id);
   void moleculeRemoved(const moleculeId_t _id);
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp	(revision e254484494f1093b5f83e79385d6f87cc3ea6588)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldView.cpp	(revision 7c7c4adf3a00ea2410433016fef5f193bab8b957)
@@ -93,5 +93,4 @@
   connect(this, SIGNAL(atomInserted(const moleculeId_t, const atomId_t)), worldscene, SLOT(atomInserted(const moleculeId_t, const atomId_t)), Qt::DirectConnection);
   connect(this, SIGNAL(moleculeInserted(const moleculeId_t)), worldscene, SLOT(moleculePrepareInserted(const moleculeId_t)), Qt::DirectConnection);
-  connect(this, SIGNAL(moleculeRemoved(const moleculeId_t)), worldscene, SLOT(moleculePrepareRemoved(const moleculeId_t)), Qt::DirectConnection);
   //connect(this, SIGNAL(changed()), this, SLOT(updateGL()));
   connect(this, SIGNAL(changed()), this, SLOT(sceneChangeSignalled()));
@@ -370,7 +369,8 @@
 
   if (mol != NULL) {
-
-    // sign off
-    signOffFromMolecule(mol);
+    ObservedMolecules.erase(mol);
+//
+//    // sign off
+//    signOffFromMolecule(mol);
 
     // emit removed signal
Index: src/UIElements/Views/Qt4/Qt3D/ObservedValue_wCallback.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/ObservedValue_wCallback.hpp	(revision 7c7c4adf3a00ea2410433016fef5f193bab8b957)
+++ src/UIElements/Views/Qt4/Qt3D/ObservedValue_wCallback.hpp	(revision 7c7c4adf3a00ea2410433016fef5f193bab8b957)
@@ -0,0 +1,52 @@
+/*
+ * ObservedValue_wCallback.hpp
+ *
+ *  Created on: Oct 16, 2015
+ *      Author: heber
+ */
+
+
+#ifndef OBSERVEDVALUE_WCALLBACK_HPP_
+#define OBSERVEDVALUE_WCALLBACK_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "CodePatterns/ObservedValue.hpp"
+#include "CodePatterns/Observer/Observable.hpp"
+
+/** We derive from ObservedValue in order to tell owning instance about
+ * subjectKilled() having been called.
+ */
+template <class T>
+class ObservedValue_wCallback : public ObservedValue<T>
+{
+public:
+  ObservedValue_wCallback(
+      const Observable * const _owner,
+      const boost::function<T()> &_recalcMethod,
+      const std::string &_name,
+      const T &_initialvalue,
+      const Observable::channels_t &_channels,
+      const boost::function<void()> &_callback) :
+        ObservedValue<T>(_owner, _recalcMethod, _name, _initialvalue, _channels),
+        callback(_callback)
+  {}
+  virtual ~ObservedValue_wCallback()
+  {}
+
+protected:
+  virtual void subjectKilled(Observable *publisher)
+  {
+    ObservedValue<T>::subjectKilled(publisher);
+    callback();
+  }
+
+private:
+  //!> callback function to tell other entity about subjectKilled
+  const boost::function<void()> callback;
+};
+
+#endif /* OBSERVEDVALUE_WCALLBACK_HPP_ */
