Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp	(revision b4bd0ec170830621ec3bcc64a4a1a99403399bd9)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.cpp	(revision 96f14ae4f021b1976486ad5658a68c30645c7467)
@@ -77,11 +77,5 @@
   connect( ObservedAtom.get(), SIGNAL(elementChanged()), this, SLOT(resetElement()));
   connect( ObservedAtom.get(), SIGNAL(positionChanged()), this, SLOT(resetPosition()));
-  connect( ObservedAtom.get(), SIGNAL(bondsChanged()), this, SLOT(resetBonds()));
   connect( ObservedAtom.get(), SIGNAL(selectedChanged()), this, SLOT(resetSelected()));
-
-  // use that ObservedValues::AtomBonds is always up-to-date
-  // don't call here, is done by GLMoleculeObject_molecule
-//  resetBonds();
-
 }
 
@@ -104,5 +98,5 @@
 {
   const Vector Position = ObservedAtom->getAtomPosition();
-  LOG(4, "INFO: GLMoleculeObject_atom::resetIndex() - new position is "+toString(Position)+".");
+  LOG(4, "INFO: GLMoleculeObject_atom::resetPosition() - new position is "+toString(Position)+".");
   setPosition(QVector3D(Position[0], Position[1], Position[2]));
 }
@@ -118,10 +112,10 @@
     elementno = 1;
   }
-  LOG(4, "INFO: GLMoleculeObject_atom::resetIndex() - new element number is "+toString(elementno)+".");
+  LOG(4, "INFO: GLMoleculeObject_atom::resetElement() - new element number is "+toString(elementno)+".");
 
   // set materials
   QGLMaterial *elementmaterial = getMaterial(elementno);
   ASSERT(elementmaterial != NULL,
-      "GLMoleculeObject_atom::GLMoleculeObject_atom() - QGLMaterial ref from getter function is NULL.");
+      "GLMoleculeObject_atom::resetElement() - QGLMaterial ref from getter function is NULL.");
   setMaterial(elementmaterial);
 
@@ -134,33 +128,4 @@
   }
   setScale( radius / 4. );
-}
-
-void GLMoleculeObject_atom::resetBonds()
-{
-  QtObservedAtom::ListOfBonds_t ListOfBonds_new = ObservedAtom->getAtomBonds();
-  std::sort(ListOfBonds_new.begin(), ListOfBonds_new.end());
-  QtObservedAtom::ListOfBonds_t BondsToAdd;
-  std::set_difference(
-      ListOfBonds_new.begin(), ListOfBonds_new.end(),
-      ListOfBonds.begin(), ListOfBonds.end(),
-      std::back_inserter(BondsToAdd));
-  QtObservedAtom::ListOfBonds_t BondsToRemove;
-  std::set_difference(
-      ListOfBonds.begin(), ListOfBonds.end(),
-      ListOfBonds_new.begin(), ListOfBonds_new.end(),
-      std::back_inserter(BondsToRemove));
-  for (QtObservedAtom::ListOfBonds_t::const_iterator iter = BondsToAdd.begin();
-      iter != BondsToAdd.end();
-      ++iter) {
-    const GLMoleculeObject_bond::SideOfBond side = (iter->first == ObservedAtom->getAtomIndex()) ?
-        GLMoleculeObject_bond::left : GLMoleculeObject_bond::right;
-    emit BondsAdded(iter->first, iter->second, side);
-  }
-  for (QtObservedAtom::ListOfBonds_t::const_iterator iter = BondsToRemove.begin();
-      iter != BondsToRemove.end();
-      ++iter) {
-    emit BondsRemoved(iter->first, iter->second);
-  }
-  ListOfBonds = ListOfBonds_new;
 }
 
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision b4bd0ec170830621ec3bcc64a4a1a99403399bd9)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp	(revision 96f14ae4f021b1976486ad5658a68c30645c7467)
@@ -41,6 +41,4 @@
   void draw(QGLPainter *painter, const QVector4D &cameraPlane);
 
-  void resetBonds();
-
 private slots:
   void wasClicked();
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.cpp	(revision b4bd0ec170830621ec3bcc64a4a1a99403399bd9)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.cpp	(revision 96f14ae4f021b1976486ad5658a68c30645c7467)
@@ -47,7 +47,5 @@
 #include "CodePatterns/Assert.hpp"
 #include "CodePatterns/Log.hpp"
-#include "CodePatterns/Observer/Notification.hpp"
-#include "CodePatterns/Observer/ObserverLog.hpp"
-#include "Descriptors/AtomIdDescriptor.hpp"
+
 #include "Atom/atom.hpp"
 #include "Bond/bond.hpp"
@@ -56,275 +54,69 @@
 #include "LinearAlgebra/Line.hpp"
 #include "LinearAlgebra/Vector.hpp"
-#include "UIElements/Qt4/InstanceBoard/ObservedValue_wCallback.hpp"
 #include "World.hpp"
-
-
-// static entities
-const Observable::channels_t
-GLMoleculeObject_bond::IndexChannels(1, AtomObservable::IndexChanged);
-const Observable::channels_t
-GLMoleculeObject_bond::BondPositionChannels(1, AtomObservable::PositionChanged);
-const Observable::channels_t
-GLMoleculeObject_bond::BondDegreeChannels(1, BondObservable::DegreeChanged);
-const Observable::channels_t
-GLMoleculeObject_bond::BondElementChannels(1, AtomObservable::ElementChanged);
-
-static GLMoleculeObject_bond::bondIds_t getBondIdsForIds(
-    const boost::function<const atomId_t()> &_left,
-    const boost::function<const atomId_t()> &_right)
-{
-  return std::make_pair(_left(), _right());
-}
 
 GLMoleculeObject_bond::GLMoleculeObject_bond(
     QGLSceneNode *mesh[],
     QObject *parent,
-    const bondIds_t bondIds,
+    QtObservedBond::ptr &_ObservedBond,
     const enum SideOfBond side) :
   GLMoleculeObject(mesh, parent),
-  Observer(std::string("GLMoleculeObject_bond")
-      +toString(bondIds.first)
-      +std::string("-")
-      +toString(bondIds.second)),
-  leftowner(getAtomConst(bondIds.first)),
-  rightowner(getAtomConst(bondIds.second)),
-  bondowner(getAtomConst(bondIds.first)->getBond(getAtomConst(bondIds.second)).get()),
   BondSide(side),
