Index: src/UIElements/Qt4/InstanceBoard/ObservedValue_UpdateAtoms.hpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/ObservedValue_UpdateAtoms.hpp	(revision 494478e91be04149753f2f153a7dfad4d8911944)
+++ src/UIElements/Qt4/InstanceBoard/ObservedValue_UpdateAtoms.hpp	(revision 494478e91be04149753f2f153a7dfad4d8911944)
@@ -0,0 +1,87 @@
+/*
+ * ObservedValue_UpdateAtoms.hpp
+ *
+ *  Created on: Oct 17, 2015
+ *      Author: heber
+ */
+
+
+#ifndef OBSERVEDVALUE_UPDATEATOMS_HPP_
+#define OBSERVEDVALUE_UPDATEATOMS_HPP_
+
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <set>
+
+#include <boost/function.hpp>
+
+#include "ObservedValue_wCallback.hpp"
+
+#include "Descriptors/MoleculeIdDescriptor.hpp"
+#include "types.hpp"
+#include "World.hpp"
+
+/** This is a specialization of ObservedValue_wCallback for a set of atomic ids.
+ *
+ * The problem is that on an update signal we only get a single id. However, get()
+ * requires us to return a set of ids (namely all contained atoms by id and update
+ * only gives left or added ones).
+ *
+ * Hence, we need to add a member variable storing the current set.
+ *
+ */
+class ObservedValue_UpdateAtoms : public ObservedValue_wCallback< std::set<atomId_t>, moleculeId_t >
+{
+  typedef std::set<atomId_t> atoms_t;
+
+public:
+  ObservedValue_UpdateAtoms(
+    const Observable * const _owner,
+    const std::string &_name,
+    const Observable::channels_t &_channels,
+    const boost::function<void(moleculeId_t)> &_callback,
+    const boost::function<const moleculeId_t ()> &_getMolIndex
+    ) :
+      ObservedValue_wCallback<atoms_t, moleculeId_t>(
+          _owner,
+          boost::bind(&ObservedValue_UpdateAtoms::updateAtoms,
+              this), _name,
+              atoms_t(),
+              _channels,
+              _callback,
+              _getMolIndex),
+      getMolIndex(_getMolIndex)
+    {}
+
+  virtual ~ObservedValue_UpdateAtoms ()
+  {}
+
+protected:
+  atoms_t updateAtoms()
+  {
+    atoms_t current_atomset = get();
+    const molecule * const mol = const_cast<const World &>(World::getInstance()).
+        getMolecule(MoleculeById(getMolIndex()));
+    if (mol != NULL) {
+      const atomId_t id = mol->lastChangedAtomId();
+      if (mol->containsAtom(id))
+        current_atomset.insert(id);
+      else
+        current_atomset.erase(id);
+    }
+    return current_atomset;
+  }
+
+private:
+
+  //!> contains the set of atoms displayed
+  atoms_t DisplayedAtoms;
+
+  //!> getter function for the molecule index whose current set of atoms we observe
+  const boost::function<const moleculeId_t ()> getMolIndex;
+};
+
+#endif /* OBSERVEDVALUE_UPDATEATOMS_HPP_ */
Index: src/UIElements/Qt4/InstanceBoard/ObservedValue_wCallback.hpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/ObservedValue_wCallback.hpp	(revision 494478e91be04149753f2f153a7dfad4d8911944)
+++ src/UIElements/Qt4/InstanceBoard/ObservedValue_wCallback.hpp	(revision 494478e91be04149753f2f153a7dfad4d8911944)
@@ -0,0 +1,116 @@
+/*
+ * 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"
+
+#include <string>
+
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+
+/** We derive from ObservedValue in order to tell owning instance about
+ * subjectKilled() having been called.
+ */
+template <class T, class id=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(const id)> &_callback,
+      const boost::function<const id()> &_getId) :
+        ObservedValue<T>(_owner, _recalcMethod, _name, _initialvalue, _channels),
+        callback(_callback),
+        getId(_getId)
+  {}
+  virtual ~ObservedValue_wCallback()
+  {}
+
+protected:
+  virtual void subjectKilled(Observable *publisher)
+  {
+    ObservedValue<T>::subjectKilled(publisher);
+    callback(getId());
+  }
+
+private:
+  //!> callback function to tell other entity about subjectKilled
+  const boost::function<void(const id)> callback;
+  const boost::function<const id()> getId;
+};
+
+/** Specialization of ObservedValue_wCallback for the index ObservedValue.
+ *
+ * The index serves as the unique identifier for the object instance whose
+ * properties are monitored in ObservedValue. Hence, how to give a subjectKilled()
+ * with an external getId() function? For the index the ObservedValue::get() is
+ * the getId() we need to call! Hence, we may simply connect these internally
+ * in this partial template specialization.
+ *
+ * Because atomicNumber_t, atomId_t and moleculeId_t are not unique types but
+ * -- at the writing of this class -- just typedefs, we have to resort to the
+ * trick with two constructors, one taking an external getId(), the other
+ * routing the getId() internally by binding to ObservedValue<T>::get().
+ */
+template <class T>
+class ObservedValue_wCallback<T,T> : 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(const T)> &_callback,
+      const boost::function<const T()> &_getId) :
+        ObservedValue<T>(_owner, _recalcMethod, _name, _initialvalue, _channels),
+        callback(_callback),
+        getId(_getId)
+  {}
+  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(const T)> &_callback) :
+        ObservedValue<T>(_owner, _recalcMethod, _name, _initialvalue, _channels),
+        callback(_callback),
+        getId(boost::bind(&ObservedValue<T>::get, this))
+  {}
+  virtual ~ObservedValue_wCallback()
+  {}
+
+protected:
+  virtual void subjectKilled(Observable *publisher)
+  {
+    ObservedValue<T>::subjectKilled(publisher);
+    callback(getId());
+  }
+
+private:
+  //!> callback function to tell other entity about subjectKilled
+  const boost::function<void(const T)> callback;
+  const boost::function<const T()> getId;
+};
+
+#endif /* OBSERVEDVALUE_WCALLBACK_HPP_ */
Index: src/UIElements/Qt4/InstanceBoard/ObservedValuesContainer_impl.hpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/ObservedValuesContainer_impl.hpp	(revision 65c3231ff9731698df9e1c840c3c6b5d4c56b2cf)
+++ src/UIElements/Qt4/InstanceBoard/ObservedValuesContainer_impl.hpp	(revision 494478e91be04149753f2f153a7dfad4d8911944)
@@ -38,20 +38,4 @@
   ++(iter->second.second);
   typename T::ptr _molecule(new T(obsvalues, board));
