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

/**********************************************************************
  Engine - Engine interface and plugin factory.

  Copyright (C) 2007 Donald Ephraim Curtis
  Copyright (C) 2008 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 ENGINE_H
#define ENGINE_H

#include <avogadro/global.h>

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

#include "primitivelist.h"
#include "plugin.h"

#include <QList>
#include <QSettings>
#include <QtPlugin>

#define AVOGADRO_ENGINE(i, t, d)                             \
  public: \
    static QString staticIdentifier() { return i; }          \
    QString identifier() const { return i; }                 \
    static QString staticName() { return t; }                \
    QString name() const { return t; }                       \
    static QString staticDescription() { return d; }         \
    QString description() const                              \
    { if (m_description.isEmpty()) return d;                 \
      else return m_description; }

#define AVOGADRO_ENGINE_FACTORY(c)                           \
  public: \
    Avogadro::Plugin *createInstance(QObject *parent = 0) { return new c(parent); } \
    Avogadro::Plugin::Type type() const { return Avogadro::Plugin::EngineType; } \
    QString identifier() const { return c::staticIdentifier(); } \
    QString name() const { return c::staticName(); }         \
    QString description() const { return c::staticDescription(); }

namespace Avogadro {

  class PainterDevice;
  class Atom;
  class Bond;
  class Molecule;
  class Color;

  class EnginePrivate;
  class A_EXPORT Engine : public Plugin
  {
    Q_OBJECT

    public:
      enum Layer {
        Opaque = 0x00, 
        Transparent = 0x01, 
        Overlay = 0x02 
      };
      Q_DECLARE_FLAGS(Layers, Layer)

    
      enum PrimitiveType {
        NoPrimitives = 0x00, 
        Atoms = 0x01, 
        Bonds = 0x02, 
        Molecules = 0x04, 
        Surfaces = 0x08, 
        Fragments = 0x10 
      };
      Q_DECLARE_FLAGS(PrimitiveTypes, PrimitiveType)

    
      enum ColorType {
        NoColors = 0x00, 
        ColorPlugins = 0x01, 
        IndexedColors = 0x02, 
        ColorGradients = 0x04 
      };
      Q_DECLARE_FLAGS(ColorTypes, ColorType)

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

      virtual QString identifier() const = 0;

      Plugin::Type type() const;

      QString typeName() const;

      virtual QString name() const = 0;

      QString alias() const;

      void setAlias(const QString &alias);

      QString description() const;

      void setDescription(const QString &description);

      GLuint shader() { return m_shader; }

      void setShader(GLuint shader) { m_shader = shader; }

      virtual Layers layers() const;

      virtual bool renderOpaque(PainterDevice *pd) = 0;
      virtual bool renderTransparent(PainterDevice *) { return true; }

      virtual bool renderQuick(PainterDevice *pd)
      {
        renderOpaque(pd);
        return true;
      }

      virtual bool renderPick(PainterDevice *pd)
      {
        renderQuick(pd);
        return true;
      }

      virtual double transparencyDepth() const;

      virtual PrimitiveTypes primitiveTypes() const;

      virtual const PrimitiveList primitives() const;

      virtual const QList<Atom *> atoms() const;

      virtual const QList<Bond *> bonds() const;

      virtual void setPrimitives(const PrimitiveList &primitives);

      virtual void clearPrimitives();

      virtual const PainterDevice * painterDevice() const { return m_pd; }

      virtual void setPainterDevice(const PainterDevice *pd);

      virtual const Molecule * molecule() const { return m_molecule; }

      virtual double radius(const PainterDevice *pd, const Primitive *primitive = 0) const;

      bool isEnabled() const { return m_enabled; }

      void setEnabled(bool enabled);

      virtual ColorTypes colorTypes() const;

      virtual Color *colorMap() { return m_colorMap; }

      virtual Engine *clone() const = 0;

      virtual QWidget *settingsWidget();

      virtual bool hasSettings();

      virtual void writeSettings(QSettings &settings) const;

      virtual void readSettings(QSettings &settings);

    Q_SIGNALS:
      void changed();

      void enableToggled(bool enabled);

    public Q_SLOTS:
      virtual void addPrimitive(Primitive *primitive);

      virtual void updatePrimitive(Primitive *primitive);

      virtual void removePrimitive(Primitive *primitive);

      virtual void addAtom(Atom *atom);

      virtual void removeAtom(Atom *atom);

      virtual void addBond(Bond *bond);

      virtual void removeBond(Bond *bond);

      virtual void setColorMap(Color *map);

      virtual void colorMapChanged();

      virtual void setMolecule(const Molecule *molecule);

      virtual void setMolecule(Molecule *molecule);

    protected:
      EnginePrivate *const d;
      GLuint m_shader;
      const PainterDevice *m_pd;
      const Molecule *m_molecule;
      Color *m_colorMap;
      bool m_enabled;
      bool m_customPrims;
      PrimitiveList m_primitives;
      QList<Atom *> m_atoms;
      QList<Bond *> m_bonds;
      QString m_alias;
      QString m_description;

      virtual void useCustomPrimitives();
  };

} // end namespace Avogadro

Q_DECLARE_METATYPE(Avogadro::Engine*)

Q_DECLARE_OPERATORS_FOR_FLAGS(Avogadro::Engine::Layers)
Q_DECLARE_OPERATORS_FOR_FLAGS(Avogadro::Engine::PrimitiveTypes)
Q_DECLARE_OPERATORS_FOR_FLAGS(Avogadro::Engine::ColorTypes)

#endif