/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2006

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_EPS_H

#define LEMON_EPS_H

#include<string>

#include<iostream>

#include<fstream>

#include<sstream>

#include<lemon/color.h>

#include<lemon/xy.h>

  ///\ingroup io_group

  ///\file

  ///\brief Simple tool to create \c .eps files

  ///

  ///\author Alpar Juttner

namespace lemon {

  ///\ingroup io_group

  ///\brief A simple tool to create \c .eps files

  ///

  ///A simple tool to create \c .eps files

  ///\author Alpar Juttner

  class EpsDrawer

  {

    void defMacros();

    void init(int x1,int y1,int x2,int y2);

    void init(double x1,double y1,double x2,double y2);

    bool local_stream;

  public:

    std::ostream &out;

    ///\e 

    ///The generated file is put to \c os.

    ///

    /// \c x and \c y determine the upper

    ///right corner of the bounding box. The lower left corner is (0,0).

    EpsDrawer(std::ostream &os,int x,int y);

    ///\e

    ///The generated file is put to \c os.

    ///

    ///(x1,y1) and (x2,y2)

    /// determine the lower left and the upper right corners of

    ///the bounding box, respectively.

    EpsDrawer(std::ostream &os,int x1,int y1,int x2,int y2);

    ///\e

    ///The generated file is put to \c os.

    ///

    ///\c s determines the upper

    ///right corner of the bounding box. The lower left corner is (0,0).

    EpsDrawer(std::ostream &os,xy<double> s);

    ///\e

    ///The generated file is put to \c os.

    ///

    ///\c a and \c b

    /// determine the lower left and the upper right corners of

    ///the bounding box, respectively.

    EpsDrawer(std::ostream &os,xy<double> a, xy<double> b);

    ///\e

    ///The generated picture is put to the file \c name.

    ///

    ///\c x and \c y determine the upper

    ///right corner of the bounding box. The lower left corner is (0,0).

    EpsDrawer(const std::string &name,int x,int y);

    ///\e

    ///The generated picture is put to the file \c name.

    ///

    ///(x1,y1) and (x2,y2)

    /// determine the lower left and the upper right corners of

    ///the bounding box, respectively.

    EpsDrawer(const std::string &name,int x1,int y1,int x2,int y2);

    ///\e

    ///The generated picture is put to the file \c name.

    ///

    ///\c s determines the upper

    ///right corner of the bounding box. The lower left corner is (0,0).

    EpsDrawer(const std::string &name,xy<double> s);

    ///\e

    ///The generated picture is put to the file \c name.

    ///

    ///\c a and \c b

    /// determine the lower left and the upper right corners of

    ///the bounding box, respectively.

    EpsDrawer(const std::string &name,xy<double> a, xy<double> b);

//     template<class T> EpsDrawer(std::ostream &os,BoundingBox<T> b) 

//     template<class T> EpsDrawer(std::ostream &os,BoundingBox<T> b);

    ~EpsDrawer();

    ///Save the current graphic state.

    ///This function saves the current coordinate system, and the parameters

    ///set by \ref color(), \ref lineWidth() etc.

    ///The can be \ref restore "restore()"d later.

    ///

    ///The \ref save() - \ref restore() pairs can be nested.

    ///

    EpsDrawer &save();

    ///Restore the saves graphic state.

    EpsDrawer &restore();

    ///Draw a line

    EpsDrawer &line(double x1,double y1,double x2,double y2);

    ///Draw a line from the current point

    EpsDrawer &lineTo(double x1,double y1);

    ///Move the current point

    EpsDrawer &moveTo(double x1,double y1);

    ///Draw a circle

    EpsDrawer &circle(double x,double y, double r);

    ///Draw a line

    template<class T> EpsDrawer &line(xy<T> p1,xy<T> p2) 

    {

      return line(p1.x,p1.y,p2.x,p2.y);

    }

    ///Draw a line from the current point

    template<class T> EpsDrawer &lineTo(xy<T> p)

    {

      return lineTo(p.x,p.y);

    }

    ///Move the current point

    template<class T> EpsDrawer &moveTo(xy<T> p)

    {

      return moveTo(p.x,p.y);

    }