-  ObservedValues(MAX_ObservedTypes),
-  subjectKilledCount(0),
-  leftobservable_enabled(false),
-  rightobservable_enabled(false),
-  board_subjectKilled(
-      boost::bind(
-          static_cast<void (GLMoleculeObject_bond::*) ()>(
-              &GLMoleculeObject_bond::countsubjectKilled),
-          this))
+  ObservedBond(_ObservedBond)
 {
-  boost::function<void(const atomId_t &)> leftsubjectKilled =
-      boost::bind(
-          static_cast<void (GLMoleculeObject_bond::*) (const atomId_t &)>(
-              &GLMoleculeObject_bond::countsubjectKilled),
-          this, _1);
-  boost::function<void(const atomId_t &)> rightsubjectKilled =
-      boost::bind(
-          static_cast<void (GLMoleculeObject_bond::*) (const atomId_t &)>(
-              &GLMoleculeObject_bond::countsubjectKilled)
-              , this, _1);
-  boost::function<void(const bondIds_t &)> bondsubjectKilled =
-      boost::bind(
-          static_cast<void (GLMoleculeObject_bond::*) (const bondIds_t &)>(
-              &GLMoleculeObject_bond::countsubjectKilled)
-              , this, _1);
-  initObservedValues(
-      ObservedValues,
-      bondIds.first,
-      bondIds.second,
-      leftowner,
-      rightowner,
-      bondowner,
-      leftsubjectKilled,
-      rightsubjectKilled,
-      bondsubjectKilled);
-
-  init();
-}
-
-GLMoleculeObject_bond::GLMoleculeObject_bond(
-    QGLSceneNode *mesh[],
-    QObject *parent,
-    const bondIds_t bondIds,
-    const enum SideOfBond side,
-    std::vector<boost::any> &_ObservedValues,
-    const boost::function<void (const bondIds_t)> &_subjectKilled) :
-  GLMoleculeObject(mesh, parent),
-  Observer(std::string("GLMoleculeObject_bond")
-      +toString(bondIds.first)
-      +std::string("-")
-      +toString(bondIds.second)),
-  leftowner(getAtomConst(bondIds.first)),
-  rightowner(getAtomConst(bondIds.second)),
-  bondowner(getAtomConst(bondIds.first)->getBond(getAtomConst(bondIds.second)).get()),
-  BondSide(side),
-  ObservedValues(_ObservedValues),
-  subjectKilledCount(0),
-  leftobservable_enabled(false),
-  rightobservable_enabled(false),
-  board_subjectKilled(_subjectKilled)
-{
-  init();
-}
-
-void GLMoleculeObject_bond::init()
-{
-  // sign on as observer (obtain non-const instance before)
-  bondowner->signOn(this, BondObservable::BondRemoved);
-  bondowner->signOn(this, BondObservable::DegreeChanged);
-  bond_enabled = true;
-  leftowner->signOn(this, AtomObservable::PositionChanged);
-  leftowner->signOn(this, AtomObservable::ElementChanged);
-  leftobservable_enabled = true;
-  rightowner->signOn(this, AtomObservable::PositionChanged);
-  rightowner->signOn(this, AtomObservable::ElementChanged);
-  rightobservable_enabled = true;
-
   resetElement();
   resetPosition();
   resetWidth();
 
-  connect(this, SIGNAL(elementChanged()), this, SLOT(resetElement()), Qt::QueuedConnection);
-  connect(this, SIGNAL(positionChanged()), this, SLOT(resetPosition()), Qt::QueuedConnection);
-  connect(this, SIGNAL(degreeChanged()), this, SLOT(resetWidth()), Qt::QueuedConnection);
+  // connect to observed bond's signals
+  connect(_ObservedBond.get(), SIGNAL(degreeChanged()), this, SLOT(resetWidth()));
+  if (side == left)
+    connect(_ObservedBond.get(), SIGNAL(leftAtomElementChanged()), this, SLOT(resetElement()));
+  else
+    connect(_ObservedBond.get(), SIGNAL(rightAtomElementChanged()), this, SLOT(resetElement()));
+  connect(_ObservedBond.get(), SIGNAL(leftAtomPositionChanged()), this, SLOT(resetPosition()));
+  connect(_ObservedBond.get(), SIGNAL(rightAtomPositionChanged()), this, SLOT(resetPosition()));
+}
+
+static const atomicNumber_t& getElement(
+    const QtObservedBond::ptr &_ObservedBond,
+    const enum GLMoleculeObject_bond::SideOfBond _side)
+{
+  if (_side == GLMoleculeObject_bond::left)
+    return _ObservedBond->getLeftAtomElement();
+  else
+    return _ObservedBond->getRightAtomElement();
+}
+
+static const Vector& getPosition(
+    const QtObservedBond::ptr &_ObservedBond,
+    const enum GLMoleculeObject_bond::SideOfBond _side)
+{
+  if (_side == GLMoleculeObject_bond::left)
+    return _ObservedBond->getLeftAtomPosition();
+  else
+    return _ObservedBond->getRightAtomPosition();
+}
+
+static const Vector& getOtherPosition(
+    const QtObservedBond::ptr &_ObservedBond,
+    const enum GLMoleculeObject_bond::SideOfBond _side)
+{
+  if (_side == GLMoleculeObject_bond::left)
+    return _ObservedBond->getRightAtomPosition();
+  else
+    return _ObservedBond->getLeftAtomPosition();
 }
 
 GLMoleculeObject_bond::~GLMoleculeObject_bond()
 {
-  LOG(3, "DEBUG: Destroying  GLMoleculeObject_bond to bond [" <<
-      getleftIndex() << "," << getrightIndex() << "] and side " << BondSide << ".");
+  LOG(4, "DEBUG: Destroying  GLMoleculeObject_bond to bond [" <<
+      ObservedBond->getBondIndex() << "] and side " << BondSide << ".");
   // signOff() if not already done
-  removeChannels();
-  destroyObservedValues(ObservedValues);
-}
-
-void GLMoleculeObject_bond::removeChannels()
-{
-  // at this point both atoms should still be alive, hence we may safely sign off
-  // from the AtomObservable itself
-  if (bond_enabled) {
-    if (bondowner != NULL) {
-      bondowner->signOff(this, BondObservable::BondRemoved);
-      bondowner->signOff(this, BondObservable::DegreeChanged);
-    }
-    bond_enabled = false;
-  }
-  if (leftobservable_enabled) {
-    if (leftowner != NULL) {
-      leftowner->signOff(this, AtomObservable::PositionChanged);
-      leftowner->signOff(this, AtomObservable::ElementChanged);
-    }
-    leftobservable_enabled = false;
-  }
-  if (rightobservable_enabled) {
-    if (rightowner != NULL) {
-      rightowner->signOff(this, AtomObservable::PositionChanged);
-      rightowner->signOff(this, AtomObservable::ElementChanged);
-    }
-    rightobservable_enabled = false;
-  }
-}
-
-void GLMoleculeObject_bond::update(Observable *publisher)
-{
-  ASSERT(0, "GLMoleculeObject_bond::update() - we are not signed on for any global updates.");
-}
-
-void GLMoleculeObject_bond::subjectKilled(Observable *publisher)
-{
-  // we signOff from all other sources
-  removeChannels();
-  // check whether we should be removed
-  board_subjectKilled(std::make_pair(getleftIndex(), getrightIndex()));
-}
-
-void GLMoleculeObject_bond::recieveNotification(Observable *publisher, Notification_ptr notification)
-{
-#ifdef LOG_OBSERVER
-  if (publisher == static_cast<const Observable *>(bondowner)) {
-    observerLog().addMessage() << "++ Update of Observer "
-        << observerLog().getName(static_cast<Observer*>(this))
-        << " received notification from bond for channel "
-        << notification->getChannelNo() << ".";
-  } else if (publisher == static_cast<const Observable * const>(leftowner)) {
-    observerLog().addMessage() << "++ Update of Observer "
-        << observerLog().getName(static_cast<Observer*>(this))
-        << " received notification from leftatom " << getleftIndex() << " for channel "
-        << notification->getChannelNo() << ".";
-  } else if (publisher == static_cast<const Observable * const>(rightowner)) {
-    observerLog().addMessage() << "++ Update of Observer "
-        << observerLog().getName(static_cast<Observer*>(this))
-        << " received notification from rightatom " << getrightIndex() << " for channel "
-        << notification->getChannelNo() << ".";
-  }
-#endif
-  if (publisher == static_cast<const Observable *>(bondowner)){
-    switch (notification->getChannelNo()) {
-    case BondObservable::BondRemoved:
-//      removeMe();
-      break;
-    case BondObservable::DegreeChanged:
-      emit degreeChanged();
-      break;
-    default:
-      ASSERT(0, "GLMoleculeObject_bond::recieveNotification() - unknown signal.");
-      break;
-    }
-  } else {
-    // from an atom
-    switch (notification->getChannelNo()) {
-    case AtomObservable::PositionChanged:
-      LOG(2, "INFO: Received notification of PositionChanged.");
-      emit positionChanged();
-      break;
-    case AtomObservable::ElementChanged:
-      LOG(2, "INFO: Received notification of ElementChanged.");
-      emit elementChanged();
-      break;
-    default:
-      break;
-    }
-  }
-}
-
-atomId_t GLMoleculeObject_bond::updateIndex()
-{
-  return const_cast<const World &>(World::getInstance()).lastChangedAtomId();
-}
-
-Vector GLMoleculeObject_bond::updateLeftPosition(
-    const boost::function<const atomId_t ()> &_getLeftAtomIndex)
-{
-  const atom * const _atom = getAtomConst(_getLeftAtomIndex());
-  return _atom->getPosition();
-}
-
-Vector GLMoleculeObject_bond::updateRightPosition(
-    const boost::function<const atomId_t ()> &_getRightAtomIndex)
-{
-  const atom * const _atom = getAtomConst(_getRightAtomIndex());
-  return _atom->getPosition();
-}
-
-atomicNumber_t GLMoleculeObject_bond::updateLeftElement(
-    const boost::function<const atomId_t ()> &_getLeftAtomIndex)
-{
-  const atom * const _atom = getAtomConst(_getLeftAtomIndex());
-  return _atom->getElementNo();
-}
-
-atomicNumber_t GLMoleculeObject_bond::updateRightElement(
-    const boost::function<const atomId_t ()> &_getRightAtomIndex)
-{
-  const atom * const _atom = getAtomConst(_getRightAtomIndex());
-  return _atom->getElementNo();
-}
-
-int GLMoleculeObject_bond::updateDegree(
-    const boost::function<const atomId_t ()> &_getLeftAtomIndex,
-    const boost::function<const atomId_t ()> &_getRightAtomIndex)
-{
-  const atom * const _leftatom = const_cast<const World &>(World::getInstance()).
-      getAtom(AtomById(_getLeftAtomIndex()));
-  const atom * const _rightatom = const_cast<const World &>(World::getInstance()).
-      getAtom(AtomById(_getRightAtomIndex()));
-  if ((_leftatom != NULL) && (_rightatom != NULL)) {
-    bond::ptr _bond = _leftatom->getBond(_rightatom);
-    return _bond->getDegree();
-  } else {
-    return 1;
-  }
 }
 
 void GLMoleculeObject_bond::resetElement()
 {
-  size_t elementno = getrightElement();
+  const atomicNumber_t& elementno = getElement(ObservedBond, BondSide);
   QGLMaterial *elementmaterial = getMaterial(elementno);
   setMaterial(elementmaterial);
@@ -333,6 +125,6 @@
 void GLMoleculeObject_bond::resetWidth()
 {
-  const double factor = 1.0f+.5f*(getDegree()-1);
-  LOG(2, "DEBUG: GLMoleculeObject_bond::resetWidth() - setting bond's width to " << factor << ".");
+  const double factor = 1.0f+.5f*(ObservedBond->getBondDegree()-1);
+  LOG(4, "DEBUG: GLMoleculeObject_bond::resetWidth() - setting bond's width to " << factor << ".");
   setScaleX(factor);
   setScaleY(factor);
@@ -343,6 +135,6 @@
 void GLMoleculeObject_bond::resetPosition()
 {
-  Vector Position = getleftPosition();
-  Vector OtherPosition = getrightPosition();
+  const Vector& Position = getPosition(ObservedBond, BondSide);
+  const Vector& OtherPosition = getOtherPosition(ObservedBond, BondSide);
   const double distance =
       Position.distance(OtherPosition)/2.;
@@ -355,5 +147,5 @@
   Vector OtherAxis;
   double alpha;
-  a = Position - OtherPosition;
+  a = OtherPosition - Position;
   // construct rotation axis
   b = a;
@@ -370,9 +162,9 @@
   // check
   Vector a_rotated = axis.rotateVector(a, alpha);
-  LOG(3, "INFO: Created cylinder from "// << Position << " to " << OtherPosition
+  LOG(4, "DEBUG: Created cylinder from "// << Position << " to " << OtherPosition
       << a << " to " << a_rotated << " around " << b << " by " << alpha/M_PI*180. << ", respectively.");
 
   // set position (cylinder offset is in its barymetric center)
-  Vector OneFourth(Position - 0.75 * a);
+  Vector OneFourth(OtherPosition - 0.75 * a);
   setPosition(QVector3D(OneFourth[0], OneFourth[1], OneFourth[2]));
   setRotationVector(QVector3D(b[0], b[1], b[2]));
@@ -381,181 +173,2 @@
   emit changed();
 }
-
-atom * const GLMoleculeObject_bond::getAtom(const atomId_t _id)
-{
-  atom * const _atom = World::getInstance().getAtom(AtomById(_id));
-  return _atom;
-}
-
-const atom * const GLMoleculeObject_bond::getAtomConst(const atomId_t _id)
-{
-  const atom * const _atom = const_cast<const World &>(World::getInstance()).
-      getAtom(AtomById(_id));
-  return _atom;
-}
-
-void GLMoleculeObject_bond::countsubjectKilled()
-{
-  ++subjectKilledCount;
-
-  if (subjectKilledCount > ObservedValues.size())
-    emit BondRemoved(getleftIndex(), getrightIndex());
-}
-
-void GLMoleculeObject_bond::initObservedValues(
-    std::vector<boost::any> &_ObservedValues,
-    const atomId_t _leftatomId,
-    const atomId_t _rightatomId,
-    const Observable * const _leftowner,
-    const Observable * const _rightowner,
-    const Observable * const _bondowner,
-    const boost::function<void(const atomId_t &)> &_leftsubjectKilled,
-    const boost::function<void(const atomId_t &)> &_rightsubjectKilled,
-    const boost::function<void(const bondIds_t &)> &_bondsubjectKilled)
-{
-  /* 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,
-      "GLMoleculeObject_bond::initObservedValues() - given ObservedValues has not correct size.");
-
-  // fill ObservedValues: index first
-  // Note that we only need one as the function just checks on the last changed id
-  // and ids cannot be changed simultaneously
-  const boost::function<atomId_t ()> AtomIndexUpdater(
-      boost::bind(&GLMoleculeObject_bond::updateIndex));
-
-  ObservedValue_wCallback<atomId_t> * const LeftIndexObservable =
-      new ObservedValue_wCallback<atomId_t>(
-        _leftowner,
-        AtomIndexUpdater,
-        "Bonds_LeftAtomIndex_"+toString(_leftatomId),
-        _leftatomId,
-        IndexChannels,
-        _leftsubjectKilled);
-  _ObservedValues[leftIndex] = LeftIndexObservable;
-  ObservedValue_wCallback<atomId_t> * const RightIndexObservable =
-      new ObservedValue_wCallback<atomId_t>(
-        _rightowner,
-        AtomIndexUpdater,
-        "Bonds_RightAtomIndex_"+toString(_rightatomId),
-        _rightatomId,
-        IndexChannels,
-        _rightsubjectKilled);
-  _ObservedValues[rightIndex] = RightIndexObservable;
-
-  const boost::function<const atomId_t ()> LeftIndexGetter =
-      boost::bind(&ObservedValue_wCallback<atomId_t>::get,
-          LeftIndexObservable);
-  const boost::function<const atomId_t ()> RightIndexGetter =
-      boost::bind(&ObservedValue_wCallback<atomId_t>::get,
-          RightIndexObservable);
-
-  // fill ObservedValues: then all the other that need index
-  const boost::function<Vector ()> LeftPositionUpdater(
-      boost::bind(&GLMoleculeObject_bond::updateLeftPosition, LeftIndexGetter));
-  const boost::function<Vector ()> RightPositionUpdater(
-      boost::bind(&GLMoleculeObject_bond::updateRightPosition, RightIndexGetter));
-  const boost::function<atomicNumber_t ()> LeftElementUpdater(
-      boost::bind(&GLMoleculeObject_bond::updateLeftElement, LeftIndexGetter));
-  const boost::function<atomicNumber_t ()> RightElementUpdater(
-      boost::bind(&GLMoleculeObject_bond::updateRightElement, RightIndexGetter));
-  const boost::function<int ()> DegreeUpdater(
-      boost::bind(&GLMoleculeObject_bond::updateDegree, LeftIndexGetter, RightIndexGetter));
-  const boost::function<bondIds_t ()> BondIdGetter(
-      boost::bind(&getBondIdsForIds, LeftIndexGetter, RightIndexGetter));
-
-  _ObservedValues[leftPosition] = new ObservedValue_wCallback<Vector, atomId_t>(
-      _leftowner,
-      LeftPositionUpdater,
-      "BondleftPosition_"+toString(_leftatomId),
-      LeftPositionUpdater(),
-      BondPositionChannels,
-      _leftsubjectKilled,
-      LeftIndexGetter);
-  _ObservedValues[rightPosition] = new ObservedValue_wCallback<Vector, atomId_t>(
-      _rightowner,
-      RightPositionUpdater,
-      "BondrightPosition_"+toString(_rightatomId),
-      RightPositionUpdater(),
-      BondPositionChannels,
-      _rightsubjectKilled,
-      RightIndexGetter);
-  _ObservedValues[leftElement] = new ObservedValue_wCallback<atomicNumber_t, atomId_t>(
-      _leftowner,
-      LeftElementUpdater,
-      "BondleftElement"+toString(_leftatomId),
-      LeftElementUpdater(),
-      BondElementChannels,
-      _leftsubjectKilled,
-      LeftIndexGetter);
-  _ObservedValues[rightElement] = new ObservedValue_wCallback<atomicNumber_t, atomId_t>(
-      _rightowner,
-      RightElementUpdater,
-      "BondrightElement"+toString(_rightatomId),
-      RightElementUpdater(),
-      BondElementChannels,
-      _rightsubjectKilled,
-      RightIndexGetter);
-  _ObservedValues[Degree] = new ObservedValue_wCallback<int, bondIds_t>(
-      _bondowner,
-      DegreeUpdater,
-      "BondDegree"+toString(_leftatomId)+"_"+toString(_rightatomId),
-      DegreeUpdater(),
-      BondDegreeChannels,
-      _bondsubjectKilled,
-      BondIdGetter);
-}
-
-void GLMoleculeObject_bond::destroyObservedValues(
-    std::vector<boost::any> &_ObservedValues)
-{
-  delete boost::any_cast<ObservedValue_wCallback<atomId_t> *>(_ObservedValues[leftIndex]);
-  delete boost::any_cast<ObservedValue_wCallback<atomId_t> *>(_ObservedValues[rightIndex]);
-  delete boost::any_cast<ObservedValue_wCallback<Vector,atomId_t> *>(_ObservedValues[leftPosition]);
-  delete boost::any_cast<ObservedValue_wCallback<Vector,atomId_t> *>(_ObservedValues[rightPosition]);
-  delete boost::any_cast<ObservedValue_wCallback<atomicNumber_t,atomId_t> *>(_ObservedValues[leftElement]);
-  delete boost::any_cast<ObservedValue_wCallback<atomicNumber_t,atomId_t> *>(_ObservedValues[rightElement]);
-  delete boost::any_cast<ObservedValue_wCallback<int, bondIds_t> *>(_ObservedValues[Degree]);
-  _ObservedValues.clear();
-}
-
-const atomId_t& GLMoleculeObject_bond::getleftIndex() const
-{
-  return boost::any_cast<ObservedValue_wCallback<atomId_t> *>(ObservedValues[leftIndex])->get();
-}
-
-const atomId_t& GLMoleculeObject_bond::getrightIndex() const
-{
-  return boost::any_cast<ObservedValue_wCallback<atomId_t> *>(ObservedValues[rightIndex])->get();
-}
-
-const Vector& GLMoleculeObject_bond::getleftPosition() const
-{
-  return boost::any_cast<ObservedValue_wCallback<Vector,atomId_t> *>(ObservedValues[leftPosition])->get();
-}
-
-const Vector& GLMoleculeObject_bond::getrightPosition() const
-{
-  return boost::any_cast<ObservedValue_wCallback<Vector, atomId_t> *>(ObservedValues[rightPosition])->get();
-}
-
-const atomicNumber_t& GLMoleculeObject_bond::getleftElement() const
-{
-  return boost::any_cast<ObservedValue_wCallback<atomicNumber_t, atomId_t> *>(ObservedValues[leftElement])->get();
-}
-
-const atomicNumber_t& GLMoleculeObject_bond::getrightElement() const
-{
-  return boost::any_cast<ObservedValue_wCallback<atomicNumber_t, atomId_t> *>(ObservedValues[rightElement])->get();
-}
-
-const int& GLMoleculeObject_bond::getDegree() const
-{
-  return boost::any_cast<ObservedValue_wCallback<int, bondIds_t> *>(ObservedValues[Degree])->get();
-}
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp	(revision b4bd0ec170830621ec3bcc64a4a1a99403399bd9)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_bond.hpp	(revision 96f14ae4f021b1976486ad5658a68c30645c7467)
@@ -20,11 +20,9 @@
 #include <boost/function.hpp>
 
-#include "CodePatterns/Observer/Observer.hpp"
-#include "CodePatterns/ObservedValue.hpp"
-
 #include "LinearAlgebra/Vector.hpp"
 
-#include "Bond/bond.hpp"
 #include "types.hpp"
+
+#include "UIElements/Qt4/InstanceBoard/QtObservedBond.hpp"
 
 class atom;
@@ -32,5 +30,5 @@
 class GLWorldScene;
 
-class GLMoleculeObject_bond : public GLMoleculeObject, public Observer
+class GLMoleculeObject_bond : public GLMoleculeObject
 {
   Q_OBJECT
@@ -43,25 +41,10 @@
       QGLSceneNode *mesh[],
       QObject *parent,
-      const bondIds_t bondIds,
+      QtObservedBond::ptr &_ObservedBond,
       const enum SideOfBond side);
-  GLMoleculeObject_bond(
-      QGLSceneNode *mesh[],
-      QObject *parent,
-      const bondIds_t bondIds,
-      const enum SideOfBond side,
-      std::vector<boost::any> &_ObservedValues,
-      const boost::function<void (const bondIds_t)> &_subjectKilled);
   virtual ~GLMoleculeObject_bond();
-
-  // Observer functions
-  void update(Observable *publisher);
-  void subjectKilled(Observable *publisher);
-  void recieveNotification(Observable *publisher, Notification_ptr notification);
 
 signals:
   void BondRemoved(const atomId_t leftnr, const atomId_t rightnr);
-  void elementChanged();
-  void positionChanged();
-  void degreeChanged();
 
 private slots:
@@ -85,179 +68,8 @@
 
 private:
-
-  void init();
-
-  void removeChannels();
-
-  static atomId_t updateIndex();
-  static Vector updateLeftPosition(
-      const boost::function<const atomId_t ()> &_getLeftAtomIndex);
-  static Vector updateRightPosition(
-      const boost::function<const atomId_t ()> &_getRightAtomIndex);
-  static atomicNumber_t updateLeftElement(
-      const boost::function<const atomId_t ()> &_getLeftAtomIndex);
-  static atomicNumber_t updateRightElement(
-      const boost::function<const atomId_t ()> &_getRightAtomIndex);
-  static int updateDegree(
-      const boost::function<const atomId_t ()> &_getLeftAtomIndex,
-      const boost::function<const atomId_t ()> &_getRightAtomIndex);
-
-  static const atom * const getAtomConst(const atomId_t _id);
-  static atom * const getAtom(const atomId_t _id);
-
-private:
-  //!> contains ref to Observable of left atom
-  const Observable * const leftowner;
-  //!> contains ref to Observable of right atom
-  const Observable * const rightowner;
-  //!> temporary variable used in cstor
-  const Observable * const bondowner;
-
+  //!> which part of half the bond this object represents
   const enum SideOfBond BondSide;
-
-
-private:
-  /** Observed Values **/
-
-  //!> enumeration of observed values to match with entries in ObservedValues
-  enum ObservedTypes {
-    //!> contains the id of the left atom
-    leftIndex,
-    //!> contains the id of the right atom
-    rightIndex,
-    //!> 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.
-   *
-   * \param _ObservedValues vector of ObservedValue to be filled
-   * \param _leftatomId left atom id
-   * \param _rightatomId right atom id
-   * \param _leftowner reference to left atom
-   * \param _rightowner reference to right atom
-   * \param _bondowner reference to bond
-   * \param _leftsubjectKilled ref to function to call on subjectKilled() for left atom
-   * \param _rightsubjectKilled ref to function to call on subjectKilled() for right atom
-   * \param _bondsubjectKilled ref to function to call on subjectKilled() for bond
-   */
-  static void initObservedValues(
-      std::vector<boost::any> &_ObservedValues,
-      const atomId_t _leftatomId,
-      const atomId_t _rightatomId,
-      const Observable * const _leftowner,
-      const Observable * const _rightowner,
-      const Observable * const _bondowner,
-      const boost::function<void(const atomId_t &)> &_leftsubjectKilled,
-      const boost::function<void(const atomId_t &)> &_rightsubjectKilled,
-      const boost::function<void(const bondIds_t &)> &_bondsubjectKilled);
-
-  /** Destroys all \a ObservedValues entries.
-   *
-   * \param _ObservedValues vector of ObservedValue to be destroyed
-   */
-  static void destroyObservedValues(
-      std::vector<boost::any> &_ObservedValues);
-
-  /** Getter to left atom's id contained in \a ObservedValues.
-   *
-   * \return left atom's id
-   */
-  const atomId_t& getleftIndex() const;
-
-  /** Getter to right atom's id contained in \a ObservedValues.
-   *
-   * \return right atom's id
-   */
-  const atomId_t& getrightIndex() const;
-
-  /** Getter to left atom's position contained in \a ObservedValues.
-   *
-   * \return left atom's position
-   */
-  const Vector& getleftPosition() const;
-
-  /** Getter to right atom's position contained in \a ObservedValues.
-   *
-   * \return right atom's position
-   */
-  const Vector& getrightPosition() const;
-
-  /** Getter to left atom's element contained in \a ObservedValues.
-   *
-   * \return left atom's element
-   */
-  const atomicNumber_t& getleftElement() const;
-
-  /** Getter to rightatom's element contained in \a ObservedValues.
-   *
-   * \return right atom's element
-   */
-  const atomicNumber_t& getrightElement() const;
-
-  /** Getter to bond's degree contained in \a ObservedValues.
-   *
-   * \return bond's degree
-   */
-  const 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.
-   *
-   * \param _bondIds bond ids whose bond has called subjectKilled()
-   */
-  void countsubjectKilled(
-      const bondIds_t &_bondIds)
-  {
-    countsubjectKilled();
-  }
-
-  void countsubjectKilled(
-      const atomId_t &_atomid)
-  {
-    countsubjectKilled();
-  }
-
-  void countsubjectKilled();
-
-  //!> counts how many ObservedValues have already been subjectKilled()
-  mutable size_t subjectKilledCount;
-
-private:
-
-  //!> indicate whether we are signed in to leftobservable
-  bool leftobservable_enabled;
-  //!> indicate whether we are signed in to rightobservable
-  bool rightobservable_enabled;
-  //!> indicate whether we are signed in to bond itself
-  bool bond_enabled;
-
-  //!> list of channels when id needs to update
-  static const Observable::channels_t IndexChannels;
-  //!> list of channels when position needs to update
-  static const Observable::channels_t BondPositionChannels;
-  //!>list of channels when degree needs to update
-  static const Observable::channels_t BondDegreeChannels;
-  //!> list of channels when element needs to update
-  static const Observable::channels_t BondElementChannels;
-
-  //!> callback function to inform about subjectKilled()
-  const boost::function<void (const bondIds_t)> board_subjectKilled;
+  //!> state of the bond this object visually represents
+  const QtObservedBond::ptr ObservedBond;
 };
 
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp	(revision b4bd0ec170830621ec3bcc64a4a1a99403399bd9)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp	(revision 96f14ae4f021b1976486ad5658a68c30645c7467)
@@ -91,5 +91,5 @@
   ObservedMolecule(_ObservedMolecule)
 {
-  init(ObservedMolecule->getMolIndex());
+  init();
 }
 
@@ -105,13 +105,13 @@
   ObservedMolecule(_ObservedMolecule)
 {
-  init(ObservedMolecule->getMolIndex());
-}
-
-void GLMoleculeObject_molecule::init(const moleculeId_t _molid)
-{
-  setObjectId(_molid);
+  init();
+}
+
+void GLMoleculeObject_molecule::init()
+{
+  setObjectId(ObservedMolecule->getMolIndex());
   setMaterial(getMaterial(1));
 
-  m_selected = const_cast<const World &>(World::getInstance()).isMoleculeSelected(_molid);
+  m_selected = ObservedMolecule->getMolSelected();
 
   // initially, atoms and bonds should be visible
@@ -136,21 +136,4 @@
 GLMoleculeObject_molecule::~GLMoleculeObject_molecule()
 {}
-
-void GLMoleculeObject_molecule::addAtomBonds(
-    const bond::ptr &_bond,
-    const GLMoleculeObject_bond::SideOfBond _side
-    )
-{
-  bool bond_present = false;
-  const BondIds ids = getBondIds(_bond, _side);
-  // check whether bond is not present already
-  bond_present = BondsinSceneMap.count(ids);
-  if (!bond_present)
-    bondInserted(ids.first, ids.second, _side);
-  else {
-    BondsinSceneMap[ids]->resetPosition();
-    BondsinSceneMap[ids]->resetWidth();
-  }
-}
 
 QGeometryData GLMoleculeObject_molecule::updateTesselationHull() const
@@ -382,14 +365,7 @@
     connect (atomObject, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SIGNAL(changed()));
     connect (atomObject, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SLOT(hoverChangedSignalled(GLMoleculeObject *)));
-  //  connect (atomObject, SIGNAL(bondsChanged()), this, SLOT(bondInserted(const atomId_t, const atomId_t, const GLMoleculeObject_bond::SideOfBond)));
-    connect (atomObject, SIGNAL(BondsAdded(const atomId_t, const atomId_t, const GLMoleculeObject_bond::SideOfBond)), this, SLOT(bondInserted(const atomId_t, const atomId_t, const GLMoleculeObject_bond::SideOfBond)));
-    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)));
 
     if (m_objectId  == -1)
       setObjectId(_atom->getAtomIndex());
-
-    // first reset bonds when signals connections have been made
-    atomObject->resetBonds();
 
     emit changed();
@@ -448,52 +424,33 @@
 }
 
-
-/** Helper function to get bond ids in the correct order for BondNodeMap.
- *
- * \return pair of ids in correct order.
- */
-GLMoleculeObject_molecule::BondIds GLMoleculeObject_molecule::getBondIds(
-    const bond::ptr _bond,
-    const enum GLMoleculeObject_bond::SideOfBond _side)
-{
-  BondIds ids;
-  switch (_side) {
-    case GLMoleculeObject_bond::left:
-      ids = std::make_pair(_bond->leftatom->getId(), _bond->rightatom->getId());
-      break;
-    case GLMoleculeObject_bond::right:
-      ids = std::make_pair(_bond->rightatom->getId(), _bond->leftatom->getId());
-      break;
-  }
-  return ids;
-}
-
 /** Adds a bond to the scene.
  *
  * @param _bond bond to add
- * @param side which side of the bond (left or right)
  */
 void GLMoleculeObject_molecule::bondInserted(
-    const atomId_t _left, const atomId_t _right,
-    const enum GLMoleculeObject_bond::SideOfBond _side)
-{
-  LOG(3, "INFO: GLWorldScene::bondInserted() - Adding bond "+toString(_left)
-      +toString(_right)+".");
+    QtObservedBond::ptr _bond)
+{
+  static const std::vector< GLMoleculeObject_bond::SideOfBond > bondsides =
+      boost::assign::list_of<GLMoleculeObject_bond::SideOfBond>
+          (GLMoleculeObject_bond::left)
+          (GLMoleculeObject_bond::right);
+  LOG(3, "INFO: GLWorldScene::bondInserted() - Adding bonds " << _bond->getBondIndex());
   //LOG(4, "INFO: Currently present bonds " << BondsinSceneMap << ".");
 
-  const BondIds ids( std::make_pair(_left, _right) );
-  BondNodeMap::iterator iter = BondsinSceneMap.find(ids);
-  if (iter == BondsinSceneMap.end()) {
-    GLMoleculeObject_bond * bondObject =
-        new GLMoleculeObject_bond(GLMoleculeObject::meshCylinder, this, ids, _side);
-    connect (
-        bondObject, SIGNAL(BondRemoved(const atomId_t, const atomId_t)),
-        this, SLOT(bondRemoved(const atomId_t, const atomId_t)));
-    connect (bondObject, SIGNAL(changed()), this, SIGNAL(changed()));
-    BondsinSceneMap.insert( make_pair(ids, bondObject) );
-  //    BondIdsinSceneMap.insert( Leftids );
+  const ObservedValue_Index_t bondid = _bond->getIndex();
+  const std::pair<BondNodeMap::iterator, BondNodeMap::iterator> iters =
+      BondsinSceneMap.equal_range(bondid);
+  if (iters.first == iters.second) {
+    for (size_t i=0;i<2;++i) {
+      GLMoleculeObject_bond * bondObject =
+          new GLMoleculeObject_bond(GLMoleculeObject::meshCylinder, this, _bond, bondsides[i]);
+      connect (bondObject, SIGNAL(changed()), this, SIGNAL(changed()));
+      BondsinSceneMap.insert( std::make_pair(bondid, bondObject) );
+    }
   } else {
-    iter->second->resetPosition();
-    iter->second->resetWidth();
+    for (BondNodeMap::iterator iter = iters.first; iter != iters.second; ++iter) {
+      iter->second->resetPosition();
+      iter->second->resetWidth();
+    }
   }
   emit changed();
@@ -505,19 +462,18 @@
  * @param _bond bond to remove
  */
-void GLMoleculeObject_molecule::bondRemoved(const atomId_t leftnr, const atomId_t rightnr)
-{
-  LOG(3, "INFO: GLWorldScene::bondRemoved() - Removing bond between "+toString(leftnr)+" and "+toString(rightnr)+".");
+void GLMoleculeObject_molecule::bondRemoved(ObservedValue_Index_t _id)
+{
+  LOG(3, "INFO: GLWorldScene::bondRemoved() - Removing bond to id " << _id);
   {
     // left bond
-    const BondIds Leftids( make_pair(leftnr, rightnr) );
-    BondNodeMap::iterator leftiter = BondsinSceneMap.find( Leftids );
-    ASSERT(leftiter != BondsinSceneMap.end(),
-        "GLWorldScene::bondRemoved() - bond "+toString(leftnr)+"-"
-        +toString(rightnr)+" not on display.");
-    GLMoleculeObject_bond *bondObject = leftiter->second;
-    bondObject->disconnect();
-    BondsinSceneMap.erase(leftiter);
-    delete bondObject; // is done by signal from bond itself
-    //LOG(4, "INFO: Still present bonds " << BondsinSceneMap << ".");
+    const std::pair<BondNodeMap::iterator, BondNodeMap::iterator> iters =
+        BondsinSceneMap.equal_range(_id);
+    for (BondNodeMap::iterator iter = iters.first; iter != iters.second; ++iter) {
+      GLMoleculeObject_bond *bondObject = iter->second;
+      bondObject->disconnect();
+      delete bondObject; // is done by signal from bond itself
+      //LOG(4, "INFO: Still present bonds " << BondsinSceneMap << ".");
+    }
+    BondsinSceneMap.erase(_id);
   }
 
Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp	(revision b4bd0ec170830621ec3bcc64a4a1a99403399bd9)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.hpp	(revision 96f14ae4f021b1976486ad5658a68c30645c7467)
@@ -23,7 +23,4 @@
 
 #include <boost/function.hpp>
-
-#include "CodePatterns/Cacheable.hpp"
-#include "CodePatterns/Observer/Observable.hpp"
 
 #include "GLMoleculeObject_bond.hpp"
@@ -59,8 +56,4 @@
   friend std::ostream &operator<<(std::ostream &ost, const BondIds &t);
 
-  static BondIds getBondIds(
-      const bond::ptr _bond,
-      const enum GLMoleculeObject_bond::SideOfBond side);
-
 signals:
   void changed();
@@ -80,6 +73,6 @@
   void atomInserted(QtObservedAtom::ptr _atom);
   void atomRemoved(ObservedValue_Index_t _id);
-  void bondInserted(const atomId_t, const atomId_t, const GLMoleculeObject_bond::SideOfBond side);
-  void bondRemoved(const atomId_t leftnr, const atomId_t rightnr);
+  void bondInserted(QtObservedBond::ptr _bond);
+  void bondRemoved(ObservedValue_Index_t _id);
   void hoverChangedSignalled(GLMoleculeObject *ob);
 
@@ -92,10 +85,6 @@
 
 private:
-  void addAtomBonds(
-      const bond::ptr &_bond,
-      const GLMoleculeObject_bond::SideOfBond _side
-      );
 
-  void init(const moleculeId_t _molid);
+  void init();
 
 private:
@@ -113,5 +102,5 @@
 
   typedef std::map< ObservedValue_Index_t, GLMoleculeObject_atom* > AtomNodeMap;
-  typedef std::map< BondIds , GLMoleculeObject_bond* > BondNodeMap;
+  typedef std::multimap< ObservedValue_Index_t, GLMoleculeObject_bond* > BondNodeMap;
   AtomNodeMap AtomsinSceneMap;
   BondNodeMap BondsinSceneMap;
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision b4bd0ec170830621ec3bcc64a4a1a99403399bd9)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 96f14ae4f021b1976486ad5658a68c30645c7467)
@@ -101,4 +101,8 @@
   connect(board, SIGNAL(atomRemoved(ObservedValue_Index_t)),
       this, SLOT(atomRemoved(ObservedValue_Index_t)));
+  connect(board, SIGNAL(bondInserted(QtObservedBond::ptr)),
+      this, SLOT(bondInserted(QtObservedBond::ptr)));
+  connect(board, SIGNAL(bondRemoved(ObservedValue_Index_t)),
+      this, SLOT(bondRemoved(ObservedValue_Index_t)));
   connect(this, SIGNAL(insertMolecule(QtObservedMolecule::ptr)),
       this, SLOT(moleculeInserted(QtObservedMolecule::ptr)) );
@@ -182,4 +186,78 @@
       +" is not present in QtObservedAtomMap.");
   QtObservedAtomMap.erase(eraseiter);
+}
+
+/** Prepares insertion of a bond.
+ *
+ * This is called before the insertion into a molecule and thus before the
+ * insertion into the scene.
+ *
+ * @param _bond bond to insert
+ */
+void GLWorldScene::bondInserted(QtObservedBond::ptr _bond)
+{
+  const ObservedValue_Index_t bondid = _bond->getIndex();
+  ASSERT( QtObservedBondMap.find(bondid) == QtObservedBondMap.end(),
+      "GLWorldScene::BondInserted() - bond with id "+toString(_bond->getBondIndex())
+      +" is already present in QtObservedBondMap.");
+  QtObservedBondMap[bondid] = _bond;
+
+  // assign to its molecule if present
+  const moleculeId_t molid = _bond->getMoleculeIndex();
+  if (molid != (moleculeId_t)-1) {
+    QtObservedMolecule::ptr mol = board->getObservedMolecule(molid);
+    emit moleculesBondInserted(_bond, mol.get());
+  } else {
+    // watch bond till it has a molecule
+    connect( _bond.get(), SIGNAL(moleculeIndexChanged(moleculeId_t,moleculeId_t)),
+        this, SLOT(bondsMoleculeChanged(moleculeId_t, moleculeId_t)));
+  }
+}
+
+/** Handle change of molecule from initial none.
+ *
+ */
+void GLWorldScene::bondsMoleculeChanged(moleculeId_t _oldid, moleculeId_t _newid)
+{
+  ASSERT( _oldid == (moleculeId_t)-1,
+      "GLWorldScene::bondsMoleculeChanged() - got true index change from "
+      +toString(_oldid)+" to "+toString(_newid)+" and not just added to mol.");
+  QtObservedBond* bondref = static_cast<QtObservedBond*>(sender());
+
+  // disconnect from further molecule changes
+  disconnect( bondref, SIGNAL(moleculeIndexChanged(moleculeId_t,moleculeId_t)),
+      this, SLOT(bondsMoleculeChanged(moleculeId_t, moleculeId_t)));
+
+  // add it to its molecule
+  QtObservedMolecule::ptr mol = board->getObservedMolecule(_newid);
+  emit moleculesBondInserted(bondref->getRef(), mol.get());
+}
+
+
+/** Removes an general bond.
+ *
+ * This is called when the bond has been removed from the molecule.
+ *
+ * @param _bond bond to remove
+ */
+void GLWorldScene::bondRemoved(ObservedValue_Index_t _bondid)
+{
+  const QtObservedBondMap_t::iterator eraseiter = QtObservedBondMap.find(_bondid);
+  ASSERT( eraseiter != QtObservedBondMap.end(),
+      "GLWorldScene::BondRemoved() - bond with id "+toString(_bondid)
+      +" is not present in QtObservedBondMap.");
+  QtObservedBond::ptr bondref = eraseiter->second;
+
+  // tell its assigned molecule if present
+  const moleculeId_t molid = bondref->getMoleculeIndex();
+  if (molid != (moleculeId_t)-1) {
+    QtObservedMolecule::ptr mol = board->getObservedMolecule(molid);
+    emit moleculesBondRemoved(_bondid, mol.get());
+  } else {
+    // it might have still been waiting for a molecule assignment
+    disconnect( bondref.get(), SIGNAL(moleculeIndexChanged(moleculeId_t,moleculeId_t)),
+        this, SLOT(bondsMoleculeChanged(moleculeId_t, moleculeId_t)));
+  }
+  QtObservedBondMap.erase(eraseiter);
 }
 
@@ -329,4 +407,123 @@
 }
 
