NAMESPACE_UPP

typedef const signed char  LineStyle[];
typedef const signed char *LineStyleArg;

extern LineStyle SolidLine;
extern LineStyle DashLine;
extern LineStyle DotLine;
extern LineStyle DashDotLine;
extern LineStyle DashDotDotLine;
extern LineStyle EmptyLine;

class LineDraw
{
public:
	LineDraw();
	LineDraw(Draw& draw, LineStyleArg pattern = SolidLine, Color color = Black, int width = -10, double dash = 0);

	operator bool () const                { return draw && !empty; }

	void           Set(Draw& draw, LineStyleArg pattern = SolidLine, Color color = Black, int width = -10, double dash = 0);

	bool           SetExtent(const Rect& rc);
	void           ClearExtent();

	void           Clear();
	void           Flush(); // flush polyline buffer

	void           MoveTo(Point pt)       { ASSERT(MoveToRaw); (this->*MoveToRaw)(pt); }
	void           LineTo(Point pt)       { ASSERT(LineToRaw); (this->*LineToRaw)(pt); }
	void           Close();

	LineDraw&      operator << (Point pt) { LineTo(pt); return *this; }

	void           Line(Point p, Point q) { MoveTo(p); LineTo(q); }

	void           Rectangle(const Rect& rc);

	void           ArcTo(Point p, int bulge, int levels = 10);
	void           Arc(Point p, Point q, int bulge, int levels = 10) { MoveTo(p); ArcTo(q, bulge, levels); }
	void           Circle(Point centre, int radius);
	void           Ellipse(const Rect& rc);

private:
	void           RecurseArc(Point to, int length, int bulge, int levels);
	void           MoveToEmpty(Point pt);
	void           MoveToSolid(Point pt);
	void           MoveToDashed(Point pt);
	void           LineToEmpty(Point pt);
	void           LineToSolidSimple(Point pt);
	void           LineToSolidClip(Point pt);
	void           LineToDashedSimple(Point pt);
	void           LineToDashedClip(Point pt);
	void           AddVectorThin(Point a, Point b);
	void           AddVectorThick(Point a, Point b);
	void           AddVectorArea(Point a, Point b);

private:
	void (LineDraw::*MoveToRaw)(Point pt);
	void (LineDraw::*LineToRaw)(Point pt);
	void (LineDraw::*AddVector)(Point a, Point b);

	Draw          *draw;
	int            max_rad;
	int            pen_width;
	Color          pen_color;
	Rect           clip;
	Point          first;
	Point          last;
	Vector<double> segments;
	const double  *active;
	double         remains;
	double         factor;
	bool           empty;
	int            half_width;
	Vector<Point>  vertices;
	Vector<int>    indices;
};

class Plotter
{
public:
	Plotter() : draw(0), ltop(0), ltopoint(0), path_map(0) {}

	Plotter(Draw& draw, const Rectf& src, const Rectf& dest,
		int flags = ISOTROPIC | MIRROR_Y, int reserve = 0, double map_meters = 1)
	{ Set(draw, src, dest, flags, reserve, map_meters); }

	Plotter(Draw& draw, Sizef scale, Pointf delta = Pointf(0, 0), int reserve = 0, double map_meters = 1)
	{ Set(draw, scale, delta, reserve, map_meters); }

	Plotter(Draw& draw, const Matrixf& matrix = Matrixf_1(), int reserve = 0, double map_meters = 1)
	{ Set(draw, matrix, reserve, map_meters); }

	Plotter(Draw& draw, const Matrixf& matrix, const Rect& clip, double map_meters = 1)
	{ Set(draw, matrix, clip, map_meters); }

	Plotter(const Plotter& info, const Rect& clip)
	{ Set(info, clip); }

	Plotter(const Plotter& info, int reserve)
	{ Set(info, reserve); }

	Plotter(const Plotter& info)
	{ Set(info); }

	enum
	{
		MIRROR_X  = 0x01,
		MIRROR_Y  = 0x02,
		ISOTROPIC = 0x04,
	};

