source: src/UIElements/Views/Qt4/Qt3D/GLMoleculeObject_molecule.cpp@ 07b800

/*
 * Project: MoleCuilder
 * Description: creates and alters molecular systems
 * Copyright (C)  2010-2012 University of Bonn. All rights reserved.
 * Copyright (C)  2013 Frederik Heber. All rights reserved.
 * 
 *
 *   This file is part of MoleCuilder.
 *
 *    MoleCuilder is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    MoleCuilder is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with MoleCuilder.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * GLMoleculeObject_molecule.cpp
 *
 *  Created on: Mar 30, 2012
 *      Author: ankele
 */


// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "GLMoleculeObject_molecule.hpp"

#include <Qt3D/qglscenenode.h>
#include <Qt3D/qglbuilder.h>

#include "CodePatterns/MemDebug.hpp"

#include <boost/assign.hpp>

#include "CodePatterns/Assert.hpp"
#include "CodePatterns/Log.hpp"
#include "CodePatterns/Observer/Notification.hpp"
#include "CodePatterns/Observer/ObserverLog.hpp"

#include "Atom/atom.hpp"
#include "molecule.hpp"
#include "Descriptors/AtomIdDescriptor.hpp"
#include "Descriptors/MoleculeIdDescriptor.hpp"
#include "Element/element.hpp"
#include "LinearAlgebra/Vector.hpp"
#include "LinkedCell/PointCloudAdaptor.hpp"
#include "LinkedCell/linkedcell.hpp"
#include "Tesselation/tesselation.hpp"
#include "Tesselation/BoundaryLineSet.hpp"
#include "Tesselation/BoundaryTriangleSet.hpp"
#include "Tesselation/CandidateForTesselation.hpp"
#include "Atom/TesselPoint.hpp"
#include "World.hpp"

using namespace boost::assign;

#include "GLMoleculeObject_atom.hpp"

static Observable::channels_t getAtomsChannels()
{
  Observable::channels_t channels;
  channels += molecule::AtomInserted, molecule::AtomRemoved;
  return channels;
}

static Observable::channels_t getAllAtomicChangesChannels()
{
  Observable::channels_t channels;
  channels += molecule::AtomInserted, molecule::AtomRemoved, molecule::AtomMoved;
  return channels;
}

// static instances
const Observable::channels_t GLMoleculeObject_molecule::AtomsChannels(getAtomsChannels());
const Observable::channels_t GLMoleculeObject_molecule::HullChannels(getAllAtomicChangesChannels());
const Observable::channels_t GLMoleculeObject_molecule::BoundingBoxChannels(getAllAtomicChangesChannels());
const Observable::channels_t GLMoleculeObject_molecule::IndexChannels(1, molecule::IndexChanged);

static QGLSceneNode *createMoleculeMesh(const QGeometryData &_geo)
{
  // Build a mesh from the geometry.
  QGLBuilder builder;
  builder.addTriangles(_geo);
  QGLSceneNode *mesh = builder.finalizedSceneNode();
  return mesh;
}