+/** Inserts an bond into the scene when molecule is present.
+ *
+ * @param _bond bond to insert
+ */
+void GLWorldScene::moleculesBondInserted(QtObservedBond::ptr _bond, QtObservedMolecule * _mol)
+{
+  const ObservedValue_Index_t bondid = _bond->getIndex();
+  LOG(3, "INFO: GLWorldScene: Received signal bondInserted for bond " << _bond->getBondIndex());
+  const ObservedValue_Index_t molid = _mol->getIndex();
+
+  // check of molecule is already present
+  boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
+  const MoleculeNodeMap::iterator moliter = MoleculesinSceneMap.find(molid);
+  if (moliter != MoleculesinSceneMap.end()) {
+    // check that it is the right molecule
+    QtObservedMolecule::ptr &checkmol = moliter->second->ObservedMolecule;
+    ASSERT( checkmol.get() == _mol,
+        "GLWorldScene::moleculesBondInserted() - claimed and present molecule differ.");
+    LOG(3, "INFO: GLWorldScene: Sending signal moleculesBondInserted for bond "
+        << _bond->getBondIndex());
+    QMetaObject::invokeMethod(moliter->second,        // pointer to a QObject
+                              "bondInserted",       // member name (no parameters here)
+                              Qt::QueuedConnection,     // connection type
+                              Q_ARG(QtObservedBond::ptr, _bond));     // parameters
+  } else {
+#ifndef NDEBUG
+    const RemovedMoleculesMap_t::iterator removedmoliter = RemovedMolecules.find(_mol);
+    ASSERT( removedmoliter != RemovedMolecules.end(),
+          "GLWorldScene::moleculesBondInserted() - would need to send bondInserted to already removed molecule.");
+#endif
+    boost::recursive_mutex::scoped_lock lock(MoleculeMissedStateMap_mutex);
+    // only record missed state for molecule if (still) present but not instantiated
+    if (QtObservedMoleculeMap.count(molid)) {
+      // store signal for when it is instantiated
+      if (MoleculeMissedStateMap.count(molid) == 0)
+        MoleculeMissedStateMap.insert( std::make_pair(molid ,StateChangeMap_t()) );
+      MoleculeMissedStateMap[molid].insert( std::make_pair(bondid, bondInsertedState) );
+      ASSERT( QtObservedBondMap[bondid] == _bond,
+          "GLWorldScene::moleculesBondInserted() - bond "+toString(bondid)
+          +" inserted in molecule "+toString(_mol->getMolIndex())
+          +" which does not match bond in QtObservedBondMap.");
+      LOG(3, "INFO: GLWorldScene: Placing bondInserted for bond " << _bond->getBondIndex()
+           << " and molecule " << _mol->getMolIndex() << " into missed state map.");
+    }
+  }
+}
+
+/** Removes an bond into the scene before molecule is present.
+ *
+ * @param _bondid bond to remove
+ */
+void GLWorldScene::moleculesBondRemoved(ObservedValue_Index_t _bondid, QtObservedMolecule * _mol)
+{
+  LOG(3, "INFO: GLWorldScene: Received signal bondRemoved for bond "+toString(_bondid)+".");
+
+  const ObservedValue_Index_t molid = _mol->getIndex();
+  // check of molecule is already present
+  boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
+  const MoleculeNodeMap::iterator moliter = MoleculesinSceneMap.find(molid);
+  if (moliter != MoleculesinSceneMap.end()) {
+    const QtObservedMolecule::ptr &checkmol = moliter->second->ObservedMolecule;
+    if (checkmol.get() == _mol) {
+      LOG(3, "INFO: GLWorldScene: Sending signal moleculesBondRemoved for bond "+toString(_bondid)+".");
+      QMetaObject::invokeMethod(moliter->second,        // pointer to a QObject
+                                "bondRemoved",       // member name (no parameters here)
+                                Qt::QueuedConnection,     // connection type
+                                Q_ARG(ObservedValue_Index_t, _bondid));     // parameters
+    } else {
+      // relay bondRemoved to GLMoleculeObject_molecule in RemovedMolecules
+      LOG(3, "INFO: GLWorldScene: Sending signal moleculesBondRemoved for bond "+toString(_bondid)
+          +" to molecule in RemovedMolecules.");
+      const RemovedMoleculesMap_t::iterator removedmoliter = RemovedMolecules.find(_mol);
+      ASSERT( removedmoliter != RemovedMolecules.end(),
+          "GLWorldScene::moleculesBondRemoved() - signal from old molecule "
+          +toString(molid)+", but not present in RemovedMolecules");
+#ifndef NDEBUG
+      const QtObservedMolecule::ptr &othercheckmol = removedmoliter->second->ObservedMolecule;
+      ASSERT( othercheckmol.get() == _mol,
+          "GLWorldScene::moleculesBondRemoved() - signal from old molecule "
+          +toString(molid)+", but different one "+toString(othercheckmol)
+          +" present in RemovedMolecules.");
+#endif
+      QMetaObject::invokeMethod(removedmoliter->second,        // pointer to a QObject
+                                "bondRemoved",       // member name (no parameters here)
+                                Qt::QueuedConnection,     // connection type
+                                Q_ARG(ObservedValue_Index_t, _bondid));     // parameters
+    }
+  } else {
+    const RemovedMoleculesMap_t::iterator removedmoliter = RemovedMolecules.find(_mol);
+    if (removedmoliter != RemovedMolecules.end()) {
+      ASSERT( removedmoliter != RemovedMolecules.end(),
+          "GLWorldScene::moleculesBondRemoved() - signal from old molecule "
+          +toString(molid)+", but not present in RemovedMolecules");
+#ifndef NDEBUG
+      const QtObservedMolecule::ptr &othercheckmol = removedmoliter->second->ObservedMolecule;
+      ASSERT( othercheckmol.get() == _mol,
+          "GLWorldScene::moleculesBondRemoved() - signal from old molecule "
+          +toString(molid)+", but different one "+toString(othercheckmol)
+          +" present in RemovedMolecules.");
+#endif
+      QMetaObject::invokeMethod(removedmoliter->second,        // pointer to a QObject
+                                "bondRemoved",       // member name (no parameters here)
+                                Qt::QueuedConnection,     // connection type
+                                Q_ARG(ObservedValue_Index_t, _bondid));     // parameters
+    } else {
+      boost::recursive_mutex::scoped_lock lock(MoleculeMissedStateMap_mutex);
+      // only record missed state for molecule if (still) present but not instantiated
+      if (QtObservedMoleculeMap.count(molid)) {
+        // store signal for when it is instantiated
+        if (MoleculeMissedStateMap.count(molid) == 0)
+          MoleculeMissedStateMap.insert( std::make_pair(molid, StateChangeMap_t()) );
+        MoleculeMissedStateMap[molid].insert( std::make_pair(_bondid, bondRemovedState) );
+        LOG(3, "INFO: GLWorldScene: Placing bondRemoved for bond " << _bondid
+             << " and molecule " << molid << " into missed state map.");
+      }
+    }
+  }
+}
+
 void GLWorldScene::moleculeSignOn(QtObservedMolecule::ptr _mol)
 {
@@ -418,18 +615,40 @@
             stateiter != rangeiter.second; ++stateiter)
           ++StateChangeAmounts[stateiter->second];
