• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• kdeedu

• Sitemap
• Contact Us

 

kalzium

bondcentrictool.cpp

Go to the documentation of this file.

/**********************************************************************
  BondCentricTool - Bond Centric Manipulation Tool for Avogadro

  Copyright (C) 2007 by Shahzad Ali
  Copyright (C) 2007 by Ross Braithwaite
  Copyright (C) 2007 by James Bunt
  Copyright (C) 2007 by Marcus D. Hanwell
  Copyright (C) 2006,2007 by Benoit Jacob

  This file is part of the Avogadro molecular editor project.
  For more information, see <http://avogadro.sourceforge.net/>

  Avogadro 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.

  Avogadro 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 this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
 **********************************************************************/

#include "bondcentrictool.h"
#include "quaternion.h"

#ifdef WIN32
#include <float.h>
#include <math.h>
#define isnan(x) _isnan(x)
#endif

#include <iostream>

#include <avogadro/navigate.h>
#include <avogadro/primitive.h>
#include <avogadro/color.h>
#include <avogadro/glwidget.h>
#include <avogadro/camera.h>
#include <avogadro/toolgroup.h>

#include <openbabel/obiter.h>
#include <openbabel/mol.h>

#include <QtPlugin>
#include <QString>

#include <QDebug>

using namespace std;
using namespace OpenBabel;
using namespace Eigen;

namespace Avogadro {

  // ############################ BondCentricTool ################################

  // ##########  Constructor  ##########

  BondCentricTool::BondCentricTool(QObject *parent) : Tool(parent),
  m_molecule(NULL),
  m_settingsWidget(NULL),
  m_clickedAtom(NULL),
  m_clickedBond(NULL),
  m_selectedBond(NULL),
  m_skeleton(NULL),
  m_referencePoint(NULL),
  m_currentReference(NULL),
  m_directionVector(NULL),
  m_snapped(false),
  m_toolGroup(NULL),
  m_leftButtonPressed(false),
  m_midButtonPressed(false),
  m_rightButtonPressed(false),
  m_movedSinceButtonPressed(false),
  m_showAngles(true),
  m_snapToEnabled(true),
  m_snapToAngle(10)
  {
    QAction *action = activateAction();
    action->setIcon(QIcon(QString::fromUtf8(":/bondcentric/bondcentric.png")));
    action->setToolTip(tr("Bond Centric Manipulation Tool\n\n"
          "Left Mouse:   Click and drag to rotate the view\n"
          "Middle Mouse: Click and drag to zoom in or out\n"
          "Right Mouse:  Click and drag to move the view\n\n"
          "Left Click & drag on a Bond to set the Manipulation Plane:\n"
          "- Left Click & Drag one of the Atoms in the Bond to change the angle\n"
          "- Right Click & Drag one of the Atoms in the Bond to change the length"));
    //action->setShortcut(Qt::Key_F9);
    connect(action,SIGNAL(toggled(bool)),this,SLOT(toolChanged(bool)));
  }

  // ##########  Desctructor  ##########

  BondCentricTool::~BondCentricTool()
  {
    delete m_referencePoint;
    m_referencePoint = NULL;
    delete m_currentReference;
    m_currentReference = NULL;
    delete m_directionVector;
    m_directionVector = NULL;

    if (m_settingsWidget)
    {
      m_snapToAngleLabel->deleteLater();
      m_spacer->deleteLater();
      m_showAnglesBox->deleteLater();
      m_snapToCheckBox->deleteLater();
      m_snapToAngleBox->deleteLater();
      m_layout->deleteLater();

      m_settingsWidget->deleteLater();
    }
  }

  // ##########  clearData  ##########

