• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• kdeedu

• Sitemap
• Contact Us

 

kalzium

bondcentrictool.h

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.
 **********************************************************************/

#ifndef BONDCENTRICTOOL_H
#define BONDCENTRICTOOL_H

#include "skeletontree.h"

#include <avogadro/glwidget.h>
#include <avogadro/tool.h>

#include <openbabel/mol.h>

#include <QGLWidget>
#include <QObject>
#include <QStringList>
#include <QImage>
#include <QAction>
#include <QUndoCommand>

#include <QLabel>
#include <QSpinBox>
#include <QCheckBox>
#include <QGridLayout>


namespace Avogadro {

  class BondCentricTool : public Tool
  {
    Q_OBJECT

    public:
      BondCentricTool(QObject *parent = 0);
      virtual ~BondCentricTool();



      virtual QString name() const { return(tr("Bond Centric Manipulate")); }
      virtual QString description() const { return(tr("Bond Centric Manipulation Tool")); }



      virtual QUndoCommand* mousePress(GLWidget *widget, const QMouseEvent *event);
      virtual QUndoCommand* mouseRelease(GLWidget *widget, const QMouseEvent *event);
      virtual QUndoCommand* mouseMove(GLWidget *widget, const QMouseEvent *event);
      virtual QUndoCommand* wheel(GLWidget *widget, const QWheelEvent *event);

      virtual int usefulness() const;

      virtual bool paint(GLWidget *widget);

      virtual QWidget *settingsWidget();
      virtual void writeSettings(QSettings &settings) const;

      virtual void readSettings(QSettings &settings);

      void setMolecule(Molecule* molecule);

    public Q_SLOTS:
      void snapToAngleChanged(int newAngle);

      void snapToCheckBoxChanged(int state);

      void showAnglesChanged(int state);

    protected:
      Molecule *          m_molecule;
      QWidget *           m_settingsWidget;


      Atom *              m_clickedAtom;
      Bond *              m_clickedBond;
      Bond *              m_selectedBond;

      SkeletonTree *      m_skeleton;

      Eigen::Vector3d *   m_referencePoint;
      Eigen::Vector3d *   m_currentReference;
      Eigen::Vector3d *   m_directionVector;

      bool                m_snapped;
      ToolGroup *         m_toolGroup;

      QUndoCommand *      m_undo; // The current undo command

      bool                m_leftButtonPressed;  // rotation
      bool                m_midButtonPressed;   // scale / zoom
      bool                m_rightButtonPressed; // translation
      bool                m_movedSinceButtonPressed;

      bool                m_showAngles;
      bool                m_snapToEnabled;

      int                 m_snapToAngle; // In degrees

      QPoint              m_lastDraggingPosition;

      QLabel *            m_snapToAngleLabel;
      QLabel *            m_spacer;
      QCheckBox *         m_showAnglesBox;
      QCheckBox *         m_snapToCheckBox;
      QSpinBox *          m_snapToAngleBox;
      QGridLayout *       m_layout;




      bool isAtomInBond(Atom *atom, Bond *bond);

      void drawAngleSector(GLWidget *widget, Eigen::Vector3d origin,
                           Eigen::Vector3d direction1, Eigen::Vector3d direction2,
                           bool alternateAngle = false);

      void drawAtomAngles(GLWidget *widget, Atom *atom);

      void drawAngles(GLWidget *widget, Atom *atom, Bond *bond);

      void drawSkeletonAngles(GLWidget *widget, SkeletonTree *skeleton);

      void drawDihedralAngle(GLWidget *widget, Atom *A, Atom *D, Bond *BC,
                             bool alternateAngle = false);

      void drawDihedralAngles(GLWidget *widget, Atom *A, Bond *BC);

      void drawSingleDihedralAngles(GLWidget *widget, Atom *A, Bond *BC);

      Eigen::Vector3d* calculateSnapTo(Bond *bond,  Eigen::Vector3d *referencePoint,
                                       double maximumAngle);

      void drawManipulationRectangle(GLWidget *widget, Bond *bond,
                                     Eigen::Vector3d *referencePoint, double rgb[3]);

      void drawDihedralRectangle(GLWidget *widget, Bond *bond, Atom *atom, double rgb[3]);

      void drawDihedralRectanglesOfAtom(GLWidget *widget, Bond *bond, Atom *atom,
                                        double rgb[3]);

      void drawSphere(GLWidget *widget, const Eigen::Vector3d &center, double radius,
                      float alpha);

      void clearData();

      Eigen::Vector3d performRotation(double angle, Eigen::Vector3d rotationVector,
                                      Eigen::Vector3d centerVector,
                                      Eigen::Vector3d positionVector);

    private Q_SLOTS:
      void toolChanged(bool checked);

      void primitiveRemoved(Primitive* primitive);

      void settingsWidgetDestroyed();

  };

  class BondCentricMoveCommand : public QUndoCommand
  {
    public:

      explicit BondCentricMoveCommand(Molecule *molecule, QUndoCommand *parent = 0);


      BondCentricMoveCommand(Molecule *molecule, Atom *atom,
                             Eigen::Vector3d pos, QUndoCommand *parent = 0);

      void redo();

      void undo();

      bool mergeWith(const QUndoCommand * command);

      int id() const;

    private:
      Molecule m_moleculeCopy;
      Molecule *m_molecule;
      int m_atomIndex;
      Eigen::Vector3d m_pos;
      bool undone;
  };


  class BondCentricToolFactory : public QObject, public ToolFactory
  {
    Q_OBJECT
    Q_INTERFACES(Avogadro::ToolFactory)

    public:
      Tool *createInstance(QObject *parent = 0) { return new BondCentricTool(parent); }
  };

} // end namespace Avogadro

#endif /*__BONDCENTRICTOOL_H*/

kalzium

Skip menu "kalzium"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

kdeedu

Skip menu "kdeedu"

• kalzium
• kanagram
• kig
•   lib
• klettres
• kstars
• libkdeedu
•   keduvocdocument
•   docs
•   src
• parley
•   stepcore

Generated for kdeedu by doxygen 1.5.4
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal