Index: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp	(revision 03e69e2faa3ae6d3c118759dd157a9b956ddfa77)
+++ src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp	(revision 59f1bcc899a181c8225110eb43adbf27eb563d57)
@@ -126,8 +126,9 @@
   connect (ObservedMolecule.get(), SIGNAL(indexChanged(const moleculeId_t, const moleculeId_t)),
       this, SLOT(resetIndex(const moleculeId_t, const moleculeId_t)));
-  connect (ObservedMolecule.get(), SIGNAL(atomInserted(QtObservedAtom::ptr)),
-      this, SLOT(atomInserted(QtObservedAtom::ptr)) );
-  connect (ObservedMolecule.get(), SIGNAL(atomRemoved(const atomId_t)),
-      this, SLOT(atomRemoved(const atomId_t)) );
+  /// these are channeled through GLWorldScene instead to ensure synchronicity
+//  connect (ObservedMolecule.get(), SIGNAL(atomInserted(QtObservedAtom::ptr)),
+//      this, SLOT(atomInserted(QtObservedAtom::ptr)) );
+//  connect (ObservedMolecule.get(), SIGNAL(atomRemoved(const atomId_t)),
+//      this, SLOT(atomRemoved(const atomId_t)) );
   connect (ObservedMolecule.get(), SIGNAL(selectedChanged()), this, SLOT(resetSelected()));
 
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 03e69e2faa3ae6d3c118759dd157a9b956ddfa77)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.cpp	(revision 59f1bcc899a181c8225110eb43adbf27eb563d57)
@@ -94,9 +94,13 @@
   }
   connect(board, SIGNAL(moleculeInserted(QtObservedMolecule::ptr)),
-      this, SLOT(moleculeSignOn(QtObservedMolecule::ptr)));
+      this, SLOT(moleculeSignOn(QtObservedMolecule::ptr)), Qt::DirectConnection);
   connect(board, SIGNAL(moleculeRemoved(const moleculeId_t)),
-      this, SLOT(moleculeSignOff(const moleculeId_t)));
+      this, SLOT(moleculeSignOff(const moleculeId_t)), Qt::DirectConnection);
   connect(board, SIGNAL(moleculeIndexChanged(const moleculeId_t, const moleculeId_t)),
       this, SLOT(moleculeIndexChanged(const moleculeId_t, const moleculeId_t)));
+  connect(board, SIGNAL(atomInserted(QtObservedAtom::ptr)),
+      this, SLOT(atomInserted(QtObservedAtom::ptr)));
+  connect(board, SIGNAL(atomRemoved(const atomId_t)),
+      this, SLOT(atomRemoved(const atomId_t)));
   connect(this, SIGNAL(insertMolecule(QtObservedMolecule::ptr)),
       this, SLOT(moleculeInserted(QtObservedMolecule::ptr)) );
@@ -151,13 +155,45 @@
 }
 