	void                Set(Draw& draw, const Rectf& src, const Rectf& dest, int flags = ISOTROPIC | MIRROR_Y, int reserve = 0, double map_meters = 1);
	void                Set(Draw& draw, Sizef scale, Pointf delta = Pointf(0, 0), int reserve = 0, double map_meters = 1);
	void                Set(Draw& draw, const Matrixf& matrix = Matrixf_1(), int reserve = 0, double map_meters = 1);
	void                Set(Draw& draw, const Matrixf& matrix, const Rect& clip, double map_meters = 1);
	void                Set(const Plotter& info, const Rect& clip);
	void                Set(const Plotter& info, int reserve);
	void                Set(const Plotter& info)                          { *this = info; }
	void                SetDraw(Draw& draw, const Rect& clip, double map_meters);

	void                SetPixelsPerDot(double  _ppd)                     { pixels_per_dot = _ppd; }
	double              GetPixelsPerDot() const                           { return pixels_per_dot; }
	double              GetPixelsPerPoint() const                         { return pixels_per_dot * (600.0 / 72.0); }
	double              GetPixelsPerInch() const                          { return pixels_per_dot * 600.0; }
	double              GetPixelsPerMeter() const                         { return pixels_per_dot * (6e5 / 25.4); }

	void                SetMapMeters(double mm);
	double              GetPhysicalScale() const                          { return physical_scale; }

	Draw&               GetDraw()                                         { ASSERT(draw); return *draw; }
	void                SetXorMode(bool xm);

	Point               LtoPoint(Pointf pt) const                         { ASSERT(ltopoint); return (this->*ltopoint)(pt); }

	double              LtoP(double dist) const                           { return dist * measure; }
	double              PtoL(double dist) const                           { return dist / measure; }

	Pointf              LtoP(Pointf pt) const                             { ASSERT(ltop); return (this->*ltop)(pt); }
	Pointf              LtoPrel(Pointf pt) const                          { return pt % physical; }

	Pointf              PtoL(Pointf pt) const                             { return pt * logical; }
	Pointf              PtoLrel(Pointf pt) const                          { return pt % logical; }

	Rectf               LtoP(const Rectf& rc) const;
	Rectf               LtoPrel(const Rectf& rc) const;

	Rectf               PtoL(const Rectf& rc) const;
	Rectf               PtoLrel(const Rectf& rc) const;

	const Matrixf&      LtoP() const                                      { return physical; }
	const Matrixf&      PtoL() const                                      { return logical; }

	const Rectf&        GetLClip() const                                  { return logclip; }
	const Rect&         GetPClip() const                                  { return clip; }

	bool                IntersectsLClip(const Rectf& rc) const            { return logclip && rc; }
	bool                IntersectsPClip(const Rectf& rc) const            { return rc.left < clip.right && rc.top < clip.bottom && rc.right > clip.left && rc.bottom > clip.top; }
	bool                InLClip(const Rectf& rc) const                    { return logclip.Contains(rc); }
	bool                InPClip(const Rectf& rc) const                    { return rc.left >= clip.left && rc.top >= clip.top && rc.right <= clip.right && rc.bottom <= clip.bottom; }
	bool                InLClip(Pointf pt) const                          { return logclip.Contains(pt); }
	bool                InPClip(Pointf pt) const                          { return pt.x >= clip.left && pt.y >= clip.top && pt.x <= clip.right && pt.y <= clip.bottom; }
	bool                InLClipX(double x) const                          { return x >= logclip.left && x <= logclip.right; }
	bool                InLClipY(double y) const                          { return y >= logclip.top  && y <= logclip.bottom; }