GLMoleculeObject_molecule::GLMoleculeObject_molecule(QObject *parent, const moleculeId_t _molid) :
  GLMoleculeObject((QGLSceneNode *)NULL, parent),
  Observer(std::string("GLMoleculeObject_molecule")+toString(_molid)),
  owner(NULL),
  molref(getMolecule(_molid)),
  /* 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.
   */
  MolIndexUpdater(
      boost::bind(&GLMoleculeObject_molecule::updateIndex, this)
      ),
  TesselationHullUpdater(
      boost::bind(&GLMoleculeObject_molecule::updateTesselationHull, this)
      ),
  BoundingBoxUpdater(
      boost::bind(&GLMoleculeObject_molecule::updateBoundingBox, this)
      ),
  PresentAtomsUpdater(
      boost::bind(&GLMoleculeObject_molecule::updateAtoms, this)
      ),
  MolIndex(
      molref,
      MolIndexUpdater,
      "MoleculeIndex_"+toString(_molid),
      _molid,
      IndexChannels),
  TesselationHull(
      molref,
      TesselationHullUpdater,
      "MoleculeTesselationHull_"+toString(_molid),
      HullChannels),
  BoundingBox(
      molref,
      BoundingBoxUpdater,
      "MoleculeBoundingBox_"+toString(_molid),
      updateBoundingBox(),
      BoundingBoxChannels),
  PresentAtoms(
      molref,
      PresentAtomsUpdater,
      "MoleculeAtoms_"+toString(_molid),
      updateAtoms(),
      AtomsChannels),
  hoverAtomId(-1)
{
  setObjectId(_molid);
  setMaterial(getMaterial(1));

  m_selected = const_cast<const World &>(World::getInstance()).isMoleculeSelected(_molid);

  // initially, atoms and bonds should be visible
  m_visible = false;

  connect (this, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SLOT(hoverChangedSignalled(GLMoleculeObject *)));
  connect (this, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SIGNAL(changed()));
  connect (this, SIGNAL(TesselationHullChanged()), this, SLOT(resetTesselationHull()), Qt::QueuedConnection);
  connect (this, SIGNAL(BoundingBoxChanged()), this, SLOT(resetBoundingBox()), Qt::QueuedConnection);
  connect (this, SIGNAL(IsSelectedChanged()), this, SLOT(resetIsSelected()), Qt::QueuedConnection);
  connect (this, SIGNAL(IdChanged()), this, SLOT(resetIndex()), Qt::QueuedConnection);
  connect (this, SIGNAL(AtomInserted(const atomId_t)), this, SLOT(atomInserted(const atomId_t)), Qt::QueuedConnection);
  connect (this, SIGNAL(AtomInserted(const atomId_t)), this, SLOT(resetAtoms()), Qt::QueuedConnection);
  connect (this, SIGNAL(AtomRemoved(const atomId_t)), this, SLOT(resetAtoms()), Qt::QueuedConnection);
  connect (this, SIGNAL(AtomRemoved(const atomId_t)), this, SLOT(atomRemoved(const atomId_t)), Qt::QueuedConnection);

  connect( this, SIGNAL(clicked()), this, SLOT(wasClicked()));
}

