/*
   gloobs.h
   Gloobs graphics library

   by Smylers
   2000 January  5: initial version
   2000 January 18: improved comments
   2000 January 26: Canvas::pause() overloaded
*/


#ifndef _GLOOBS_H_
#define _GLOOBS_H_

// as an interface to g2, Gloobs obviously needs the g2 headers; the STL vector
// collection is used for forming Gloobs::Objects out of Gloobs::Primitives:
#include <g2.h>
#include <g2_PS.h>
#include <vector>

// all of Gloobs is defined within its own namespace:
namespace Gloobs
{

  // a Gloobs::Canvas can be of one of these types:
  enum CanvasType
  {
    X11,
    PNG,
    PS
  };


  // pretend that PretendCanvas doesn't exist; it's used to implement mutual
  // recursion between the Canvas and Object classes; the only purpose of
  // PretendCanvas is for it to be inherited by Canvas, and there shouldn't
  // ever be a need to do anything with it directly:
  class PretendCanvas
  {
    public:
      virtual void move(double, double) = 0;
      virtual void move_r(double, double) = 0;
      virtual void plot(double, double) = 0;
      virtual void plot_r(double, double) = 0;
      virtual void set_QP(double, QPshape) = 0;
      virtual void plot_QP(double, double) = 0;
      virtual void line(double, double, double, double) = 0;
      virtual void line_to(double, double) = 0;
      virtual void line_r(double, double) = 0;
      virtual void poly_line(int, double*) = 0;
      virtual void triangle(double, double, double, double, double, double) = 0;
      virtual void filled_triangle(double, double, double, double, double, double) = 0;
      virtual void rectangle(double, double, double, double) = 0;
      virtual void filled_rectangle(double, double, double, double) = 0;
      virtual void polygon(int, double*) = 0;
      virtual void filled_polygon(int, double*) = 0;
      virtual void circle(double, double, double) = 0;
      virtual void filled_circle(double, double, double) = 0;
      virtual void ellipse(double, double, double, double) = 0;
      virtual void filled_ellipse(double, double, double, double) = 0;
      virtual void arc(double, double, double, double, double, double) = 0;
      virtual void filled_arc(double, double, double, double, double, double) = 0;
      virtual void string(double, double, char*) = 0;
      virtual void image(double, double, int, int, int*) = 0;
      virtual void pen(int) = 0;
      virtual void clear_palette() = 0;
      virtual void set_dash(int, double*) = 0;
      virtual void set_dash() = 0;
      virtual void set_line_width(double) = 0;
      virtual void set_font_size(double) = 0;
  };