	void                PathMap(const PathStyleMap *pm)                   { path_map = pm; }
	const PathStyleMap *GetPathMap() const                                { return path_map; }
	PathStyle           GetPath(const String& spec) const                 { ASSERT(path_map); return path_map -> Scan(spec); }

public:
	Draw               *draw;
	const PathStyleMap *path_map;
	double              pixels_per_dot;
	double              map_meters;
	Matrixf             physical;
	Matrixf             logical;
	Rectf               logclip;
	Rect                clip;
	double              logdiag;
	double              logprec;
	double              measure;
	double              physical_scale;
	bool                ortho;

private:
	Pointf              LtoPFull(Pointf pt) const                   { return pt * physical; }
	Pointf              LtoPOrtho(Pointf pt) const                  { return Pointf(pt.x * physical.x.x + physical.a.x, pt.y * physical.y.y + physical.a.y); }

	Point               LtoPointFull(Pointf pt) const;
	Point               LtoPointOrtho(Pointf pt) const;

	Pointf              (Plotter::*ltop)(Pointf pt) const;
	Point               (Plotter::*ltopoint)(Pointf pt) const;
};

void PlotDragRect(Plotter& plotter, const Rectf& rc);

class PlotterTool
{
public:
	typedef PlotterTool CLASSNAME;
	PlotterTool();
	virtual ~PlotterTool();

	Plotter&          GetPlotter()                      { return plotter; }
	const Plotter&    GetPlotter() const                { return plotter; }

	virtual void      Paint(); // flush & clear paint buffer
	virtual void      Clear(); // clear paint buffer

	void              MoveTo(double x, double y)        { MoveToRaw(Pointf(x, y)); }
	void              MoveTo(Pointf pt)                 { MoveToRaw(pt); }
	void              MoveRel(Pointf pt)                { MoveToRaw(pt + last_point); }
	Callback1<Pointf> GetMoveTo() const                 { return MoveToRaw; }

	void              LineTo(double x, double y)        { LineToRaw(Pointf(x, y)); }
	void              LineTo(Pointf pt)                 { LineToRaw(pt); }
	void              LineRel(Pointf pt)                { LineToRaw(pt + last_point); }
	Callback1<Pointf> GetLineTo() const                 { return LineToRaw; }

	void              DrawTo(double x, double y, bool d) { if(d) LineTo(x, y); else MoveTo(x, y); }
	void              DrawTo(Pointf pt, bool d)         { if(d) LineTo(pt); else MoveTo(pt); }
	void              DrawRel(Point pt, bool d)         { if(d) LineRel(pt); else MoveRel(pt); }

	void              Line(Pointf p, Pointf q)          { MoveTo(p); LineTo(q); }
	void              Line(double x1, double y1, double x2, double y2) { MoveTo(x1, y1); LineTo(x2, y2); }
	void              Line(const Array<Pointf>& points);

	virtual void      ArcTo(Pointf pt, double bulge, int levels = 10);

	void              Rectangle(double x1, double y1, double x2, double y2, bool r = false);
	void              Rectangle(Pointf p, Pointf q, bool r = false) { Rectangle(p.x, p.y, q.x, q.y, r); }
	void              Rectangle(const Rectf& rc, bool r = false)    { Rectangle(rc.left, rc.top, rc.right, rc.bottom, r); }

	void              Circle(double x, double y, double radius);
	void              Circle(Pointf centre, double radius) { Circle(centre.x, centre.y, radius); }

	void              Ellipse(const Rectf& rc);

	void              ArrowHead(Pointf P, Pointf Q, double length, double angle);
	void              Arrow(Pointf P, Pointf Q, double length, double angle);
	void              BiArrow(Pointf P, Pointf Q, double length, double angle);

protected:
	virtual bool      ArcToRaw(Pointf pt, double bulge);

protected:
	Plotter           plotter;
	Pointf            last_point;
	bool              clip_arcs;

	Callback1<Pointf> MoveToRaw;
	Callback1<Pointf> LineToRaw;
};

class PathTool : public PlotterTool
{
public:
	typedef PathTool CLASSNAME;
	PathTool();
	virtual ~PathTool();

	virtual void   Paint(); // flush & clear paint buffer
	virtual void   Clear(); // clear paint buffer

	void           Set(const Plotter& info, const String& style = Null,
		Color color = Black, int width = -10, double dash = Null);