  void BondCentricTool::clearData()
  {
    m_clickedAtom = NULL;
    m_clickedBond = NULL;
    m_selectedBond = NULL;
    delete m_referencePoint;
    m_referencePoint = NULL;
    delete m_currentReference;
    m_currentReference = NULL;
    delete m_directionVector;
    m_directionVector = NULL;
    m_toolGroup = NULL;
    m_leftButtonPressed = false;
    m_midButtonPressed = false;
    m_rightButtonPressed = false;
    m_movedSinceButtonPressed = false;
    m_snapped = false;
  }

  // ##########  moleculeChanged  ##########

  void BondCentricTool::setMolecule(Molecule* molecule)
  {
    if(m_molecule) {
      disconnect(m_molecule, 0 , this, 0);
    }

    if (molecule) {
      m_molecule = molecule;
      connect(molecule, SIGNAL(primitiveRemoved(Primitive*)), this,
          SLOT(primitiveRemoved(Primitive*)));
    }

    clearData();
  }

  // ##########  primitiveRemoved  ##########

  void BondCentricTool::primitiveRemoved(Primitive *primitive)
  {
    if (primitive == m_clickedAtom || primitive == m_clickedBond ||
        primitive == m_selectedBond) {
      clearData();
    }
  }

  // ##########  toolChanged  ##########

  void BondCentricTool::toolChanged(bool checked)
  {
    if(!checked && m_molecule)
    {
      m_molecule->update();
      clearData();
    }
  }

  // ##########  usefulness  ##########

  int BondCentricTool::usefulness() const
  {
    return 2000000;
  }

  // ##########  mousePress  ##########