  // the Primitive class is inherited by the various primitive classes defined
  // later; all Primitives must have a public Pen variable and a draw()
  // function with a common interface:
  class Primitive
  {
    public:
      virtual void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale) = 0;
      int Pen;
  };

  // a Gloobs::Object is a (vector) collection of Primitives; it can be
  // iterated through with variables of type Iter:
  typedef std::vector<Primitive*> Object;
  typedef Object::iterator Iter;


  // a Gloobs::Canvas is used for creating Gloobs images:
  class Canvas: public PretendCanvas
  {
    private:
      int Handle;
      enum CanvasType Type;
      double QPScale;
    public:
      // a Canvas must always have a Type and a Name; if its type is X11 or PNG
      // then it should have a Width and Height; if it's PS then it needs a
      // Size and Orientation (as defined in g2_PS.h):
      Canvas(CanvasType Type, int Width, int Height, char* Name);
      Canvas(CanvasType Type,
          g2_PS_paper Size, g2_PS_orientation Orientation, char* Name);
      ~Canvas();

      // function to pause the program so as to allow an X11 canvas to be
      // viewed; give the argument false to suppress the prompt:
      void pause();
      void pause(bool);

      void clear_palette();

      // inks can be defined in several ways; doubles are in the range 0.0 to
      // 0.1; ints 0 to 255 (or 0x00 to 0xFF); char* are six characters, with
      // each pair in the range "00" to "FF":
      int ink(double Red, double Green, double Blue);
      int ink(int Red, int Green, int Blue);
      int ink(const char* RRGGBB);

      // functions to set parameters that will affect subsequent drawing
      // commands:
      void pen(int Ink);
      void set_background(int Ink);
      void set_dash(int NumDashes, double* DashLengths);
      void set_dash(); // return to default of a solid line
      void set_line_width(double Thickness);
      void set_font_size(double Size);

      // functions to draw primitives, based very closely on their g2
      // counterparts:
      void move(double X, double Y);
      void move_r(double DX, double DY);
      void plot(double X, double Y);
      void plot_r(double DX, double DY);
      void set_QP(double Size, QPshape Shape); // QPrect or QPcirc, see g2.h
      void plot_QP(double X, double Y);
      void line(double X0, double Y0, double X1, double Y1);
      void line_to(double X, double Y);
      void line_r(double DX, double DY);
      void poly_line(int NumCoords, double* Coords);
      void triangle(double X0, double Y0, double X1, double Y1,
          double X2, double Y2);
      void filled_triangle(double X0, double Y0, double X1, double Y1,
          double X2, double Y2);
      void rectangle(double X0, double Y0, double X1, double Y1);
      void filled_rectangle(double X0, double Y0, double X1, double Y1);
      void polygon(int NumCoords, double* Coords);
      void filled_polygon(int NumCoords, double* Coords);
      void circle(double X, double Y, double Radius);
      void filled_circle(double X, double Y, double Radius);
      void ellipse(double X, double Y, double XRadius, double YRadius);
      void filled_ellipse(double X, double Y, double XRadius, double YRadius);
      void arc(double X, double Y, double XRadius, double YRadius,
          double StartAngle, double EndAngle); // in degrees
      void filled_arc(double X, double Y, double XRadius, double YRadius,
          double StartAngle, double EndAngle);
      void string(double X, double Y, char* Text);
      void image(double X, double Y, int Width, int Height, int* Inks);
      void draw_object(Object& Object);
      void draw_object(Object& Object, float Scale);
      void draw_object(Object& Object, float XOffset, float YOffset);
      void draw_object(Object& Object, float XOffset, float YOffset,
          float Scale);
  };


  // The various Primitive classes are declared next.  Generally, the
  // constructor for each one takes an ink number as its first parameter, and a
  // thickness as its second.  The remaining parameters tend to be the same as
  // those passed to the equivalent Canvas functions for drawing those
  // primitives directly.
  // 
  // For 2D shapes, the thickness parameter can be the constant Filled, meaning
  // that the shape is to be filled, or numerical, meaning that the shape
  // should be open and drawn using lines of the specified thickness.
  //
  // The purposes of the remaining parameters can be determined by examining
  // the names of the private variables!
  // 
  // You will probably never call a Primitive's draw() function yourself; these
  // are needed by the Canvas::draw_object() functions, but can otherwise be
  // ignored.

  const double Filled = 0;

  class Move: public Primitive
  {
    public:
      Move(double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      double X, Y;
  };

  class Move_R: public Primitive
  {
    public:
      Move_R(double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      double DX, DY;
  };

  class Pixel: public Primitive
  {
    public:
      Pixel(int, double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      double X, Y;
  };

  class Pixel_R: public Primitive
  {
    public:
      Pixel_R(int, double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      double DX, DY;
  };

  class QP: public Primitive
  {
    public:
      QP(int, double, QPshape, double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      double Size;
      QPshape Shape;
      double X, Y;
  };

  class Line: public Primitive
  {
    public:
      Line(int, double, double, double, double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      double Thickness;
      double X0, Y0;
      double X1, Y1;
  };

  class Line_To: public Primitive
  {
    public:
      Line_To(int, double, double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      double Thickness;
      double X, Y;
  };

  class Line_R: public Primitive
  {
    public:
      Line_R(int, double, double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      double Thickness;
      double DX, DY;
  };

  class Poly_Line: public Primitive
  {
    public:
      Poly_Line(int, double, int, const double*);
      ~Poly_Line();
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      double Thickness;
      int NumPoints;
      double* Points;
  };

  class Triangle: public Primitive
  {
    public:
      Triangle(int, double, double, double, double, double, double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      float Thickness;
      double X0, Y0;
      double X1, Y1;
      double X2, Y2;
  };

  class Rectangle: public Primitive
  {
    public:
      Rectangle(int, double, double, double, double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      float Thickness;
      double X0, Y0;
      double X1, Y1;
  };

  class Polygon: public Primitive
  {
    public:
      Polygon(int, double, int, const double*);
      ~Polygon();
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      float Thickness;
      int NumPoints;
      double* Points;
  };

  class Circle: public Primitive
  {
    public:
      Circle(int, double, double, double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      float Thickness;
      double X, Y;
      double Radius;
  };

  class Ellipse: public Primitive
  {
    public:
      Ellipse(int, double, double, double, double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      float Thickness;
      double X, Y;
      double XRadius, YRadius;
  };

  class Arc: public Primitive
  {
    public:
      Arc(int, double, double, double, double, double, double, double);
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      float Thickness;
      double X, Y;
      double XRadius, YRadius;
      double StartAngle, EndAngle; // in degrees
  };

  class String: public Primitive
  {
    public:
      String(int, double, double, double, const char*);
      ~String();
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      double Size;
      double X, Y;
      char* Text;
  };

  class Bitmap: public Primitive
  {
    public:
      Bitmap(double, double, int, int, int*);
      ~Bitmap();
      void draw(PretendCanvas& Destination,
          float XOffset, float YOffset, float Scale);
    private:
      double X, Y;
      int Width, Height;
      int* Colrs;
  };

} // end of Gloobs namespace
#endif // _GLOOBS_H_