-        ASSERT( StateChangeAmounts[atomInsertedState] >= StateChangeAmounts[atomRemovedState],
-            "GLWorldScene::moleculeInserted() - more atomRemoved states "
-            +toString(StateChangeAmounts[atomRemovedState])+" than atomInserted "
-            +toString(StateChangeAmounts[atomInsertedState])+" for atom "+toString(iter->first));
-        if (StateChangeAmounts[atomInsertedState] > StateChangeAmounts[atomRemovedState]) {
-          LOG(1, "INFO: invoking atomInserted for atom " << iter->first);
-          QMetaObject::invokeMethod(molObject,        // pointer to a QObject
-                                    "atomInserted",       // member name (no parameters here)
-                                    Qt::QueuedConnection,     // connection type
-                                    Q_ARG(QtObservedAtom::ptr, QtObservedAtomMap[iter->first]));     // parameters
-        } else {
-          LOG(1, "INFO: Atom " << iter->first << " has been inserted and removed already.");
+        // is it an atom?
+        if ((StateChangeAmounts[atomInsertedState] + StateChangeAmounts[atomRemovedState]) != 0) {
+          ASSERT( StateChangeAmounts[atomInsertedState] >= StateChangeAmounts[atomRemovedState],
+              "GLWorldScene::moleculeInserted() - more atomRemoved states "
+              +toString(StateChangeAmounts[atomRemovedState])+" than atomInserted "
+              +toString(StateChangeAmounts[atomInsertedState])+" for atom "+toString(iter->first));
+          if (StateChangeAmounts[atomInsertedState] > StateChangeAmounts[atomRemovedState]) {
+            LOG(1, "INFO: invoking atomInserted for atom " << iter->first);
+            QMetaObject::invokeMethod(molObject,        // pointer to a QObject
+                                      "atomInserted",       // member name (no parameters here)
+                                      Qt::QueuedConnection,     // connection type
+                                      Q_ARG(QtObservedAtom::ptr, QtObservedAtomMap[iter->first]));     // parameters
+          } else {
+            LOG(1, "INFO: Atom " << iter->first << " has been inserted and removed already.");
+          }
         }
-        // removed all state changes for this atom
+        // or is it a bond?
+        if ((StateChangeAmounts[bondInsertedState] + StateChangeAmounts[bondInsertedState]) != 0) {
+          ASSERT( StateChangeAmounts[bondInsertedState] >= StateChangeAmounts[bondRemovedState],
+              "GLWorldScene::moleculeInserted() - more bondRemoved states "
+              +toString(StateChangeAmounts[bondRemovedState])+" than bondInserted "
+              +toString(StateChangeAmounts[bondInsertedState])+" for bond "+toString(iter->first));
+          if (StateChangeAmounts[bondInsertedState] > StateChangeAmounts[bondRemovedState]) {
+            LOG(1, "INFO: invoking bondInserted for bond " << iter->first);
+            QMetaObject::invokeMethod(molObject,        // pointer to a QObject
+                                      "bondInserted",       // member name (no parameters here)
+                                      Qt::QueuedConnection,     // connection type
+                                      Q_ARG(QtObservedBond::ptr, QtObservedBondMap[iter->first]));     // parameters
+          } else {
+            LOG(1, "INFO: Bond " << iter->first << " has been inserted and removed already.");
+          }
+        }
+        ASSERT( (StateChangeAmounts[bondInsertedState] + StateChangeAmounts[bondInsertedState]
+            + StateChangeAmounts[atomInsertedState] + StateChangeAmounts[atomRemovedState]) != 0,
+            "GLWorldScene::moleculeInserted() - state with no changes for "+toString(iter->first));
+        // removed all state changes for this atom/bond
         MoleculeMissedStateMap[molid].erase(rangeiter.first, rangeiter.second);
       } else {
@@ -450,4 +669,18 @@
             break;
           }