GLMoleculeObject_molecule::GLMoleculeObject_molecule(QGLSceneNode *mesh[], QObject *parent, const moleculeId_t _molid) :
  GLMoleculeObject(mesh, parent),
  Observer(std::string("GLMoleculeObject_molecule")+toString(_molid)),
  owner(NULL),
  molref(getMolecule(_molid)),
  /* 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.
   */
  MolIndexUpdater(
      boost::bind(&GLMoleculeObject_molecule::updateIndex, this)
      ),
  TesselationHullUpdater(
      boost::bind(&GLMoleculeObject_molecule::updateTesselationHull, this)
      ),
  BoundingBoxUpdater(
      boost::bind(&GLMoleculeObject_molecule::updateBoundingBox, this)
      ),
  PresentAtomsUpdater(
      boost::bind(&GLMoleculeObject_molecule::updateAtoms, this)
      ),
  MolIndex(
      molref,
      MolIndexUpdater,
      "MoleculeIndex_"+toString(_molid),
      _molid,
      IndexChannels),
  TesselationHull(
      molref,
      TesselationHullUpdater,
      "MoleculeTesselationHull_"+toString(_molid),
      HullChannels),
  BoundingBox(
      molref,
      BoundingBoxUpdater,
      "MoleculeBoundingBox_"+toString(_molid),
      updateBoundingBox(),
      BoundingBoxChannels),
  PresentAtoms(
      molref,
      PresentAtomsUpdater,
      "MoleculeAtoms_"+toString(_molid),
      atoms_t(),
      AtomsChannels),
  hoverAtomId(-1)
{
  setObjectId(_molid);
  setMaterial(getMaterial(1));

  m_selected = const_cast<const World &>(World::getInstance()).isMoleculeSelected(_molid);

  // initially, atoms and bonds should be visible
  m_visible = false;

  connect (this, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SLOT(hoverChangedSignalled(GLMoleculeObject *)));
  connect (this, SIGNAL(hoverChanged(GLMoleculeObject *)), this, SIGNAL(changed()));
  connect (this, SIGNAL(TesselationHullChanged()), this, SLOT(resetTesselationHull()), Qt::QueuedConnection);
  connect (this, SIGNAL(BoundingBoxChanged()), this, SLOT(resetBoundingBox()), Qt::QueuedConnection);
  connect (this, SIGNAL(IdChanged()), this, SLOT(resetIndex()), Qt::QueuedConnection);
  connect (this, SIGNAL(AtomInserted(const atomId_t)), this, SLOT(atomInserted(const atomId_t)), Qt::QueuedConnection);
  connect (this, SIGNAL(AtomInserted(const atomId_t)), this, SLOT(resetAtoms()), Qt::QueuedConnection);
  connect (this, SIGNAL(AtomRemoved(const atomId_t)), this, SLOT(resetAtoms()), Qt::QueuedConnection);
  connect (this, SIGNAL(AtomRemoved(const atomId_t)), this, SLOT(atomRemoved(const atomId_t)), Qt::QueuedConnection);

  connect( this, SIGNAL(clicked()), this, SLOT(wasClicked()));
}

GLMoleculeObject_molecule::~GLMoleculeObject_molecule()
{
  deactivateObserver();
}

void GLMoleculeObject_molecule::deactivateObserver()
{
  if (owner != NULL) {
    owner->signOff(this, molecule::AtomInserted);
    owner->signOff(this, molecule::AtomRemoved);
    owner->signOff(this, molecule::AtomMoved);
    owner->signOff(this, molecule::IndexChanged);
    owner = NULL;
  }
}

void GLMoleculeObject_molecule::activateObserver()
{
  // sign on as observer (obtain non-const instance before)
  const molecule * const _molecule = getMolecule(MolIndex.get());
  if (_molecule != NULL) {
    owner = static_cast<const Observable *>(_molecule);
    owner->signOn(this, molecule::AtomInserted);
    owner->signOn(this, molecule::AtomRemoved);
    owner->signOn(this, molecule::AtomMoved);
    owner->signOn(this, molecule::IndexChanged);
  } else {
    ELOG(1, "GLMoleculeObject_molecule() - added null object for not present mol id " << MolIndex.get());
  }

}

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

void GLMoleculeObject_molecule::addAtomBonds(
    const atom *_atom)
{
  const bool atom_present = AtomsinSceneMap.count(_atom->getId());
  const BondList &bondlist = _atom->getListOfBonds();
  for (BondList::const_iterator bonditer = bondlist.begin();
      (bonditer != bondlist.end()) && atom_present;
      ++bonditer) {
    const bond::ptr _bond = *bonditer;
    // check if OtherAtom's sphere is already present
    const atom *OtherAtom = _bond->GetOtherAtom(_atom);
    const bool otheratom_present = AtomsinSceneMap.count(OtherAtom->getId());
    if (otheratom_present && atom_present) {
      const GLMoleculeObject_bond::SideOfBond side = (_bond->leftatom == _atom) ?
          GLMoleculeObject_bond::left : GLMoleculeObject_bond::right;
      const GLMoleculeObject_bond::SideOfBond otherside = (_bond->leftatom == _atom) ?
          GLMoleculeObject_bond::right : GLMoleculeObject_bond::left;
      addAtomBonds(_bond, side);
      addAtomBonds(_bond, otherside);
    }
  }
}