-/** Inserts an atom into the scene before molecule is present.
- *
- * @param _molid molecule to insert atom for
- * @param _atomid atom to insert
+/** Prepares insertion of a general atom.
+ *
+ * This is called before the insertion into a molecule and thus before the
+ * insertion into the scene.
+ *
+ * @param _atom atom to insert
  */
 void GLWorldScene::atomInserted(QtObservedAtom::ptr _atom)
 {
-  ASSERT (_atom,
-      "GLWorldScene::moleculeInserted() - received shared_ptr for atom is empty?");
+  const atomId_t atomid = _atom->getAtomIndex();
+  ASSERT( QtObservedAtomMap.find(atomid) == QtObservedAtomMap.end(),
+      "GLWorldScene::AtomInserted() - atom with id "+toString(atomid)
+      +" is already present in QtObservedAtomMap.");
+  QtObservedAtomMap[atomid] = _atom;
+  connect(_atom.get(), SIGNAL(indexChanged(const atomId_t,const atomId_t)),
+      this, SLOT(atomIndexChanged(const atomId_t,const atomId_t)) );
+}
+
+/** Removes an general atom.
+ *
+ * This is called when the atom has been removed from the molecule.
+ *
+ * @param _atom atom to remove
+ */
+void GLWorldScene::atomRemoved(const atomId_t _atomid)
+{
+  const QtObservedAtomMap_t::iterator eraseiter = QtObservedAtomMap.find(_atomid);
+  ASSERT( eraseiter != QtObservedAtomMap.end(),
+      "GLWorldScene::AtomRemoved() - atom with id "+toString(_atomid)
+      +" is not present in QtObservedAtomMap.");
+  disconnect(eraseiter->second.get(), SIGNAL(indexChanged(const atomId_t,const atomId_t)),
+      this, SLOT(atomIndexChanged(const atomId_t,const atomId_t)) );
+  QtObservedAtomMap.erase(eraseiter);
+}
+
+/** Inserts an atom into the scene when molecule is present.
+ *
+ * @param _atom atom to insert
+ */
+void GLWorldScene::moleculesAtomInserted(QtObservedAtom::ptr _atom)
+{
   const atomId_t atomid = _atom->getAtomIndex();
   const atomId_t molid = _atom->getAtomMoleculeIndex();
@@ -165,17 +201,27 @@
 
   // check of molecule is already present
+  boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
   MoleculeNodeMap::iterator moliter = MoleculesinSceneMap.find(molid);
   if (moliter != MoleculesinSceneMap.end()) {
-    // no action, is also caught via QtObservedMolecule by GLMoleculeObject_molecule
+    LOG(3, "INFO: GLWorldScene: Sending signal moleculesAtomInserted for atom "+toString(atomid)+".");
+    QMetaObject::invokeMethod(moliter->second,        // pointer to a QObject
+                              "atomInserted",       // member name (no parameters here)
+                              Qt::QueuedConnection,     // connection type
+                              Q_ARG(QtObservedAtom::ptr, _atom));     // parameters
   } else {
-    // 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(atomid, atomInsertedState) );
-    QtObservedAtomMap[atomid] = _atom;
-    connect(_atom.get(), SIGNAL(indexChanged(const atomId_t,const atomId_t)),
-        this, SLOT(atomIndexChanged(const atomId_t,const atomId_t)) );
-    LOG(3, "INFO: GLWorldScene: Placing atomInserted for atom " << atomid
-         << " and molecule " << molid << " into missed state map.");
+    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(atomid, atomInsertedState) );
+      ASSERT( QtObservedAtomMap[atomid] == _atom,
+          "GLWorldScene::moleculesAtomInserted() - atom "+toString(atomid)
+          +" inserted in molecule "+toString(molid)
+          +" which does not match atom in QtObservedAtomMap.");
+      LOG(3, "INFO: GLWorldScene: Placing atomInserted for atom " << atomid
+           << " and molecule " << molid << " into missed state map.");
+    }
   }
 }
@@ -183,11 +229,8 @@
 /** Removes an atom into the scene before molecule is present.
  *
- * @param _molid molecule to insert atom for
- * @param _atomid atom to insert
- */
-void GLWorldScene::atomRemoved(const atomId_t _atomid)
-{
-  boost::recursive_mutex::scoped_lock lock(MoleculeMissedStateMap_mutex);
-
+ * @param _atomid atom to remove
+ */
+void GLWorldScene::moleculesAtomRemoved(const atomId_t _atomid)
+{
   LOG(3, "INFO: GLWorldScene: Received signal atomRemoved for atom "+toString(_atomid)+".");
 
@@ -197,14 +240,23 @@
     const moleculeId_t molid = atom->getAtomMoleculeIndex();
     // check of molecule is already present
+    boost::recursive_mutex::scoped_lock lock(MoleculeinSceneMap_mutex);
     MoleculeNodeMap::iterator moliter = MoleculesinSceneMap.find(molid);
     if (moliter != MoleculesinSceneMap.end()) {
-      // no action, is also caught via QtObservedMolecule by GLMoleculeObject_molecule
+      LOG(3, "INFO: GLWorldScene: Sending signal moleculesAtomRemoved for atom "+toString(_atomid)+".");
+      QMetaObject::invokeMethod(moliter->second,        // pointer to a QObject
+                                "atomRemoved",       // member name (no parameters here)
+                                Qt::QueuedConnection,     // connection type
+                                Q_ARG(const atomId_t, _atomid));     // parameters
     } else {
-      // 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(_atomid, atomRemovedState) );
-      LOG(3, "INFO: GLWorldScene: Placing atomRemoved for atom " << _atomid
-           << " and molecule " << molid << " into missed state map.");
+      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(_atomid, atomRemovedState) );
+        LOG(3, "INFO: GLWorldScene: Placing atomRemoved for atom " << _atomid
+             << " and molecule " << molid << " into missed state map.");
+      }
     }
   }