-
-  return _molecule;
-}
-
-template <>
-typename QtObservedMolecule::ptr
-ObservedValuesContainer<QtObservedMolecule,moleculeId_t>::get(const moleculeId_t _id)
-{
-  typename CountedObservedValues_t::iterator iter = ObservedValues.find(_id);
-  ASSERT( iter != ObservedValues.end(),
-      "ObservedValuesContainer::getObservedValues() - no observed values present for "
-      +NameOfType+" "+toString(_id));
-  const ObservedValues_t &obsvalues = iter->second.first;
-  // increase refcount
-  ++(iter->second.second);
-  typename QtObservedMolecule::ptr _molecule(new QtObservedMolecule(obsvalues));
 
   return _molecule;
Index: src/UIElements/Qt4/InstanceBoard/QtObservedAtom.cpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/QtObservedAtom.cpp	(revision 65c3231ff9731698df9e1c840c3c6b5d4c56b2cf)
+++ src/UIElements/Qt4/InstanceBoard/QtObservedAtom.cpp	(revision 494478e91be04149753f2f153a7dfad4d8911944)
@@ -48,5 +48,5 @@
 #include "World.hpp"
 
-#include "UIElements/Views/Qt4/Qt3D/ObservedValue_wCallback.hpp"
+#include "UIElements/Qt4/InstanceBoard/ObservedValue_wCallback.hpp"
 
 using namespace boost::assign;
Index: src/UIElements/Qt4/InstanceBoard/QtObservedInstanceBoard.cpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/QtObservedInstanceBoard.cpp	(revision 65c3231ff9731698df9e1c840c3c6b5d4c56b2cf)
+++ src/UIElements/Qt4/InstanceBoard/QtObservedInstanceBoard.cpp	(revision 494478e91be04149753f2f153a7dfad4d8911944)
@@ -36,6 +36,6 @@
 #include "QtObservedInstanceBoard.hpp"
 
-#include "UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp"
 #include "UIElements/Qt4/InstanceBoard/QtObservedAtom.hpp"
+#include "UIElements/Qt4/InstanceBoard/QtObservedMolecule.hpp"
 
 #include "CodePatterns/MemDebug.hpp"
@@ -134,7 +134,7 @@
             getMolecule(MoleculeById(_id));
         if (_molecule != NULL) {
-          ObservedValues_t ObservedValues(GLMoleculeObject_molecule::MAX_ObservedTypes);
+          ObservedValues_t ObservedValues(QtObservedMolecule::MAX_ObservedTypes);
           LOG(3, "DEBUG: InformationBoard initializes ObservedValues for molecule " << _id);
-          GLMoleculeObject_molecule::initObservedValues(
+          QtObservedMolecule::initObservedValues(
               ObservedValues,
               _id,
@@ -327,5 +327,5 @@
   ++(iter->second);
 
-  if (iter->second > GLMoleculeObject_molecule::MAX_ObservedTypes) {
+  if (iter->second > QtObservedMolecule::MAX_ObservedTypes) {
     ASSERT( moleculeObservedValues.getRefCount(_molid) == 0,
         "QtObservedInstanceBoard::moleculecountsubjectKilled() - observed Values for molecule "
Index: src/UIElements/Qt4/InstanceBoard/QtObservedInstanceBoard.hpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/QtObservedInstanceBoard.hpp	(revision 65c3231ff9731698df9e1c840c3c6b5d4c56b2cf)
+++ src/UIElements/Qt4/InstanceBoard/QtObservedInstanceBoard.hpp	(revision 494478e91be04149753f2f153a7dfad4d8911944)
@@ -101,6 +101,6 @@
   friend class GLWorldScene;
   friend class GLMoleculeObject_bond;
-  friend class GLMoleculeObject_molecule;
   friend class QtObservedAtom;
+  friend class QtObservedMolecule;
 
   //!> indicating whether we are still signedOn to World or not
Index: src/UIElements/Qt4/InstanceBoard/QtObservedMolecule.cpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/QtObservedMolecule.cpp	(revision 65c3231ff9731698df9e1c840c3c6b5d4c56b2cf)
+++ src/UIElements/Qt4/InstanceBoard/QtObservedMolecule.cpp	(revision 494478e91be04149753f2f153a7dfad4d8911944)
@@ -36,23 +36,282 @@
 #include "QtObservedMolecule.hpp"
 
+#include "UIElements/Qt4/InstanceBoard/QtObservedInstanceBoard.hpp"
+
 #include "CodePatterns/MemDebug.hpp"
+#include "CodePatterns/Assert.hpp"
+#include "CodePatterns/Log.hpp"
+
+#include <boost/assign.hpp>
+#include <boost/bind.hpp>
+
+#include "UIElements/Qt4/InstanceBoard/ObservedValue_wCallback.hpp"
+#include "UIElements/Qt4/InstanceBoard/ObservedValue_UpdateAtoms.hpp"
+
+#include "Atom/atom.hpp"
+#include "Descriptors/MoleculeIdDescriptor.hpp"
+#include "World.hpp"
+
+using namespace boost::assign;
+
+static const Observable::channels_t getAllObservedChannels()
+{
+  Observable::channels_t channels;
+  channels +=
+      molecule::AtomInserted,
+      molecule::AtomRemoved,
+      molecule::IndexChanged,
+      molecule::MoleculeNameChanged,
+      molecule::BoundingBoxChanged;
+  return channels;
+}
+
+// static instances
+const Observable::channels_t QtObservedMolecule::BoundingBoxChannels(1, molecule::BoundingBoxChanged);
+const Observable::channels_t QtObservedMolecule::IndexChannels(1, molecule::IndexChanged);
+const Observable::channels_t QtObservedMolecule::NameChannels(1, molecule::MoleculeNameChanged);
 
 QtObservedMolecule::QtObservedMolecule(
-    const ObservedValues_t &_obsvalues,
+    const ObservedValues_t &_ObservedValues,
+    QtObservedInstanceBoard &_board,
     QWidget * _parent) :
   QWidget(_parent),
   Observer("QtObservedMolecule"),
-  obsvalues(_obsvalues)
-{}
+  subjectKilledCount(0),
+  AllsignedOnChannels(getAllObservedChannels().size()),
+  signedOffChannels(0),
+  owner(NULL),
+  board(_board),
+  ObservedValues(_ObservedValues)
+{
+  activateObserver();
+}
 
 QtObservedMolecule::~QtObservedMolecule()
-{}
+{
+  deactivateObserver();
+}
+
+void QtObservedMolecule::deactivateObserver()
+{
+  if (owner != NULL) {
+    Observable::channels_t channels = getAllObservedChannels();
+    for (Observable::channels_t::const_iterator iter = channels.begin();
+        iter != channels.end(); ++iter)
+      owner->signOff(this, *iter);
+    owner = NULL;
+    signedOffChannels = AllsignedOnChannels;
+  }
+}
+
+void QtObservedMolecule::activateObserver()
+{
+  // sign on as observer (obtain non-const instance before)
+  const molecule * const _molecule = getMolecule(getMolIndex());
+  if (_molecule != NULL) {
+    Observable::channels_t channels = getAllObservedChannels();
+    owner = static_cast<const Observable *>(_molecule);
+    for (Observable::channels_t::const_iterator iter = channels.begin();
+        iter != channels.end(); ++iter)
+      owner->signOn(this, *iter);
+  } else
+    signedOffChannels = AllsignedOnChannels;
+}
 
 void QtObservedMolecule::update(Observable *publisher)
-{}
+{
+  ASSERT(0,
+      "QtObservedMolecule::update() - general update from unexpected source.");
+}
 
 void QtObservedMolecule::subjectKilled(Observable *publisher)
-{}
+{
+  ++signedOffChannels;
+
+  if (signedOffChannels == AllsignedOnChannels) {
+    // remove owner: no more signOff needed
+    owner = NULL;
+
+    board.moleculecountsubjectKilled(getMolIndex());
+  }
+}
 
 void QtObservedMolecule::recieveNotification(Observable *publisher, Notification_ptr notification)
-{}
+{
+  const molecule * const _molecule = getMolecule(getMolIndex());
+  // when molecule is NULL we will soon get destroyed anyway
+  if (_molecule == NULL)
+    return;
+  if (publisher == dynamic_cast<const Observable*>(_molecule)){
+    // notification from atom
+#ifdef LOG_OBSERVER
+    observerLog().addMessage() << "++ Update of Observer "<< observerLog().getName(static_cast<Observer *>(this))
+          << " received notification from molecule " << getMolIndex() << " for channel "
+          << notification->getChannelNo() << ".";
+#endif
+    switch (notification->getChannelNo()) {
+      case molecule::AtomInserted:
+      {
+        const atomId_t _id = _molecule->lastChangedAtomId();
+        emit atomInserted(_id);
+        break;
+      }
+      case molecule::AtomRemoved:
+      {
+        const atomId_t _id = _molecule->lastChangedAtomId();
+        emit atomRemoved(_id);
+        break;
+      }
+      case molecule::BoundingBoxChanged:
+      {
+  #ifdef LOG_OBSERVER
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that bounding box has changed.";
+  #endif
+        emit tesselationhullChanged();
+        emit boundingboxChanged();
+        break;
+      }
+      case molecule::IndexChanged:
+      {
+  #ifdef LOG_OBSERVER
+        const atomId_t _id = _molecule->lastChangedAtomId();
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that atom "+toString(_id)+"'s index has changed.";
+  #endif
+        emit indexChanged();
+        break;
+      }
+      case molecule::MoleculeNameChanged:
+      {
+  #ifdef LOG_OBSERVER
+        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that name has changed.";
+  #endif
+        emit nameChanged();
+        break;
+      }
+      default:
+        break;
+    }
+  }
+}
+
+const molecule * const QtObservedMolecule::getMolecule(const moleculeId_t _id)
+{
+  const molecule * const mol = const_cast<const World &>(World::getInstance()).
+      getMolecule(MoleculeById(_id));
+  return mol;
+}
+
+static molecule::BoundingBoxInfo initBoundingBox()
+{
+  molecule::BoundingBoxInfo info;
+  info.position = zeroVec;
+  info.radius = 0.;
+  return info;
+}
+
+void QtObservedMolecule::initObservedValues(
+    ObservedValues_t &_ObservedValues,
+    const moleculeId_t _molid,
+    const molecule * const _molref,
+    const boost::function<void(const moleculeId_t)> &_subjectKilled)
+{
+  /* This is an old note from when the code was still part of cstor's initializer body.
+   * TODO: Probably does not apply anymore but has not yet been tested.
+   *
+   * We must not use boost::cref(this) as "this" has not been properly constructed and seemingly
+   * boost::cref tries to do some magic to grasp the inheritance hierarchy which fails because
+   * the class has not been fully constructed yet. "This" itself seems to be working fine.
+   */
+
+  ASSERT( _ObservedValues.size() == MAX_ObservedTypes,
+      "QtObservedMolecule::initObservedValues() - given ObservedValues has not correct size.");
+
+  // fill ObservedValues: index first
+  const boost::function<moleculeId_t ()> MolIndexUpdater(
+      boost::bind(&QtObservedMolecule::updateIndex));
+
+  ObservedValue_wCallback<moleculeId_t> * const IndexObservable =
+      new ObservedValue_wCallback<moleculeId_t>(
+        _molref,
+        MolIndexUpdater,
+        "MoleculeIndex_"+toString(_molid),
+        _molid,
+        IndexChannels,
+        _subjectKilled);
+  _ObservedValues[MolIndex] = IndexObservable;
+
+  const boost::function<const moleculeId_t ()> MolIndexGetter =
+      boost::bind(&ObservedValue_wCallback<moleculeId_t>::get,
+          IndexObservable);
+
+  // fill ObservedValues: then all the other that need index
+  const boost::function<std::string ()> MolNameUpdater(
+      boost::bind(&QtObservedMolecule::updateName, MolIndexGetter));
+  const boost::function<molecule::BoundingBoxInfo ()> BoundingBoxUpdater(
+      boost::bind(&QtObservedMolecule::updateBoundingBox, MolIndexGetter));
+
+  _ObservedValues[MolName] = new ObservedValue_wCallback<std::string, moleculeId_t>(
+      _molref,
+      MolNameUpdater,
+      "MoleculeName_"+toString(_molid),
+      MolNameUpdater(),
+      NameChannels,
+      _subjectKilled,
+      MolIndexGetter);
+  _ObservedValues[BoundingBox] = new ObservedValue_wCallback<molecule::BoundingBoxInfo, moleculeId_t>(
+      _molref,
+      BoundingBoxUpdater,
+      "MoleculeBoundingBox_"+toString(_molid),
+      initBoundingBox(),
+      BoundingBoxChannels,
+      _subjectKilled,
+      MolIndexGetter);
+}
+
+void QtObservedMolecule::destroyObservedValues(
+    std::vector<boost::any> &_ObservedValues)
+{
+  delete boost::any_cast<ObservedValue_wCallback<moleculeId_t> *>(_ObservedValues[MolIndex]);
+  delete boost::any_cast<ObservedValue_wCallback<std::string, moleculeId_t> *>(_ObservedValues[MolName]);
+  delete boost::any_cast<ObservedValue_wCallback<molecule::BoundingBoxInfo, moleculeId_t> *>(_ObservedValues[BoundingBox]);
+  _ObservedValues.clear();
+}
+
+molecule::BoundingBoxInfo QtObservedMolecule::updateBoundingBox(
+    const boost::function<const moleculeId_t ()> &_getMolIndex)
+{
+  const molecule * const mol = getMolecule(_getMolIndex());
+  if (mol != NULL)
+    return mol->getBoundingBox();
+  else
+    return molecule::BoundingBoxInfo();
+}
+
+moleculeId_t QtObservedMolecule::updateIndex()
+{
+  return const_cast<const World &>(World::getInstance()).lastChangedMolId();
+}
+
+std::string QtObservedMolecule::updateName(
+    const boost::function<const moleculeId_t ()> &_getMolIndex)
+{
+  const molecule * const mol = getMolecule(_getMolIndex());
+  if (mol != NULL)
+    return mol->getName();
+  else
+    return std::string("");
+}
+
+moleculeId_t QtObservedMolecule::getMolIndex() const
+{
+  return boost::any_cast<ObservedValue_wCallback<moleculeId_t> *>(ObservedValues[MolIndex])->get();
+}
+
+std::string QtObservedMolecule::getMolName() const
+{
+  return boost::any_cast<ObservedValue_wCallback<std::string, moleculeId_t> *>(ObservedValues[MolName])->get();
+}
+
+molecule::BoundingBoxInfo QtObservedMolecule::getBoundingBox() const
+{
+  return boost::any_cast<ObservedValue_wCallback<molecule::BoundingBoxInfo, moleculeId_t> *>(ObservedValues[BoundingBox])->get();
+}
Index: src/UIElements/Qt4/InstanceBoard/QtObservedMolecule.hpp
===================================================================
--- src/UIElements/Qt4/InstanceBoard/QtObservedMolecule.hpp	(revision 65c3231ff9731698df9e1c840c3c6b5d4c56b2cf)
+++ src/UIElements/Qt4/InstanceBoard/QtObservedMolecule.hpp	(revision 494478e91be04149753f2f153a7dfad4d8911944)
@@ -17,8 +17,11 @@
 #include <QtGui/QWidget>
 
+#include <boost/function.hpp>
 #include <boost/shared_ptr.hpp>
 
+#include "CodePatterns/Observer/Observable.hpp"
 #include "CodePatterns/Observer/Observer.hpp"
 
+#include "molecule.hpp"
 #include "UIElements/Qt4/InstanceBoard/ObservedValue_types.hpp"
 #include "UIElements/Qt4/InstanceBoard/ObservedValuesContainer.hpp"
@@ -41,4 +44,10 @@
   Q_OBJECT
 
+public:
+
+  //!> typedef for instance wrapped in shared ptr
+  typedef boost::shared_ptr<QtObservedMolecule> ptr;
+
+private:
   //!> ObservedValuesContainer needs to access private cstor and dstor
   friend class ObservedValuesContainer<QtObservedMolecule, moleculeId_t>;
@@ -46,14 +55,13 @@
   friend class QtObservedInstanceBoard;
 
-  //!> typedef for instance wrapped in shared ptr
-  typedef boost::shared_ptr<QtObservedMolecule> ptr;
-
   /** Cstor of QtObservedMolecule.
    *
-   * \param _obsvalues ref to set of observed values for this instance
+   * \param _ObservedValues ref to set of observed values for this instance
+   * \param _board ref to InstanceBoard for callbacks on occasion of subjectKilled()
    * \param _parent Qt parent to automatically destroy when parent is destroyed
    */
   QtObservedMolecule(
-      const ObservedValues_t &_obsvalues,
+      const ObservedValues_t &_ObservedValues,
+      QtObservedInstanceBoard &_board,
       QWidget * _parent=0);
 
@@ -70,12 +78,105 @@
   void recieveNotification(Observable *publisher, Notification_ptr notification);
 
+  /** 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;
+
+  static const molecule * const getMolecule(const moleculeId_t _id);
+
 signals:
-
-private slots:
-
+  void indexChanged();
+  void nameChanged();
+  void tesselationhullChanged();
+  void boundingboxChanged();
+  void atomInserted(const atomId_t);
+  void atomRemoved(const atomId_t);
 
 private:
+
+  void activateObserver();
+  void deactivateObserver();
+
+private:
+  static molecule::BoundingBoxInfo updateBoundingBox(
+      const boost::function<const moleculeId_t ()> &_getMolIndex);
+  static moleculeId_t updateIndex();
+  static std::string updateName(
+      const boost::function<const moleculeId_t ()> &_getMolIndex);
+
+  //!> list of channels when bounding box needs to update
+  static const Observable::channels_t BoundingBoxChannels;
+  //!> list of channels when the index needs to update
+  static const Observable::channels_t IndexChannels;
+  //!> list of channels when the name needs to update
+  static const Observable::channels_t NameChannels;
+
+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,
+    //!> gives the size of the enumeration
+    MAX_ObservedTypes
+  };
+
+  /** Initializes all \a _ObservedValues entries.
+   *
+   * \param _ObservedValues vector of ObservedValue to be filled
+   * \param _moid molecule id
+   * \param _molref reference to molecule
+   * \param _subjectKilled ref to function to call on subjectKilled()
+   */
+  static void initObservedValues(
+      ObservedValues_t &_ObservedValues,
+      const moleculeId_t _molid,
+      const molecule * const _molref,
+      const boost::function<void(const moleculeId_t)> &_subjectKilled);
+
+  /** Destroys all \a ObservedValues entries.
+   *
+   * \param _ObservedValues vector of ObservedValue to be destroyed
+   */
+  static void destroyObservedValues(
+      std::vector<boost::any> &_ObservedValues);
+
+  //!> counts how many ObservedValues have already been subjectKilled()
+  mutable size_t subjectKilledCount;
+
+private:
+
+  //!> we get multiple subjectKilled(), count and call callback() only on last
+  const unsigned int AllsignedOnChannels;
+  unsigned int signedOffChannels;
+
+  //!> the Observable we are signed on, also indicates whether we are sign on (not NULL)
+  const Observable *owner;
+
+private:
+
+  //!> reference to InstanceBoard for callbacks on subjectKilled()
+  QtObservedInstanceBoard & board;
+
   //!> internal reference to ObservedValues held by QtObservedInstanceBoard
-  const ObservedValues_t &obsvalues;
+  ObservedValues_t ObservedValues;
 };
 