  QUndoCommand* BondCentricTool::mousePress(GLWidget *widget, const QMouseEvent *event)
  {
    m_undo = 0;

    m_lastDraggingPosition = event->pos();
    m_movedSinceButtonPressed = false;

#ifdef Q_WS_MAC
    m_leftButtonPressed = (event->buttons() & Qt::LeftButton
        && event->modifiers() == Qt::NoModifier);
    // On the Mac, either use a three-button mouse
    // or hold down the Shift key
    m_midButtonPressed = ((event->buttons() & Qt::MidButton) ||
        (event->buttons() & Qt::LeftButton && event->modifiers()
         & Qt::ShiftModifier));
    // Hold down the Command key (ControlModifier in Qt notation) for right button
    m_rightButtonPressed = ((event->buttons() & Qt::RightButton) ||
        (event->buttons() & Qt::LeftButton &&
         (event->modifiers() == Qt::ControlModifier ||
          event->modifiers() == Qt::MetaModifier)));
#else
    m_leftButtonPressed = (event->buttons() & Qt::LeftButton);
    m_midButtonPressed = (event->buttons() & Qt::MidButton);
    m_rightButtonPressed = (event->buttons() & Qt::RightButton);
#endif

    m_clickedAtom = NULL;
    m_clickedBond = NULL;

    int oldName = m_selectedBond ? m_selectedBond->GetIdx() : -1;

    // Check if the mouse clicked on any Atoms or Bonds.
    Primitive *clickedPrim = widget->computeClickedPrimitive(event->pos());

    if (clickedPrim && clickedPrim->type() == Primitive::AtomType)
    {
      // Atom clicked on.
      m_clickedAtom = (Atom*)clickedPrim;

      if ((m_rightButtonPressed || m_leftButtonPressed) && isAtomInBond(m_clickedAtom, m_selectedBond))
      {
        //Create an undo instance for this manipulation
        m_undo = new BondCentricMoveCommand(widget->molecule());

        // Populate the skeleton in preparation to alter the angle or length of the bond.
        m_skeleton = new SkeletonTree();
        m_skeleton->populate(m_clickedAtom, m_selectedBond, widget->molecule());

        if (m_leftButtonPressed)
        {
          // If the bond is to be rotated, save off a vector used in the calculation.
          // If the vector is calculated every mouse movement it causes the molecule to
          // jitter, saving it now prevents this.

          Atom *otherAtom;
          if (m_clickedAtom == static_cast<Atom*>(m_selectedBond->GetBeginAtom()))
            otherAtom = static_cast<Atom*>(m_selectedBond->GetEndAtom());
          else
            otherAtom = static_cast<Atom*>(m_selectedBond->GetBeginAtom());

          Vector3d centerProj = widget->camera()->project(otherAtom->pos());
          centerProj -= Vector3d(0,0,centerProj.z());
          Vector3d clickedProj = widget->camera()->project(m_clickedAtom->pos());
          clickedProj -= Vector3d(0,0,clickedProj.z());

          if ((clickedProj - centerProj).norm() == 0)
          {
            // Have no way of testing this as the chance of this happening is almost 0
            m_directionVector = new Vector3d(1, 0, 0);
          }
          else
          {
            m_directionVector = new Vector3d(clickedProj - centerProj);
            *m_directionVector = m_directionVector->normalized();
          }
        }
      }
      else if (m_selectedBond)
      {
        // Check if one of the atoms one bond away from the selected bond has
        // been clicked on in preparation to alter dihedral angles.

        Atom *dihedralRotCen = NULL;
        Bond *skeleBond = NULL;

        Atom *beginAtom = static_cast<Atom*>(m_selectedBond->GetBeginAtom());
        Atom *endAtom = static_cast<Atom*>(m_selectedBond->GetEndAtom());

        // Check which atom in the selected bond the atom being manipulated will
        // be rotated around to change its dihedral angle.
        if ((skeleBond = static_cast<Bond*>(m_clickedAtom->GetBond(beginAtom)))) {
          dihedralRotCen = beginAtom;
        }
        else if ((skeleBond = static_cast<Bond*>(m_clickedAtom->GetBond(endAtom)))) {
          dihedralRotCen = endAtom;
        }

        bool skeletonSet = false;
        if (m_rightButtonPressed && skeleBond)
        {
          //Create an undo instance for this manipulation
          m_undo = new BondCentricMoveCommand(widget->molecule());

          // Populate the skeleton in preparation to alter the dihedral angle of the
          // clicked atom.
          m_skeleton = new SkeletonTree();
          m_skeleton->populate(m_clickedAtom, skeleBond, widget->molecule());
          skeletonSet = true;
        }
        else if (m_leftButtonPressed && dihedralRotCen)
        {
          //Create an undo instance for this manipulation
          m_undo = new BondCentricMoveCommand(widget->molecule());

          // Populate the skeleton in preparation to alter the dihedral angle of all
          // the atoms bonded to this end of the bond (essentially twisting this end
          // of the bond).
          m_skeleton = new SkeletonTree();
          m_skeleton->populate(dihedralRotCen, m_selectedBond, widget->molecule());
          skeletonSet = true;
        }

        if (skeletonSet)
        {
          // If the dihedral angle is to be changed, save off a vector used in the
          // calculation. If the vector is calculated every mouse movement it causes
          // the molecule to jitter, saving it now prevents this.

          Vector3d centerProj = widget->camera()->project(dihedralRotCen->pos());
          centerProj -= Vector3d(0,0,centerProj.z());
          Vector3d clickedProj = widget->camera()->project(m_clickedAtom->pos());
          clickedProj -= Vector3d(0,0,clickedProj.z());

          if ((clickedProj - centerProj).norm() == 0)
          {
            // Have no way of testing this as the chance of this happening is almost 0
            m_directionVector = new Vector3d(1, 0, 0);
          }
          else
          {
            m_directionVector = new Vector3d(clickedProj - centerProj);
            *m_directionVector = m_directionVector->normalized();
          }
        }
      }
    }
    else if (clickedPrim && clickedPrim->type() == Primitive::BondType)
    {
      // Bond clicked on.
      m_clickedBond = (Bond*)clickedPrim;

      // If the Bond was clicked on with the left mouse button, set it as the
      // currently selected bond and reset the reference point (if the Bond has
      // changed).
      if (m_leftButtonPressed)
      {
        m_selectedBond = m_clickedBond;

        if ((int)m_selectedBond->GetIdx() != oldName)
        {
          delete m_referencePoint;
          m_referencePoint = NULL;

          delete m_currentReference;
          m_currentReference = NULL;

          m_snapped = false;

          Atom *leftAtom = static_cast<Atom*>(m_selectedBond->GetBeginAtom());
          Atom *rightAtom = static_cast<Atom*>(m_selectedBond->GetEndAtom());

          Vector3d left = leftAtom->pos();
          Vector3d right = rightAtom->pos();
          Vector3d leftToRight = right - left;

          Vector3d x = Vector3d(1, 0, 0);
          Vector3d y = Vector3d(0, 1, 0);

          Vector3d A = leftToRight.cross(x);
          Vector3d B = leftToRight.cross(y);

          m_referencePoint = A.norm() >= B.norm() ? new Vector3d(A) : new Vector3d(B);
          *m_referencePoint = m_referencePoint->normalized();

          Vector3d *reference = calculateSnapTo(m_selectedBond,
              m_referencePoint, m_snapToAngle);

          if (reference && m_snapToEnabled)
          {
            m_snapped = true;
            m_currentReference = reference;
            *m_currentReference = m_currentReference->normalized();
          }
          else {
            m_currentReference = new Vector3d(*m_referencePoint);
          }
        }
      }
    }

    widget->update();
    return 0;
  }