@@ -216,9 +268,14 @@
   // source as GLMoleculeObject_molecule would
   connect(_mol.get(), SIGNAL(atomInserted(QtObservedAtom::ptr)),
-      this, SLOT(atomInserted(QtObservedAtom::ptr)) );
+      this, SLOT(moleculesAtomInserted(QtObservedAtom::ptr)) );
   connect(_mol.get(), SIGNAL(atomRemoved(const atomId_t)),
-      this, SLOT(atomRemoved(const atomId_t)) );
+      this, SLOT(moleculesAtomRemoved(const atomId_t)) );
   const moleculeId_t molid = _mol->getMolIndex();
-  QtObservedMoleculeMap.insert( std::make_pair(molid, _mol) );
+  ASSERT( QtObservedMoleculeMap.find(molid) == QtObservedMoleculeMap.end(),
+      "GLWorldScene::moleculeSignOn() - molecule with id "+toString(molid)
+      +" is already present in QtObservedMoleculeMap.");
+  QtObservedMoleculeMap[molid] = _mol;
+  connect(_mol.get(), SIGNAL(indexChanged(const moleculeId_t,const moleculeId_t)),
+      this, SLOT(moleculeIndexChanged(const moleculeId_t,const moleculeId_t)) );
 
   LOG(3, "INFO: GLWorldScene: Received signal moleculeSignOn for molecule "+toString(molid)+".");