QGeometryData GLMoleculeObject_molecule::updateTesselationHull() const
{
  QGeometryData geo;

  const molecule * const molref = getMolecule(MolIndex.get());
  if (molref == NULL) {
    ELOG(1, "Could not createMoleculeMesh, molecule with id " << MolIndex.get() << " already gone.");
    return geo;
  }
  double minradius = 2.; // TODO: set to maximum bond length value
  LOG(3, "DEBUG: Molecule fits into sphere of radius " << minradius);
  // check minimum bond radius in molecule
  double minlength = std::numeric_limits<double>::max();
  for (molecule::const_iterator iter = molref->begin();
      iter != molref->end(); ++iter) {
    const BondList &ListOfBonds = (*iter)->getListOfBonds();
    for (BondList::const_iterator bonditer = ListOfBonds.begin();
         bonditer != ListOfBonds.end(); ++bonditer) {
      const double bond_distance = (*bonditer)->GetDistance();
      minlength = std::min(bond_distance, minlength);
    }
  }
  minradius = std::max( std::max(minradius, minlength), 1.);

  // we need at least three points for tesselation
  if (molref->getAtomCount() >= 3) {
    // Tesselate the points.
    Tesselation T;
    PointCloudAdaptor<molecule> cloud(const_cast<molecule *>(molref), molref->getName());
    T(cloud, minradius);

    // Fill the points into a Qt geometry.
    LinkedCell_deprecated LinkedList(cloud, minradius);
    std::map<int, int> indices;
    std::map<int, Vector> normals;
    int index = 0;
    for (PointMap::const_iterator piter = T.PointsOnBoundary.begin();
        piter != T.PointsOnBoundary.end(); ++piter) {
      const Vector &point = piter->second->getPosition();
      // add data to the primitive
      geo.appendVertex(QVector3D(point[0], point[1], point[2]));
      Vector normalvector;
      for (LineMap::const_iterator lineiter = piter->second->lines.begin();
          lineiter != piter->second->lines.end(); ++lineiter)
        for (TriangleMap::const_iterator triangleiter = lineiter->second->triangles.begin();
            triangleiter != lineiter->second->triangles.end(); ++triangleiter)
          normalvector +=
              triangleiter->second->NormalVector;
      normalvector.Normalize();
      geo.appendNormal(QVector3D(normalvector[0], normalvector[1], normalvector[2]));
      geo.appendColor(QColor(1, 1, 1, 1));
      geo.appendTexCoord(QVector2D(0, 0));
      indices.insert( std::make_pair( piter->second->getNr(), index++));
    }

    // Fill the tesselated triangles into the geometry.
    for (TriangleMap::const_iterator runner = T.TrianglesOnBoundary.begin();
        runner != T.TrianglesOnBoundary.end(); runner++) {
      int v[3];
      for (size_t i=0; i<3; ++i)
        v[i] = runner->second->endpoints[i]->getNr();

      // Sort the vertices so the triangle is clockwise (relative to the normal vector).
      Vector cross = T.PointsOnBoundary[v[1]]->getPosition() - T.PointsOnBoundary[v[0]]->getPosition();
      cross.VectorProduct(T.PointsOnBoundary[v[2]]->getPosition() - T.PointsOnBoundary[v[0]]->getPosition());
      if (cross.ScalarProduct(runner->second->NormalVector) > 0)
        geo.appendIndices(indices[v[0]], indices[v[1]], indices[v[2]]);
      else
        geo.appendIndices(indices[v[0]], indices[v[2]], indices[v[1]]);
    }
  }

  return geo;
}

GLMoleculeObject_molecule::BoundingBoxInfo GLMoleculeObject_molecule::updateBoundingBox() const
{
  BoundingBoxInfo info;
  const molecule * const _molecule = getMolecule(MolIndex.get());
  if (_molecule != NULL) {
    Shape shape = _molecule->getBoundingSphere();
    info.position = shape.getCenter();
    info.radius = shape.getRadius();
  } else
    ELOG(2, "GLMoleculeObject_molecule cannot updateBoundingBox, molecule with "
        << MolIndex.get() << " has disappeared.");
  return info;
}