  // ##########  mouseRelease  ##########

  QUndoCommand* BondCentricTool::mouseRelease(GLWidget *widget, const QMouseEvent*)
  {
    delete m_directionVector;
    m_directionVector = NULL;

    if (!m_clickedAtom && !m_clickedBond && !m_movedSinceButtonPressed)
    {
      delete m_referencePoint;
      m_referencePoint = NULL;
      delete m_currentReference;
      m_currentReference = NULL;
      m_snapped = false;
      m_selectedBond = NULL;
    }
    else if (!m_movedSinceButtonPressed) {
      m_undo = 0;
    }

    if (m_skeleton)
    {
      delete m_skeleton;
      m_skeleton = NULL;
    }

    m_leftButtonPressed = false;
    m_midButtonPressed = false;
    m_rightButtonPressed = false;
    m_clickedAtom = NULL;
    m_clickedBond = NULL;

    widget->update();
    return m_undo;
  }

  // ##########  mouseMove  ##########

  QUndoCommand* BondCentricTool::mouseMove(GLWidget *widget, const QMouseEvent *event)
  {
    if (!m_molecule) {
      return 0;
    }

    QPoint deltaDragging = event->pos() - m_lastDraggingPosition;

    if (deltaDragging.manhattanLength() > 2) {
      m_movedSinceButtonPressed = true;
    }

    // Mouse navigation has two modes - atom centred when an atom is clicked
    // and scene if no atom has been clicked.

#ifdef Q_WS_MAC
    if (event->buttons() & Qt::LeftButton && event->modifiers() == Qt::NoModifier)
#else
      if (event->buttons() & Qt::LeftButton)
#endif
      {
        if (m_clickedBond && m_selectedBond && m_referencePoint)
        {
          Atom *beginAtom = static_cast<Atom*>(m_selectedBond->GetBeginAtom());
          Atom *endAtom = static_cast<Atom*>(m_selectedBond->GetEndAtom());

          Vector3d rotationVector = endAtom->pos() - beginAtom->pos();
          rotationVector = rotationVector / rotationVector.norm();

          Vector3d begin = widget->camera()->project(beginAtom->pos());
          Vector3d end = widget->camera()->project(endAtom->pos());

          Vector3d zAxis = Vector3d(0, 0, 1);
          Vector3d beginToEnd = end - begin;
          beginToEnd -= Vector3d(0, 0, beginToEnd.z());

          Vector3d direction = zAxis.cross(beginToEnd);
          direction = direction / direction.norm();

          Vector3d mouseMoved = Vector3d(deltaDragging.x(), deltaDragging.y(), 0);

          double magnitude = mouseMoved.dot(direction) / direction.norm();

          *m_referencePoint = performRotation(magnitude * (M_PI / 180.0),
              rotationVector, Vector3d(0, 0, 0),
              *m_referencePoint);

          Eigen::Vector3d *reference = calculateSnapTo(m_selectedBond,
              m_referencePoint, m_snapToAngle);
          if (reference && m_snapToEnabled)
          {
            m_snapped = true;
            delete m_currentReference;
            m_currentReference = reference;
            *m_currentReference = m_currentReference->normalized();
          }
          else
          {
            m_snapped = false;
            delete m_currentReference;
            m_currentReference = new Vector3d(*m_referencePoint);
          }
        }
        else if (isAtomInBond(m_clickedAtom, m_selectedBond))
        {
          //Do atom rotation.
          Atom *otherAtom;

          if (m_clickedAtom == static_cast<Atom*>(m_selectedBond->GetBeginAtom()))
            otherAtom = static_cast<Atom*>(m_selectedBond->GetEndAtom());
          else
            otherAtom = static_cast<Atom*>(m_selectedBond->GetBeginAtom());

          Vector3d center = otherAtom->pos();
          Vector3d clicked = m_clickedAtom->pos();

          Vector3d centerProj = widget->camera()->project(center);
          centerProj -= Vector3d(0,0,centerProj.z());
          Vector3d referenceProj = widget->camera()->project(*m_currentReference + center);
          referenceProj -= Vector3d(0,0,referenceProj.z());

          Vector3d referenceVector = referenceProj - centerProj;
          referenceVector = referenceVector.normalized();

          Vector3d rotationVector = referenceVector.cross(*m_directionVector);
          rotationVector = rotationVector.normalized();

          Vector3d currMouseVector = Vector3d(event->pos().x(), event->pos().y(), 0)
            - centerProj;
          if(currMouseVector.norm() > 5)
          {
            currMouseVector = currMouseVector.normalized();
            double mouseAngle = acos(m_directionVector->dot(currMouseVector) /
                currMouseVector.norm2());

            if(mouseAngle > 0)
            {
              Vector3d tester;

              tester = performRotation(mouseAngle, rotationVector, Vector3d(0, 0, 0),
                  *m_directionVector);
              double testAngle1 = acos(tester.dot(currMouseVector) /
                  currMouseVector.norm2());

              tester = performRotation(-mouseAngle, rotationVector, Vector3d(0, 0, 0),
                  *m_directionVector);
              double testAngle2 = acos(tester.dot(currMouseVector) /
                  currMouseVector.norm2());

              if(testAngle1 > testAngle2 || isnan(testAngle2)) {
                mouseAngle = -mouseAngle;
              }

              Vector3d direction = clicked - center;
              if (m_skeleton)
              {
                Vector3d currCrossDir = m_currentReference->cross(direction).normalized();

                m_skeleton->skeletonRotate(mouseAngle, currCrossDir, center);
                *m_referencePoint = performRotation(mouseAngle, currCrossDir,
                    Vector3d(0, 0, 0), *m_referencePoint);
                *m_currentReference = performRotation(mouseAngle, currCrossDir,
                    Vector3d(0, 0, 0), *m_currentReference);
                *m_directionVector = performRotation(mouseAngle, rotationVector,
                    Vector3d(0, 0, 0), *m_directionVector);
              }
            }
          }
        }
        else if (m_selectedBond && m_clickedAtom &&
            (m_clickedAtom->GetBond(m_selectedBond->GetBeginAtom()) ||
             m_clickedAtom->GetBond(m_selectedBond->GetEndAtom())))
        {
          // Do multiple dihedral rotation (twising of the bond).

          Atom *beginAtom = static_cast<Atom*>(m_selectedBond->GetBeginAtom());
          Atom *endAtom = static_cast<Atom*>(m_selectedBond->GetEndAtom());

          Vector3d center;
          Vector3d other;
          if (m_clickedAtom->GetBond(beginAtom))
          {
            center = beginAtom->pos();
            other = endAtom->pos();
          }
          else {
            center = endAtom->pos();
            other = beginAtom->pos();
          }

          Vector3d clicked = m_clickedAtom->pos();

          Vector3d axis = Vector3d(0, 0, ((widget->camera()->modelview() * other).z() >=
                (widget->camera()->modelview() * center).z() ? -1 : 1));

          Vector3d centerProj = widget->camera()->project(center);
          centerProj -= Vector3d(0,0,centerProj.z());

          Vector3d currMouseVector = Vector3d(event->pos().x(), event->pos().y(), 0)
            - centerProj;

          if(currMouseVector.norm() > 5)
          {
            currMouseVector = currMouseVector.normalized();
            double mouseAngle = acos(m_directionVector->dot(currMouseVector) /
                currMouseVector.norm2());

            if(mouseAngle > 0)
            {
              Vector3d tester;

              tester = performRotation(mouseAngle, axis, Vector3d(0, 0, 0), *m_directionVector);
              double testAngle1 = acos(tester.dot(currMouseVector) /
                  currMouseVector.norm2());

              tester = performRotation(-mouseAngle, axis, Vector3d(0, 0, 0), *m_directionVector);
              double testAngle2 = acos(tester.dot(currMouseVector) /
                  currMouseVector.norm2());

              if(testAngle1 > testAngle2 || isnan(testAngle2)) {
                mouseAngle = -mouseAngle;
              }

              if (m_skeleton)
              {
                *m_directionVector = performRotation(mouseAngle, axis,
                    Vector3d(0, 0, 0), *m_directionVector);

                axis = (other - center).normalized();
                m_skeleton->skeletonRotate(mouseAngle, axis, center);
              }
            }
          }
        }
        else {
          // rotation around the center of the molecule
          Navigate::rotate(widget, widget->center(), deltaDragging.x(), deltaDragging.y());
        }
      }
#ifdef Q_WS_MAC
    // On the Mac, either use a three-button mouse
    // or hold down the Shift key
      else if ((event->buttons() & Qt::MidButton) || (event->buttons() &
            Qt::LeftButton && event->modifiers() & Qt::ShiftModifier))
#else
      else if (event->buttons() & Qt::MidButton)
#endif
      {
        if (m_clickedAtom)
        {
          // Perform the rotation
          Navigate::tilt(widget, m_clickedAtom->pos(), deltaDragging.x());

          // Perform the zoom toward the center of a clicked atom
          Navigate::zoom(widget, m_clickedAtom->pos(), deltaDragging.y());
        }
        else if (m_clickedBond)
        {
          Atom *begin = static_cast<Atom *>(m_clickedBond->GetBeginAtom());
          Atom *end = static_cast<Atom *>(m_clickedBond->GetEndAtom());

          Vector3d btoe = end->pos() - begin->pos();
          double newLen = btoe.norm() / 2;
          btoe = btoe / btoe.norm();

          Vector3d mid = begin->pos() + btoe * newLen;

          // Perform the rotation
          Navigate::tilt(widget, mid, deltaDragging.x());

          // Perform the zoom toward the centre of a clicked bond
          Navigate::zoom(widget, mid, deltaDragging.y());
        }
        else
        {
          // Perform the rotation
          Navigate::tilt(widget, widget->center(), deltaDragging.x());

          // Perform the zoom toward molecule center
          Navigate::zoom(widget, widget->center(), deltaDragging.y());
        }
      }
#ifdef Q_WS_MAC
    // On the Mac, either use a three-button mouse
    // or hold down the Command key (ControlModifier in Qt notation)
      else if ((event->buttons() & Qt::RightButton) ||
          (event->buttons() & Qt::LeftButton &&
           (event->modifiers() == Qt::ControlModifier || event->modifiers() == Qt::MetaModifier)))
#else
      else if (event->buttons() & Qt::RightButton)
#endif
      {
        if (isAtomInBond(m_clickedAtom, m_selectedBond))
        {
          // Adjust the length of the bond following the mouse movement.

          Atom *otherAtom;

          if (m_clickedAtom == static_cast<Atom*>(m_selectedBond->GetBeginAtom()))
            otherAtom = static_cast<Atom*>(m_selectedBond->GetEndAtom());
          else
            otherAtom = static_cast<Atom*>(m_selectedBond->GetBeginAtom());

          Vector3d clicked = m_clickedAtom->pos();
          Vector3d other = otherAtom->pos();
          Vector3d direction = clicked - other;

          Vector3d mouseLast = widget->camera()->unProject(m_lastDraggingPosition);
          Vector3d mouseCurr = widget->camera()->unProject(event->pos());
          Vector3d mouseDir = mouseCurr - mouseLast;

          Vector3d component = mouseDir.dot(direction) / direction.norm2() * direction;

          if (m_skeleton) {
            m_skeleton->skeletonTranslate(component.x(), component.y(), component.z());
          }
        }
        else if (m_selectedBond && m_clickedAtom &&
            (m_clickedAtom->GetBond(m_selectedBond->GetBeginAtom()) ||
             m_clickedAtom->GetBond(m_selectedBond->GetEndAtom())))
        {
          // Do dihedral angle manipulation of the clicked atom.

          Atom *beginAtom = static_cast<Atom*>(m_selectedBond->GetBeginAtom());
          Atom *endAtom = static_cast<Atom*>(m_selectedBond->GetEndAtom());

          Vector3d center;
          Vector3d other;
          if (m_clickedAtom->GetBond(beginAtom))
          {
            center = beginAtom->pos();
            other = endAtom->pos();
          }
          else {
            center = endAtom->pos();
            other = beginAtom->pos();
          }

          Vector3d clicked = m_clickedAtom->pos();

          Vector3d axis = Vector3d(0, 0, ((widget->camera()->modelview() * other).z() >=
                (widget->camera()->modelview() * center).z() ? -1 : 1));

          Vector3d centerProj = widget->camera()->project(center);
          centerProj -= Vector3d(0,0,centerProj.z());

          Vector3d currMouseVector = Vector3d(event->pos().x(), event->pos().y(), 0)
            - centerProj;

          if(currMouseVector.norm() > 5)
          {
            currMouseVector = currMouseVector.normalized();
            double mouseAngle = acos(m_directionVector->dot(currMouseVector) /
                currMouseVector.norm2());

            if(mouseAngle > 0)
            {
              Vector3d tester;

              tester = performRotation(mouseAngle, axis, Vector3d(0, 0, 0), *m_directionVector);
              double testAngle1 = acos(tester.dot(currMouseVector) /
                  currMouseVector.norm2());

              tester = performRotation(-mouseAngle, axis, Vector3d(0, 0, 0), *m_directionVector);
              double testAngle2 = acos(tester.dot(currMouseVector) /
                  currMouseVector.norm2());

              if(testAngle1 > testAngle2 || isnan(testAngle2)) {
                mouseAngle = -mouseAngle;
              }

              if (m_skeleton)
              {
                *m_directionVector = performRotation(mouseAngle, axis,
                    Vector3d(0, 0, 0), *m_directionVector);

                axis = (other - center).normalized();
                m_skeleton->skeletonRotate(mouseAngle, axis, center);
              }
            }
          }
        }
        else {
          // Translate the molecule following mouse movement.
          Navigate::translate(widget, widget->center(), m_lastDraggingPosition, event->pos());
        }
      }

    m_lastDraggingPosition = event->pos();
    widget->update();

    return 0;
  }

