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

/**********************************************************************
  Painter - drawing spheres, cylinders and text

  Copyright (C) 2007 Benoit Jacob
  Copyright (C) 2007 Donald Ephraim Curtis
  Copyright (C) 2007-2008 Marcus D. Hanwell
  Copyright (C) 2010 Konstantin Tokarev
  Copyright (C) 2011 David C. Lonie

  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 PAINTER_H
#define PAINTER_H

#include <avogadro/global.h>
#include <avogadro/primitive.h>

class QColor;
class QFont;

namespace Avogadro
{
  class Color;
  class Mesh;
  class A_EXPORT Painter
  {
  public:
    Painter();

    virtual ~Painter();

    virtual bool initialize();

    virtual bool finalize();

    virtual int quality() const = 0;

    virtual void setName(const Primitive *primitive) = 0;

    virtual void setName(Primitive::Type type, int id) = 0;

    virtual void setColor(const Color *color) = 0;

    virtual void setColor(const QColor *color) = 0;

    virtual void setColor(float red, float green, float blue, float alpha = 1.0) = 0;

    virtual void setColor(QString name) = 0;

    virtual void drawSphere(const Eigen::Vector3d &center, double radius) = 0;

    virtual void drawSphere(const Eigen::Vector3d *center, double radius);

    virtual void drawCylinder(const Eigen::Vector3d &end1,
                              const Eigen::Vector3d &end2,
                              double radius) = 0;

    virtual void drawMultiCylinder(const Eigen::Vector3d &end1,
                                   const Eigen::Vector3d &end2,
                                   double radius, int order, double shift) = 0;

    virtual void drawCone(const Eigen::Vector3d &base,
                          const Eigen::Vector3d &cap,
                          double baseRadius,
                          double capRadius = 0.0) = 0;

    virtual void drawLine(const Eigen::Vector3d &start,
                          const Eigen::Vector3d &end,
                          double lineWidth) = 0;

    virtual void drawMultiLine(const Eigen::Vector3d &start,
                               const Eigen::Vector3d &end, double lineWidth,
                               int order, short stipple) = 0;

    virtual void drawTriangle(const Eigen::Vector3d &p1,
                              const Eigen::Vector3d &p2,
                              const Eigen::Vector3d &p3) = 0;

    virtual void drawTriangle(const Eigen::Vector3d &p1,
                              const Eigen::Vector3d &p2,
                              const Eigen::Vector3d &p3,
                              const Eigen::Vector3d &n) = 0;

    virtual void drawSpline(const QVector<Eigen::Vector3d>& pts,
                            double radius) = 0;

    virtual void drawShadedSector(const Eigen::Vector3d & origin,
                                  const Eigen::Vector3d & direction1,
                                  const Eigen::Vector3d & direction2,
                                  double radius,
                                  bool alternateAngle = false) = 0;

    virtual void drawArc(const Eigen::Vector3d & origin,
                         const Eigen::Vector3d & direction1,
                         const Eigen::Vector3d & direction2, double radius,
                         double lineWidth, bool alternateAngle = false) = 0;

    virtual void drawShadedQuadrilateral(const Eigen::Vector3d & point1,
                                         const Eigen::Vector3d & point2,
                                         const Eigen::Vector3d & point3,
                                         const Eigen::Vector3d & point4) = 0;

    virtual void drawQuadrilateral(const Eigen::Vector3d & point1,
                                   const Eigen::Vector3d & point2,
                                   const Eigen::Vector3d & point3,
                                   const Eigen::Vector3d & point4,
                                   double lineWidth);

    virtual void drawLineLoop(const QList<Eigen::Vector3d> & points,
                              const double lineWidth);

    virtual void drawMesh(const Mesh & mesh, int mode = 0) = 0;

    virtual void drawColorMesh(const Mesh & mesh, int mode = 0) = 0;

    virtual int drawText(int x, int y, const QString &string) = 0;

    virtual int drawText(const QPoint& pos, const QString &string) = 0;

    virtual int drawText(const Eigen::Vector3d & pos,
                         const QString &string) = 0;

    virtual int drawText(const Eigen::Vector3d & /*pos*/,
                          const QString & /*string*/, const QFont & /*font*/) {
      return 0; }

    virtual void drawBox(const Eigen::Vector3d &corner1,
                         const Eigen::Vector3d &corner2) = 0;

    virtual void drawBoxEdges(const Eigen::Vector3d &offset,
                              const Eigen::Vector3d &v1,
                              const Eigen::Vector3d &v2,
                              const Eigen::Vector3d &v3,
                              const double linewidth);

    virtual void drawBoxEdges(const Eigen::Vector3d &c1,
                              const Eigen::Vector3d &c2,
                              const Eigen::Vector3d &c3,
                              const Eigen::Vector3d &c4,
                              const Eigen::Vector3d &c5,
                              const Eigen::Vector3d &c6,
                              const Eigen::Vector3d &c7,
                              const Eigen::Vector3d &c8,
                              const double linewidth);

    virtual void drawTorus(const Eigen::Vector3d &pos,
                           double majorRadius, double minorRadius) = 0;

    virtual void drawEllipsoid(const Eigen::Vector3d &position,
                               const Eigen::Matrix3d &matrix) = 0;

  };
} // end namespace Avogadro

#endif