GLMoleculeObject_molecule::atoms_t GLMoleculeObject_molecule::updateAtoms()
{
  const molecule * const mol = getMolecule(MolIndex.get());
  if (mol != NULL) {
    const atomId_t id = mol->lastChangedAtomId();
    if (mol->containsAtom(id))
      DisplayedAtoms.insert(id);
    else
      DisplayedAtoms.erase(id);
  }
  return DisplayedAtoms;
}

moleculeId_t GLMoleculeObject_molecule::updateIndex() const
{
  return const_cast<const World &>(World::getInstance()).lastChangedMolId();
}

void GLMoleculeObject_molecule::resetTesselationHull()
{
  if (!TesselationHull.isValid())
    updateMesh(createMoleculeMesh(*TesselationHull));
}

void GLMoleculeObject_molecule::resetBoundingBox()
{
  BoundingBoxInfo info = BoundingBox.get();
  setPosition(QVector3D(info.position[0], info.position[1], info.position[2]));
  setScale(info.radius + 0.3); // getBoundingSphere() only sees atoms as points, so make the box a bit bigger
}

void GLMoleculeObject_molecule::resetAtoms()
{
  const atoms_t atoms = PresentAtoms.get();
  std::vector<atomId_t> InsertedAtoms;
  std::vector<atomId_t> RemovedAtoms;
  // obtain all newly inserted and removed atoms
  std::set_difference(
      atoms.begin(), atoms.end(),
      DisplayedAtoms.begin(), DisplayedAtoms.end(),
      std::back_inserter(InsertedAtoms));
  std::set_difference(
      DisplayedAtoms.begin(), DisplayedAtoms.end(),
      atoms.begin(), atoms.end(),
      std::back_inserter(RemovedAtoms));
  // remove the atoms
  std::for_each(RemovedAtoms.begin(), RemovedAtoms.end(),
      boost::bind(&GLMoleculeObject_molecule::atomRemoved, this, _1));
  // insert the atoms
  std::for_each(InsertedAtoms.begin(), InsertedAtoms.end(),
      boost::bind(&GLMoleculeObject_molecule::atomInserted, this, _1));

  emit changed();
}

void GLMoleculeObject_molecule::resetIndex()
{
  const atomId_t newId = MolIndex.get();
  const size_t oldId = objectId();
  ASSERT( newId != oldId,
      "GLMoleculeObject_molecule::resetIndex() - index "+toString(newId)+" did not change.");
  LOG(4, "INFO: GLMoleculeObject_molecule: new index is "+toString(newId)+".");
  setObjectId(newId);

  emit indexChanged(this, oldId, newId);
}

void GLMoleculeObject_molecule::AtomSelected(const atomId_t _id)
{
  AtomNodeMap::iterator iter = AtomsinSceneMap.find(_id);
  if (iter != AtomsinSceneMap.end())
    QMetaObject::invokeMethod(iter->second,        // pointer to a QObject
                            "Selected",       // member name (no parameters here)
                            Qt::QueuedConnection);     // connection type
  else
    ELOG(2, "GLMoleculeObject_molecule::AtomSelected() - atom "
        << _id << " unknown to GLMoleculeObject_molecule.");
}

void GLMoleculeObject_molecule::AtomUnselected(const atomId_t _id)
{
  AtomNodeMap::iterator iter = AtomsinSceneMap.find(_id);
  if (iter != AtomsinSceneMap.end())
    QMetaObject::invokeMethod(iter->second,        // pointer to a QObject
                            "Unselected",       // member name (no parameters here)
                            Qt::QueuedConnection);     // connection type
  else ELOG(2,  "GLMoleculeObject_molecule::AtomUnselected() - atom "
      << _id << " unknown to GLMoleculeObject_molecule.");
}