  // ##########  wheel  ##########

  QUndoCommand* BondCentricTool::wheel(GLWidget *widget, const QWheelEvent *event)
  {
    m_clickedAtom = NULL;
    m_clickedBond = NULL;

    Primitive *clickedPrim = widget->computeClickedPrimitive(event->pos());

    if (clickedPrim && clickedPrim->type() == Primitive::AtomType)
    {
      Atom *clickedAtom = (Atom*)clickedPrim;
      // Perform the zoom toward clicked atom
      Navigate::zoom(widget, clickedAtom->pos(), - MOUSE_WHEEL_SPEED * event->delta());
    }
    else if (clickedPrim && clickedPrim->type() == Primitive::BondType)
    {
      Bond *clickedBond = (Bond*)clickedPrim;

      Atom *begin = static_cast<Atom *>(clickedBond->GetBeginAtom());
      Atom *end = static_cast<Atom *>(clickedBond->GetEndAtom());

      Vector3d btoe = end->pos() - begin->pos();
      double newLen = btoe.norm() / 2;
      btoe = btoe / btoe.norm();

      Vector3d mid = begin->pos() + btoe * newLen;

      // Perform the zoom toward the centre of a clicked bond
      Navigate::zoom(widget, mid, - MOUSE_WHEEL_SPEED * event->delta());
    }
    else {
      // Perform the zoom toward molecule center
      Navigate::zoom(widget, widget->center(), - MOUSE_WHEEL_SPEED * event->delta());
    }

    widget->update();

    return 0;
  }