	bool           SetExtent(const Rectf& rc);
	void           ClearExtent();

public:
#ifdef PLOTTER_TIMING
	static int     segments;
	static int     drawn;
	static long    ticks;
#endif

protected:
	virtual bool   ArcToRaw(Pointf pt, double bulge);

	void           MoveToRawSimple(Pointf pt);
	void           MoveToRawClip(Pointf pt);
	void           LineToRawSimple(Pointf pt);
	void           LineToRawClip(Pointf pt);

protected:
	bool           use_last;
	Pointf         last_phys;
	PathDraw       pathdraw;
	bool           simple;
};

class AreaTool : public PlotterTool
{
public:
	typedef AreaTool CLASSNAME;
	AreaTool();
	virtual ~AreaTool();

	void           FlushFill();

	virtual void   Paint(); // flush & clear paint buffer
	virtual void   Clear(); // clear paint buffer

	void           Set(const Plotter& info, Color fill_color = Black, uint64 fill_pattern = 0,
		const String& outline_pattern = Null, Color outline_color = Black,
		int outline_width = -10, double outline_dash = Null);

	bool           SetExtent(const Rectf& rc);
	void           ClearExtent();

	int            GetPointPixels() const { return point_pixels; }
	Color          GetPointColor() const  { return point_color; }

	bool           IsFill() const { return !IsNull(fill_color); }
	bool           IsLine() const { return is_line; }
#ifdef _DEBUG
	void           ShowIndices();
#endif

	void           MoveToGhost(Pointf pt) { prev_ghost = true; MoveTo(pt); prev_ghost = false; }
	void           LineToGhost(Pointf pt) { prev_ghost = true; LineTo(pt); prev_ghost = false; }

protected:
	void           MoveToRawSimple(Pointf pt);
	void           MoveToRawClip(Pointf pt);
	void           LineToRawSimple(Pointf pt);
	void           LineToRawClip(Pointf pt);

private:
	void           SkipTo(Point pt, bool clockwise);
	void           Flush();
	AreaTool&      Horz(int x);
	AreaTool&      Vert(int y);
	Point          ClipBind(Pointf pt) const
	{
		return Point(
			pt.x < plotter.clip.left ? plotter.clip.left : pt.x > plotter.clip.right  ? plotter.clip.right  : fround(pt.x),
			pt.y < plotter.clip.top  ? plotter.clip.top  : pt.y > plotter.clip.bottom ? plotter.clip.bottom : fround(pt.y));
	}

private:
	enum { FLUSH_BATCH = 6000 };
	Vector<Point>  vertices;
	Vector<int>    counts;
	Vector<int>    disjunct_counts;
	Vector<int>    ghost_lines;
	bool           prev_ghost;
	int            begin_index;
	int            disjunct_begin_index;
	Pointf         last_phys;
	Pointf         last_start;
	Pointf         clip_center;
	bool           last_in;
	bool           std_pen;
	bool           simple;
	bool           is_line;

	int            point_pixels;
	Color          point_color;
	int            outline_pixels;
	PathDraw       raw_outline;
	Color          fill_outline_color;
	int            fill_outline_style;
	Color          thick_outline_color;
	uint64         fill_pattern;
	Color          fill_color;
};

class MarkTool {
public:
	class Marker {
	public:
		Marker() {}
		virtual ~Marker() {}

		virtual int  GetSize() const = 0;
		virtual void Paint(Draw& draw, const Vector<Point>& pt) = 0;
	};