void GLMoleculeObject_molecule::Selected()
{
  ASSERT( !m_selected,
      "GLMoleculeObject_molecule::Selected() - 3D rep of molecule is already selected.");
  m_selected = true;

  emit changed();
}

void GLMoleculeObject_molecule::Unselected()
{
  ASSERT( m_selected,
      "GLMoleculeObject_molecule::Unselected() - 3D rep of molecule is already unselected.");
  m_selected = false;

  emit changed();
}

void GLMoleculeObject_molecule::update(Observable *publisher)
{
#ifdef LOG_OBSERVER
  const molecule *_mol = static_cast<molecule *>(publisher);
  observerLog().addMessage() << "++ Update of Observer " << observerLog().getName(static_cast<Observer *>(this)) << " from molecule "+toString(_mol->getId())+".";
#endif
}

void GLMoleculeObject_molecule::subjectKilled(Observable *publisher)
{
  deactivateObserver();
}

void GLMoleculeObject_molecule::recieveNotification(Observable *publisher, Notification_ptr notification)
{
  const molecule * const _molecule = getMolecule(MolIndex.get());
  // when molecule is NULL we will soon get destroyed anyway
  if (_molecule == NULL)
    return;
  if (publisher == dynamic_cast<const Observable*>(_molecule)){
    // notofication from atom
#ifdef LOG_OBSERVER
    observerLog().addMessage() << "++ Update of Observer "<< observerLog().getName(static_cast<Observer *>(this))
          << " received notification from molecule " << _molecule->getId() << " for channel "
          << notification->getChannelNo() << ".";
#endif
    switch (notification->getChannelNo()) {
      case molecule::AtomInserted:
      {
        const atomId_t _id = _molecule->lastChangedAtomId();
  #ifdef LOG_OBSERVER
        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that atom "+toString(_id)+" has been inserted.";
  #endif
        emit AtomInserted(_id);
        emit TesselationHullChanged();
        emit BoundingBoxChanged();
        break;
      }
      case World::AtomRemoved:
      {
        const atomId_t _id = _molecule->lastChangedAtomId();
  #ifdef LOG_OBSERVER
        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that atom "+toString(_id)+" has been removed.";
  #endif
        emit AtomRemoved(_id);
        emit TesselationHullChanged();
        emit BoundingBoxChanged();
        break;
      }
      case molecule::AtomMoved:
      {
  #ifdef LOG_OBSERVER
        const atomId_t _id = _molecule->lastChangedAtomId();
        observerLog().addMessage() << "++ Observer " << observerLog().getName(static_cast<Observer *>(this)) << " received notification that atom "+toString(_id)+" has been inserted.";
  #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 IdChanged();
        break;
      }
      default:
        break;
    }
  }
}

void GLMoleculeObject_molecule::initialize(QGLView *view, QGLPainter *painter)
{
  // Initialize all of the mesh objects that we have as children.
  if (m_visible) {
    GLMoleculeObject::initialize(view, painter);
  } else {
   foreach (QObject *obj, children()) {
     GLMoleculeObject *meshobj = qobject_cast<GLMoleculeObject *>(obj);
       if (meshobj)
         meshobj->initialize(view, painter);
   }
  }
}