+          case bondRemovedState:
+            ASSERT( 0,
+                "GLWorldScene::moleculeInserted() - bondRemoved state without bondInserted for bond "
+                +toString(iter->first));
+            break;
+          case bondInsertedState:
+          {
+            LOG(1, "INFO: invoking bondInserted for bond " << iter->first);
+            QMetaObject::invokeMethod(molObject,        // pointer to a QObject
+                                      "bondInserted",       // member name (no parameters here)
+                                      Qt::QueuedConnection,     // connection type
+                                      Q_ARG(QtObservedBond::ptr, QtObservedBondMap[iter->first]));     // parameters
+            break;
+          }
           default:
             ASSERT( 0,
@@ -455,5 +688,5 @@
             break;
         }
-        // removed state changes for this atom
+        // removed state changes for this atom/bond
         MoleculeMissedStateMap[molid].erase(iter);
       }
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision b4bd0ec170830621ec3bcc64a4a1a99403399bd9)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision 96f14ae4f021b1976486ad5658a68c30645c7467)
@@ -28,4 +28,5 @@
 
 #include "UIElements/Qt4/InstanceBoard/QtObservedAtom.hpp"
+#include "UIElements/Qt4/InstanceBoard/QtObservedBond.hpp"
 #include "UIElements/Qt4/InstanceBoard/QtObservedMolecule.hpp"
 