	static One<Marker> Empty();
	static One<Marker> Square(int size = 10, Color color = LtRed, Color outline = Black, int outline_width = 0);
	static One<Marker> Triangle(int size = 10, Color color = LtRed, Color outline = Black, int outline_width = 0);
	static One<Marker> Circle(int size = 10, Color color = LtRed, Color outline = Black, int outline_width = 0);
	static One<Marker> Cross(int size = 10, Color outline = Black, int outline_width = 0);
	static One<Marker> Diamond(int size = 10, Color color = LtRed, Color outline = Black, int outline_width = 0);
	static One<Marker> Hexagon(int size = 10, Color color = LtRed, Color outline = Black, int outline_width = 0);
	static One<Marker> Star(int size = 10, Color color = LtRed, Color outline = Black, int outline_width = 0);
	static One<Marker> Square45(int size = 10, Color color = LtRed, Color outline = Black, int outline_width = 0);
	static One<Marker> Nabla(int size = 10, Color color = LtRed, Color outline = Black, int outline_width = 0);
	static One<Marker> Letter(char ascii, int angle = 0, Font font = StdFont(), Color color = LtRed, Color outline = Black);
	static One<Marker> Picture(Image pic, int size = 0, Color color = LtRed, bool antialias = false, bool ignore_hotspot = false);
	// angle in degrees, 360 = full circle

	enum { CIRCLE, SQUARE, TRIANGLE, CROSS, DIAMOND, HEXAGON, STAR, SQUARE45, NABLA, STD_MARK_COUNT }; // standard markers
	static One<Marker> StandardMarker(int type, int size = 10, Color color = LtRed, Color outline = Black, int outline_width = 0);

	MarkTool();
	virtual ~MarkTool();

	void             Set(const Plotter& info, One<Marker> marker);
	bool             SetExtent(const Rectf& rc);
	void             ClearExtent();

	virtual void     Paint(); // flush & clear paint buffer
	virtual void     Clear(); // clear paint buffer
	void             Flush();

	void             Put(Pointf pt)  { ASSERT(PutRaw); (this->*PutRaw)(pt); }

private:
	void             PutDummy(Pointf pt);
	void             PutClip(Pointf pt);
	void             PutSimple(Pointf pt);

private:
	void (MarkTool::*PutRaw)(Pointf pt);
	Vector<Point>    vertices;
	One<Marker>      marker;
	Plotter          plotter;
	int              size;
	enum { BUF_COUNT = 8192 };
};

class TextTool
{
public:
	TextTool();
	virtual ~TextTool();

	void Set(const Plotter& info, Font font = Arial(0), Color color = Black, Color outline = Null,
		double angle = 0, Alignment x_align = ALIGN_CENTER, Alignment y_align = ALIGN_CENTER,
		bool flip = false, int angle_prec = 24);
	// angle in radians

	void             SetFont(Font _font);
	void             SetColor(Color _color)          { color   = _color; }
	void             SetOutline(Color _outline)      { outline = _outline; }
	void             SetAngle(double _angle)         { angle   = _angle; }
	void             SetXAlign(Alignment _x)         { x_align = _x; }
	void             SetYAlign(Alignment _y)         { y_align = _y; }
	void             SetFlip(bool _flip)             { flip    = _flip; }

	void             Put(const String& text, Pointf pt, double angle);
	void             Put(const String& text, Pointf pt) { Put(text, pt, angle); }
	void             PutFlip(const String& text, Pointf pt, double angle);

	virtual void     Paint(); // flush & clear paint buffer
	virtual void     Clear(); // clear paint buffer

public:
	Plotter          plotter;
	Font             font;
	Color            color;
	Color            outline;
	double           angle;
	Alignment        x_align;
	Alignment        y_align;
	bool             flip;
	int              angle_prec;

private:
	void             Flush();
	void             ClearCache();

private:
	struct Type
	{
		int   height;
		short widths[256];

		Size  GetTextSize(const String& text) const;
	};

	struct Item
	{
		Item(Point point, const String& text, Color color, Color outline)
		: point(point), text(text), color(color), outline(outline) {}

		int    GetSize() const { return sizeof(*this) + text.GetLength(); }

		Point  point;
		String text;
		Color  color;
		Color  outline;
	};

	enum { CACHE_LIMIT = 1000000, FONT_LIMIT = 100 };
	int              cache_size;
	int              font_index;
	ArrayMap<Font, Type> font_map;
	VectorMap<int, Array<Item> > cache;
};

END_UPP_NAMESPACE
