/home/kitware/dashboards/avogadro/libavogadro/src/glwidget.h

/**********************************************************************
  GLWidget - general OpenGL display

  Copyright (C) 2006-2009 Geoffrey R. Hutchison
  Copyright (C) 2006,2007 Donald Ephraim Curtis
  Copyright (C) 2007-2009 Marcus D. Hanwell

  This file is part of the Avogadro molecular editor project.
  For more information, see <http://avogadro.openmolecules.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 GLWIDGET_H
#define GLWIDGET_H

#include <avogadro/global.h>

#include <Eigen/Core>

#ifdef ENABLE_GLSL
  #include <GL/glew.h>
#endif

#include <QtOpenGL/QGLWidget>

class QGLContext;
class QLabel;
class QMouseEvent;
class QSettings;
class QUndoStack;

namespace Avogadro {

  class Primitive;
  class Atom;
  class Bond;
  class Molecule;
  class Camera;
  class Painter;
  class Tool;
  class ToolGroup;
  class Extension;
  class Color;
  class Engine;
  class Painter;
  class PrimitiveList;

  bool engineLessThan( const Engine* lhs, const Engine* rhs );

  class GLHit;
  class GLThread;
  class GLWidgetPrivate;
  class GLPainterDevice;
  class A_EXPORT GLWidget : public QGLWidget
  {
    friend class GLThread;

    Q_OBJECT
    Q_PROPERTY(QColor background READ background WRITE setBackground)
//    Q_PROPERTY(float scale READ scale WRITE setScale)

    public:
      GLWidget(QWidget *parent = 0);

      explicit GLWidget(const QGLFormat &format, QWidget *parent = 0, const GLWidget * shareWidget = 0);

      GLWidget(Molecule *molecule, const QGLFormat &format, QWidget *parent = 0, const GLWidget * shareWidget = 0);

      ~GLWidget();

      void renderText(double x, double y, double z, const QString &str, const QFont &font, int listBase=2000);
      void setQuickRender(bool enabled);

      bool quickRender() const;

      void setRenderUnitCellAxes(bool enabled);

      bool renderUnitCellAxes() const;

      int deviceWidth() { return width(); }

      int deviceHeight() { return height(); }

      QSize sizeHint() const;

      QSize minimumSizeHint() const;

      double radius(const Primitive *p) const;

      Tool* tool() const;

      QColor background() const;

      void setColorMap(Color *);

      Color *colorMap() const;

      void setUndoStack(QUndoStack *undoStack);

      QUndoStack* undoStack() const;

      const Molecule* molecule() const;

      Molecule* molecule();

      Camera * camera() const;

      QList<Engine *> engines() const;

      QList<GLHit> hits(int x, int y, int w, int h);

      Primitive* computeClickedPrimitive(const QPoint& p);

      Atom* computeClickedAtom(const QPoint& p);

      Bond* computeClickedBond(const QPoint& p);

      const Eigen::Vector3d & center() const;
      const Eigen::Vector3d & normalVector() const;
      double radius() const;
      const Atom *farthestAtom() const;

      void setQuality(int quality);

      int quality() const;

      void setFogLevel(int level);

      int fogLevel() const;

      void setRenderAxes(bool renderAxes);

      bool renderAxes();

      void setRenderDebug(bool renderDebug);

      bool renderDebug();

      void setToolGroup(ToolGroup *toolGroup);

      ToolGroup * toolGroup() const;

      void setExtensions(QList<Extension*> extensions);

      Painter *painter() const;

      PrimitiveList selectedPrimitives() const;

      void toggleSelected(PrimitiveList primitives);

      void toggleSelected();

      void setSelected(PrimitiveList primitives, bool select = true); // do we pass by value intentionally

      void clearSelected();

      bool isSelected(const Primitive *p) const;

      bool addNamedSelection(const QString &name, PrimitiveList &primitives);
      void removeNamedSelection(const QString &name);
      void removeNamedSelection(int index);
      void renameNamedSelection(int index, const QString &name);
      QList<QString> namedSelections();
      PrimitiveList namedSelectionPrimitives(const QString &name);
      PrimitiveList namedSelectionPrimitives(int index);
      /* end selection method grouping */
      void setUnitCells(int a, int b, int c);

       void setUnitCellColor(const QColor c);

      void clearUnitCell();

      int aCells();

      int bCells();

      int cCells();

      enum ProjectionType
      {
        Perspective   = 1,
        Orthographic  = 2
      };

      void setProjection(ProjectionType type);

      ProjectionType projection() const;

      static GLWidget *m_current;

      static GLWidget *current();

      static void setCurrent(GLWidget *current);

      void renderNow();

      virtual void writeSettings(QSettings &settings) const;

      virtual void readSettings(QSettings &settings);


    protected:
      friend class GLGraphicsView;
      virtual void initializeGL();

      virtual void paintGL();

      virtual void paintGL2();

      virtual void resizeGL(int, int);

      virtual void paintEvent(QPaintEvent *event);

      virtual void resizeEvent(QResizeEvent *event);

      virtual bool event(QEvent *event);

      virtual void mousePressEvent(QMouseEvent * event);

      virtual void mouseReleaseEvent(QMouseEvent * event);

      virtual void mouseMoveEvent(QMouseEvent * event);

      virtual void wheelEvent(QWheelEvent * event);

      virtual void mouseDoubleClickEvent(QMouseEvent *event);

      virtual void keyPressEvent(QKeyEvent *event);

      virtual void keyReleaseEvent(QKeyEvent *event);

      virtual void render();

      virtual void renderCrystal(GLuint displayList);

      virtual void renderCrystalAxes();

      virtual bool renderClippedBox(const Eigen::Vector3d &offset,
                                    const Eigen::Vector3d &v1,
                                    const Eigen::Vector3d &v2,
                                    const Eigen::Vector3d &v3,
                                    double lineWidth );

      virtual void renderAxesOverlay();

      virtual void renderDebugOverlay();

      virtual void renderTextOverlay();

//       QWaitCondition *paintCondition() const;


    private:
      GLWidgetPrivate * const d;

      void constructor(const GLWidget *shareWidget =0);

      inline double computeFramesPerSecond();

      void loadEngines(QSettings &settings);

      bool              m_glslEnabled;
      Tool*             m_navigateTool; 

    public Q_SLOTS:

      void setTool(Tool *tool);

      void setBackground(const QColor &background);

      void setMolecule(Molecule *molecule);

      void unselectPrimitive(Primitive *);

      void unselectAtom(Atom *);

      void unselectBond(Bond *);

      void addEngine(Engine *engine);

      void removeEngine(Engine *engine);

      void loadDefaultEngines();

      void reloadEngines();

      void invalidateDLs();

      void updateGeometry();

      void toolsDestroyed();

      void addTextOverlay(QLabel* label);

      void addTextOverlay(const QList<QLabel*> &labels);

    Q_SIGNALS:
      void mousePress(QMouseEvent * event);

      void mouseRelease( QMouseEvent * event );

      void mouseMove( QMouseEvent * event );

      void mouseDoubleClick( QMouseEvent * event );

      void wheel( QWheelEvent * event);

      void moleculeChanged(Molecule *newMolecule);

      void engineAdded(Engine *engine);

      void engineRemoved(Engine *engine);

      void resized();

      void namedSelectionsChanged();

      void activated(GLWidget *);

      void unitCellAxesRenderChanged(bool enabled);


  };

} // end namespace Avogadro

#endif