@@ -91,12 +92,17 @@
   void moleculeClicked(moleculeId_t no);
   void moleculeRemoved(QtObservedMolecule* _mol);
-  void moleculeSignOff(ObservedValue_Index_t _id);
   void moleculeEmpty(QtObservedMolecule::ptr _mol);
   void moleculeInserted(QtObservedMolecule::ptr);
   void moleculeSignOn(QtObservedMolecule::ptr);
+  void moleculeSignOff(ObservedValue_Index_t _id);
   void moleculesAtomRemoved(ObservedValue_Index_t _atomid, QtObservedMolecule * _mol);
   void moleculesAtomInserted(QtObservedAtom::ptr, QtObservedMolecule *_mol);
+  void moleculesBondRemoved(ObservedValue_Index_t _bondid, QtObservedMolecule * _mol);
+  void moleculesBondInserted(QtObservedBond::ptr, QtObservedMolecule *_mol);
   void atomRemoved(ObservedValue_Index_t _atomid);
   void atomInserted(QtObservedAtom::ptr);
+  void bondRemoved(ObservedValue_Index_t _bondid);
+  void bondInserted(QtObservedBond::ptr);
+  void bondsMoleculeChanged(moleculeId_t _oldid, moleculeId_t _newid);
   void setSelectionModeAtom();
   void setSelectionModeMolecule();