void GLMoleculeObject_molecule::draw(QGLPainter *painter, const QVector4D &cameraPlane)
{
  // draw either molecule's mesh or all atoms and bonds
  if (m_visible) {
    resetTesselationHull();

    painter->modelViewMatrix().push();

    // Apply the material and effect to the painter.
    QGLMaterial *material;
    if (m_hovering)
        material = m_hoverMaterial;
    else if (m_selected)
        material = m_selectionMaterial;
    else
        material = m_material;

    ASSERT(material, "GLMoleculeObject::draw: chosen material is NULL");

    painter->setColor(material->diffuseColor());
    painter->setFaceMaterial(QGL::AllFaces, material);
    if (m_effect)
        painter->setUserEffect(m_effect);
    else
        painter->setStandardEffect(QGL::LitMaterial);

    // Mark the object for object picking purposes.
    int prevObjectId = painter->objectPickId();
    if (m_objectId != -1)
        painter->setObjectPickId(m_objectId);

    m_mesh[0]->draw(painter);

    // Turn off the user effect, if present.
    if (m_effect)
        painter->setStandardEffect(QGL::LitMaterial);

    // Revert to the previous object identifier.
    painter->setObjectPickId(prevObjectId);

    // Restore the modelview matrix.
    painter->modelViewMatrix().pop();

    //    GLMoleculeObject::draw(painter, cameraPlane);
  } else {
    // Draw all of the mesh objects that we have as children.
    foreach (QObject *obj, children()) {
      GLMoleculeObject *meshobj = qobject_cast<GLMoleculeObject *>(obj);
      if (meshobj)
        meshobj->draw(painter, cameraPlane);
    }

    // update bounding box prior to selection
    resetBoundingBox();

    painter->modelViewMatrix().push();
    painter->modelViewMatrix().translate(m_position);
    if (m_rotationAngle != 0.0f)
      painter->modelViewMatrix().rotate(m_rotationAngle, m_rotationVector);
    if ((m_scaleX != 1.0f) || (m_scaleY != 1.0f) || (m_scaleZ != 1.0f))
      painter->modelViewMatrix().scale(m_scaleX, m_scaleY, m_scaleZ);

    // Draw a box around the mesh, if selected.
    if (m_selected)
      drawSelectionBox(painter);

    // Restore the modelview matrix.
    painter->modelViewMatrix().pop();
  }
}

/** Adds an atom of this molecule to the scene.
 *
 * @param _atom atom to add
 */
void GLMoleculeObject_molecule::atomInserted(const atomId_t _id)
{
  LOG(3, "INFO: GLMoleculeObject_molecule: Received signal atomInserted for atom "+toString(_id)+".");

  GLMoleculeObject_atom *atomObject = new GLMoleculeObject_atom(GLMoleculeObject::meshSphere, this, _id);
  ASSERT( atomObject != NULL,
      "GLMoleculeObject_molecule::atomInserted - could not create atom object for "+toString(_id));
  AtomNodeMap::iterator iter = AtomsinSceneMap.find(_id);
  ASSERT(iter == AtomsinSceneMap.end(),
      "GLMoleculeObject_molecule::atomInserted - same atom with id "+toString(_id)+" added again.");
  AtomsinSceneMap.insert( make_pair(_id, atomObject) );

  qRegisterMetaType<atomId_t>("atomId_t");
  qRegisterMetaType<bond::ptr>("bond::ptr");
  qRegisterMetaType<GLMoleculeObject_bond::SideOfBond>("GLMoleculeObject_bond::SideOfBond");
  connect (atomObject, SIGNAL(clicked(atomId_t)), this, SIGNAL(atomClicked(atomId_t)));
  connect (atomObject, SIGNAL(changed()), this, SIGNAL(changed()));
  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(_id);

  // add all bonds
  const atom * const Walker = const_cast<const World &>(World::getInstance()).
      getAtom(AtomById(_id));
  if (Walker != NULL)
    addAtomBonds(Walker);
  else
    ELOG(1, "GLMoleculeObject_atom disappeared while about to add bonds.");

  emit changeOccured();
}

/** Removes an atom of this molecule from the scene.
 *
 * We just the id as the atom might have already been destroyed.
 *
 * @param _id id of atom to remove
 */