@@ -229,9 +286,10 @@
 void GLWorldScene::moleculeSignOff(const moleculeId_t _id)
 {
-  ASSERT( QtObservedMoleculeMap.count(_id),
+  const QtObservedMoleculeMap_t::iterator eraseiter = QtObservedMoleculeMap.find(_id);
+  ASSERT( eraseiter != QtObservedMoleculeMap.end(),
       "GLWorldScene::moleculeSignOff() - cannot find id "+toString(_id)+" in map.");
-  const QtObservedMolecule::ptr mol = QtObservedMoleculeMap[_id];
-  mol->disconnect(this);
-  QtObservedMoleculeMap.erase(_id);
+  disconnect(eraseiter->second.get(), SIGNAL(indexChanged(const moleculeId_t,const moleculeId_t)),
+      this, SLOT(moleculeIndexChanged(const moleculeId_t,const moleculeId_t)) );
+  QtObservedMoleculeMap.erase(eraseiter);
 
   LOG(3, "INFO: GLWorldScene: Received signal moleculeSignOff for molecule "+toString(_id)+".");
@@ -256,10 +314,4 @@
   ASSERT( iter == MoleculesinSceneMap.end(),
       "GLWorldScene::moleculeInserted() - molecule's id "+toString(molid)+" already present.");
-
-  // check whether molecule is still present
-  if (RemovalMolecules.count(molid) != 0) {
-    RemovalMolecules.erase(molid);
-    return;
-  }
 
   // add new object
@@ -325,5 +377,4 @@
           {
             LOG(1, "INFO: invoking atomInserted for atom " << iter->first);
-            const QtObservedAtom::ptr walker = QtObservedAtomMap[iter->first];
             QMetaObject::invokeMethod(molObject,        // pointer to a QObject
                                       "atomInserted",       // member name (no parameters here)
@@ -374,7 +425,5 @@
 
   MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_id);
-  if ( iter == MoleculesinSceneMap.end()) {
-    RemovalMolecules.insert(_id);
-  } else {
+  if ( iter != MoleculesinSceneMap.end()) {
     LOG(1, "DEBUG: Removing GLMoleculeObject_molecule to id " << _id);
     GLMoleculeObject_molecule *molObject = iter->second;
@@ -405,23 +454,33 @@
 void GLWorldScene::moleculeIndexChanged(const moleculeId_t _oldid, const moleculeId_t _newid)
 {
-  MoleculeNodeMap::iterator iter = MoleculesinSceneMap.find(_oldid);
-  if ( iter == MoleculesinSceneMap.end()) {
-    RemovalMolecule_t::iterator removeiter =
-        RemovalMolecules.find(_oldid);
-    ASSERT( removeiter != RemovalMolecules.end(),
-        "GLWorldScene::moleculeIndexChanged() - cannot find id "+toString(_oldid)+" in any map.");
-    RemovalMolecules.erase(removeiter);
-    RemovalMolecules.insert(_newid);
-    if (QtObservedMoleculeMap.count(_oldid)) {
-      const QtObservedMolecule::ptr mol = QtObservedMoleculeMap[_oldid];
-      QtObservedMoleculeMap.erase(_oldid);
-      QtObservedMoleculeMap.insert( std::make_pair(_newid, mol) );
+  {
+    QtObservedMoleculeMap_t::iterator const olditer = QtObservedMoleculeMap.find(_oldid);
+    ASSERT ( olditer != QtObservedMoleculeMap.end(),
+        "GLWorldScene::moleculeIndexChanged() - molecule "
+        +toString(_oldid)+" not present in QtObservedMoleculeMap.");
+#ifndef NDEBUG
+    QtObservedMoleculeMap_t::iterator const newiter = QtObservedMoleculeMap.find(_newid);
+    ASSERT ( newiter == QtObservedMoleculeMap.end(),
+        "GLWorldScene::moleculeIndexChanged() - molecule "
+        +toString(_newid)+" already present in QtObservedMoleculeMap.");
+#endif
+    const QtObservedMolecule::ptr mol = olditer->second;
+    QtObservedMoleculeMap.erase(olditer);
+    QtObservedMoleculeMap[_newid] = mol;
+  }
+  {
+    MoleculeNodeMap::iterator const olditer = MoleculesinSceneMap.find(_oldid);
+    if ( olditer != MoleculesinSceneMap.end()) {
+#ifndef NDEBUG
+      MoleculeNodeMap::iterator const newiter = MoleculesinSceneMap.find(_newid);
+      ASSERT ( newiter == MoleculesinSceneMap.end(),
+          "GLWorldScene::moleculeIndexChanged() - molecule "
+          +toString(_newid)+" already present in MoleculesinSceneMap.");
+#endif
+      LOG(1, "DEBUG: Changing GLMoleculeObject_molecule from " << _oldid << " to id " << _newid);
+      GLMoleculeObject_molecule* const molObject = olditer->second;
+      MoleculesinSceneMap.erase(olditer);
+      MoleculesinSceneMap[_newid] = molObject;
     }
-  } else {
-    LOG(1, "DEBUG: Changing GLMoleculeObject_molecule from " << _oldid << " to id " << _newid);
-    GLMoleculeObject_molecule* molObject = iter->second;
-    MoleculesinSceneMap.erase(iter);
-    MoleculesinSceneMap.insert(
-        std::make_pair( _newid, molObject) );
   }
 }
Index: src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp
===================================================================
--- src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision 03e69e2faa3ae6d3c118759dd157a9b956ddfa77)
+++ src/UIElements/Views/Qt4/Qt3D/GLWorldScene.hpp	(revision 59f1bcc899a181c8225110eb43adbf27eb563d57)
@@ -95,4 +95,6 @@
   void moleculeSignOn(QtObservedMolecule::ptr);
   void moleculeIndexChanged(const moleculeId_t _oldid, const moleculeId_t _newid);
+  void moleculesAtomRemoved(const atomId_t _atomid);
+  void moleculesAtomInserted(QtObservedAtom::ptr);
   void atomRemoved(const atomId_t _atomid);
   void atomInserted(QtObservedAtom::ptr);
@@ -109,8 +111,4 @@
 
 private:
-
-  typedef std::set<moleculeId_t> RemovalMolecule_t;
-  //!> list of molecule ids whose moleculeRemoved we have received but who have not been inserted yet
-  RemovalMolecule_t RemovalMolecules;
 
   typedef std::map< moleculeId_t , GLMoleculeObject_molecule* > MoleculeNodeMap;
@@ -137,4 +135,5 @@
   //!> map to contain all QtObservedMolecule that have not been instantiated so far
   QtObservedMoleculeMap_t QtObservedMoleculeMap;
+
   //!> flag to indicate whether state map is currently worked on
   boost::recursive_mutex MoleculeMissedStateMap_mutex;
Index: src/documentation/constructs/qt-gui.dox
===================================================================
--- src/documentation/constructs/qt-gui.dox	(revision 03e69e2faa3ae6d3c118759dd157a9b956ddfa77)
+++ src/documentation/constructs/qt-gui.dox	(revision 59f1bcc899a181c8225110eb43adbf27eb563d57)
@@ -59,7 +59,7 @@
  * there is a QTimer that only updates an object in regular intervals, or
  * because of asynchronous threads. Elsewhen, the slot callback for a
- * certain signal is called directly. For all of these cases we have to
+ * certain signal is called directly. All of these cases we have to
  * accommodate. This is especially problematic with the instantiation and
- * destruction of objects.
+ * destruction of objects that represent atoms and molecules in the World.
  *
  * A clarifying example: Imagine an atom is constructed, the AtomObserver
@@ -70,8 +70,9 @@
  *
  * The only possible way out is to duplicate information. This is the usual
- * way how to deal with environments with multiple threads. I.e. all the
+ * way how to proceed in environments with multiple threads. I.e. all the
  * information that the GUI representants of information inside the World
  * needs to be doubled such that when the original information is destroyed
- * the representant can still be accessed as long as needed.
+ * the representant can still be accessed as long as needed. Here, we use
+ * the ObservedValue construct of CodePatterns.
  *
  * \subsection qt-gui-general-observedvalue Observed Value
@@ -100,31 +101,111 @@
  * pieces of information that require more computing resources within the
  * updater. Also, the Cacheable's information can only be obtained as long
- * as the source of information is still alive.
- *
- * Both concepts can be used in threaded environments as mutexed are used to
+ * as the source of information is still alive. However, so far Cacheable's
+ * content is marked invalid when an update signal has been received and
+ * update itself only on request, which is no longer possible when the object
+ * to represent is gone.
+ *
+ * Both concepts can be used in threaded environments as mutexes are used to
  * protect read and write accesses.
  *
- * \subsection qt-gui-general-signalslot Observer/Observable and Signal/Slot
- *
- * In the following we refer to Observer/Observable as "O/O" and to Signal/Slot
- * as "S/S".
- *
- * One thing we need to do is to translate between update() or
- * recieveNotification() calls from an Observable and subsequent signal/slot
- * calls. The general idea is to use these ObservedValues as translation
- * points for small pieces of information and Cacheables for larger pieces.
- *
- * However, we need more of these translation points:
- * -# GLWorldView checks for
- *   -# World's MoleculeInserted
- *   -# World's SelectionChanged
- *   -# WorldTime's TimeChanged
- *   -# each molecule's AtomInserted and AtomRemoved
- *   -# AtomObservable's AtomChanged.
- *   -# ShapeRegistry's ShapedAdded, ShapeRemoved, and SelectionChanged
- * -# GLMoleculeObject_molecule checks for
- *   -# molecule's AtomInserted, AtomRemoved, AtomMoved, IndexChanged
- *   -# World's SelectionChanged
- *
+ * \subsection qt-gui-general-observedinstance The observed instance board
+ *
+ * The setup is then as follows: We have two distinct realms, the World (with
+ * atoms and molecules) on the one side and the QtGUI (with visual
+ * representations of atoms and molecules) on the other side.
+ *
+ * There is an interface between this world such that the destruction of an
+ * atom does not directly invalidate its visual representation. This interface
+ * between the two realms is contained in the class QtObservedInstanceBoard,
+ * which is a singleton and is similar to the World instance in the World realm
+ * for the QtGui realm.
+ *
+ * All properties, e.g. the position of an element, relevant to the QtGUI are
+ * duplicated as ObservedValues. Properties associated to the same instance in
+ * the World, e.g. the same atom, are combined into a QtObservedAtom instance,
+ * and similarly QtObservedMolecule for molecule. All of these observed
+ * instances are placed into ObservedValuesContainer which are contained in
+ * the interface QtObservedInstanceBoard.
+ *
+ * The sequence of events is then as follows (here exemplified with an atom):
+ * -# an atom is created (World::createAtom()), the World notifies about it
+ *    via its World::AtomInserted channel.
+ * -# QtObservedInstanceBoard is signOn()ed to this channel and instantiates
+ *    a new QtObservedAtom which is placed into its respective
+ *    ObservedValuesContainer.
+ * -# on instantiation of QtObservedAtom a vector of specific ObservedValues is
+ *    created, one for each property (position, element, bond count, ...).
+ *    Each signOn()s to the respective atom's channel. Also the QtObservedAtom
+ *    signOn()s to each of these channels as it converts these notifications
+ *    into Qt signals (and the updated value can be accessed via getters from
+ *    the QtObservedAtom instance). The QtObservedInstanceBoard is notified
+ *    of this with the instance being marked as connected.
+ * -# when the atom is destroyed (World::destroyAtom()), being an Observable
+ *    it will call subjectKilled() on all its channels. The
+ *    ObservedValue_wCallback announces this subjectKilled() via the callback
+ *    function which notifies QtObservedAtom. Once all subjectKilled(), for
+ *    each observed value and for QtObservedAtom itself, have been received,
+ *    the QtObservedInstanceBoard is notified by the instance now being
+ *    marked as disconnected and ready for erase.
+ * -# then the QtObservedInstanceBoard removes the instance from its
+ *    ObservedValuesContainer.
+ *
+ * Note however that the instance is a shared_ptr and will continue to exist
+ * and therefore its getters will still deliver the last piece of information
+ * before the atom was destroyed until all shared_ptrs are released. Hence,
+ * the QtGui may safely continue using the pointer.
+ *
+ * As new observed instances may come in immediately having the same id and
+ * as it is difficult to keep track who got its observed instance already
+ * and who not, a soft fail is required. I.e. of the QtObservedInstanceBoard
+ * returns an empty shared_ptr this means that the object -- despite any
+ * received (and probably delayed) signal -- has been destroyed and should
+ * not be displayed, updated by, ... whatsoever.
+ *
+ * \subsection qt-gui-general-signalslot Details on the slot connections
+ *
+ * Qt's event system does not guarantee that events are always processed in
+ * the order they are emitted. This is because connections can be defined
+ * as direct or queued (or both with auto). Direct connections will always
+ * be executed as direct function calls, i.e. immediately. Queued connections
+ * however are inserted into Qt's event queue and may even get processed by
+ * a different thread.
+ *
+ * We have to take care of this.
+ *
+ * Basically what we do in QtObservedInstanceBoard and the observed instances
+ * of type QtObservedAtom and QtObservedMolecule is that we translate between
+ * the Observer/Observable (O/O) system of CodePatterns with its callback
+ * functions and the event system of Qt with its Signal/Slot (S/S).
+ *
+ * That is in the recieveNotification() functions many "emit()"s can be found.
+ *
+ * Furthermore, signals are used in a specific way to ensure synchronicity.
+ * This is only a problem with the visual representation as we there find a
+ * a nested problem: First molecules, then atoms belonging to a certain
+ * molecule. This enforces a certain sequence of events and thus of signals.
+ *
+ * \subsubsection qt-gui-general-signalslot-glworldscene Details on GLWorldScene
+ *
+ * The central place for all events is the GLWorldScene instance. There
+ * signals from QtObservedInstanceBoard for insertion and removal of both atoms
+ * and molecules are caught. Insertion of molecules is dealt with directly,
+ * we sign on to the inserted&removed channels for its atoms, then we emit
+ * a queued signal to actually instantiate the GLMoleculeObject_molecule.
+ *
+ * Until its instantiation we store incoming signals in the
+ * GLWorldScene::MoleculeMissedStateMap, protected by a mutex to enforce atomic
+ * access. After it has been instantiated (and all stored signals have been
+ * processed), they are relayed onto the specific instance. However, we do not
+ * do this via emits but by directly using Qt's invokeMethod() which allows
+ * to trigger queued events. This way it is done in a likewise manner whether
+ * it has been a stored or live signal that was received.
+ *
+ * \subsubsection qt-gui-general-signalslot-other Details on other signals
+ *
+ * All other signals that only change the property of a visual representation,
+ * e.g. the element of an atom, is directly processed by, in this case, the
+ * GLMoleculeObject_atom connected to QtObservedAtom.
+. *
  * \section qt-gui-qt3d Qt3D and the way to get atoms and bonds displayed
  *
@@ -146,6 +227,6 @@
  * of an element-specific color at the atom's position. The atom relies
  * on its representants to be contain all required information but it
- * is also signOn() to the atom itself whose O/O are translated to S/S
- * for processing whenever desired.
+ * is also signOn() to the QtObservedAtom itself whose O/O are translated to
+ * S/S for processing whenever desired.
  *
  * Next comes the GLMoleculeObject_bond which displays a cylinder between
@@ -158,5 +239,5 @@
  *
  * Parallel to these are GLMoleculeObject_shape which display the surface
- * of a selected shape. A shape in general does not change after instantation,
+ * of a selected shape. A shape in general does not change after instantiation,
  * hence the shape lives with the information it gets on instantiation till
  * it dies.
@@ -168,5 +249,5 @@
  * molecules. The molecule also needs ObservedValues for its bounding box
  * (used to show when it's selected), the index, the selection status,
- * and the list of atom ids. As Cacheable we use the tesselation structure.
+ * and the list of atom ids.
  *
  * \section qt-gui-cases Sample cases
@@ -270,4 +351,4 @@
  * they automatically clear the info box.
  *
- * \date 2015-07-15
+ * \date 2016-01-08
  */