@@ -122,14 +128,19 @@
     atomInsertedState,
     atomRemovedState,
+    bondInsertedState,
+    bondRemovedState,
     MAX_StateChangeType
   };
   typedef std::map< ObservedValue_Index_t, QtObservedAtom::ptr> QtObservedAtomMap_t;
+  typedef std::map< ObservedValue_Index_t, QtObservedBond::ptr> QtObservedBondMap_t;
   typedef std::map< ObservedValue_Index_t, QtObservedMolecule::ptr> QtObservedMoleculeMap_t;
   typedef std::multimap< ObservedValue_Index_t, StateChangeType> StateChangeMap_t;
-  typedef std::map< ObservedValue_Index_t, StateChangeMap_t> MoleculeMissedStateMap_t;
+  typedef std::map< ObservedValue_Index_t, StateChangeMap_t> MissedStateMap_t;
   //!> map of all missed state changes
-  MoleculeMissedStateMap_t MoleculeMissedStateMap;
+  MissedStateMap_t MoleculeMissedStateMap;
   //!> map to contain all QtObservedAtom that have not been instantiated so far
   QtObservedAtomMap_t QtObservedAtomMap;
+  //!> map to contain all QtObservedBond that have not been instantiated so far
+  QtObservedBondMap_t QtObservedBondMap;
   //!> map to contain all QtObservedMolecule that have not been instantiated so far
   QtObservedMoleculeMap_t QtObservedMoleculeMap;
