RhodeCode

  public:

    ///Constructor

    ///Constructor 

    ///\param num the number of the allocated colors. If it is \c -1,

    ///white).  If \c num is less then 26/27 then the default color

    ///list is cut. Otherwise the color list is filled repeatedly with

    ///the default color list.  (The colors can be changed later on.)

    Palette(bool have_white=false,int num=-1)

    {

      if (num==0) return;

      do {

    void set(int i,const Color &c)

    {

      colors[i%colors.size()]=c;

    }

    void add(const Color &c) 

    {

      colors.push_back(c);

    }

    ///Returns the number of the existing colors.

    int size() const { return int(colors.size());}

  };

  ///Returns a \ref Color which is as different from the given parameter

  ///as it is possible.

  inline Color distantColor(const Color &c) 

///\ingroup eps_io

///\file

namespace lemon {

  namespace _graph_to_eps_bits {

    _preScale(true)

  {}

};

template<class T> class GraphToEps : public T 

{

  // Can't believe it is required by the C++ standard

  using T::g;

  };

  ///Sets the map of the node shapes

  ///Sets the map of the node shapes.

  ///can be found in \ref NodeShapes "enum NodeShapes".

  ///\param x must be a node map with \c int (or convertible) values. 

  ///\sa NodeShapes

  template<class X> GraphToEps<NodeShapesTraits<X> > nodeShapes(const X &x)

  ///\param x must be a node map with type that can be pushed to a standard

  ///ostream.

  ///

  ///\sa nodePsTextsPreamble()

  template<class X> GraphToEps<NodePsTextsTraits<X> > nodePsTexts(const X &x)

  {

    dontPrint=true;

    _showNodePsText=true;

  ///Negates the Y coordinates.

  ///Negates the Y coordinates.

  ///

  GraphToEps<T> &negateY(bool b=true) {

    _negY=b;return *this;

  }

  ///By default graphToEps() rescales the whole image in order to avoid

  ///very big or very small bounding boxes.

  ///

  ///Sets the width of the border around the picture

  ///Sets the width of the border around the picture

  ///

  ///Sets the width of the border around the picture

  ///Sets the width of the border around the picture

  ///

  ///Sets the length of the arrowheads

  ///Sets the length of the arrowheads

  ///

  ///Sets the width of the arrowheads

  ///Sets the width of the arrowheads

  ///

  ///Scales the drawing to fit to A4 page

  ///Scales the drawing to fit to A4 page

    _nodePsTextsPreamble=str ;return *this;

  }

  ///Sets whether the the graph is undirected

  ///

  GraphToEps<T> &undirected(bool b=true) {_undirected=b;return *this;}

  ///Sets whether the the graph is directed

  ///Sets whether the the graph is directed.

  ///Use it to show the edges as a pair of directed ones.

  GraphToEps<T> &directed(bool b=true) {_undirected=!b;return *this;}

  ///Sets the title.

  ///Sets the copyright statement of the generated image,

  ///namely it inserts a <tt>%%Copyright:</tt> DSC field to the header of

  ///the EPS file.

  GraphToEps<T> &copyright(const std::string &t) {_copyright=t;return *this;}

protected:

  bool isInsideNode(dim2::Point<double> p, double r,int t) 

  ///Draws the graph.

  ///Like other functions using

  ///\ref named-templ-func-param "named template parameters",

  ///it draws the graph.

  void run() {

    const double EPSILON=1e-9;

    if(dontPrint) return;

    _graph_to_eps_bits::_NegY<typename T::CoordsMapType>

	  sw/=-2.0;

	  dim2::Point<double>

	    dvec(mycoords[g.target(*i)]-mycoords[g.source(*i)]);

	  double l=std::sqrt(dvec.normSquare()); 

	  dim2::Point<double> d(dvec/std::max(l,EPSILON));

 	  dim2::Point<double> m;

// 	  m=dim2::Point<double>(mycoords[g.target(*i)]+mycoords[g.source(*i)])/2.0;