    ///Draw a circle

    template<class T> EpsDrawer &circle(xy<T> p, double r)

    {

      return circle(p.x,p.y,r);

    }

    ///Set the font size

    EpsDrawer &fontSize(double si);

    ///Set the fint type

    EpsDrawer &font(std::string );

    ///Sets whether text output is centerized of not

    ///Sets whether text output is centerized of not.

    ///

    ///\warning \ref save() doesn't save this setting.

    ///

    EpsDrawer &centerMode(bool m);

    ///Turn to collect mode.

    ///If you call this function, then the drawing operations like \ref line(),

    ///\ref lineTo(), \ref moveTo() will not take place immediately, but istead

    ///they

    ///are collected. These operations form a \e path.

    ///Then you can \ref stroke(), \ref fill(), \ref eofill(), \ref clip() or

    ///\ref eoclip() it.

    ///When drawing, you can also use \ref closePath() to - surprise - close the

    ///current path.

    ///

    ///This example draws a red filled diamond.

    ///\code

    ///  EpsDraw ed("diamond.eps",-1,-1,1,1);

    ///  ed.color(1,0,0,).collect().line(0,-1,1,0).lineTo(0,1)

    ///    .lineTo(-1,0).closePath().fill();

    ///\endcode

    EpsDrawer &collect();

    ///Close the current drawing path

    EpsDrawer &closePath();

    ///Stroke (draw) a path

    ///Stroke (draw) a path.

    ///\sa collect

    ///

    EpsDrawer &stroke();

    ///Fill a path

    ///Fill a path.

    ///\sa collect

    ///

    EpsDrawer &fill();

    ///Even-odd fill a path

    ///Even-odd fill a path.

    ///\sa collect

    ///

    EpsDrawer &eoFill();

    ///Set a clipping area.

    ///This function sets a clipping area. After that, the drawing operations

    ///will affect only this area.

    ///\sa collect

    ///

    EpsDrawer &clip();

    ///Set a clipping area using even-odd rule.

    ///This function sets a clipping area using even-odd rule.

    ///After that, the drawing operations

    ///will affect only this area.

    ///\sa collect

    ///

    EpsDrawer &eoClip();

    ///Set the line width.

    EpsDrawer &lineWidth(double w);

    ///Set the style of the line ends

    ///\param i It can be 0, 1 or 2

    ///

    EpsDrawer &lineCap(int i);

    ///Set the style of the line joins

    ///\param i It can be 0, 1 or 2

    ///

    EpsDrawer &lineJoin(int i);

    ///Set the cut length of near parallel joining lines.

    EpsDrawer &miterLimit(double w);

    ///Set the drawing color

    EpsDrawer &color(double r, double g, double b);

    ///Set the drawing color

    EpsDrawer &color(Color c)

    {

      return color(c.red(),c.green(),c.blue());

    }

    ///Translate the coordinate system

    EpsDrawer &translate(double x,double y);

    ///Translate the coordinate system

    template<class T> EpsDrawer &translate(xy<T> p)

    {

      return translate(p.x,p.y);

    }

    ///Rotate the coordinate system

    EpsDrawer &rotate(double r);

    ///Scale the coordinate system

    EpsDrawer &scale(double sx, double sy);

    ///Scale the coordinate system

    EpsDrawer &scale(double s) { return scale(s,s); }

    ///Scale the coordinate system

    template<class T> EpsDrawer &scale(xy<T> p)

    {

      return scale(p.x,p.y);

    }

    ///\e

    EpsDrawer &flush();

    ///Clear the image

    EpsDrawer &clear();

    ///Print a text at the current point

    EpsDrawer &operator<<(const std::string &s);

    ///Print a text at the current point

    EpsDrawer &operator<<(const char *s);

    ///Print a number at the current point

    EpsDrawer &operator<<(int i);

    ///Print a number at the current point

    EpsDrawer &operator<<(double d);

    ///Print a coordinate at the current point

    template<class T>

    EpsDrawer &operator<<(xy<T> p) 

    {

      out << "((" << p.x << ',' << p.y <<")) show\n";

      return *this;

    }

  };

}

#endif