  // ##########  paint  ##########

  bool BondCentricTool::paint(GLWidget *widget)
  {
    if(widget->toolGroup()->activeTool() != this) {
      clearData();
    }

    bool dihedralAtomClicked = false;

    // Draw the dihedral angles and rectangles if they apply.
    if ((m_leftButtonPressed || m_rightButtonPressed) && m_clickedAtom &&
        m_selectedBond && !isAtomInBond(m_clickedAtom, m_selectedBond))
    {
      Atom *begin = static_cast<Atom*>(m_selectedBond->GetBeginAtom());
      Atom *end = static_cast<Atom*>(m_selectedBond->GetEndAtom());

      if (m_clickedAtom->GetBond(begin) || m_clickedAtom->GetBond(end))
      {
        dihedralAtomClicked = true;

        if (m_rightButtonPressed) {
          drawSingleDihedralAngles(widget, m_clickedAtom, m_selectedBond);
        } else {
          drawDihedralAngles(widget, m_clickedAtom, m_selectedBond);
        }
      }
    }

    // The small yellow sphere that resembles the center of the molecule during rotation.
    if (!dihedralAtomClicked &&
        ((m_leftButtonPressed && !m_clickedBond && !isAtomInBond(m_clickedAtom, m_selectedBond))
         || (m_midButtonPressed && !m_clickedBond && !m_clickedAtom)
         || (m_rightButtonPressed && !isAtomInBond(m_clickedAtom, m_selectedBond))))
    {
      drawSphere(widget, widget->center(), 0.10, 1.0);
    }

    // If a single atom was clicked on, display the angles around it.
    if (!dihedralAtomClicked && m_leftButtonPressed && m_clickedAtom &&
        (!m_selectedBond || !isAtomInBond(m_clickedAtom, m_selectedBond)))
    {
      drawAtomAngles(widget, m_clickedAtom);
    }

    // Draw the manipulation rectangle and relative angles.
    if (m_selectedBond && !dihedralAtomClicked)
    {
      Atom *begin = static_cast<Atom*>(m_selectedBond->GetBeginAtom());
      Atom *end = static_cast<Atom*>(m_selectedBond->GetEndAtom());

      if (m_currentReference)
      {
        // Draw bond length text.