void GLMoleculeObject_molecule::atomRemoved(const atomId_t _id)
{
  LOG(3, "INFO: GLMoleculeObject_molecule: Received signal atomRemoved for atom "+toString(_id)+".");
  // bonds are removed by signal coming from ~bond

  if ((unsigned int)m_objectId == _id)
    setObjectId(-1);

  // remove atoms
  AtomNodeMap::iterator iter = AtomsinSceneMap.find(_id);
  ASSERT(iter != AtomsinSceneMap.end(),
      "GLMoleculeObject_molecule::atomRemoved() - atom "+toString(_id)+" not on display.");
  GLMoleculeObject_atom *atomObject = iter->second;
  AtomsinSceneMap.erase(iter);
  atomObject->disconnect();
  delete atomObject;

  emit changeOccured();
}

void GLMoleculeObject_molecule::hoverChangedSignalled(GLMoleculeObject *ob)
{
  // Find the atom, ob corresponds to.
  hoverAtomId = -1;
  GLMoleculeObject_atom *atomObject = dynamic_cast<GLMoleculeObject_atom *>(ob);
  if (atomObject){
    for (AtomNodeMap::iterator iter = AtomsinSceneMap.begin();iter != AtomsinSceneMap.end(); ++ iter){
      if (iter->second == atomObject)
        hoverAtomId = iter->first;
    }

    // Propagate signal.
    emit hoverChanged(hoverAtomId);
  } else {
    // Find the atom, ob corresponds to.
    GLMoleculeObject_molecule *moleculeObject = dynamic_cast<GLMoleculeObject_molecule *>(ob);
    if (moleculeObject == this){
      // Propagate signal.
      emit hoverChanged(MolIndex.get(), 0);
    }
  }
}


/** 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)+".");
  //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 );
  } else {
    iter->second->resetPosition();
    iter->second->resetWidth();
  }
  emit changeOccured();
}

/** Removes a bond from the scene.
 *
 * @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)+".");
  {
    // 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 << ".");
  }

  emit changeOccured();
}

void GLMoleculeObject_molecule::setVisible(bool value)
{
  // first update the mesh if we are going to be visible now
  if (value)
    updateTesselationHull();
  // then emit onward
  GLMoleculeObject::setVisible(value);
}

std::ostream &operator<<(std::ostream &ost, const GLMoleculeObject_molecule::BondIds &t)
{
  ost << t.first << "," << t.second;
  return ost;
}

void GLMoleculeObject_molecule::wasClicked()
{
  LOG(4, "INFO: GLMoleculeObject_molecule: atom " << MolIndex.get() << " has been clicked");
  emit moleculeClicked(MolIndex.get());
}

void GLMoleculeObject_molecule::changeAtomId(
    GLMoleculeObject_atom *ob,
    const atomId_t oldId,
    const atomId_t newId)
{
  LOG(3, "INFO: GLMoleculeObject_molecule - change atom id " << oldId << " to " << newId << ".");

  // Remove from map.
  AtomNodeMap::iterator iter = AtomsinSceneMap.find(oldId);
  ASSERT(iter != AtomsinSceneMap.end(),
      "GLMoleculeObject_molecule::changeAtomId() - atom with old id "+toString(oldId)+" not on display.");
  ASSERT(iter->second == ob,
      "GLMoleculeObject_molecule::changeAtomId() - atom with id "
      +toString(oldId)+" does not match with object in AtomsinSceneMap.");
  AtomsinSceneMap.erase(iter);

  // Reinsert with new id.
  {
    AtomNodeMap::iterator iter = AtomsinSceneMap.find(newId);
    ASSERT(iter == AtomsinSceneMap.end(),
          "GLMoleculeObject_molecule::changeAtomId() - atom with new id "+toString(newId)+" already known.");
  }
  AtomsinSceneMap.insert( make_pair(newId, ob) );
}

const molecule * const GLMoleculeObject_molecule::getMolecule(const moleculeId_t _id)
{
  const molecule * const mol = const_cast<const World &>(World::getInstance()).
      getMolecule(MoleculeById(_id));
  return mol;
}