You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
166 lines
5.1 KiB
166 lines
5.1 KiB
//---------------------------------------------------------------------------- |
|
// Anti-Grain Geometry - Version 2.4 |
|
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com) |
|
// |
|
// Permission to copy, use, modify, sell and distribute this software |
|
// is granted provided this copyright notice appears in all copies. |
|
// This software is provided "as is" without express or implied |
|
// warranty, and with no claim as to its suitability for any purpose. |
|
// |
|
//---------------------------------------------------------------------------- |
|
// Contact: mcseem@antigrain.com |
|
// mcseemagg@yahoo.com |
|
// http://www.antigrain.com |
|
//---------------------------------------------------------------------------- |
|
// |
|
// classes polygon_ctrl_impl, polygon_ctrl |
|
// |
|
//---------------------------------------------------------------------------- |
|
|
|
#ifndef POLYGON_CTRL_INCLUDED |
|
#define POLYGON_CTRL_INCLUDED |
|
|
|
#include "agg_array.h" |
|
#include "agg_conv_stroke.h" |
|
#include "agg_ellipse.h" |
|
#include "agg_color_rgba.h" |
|
#include "agg_ctrl.h" |
|
|
|
namespace agg |
|
{ |
|
class simple_polygon_vertex_source |
|
{ |
|
public: |
|
simple_polygon_vertex_source(const double* polygon, unsigned np, |
|
bool roundoff = false, |
|
bool close = true) : |
|
m_polygon(polygon), |
|
m_num_points(np), |
|
m_vertex(0), |
|
m_roundoff(roundoff), |
|
m_close(close) |
|
{ |
|
} |
|
|
|
void close(bool f) { m_close = f; } |
|
bool close() const { return m_close; } |
|
|
|
void rewind(unsigned) |
|
{ |
|
m_vertex = 0; |
|
} |
|
|
|
unsigned vertex(double* x, double* y) |
|
{ |
|
if(m_vertex > m_num_points) return path_cmd_stop; |
|
if(m_vertex == m_num_points) |
|
{ |
|
++m_vertex; |
|
return path_cmd_end_poly | (m_close ? path_flags_close : 0); |
|
} |
|
*x = m_polygon[m_vertex * 2]; |
|
*y = m_polygon[m_vertex * 2 + 1]; |
|
if(m_roundoff) |
|
{ |
|
*x = floor(*x) + 0.5; |
|
*y = floor(*y) + 0.5; |
|
} |
|
++m_vertex; |
|
return (m_vertex == 1) ? path_cmd_move_to : path_cmd_line_to; |
|
} |
|
|
|
private: |
|
const double* m_polygon; |
|
unsigned m_num_points; |
|
unsigned m_vertex; |
|
bool m_roundoff; |
|
bool m_close; |
|
}; |
|
|
|
|
|
|
|
|
|
class polygon_ctrl_impl : public ctrl |
|
{ |
|
public: |
|
polygon_ctrl_impl(unsigned np, double point_radius=5); |
|
|
|
unsigned num_points() const { return m_num_points; } |
|
double xn(unsigned n) const { return m_polygon[n * 2]; } |
|
double yn(unsigned n) const { return m_polygon[n * 2 + 1]; } |
|
double& xn(unsigned n) { return m_polygon[n * 2]; } |
|
double& yn(unsigned n) { return m_polygon[n * 2 + 1]; } |
|
|
|
const double* polygon() const { return &m_polygon[0]; } |
|
|
|
void line_width(double w) { m_stroke.width(w); } |
|
double line_width() const { return m_stroke.width(); } |
|
|
|
void point_radius(double r) { m_point_radius = r; } |
|
double point_radius() const { return m_point_radius; } |
|
|
|
void in_polygon_check(bool f) { m_in_polygon_check = f; } |
|
bool in_polygon_check() const { return m_in_polygon_check; } |
|
|
|
void close(bool f) { m_vs.close(f); } |
|
bool close() const { return m_vs.close(); } |
|
|
|
// Vertex source interface |
|
unsigned num_paths() { return 1; } |
|
void rewind(unsigned path_id); |
|
unsigned vertex(double* x, double* y); |
|
|
|
virtual bool in_rect(double x, double y) const; |
|
virtual bool on_mouse_button_down(double x, double y); |
|
virtual bool on_mouse_button_up(double x, double y); |
|
virtual bool on_mouse_move(double x, double y, bool button_flag); |
|
virtual bool on_arrow_keys(bool left, bool right, bool down, bool up); |
|
|
|
|
|
private: |
|
bool check_edge(unsigned i, double x, double y) const; |
|
bool point_in_polygon(double x, double y) const; |
|
|
|
pod_array<double> m_polygon; |
|
unsigned m_num_points; |
|
int m_node; |
|
int m_edge; |
|
simple_polygon_vertex_source m_vs; |
|
conv_stroke<simple_polygon_vertex_source> m_stroke; |
|
ellipse m_ellipse; |
|
double m_point_radius; |
|
unsigned m_status; |
|
double m_dx; |
|
double m_dy; |
|
bool m_in_polygon_check; |
|
}; |
|
|
|
|
|
|
|
//----------------------------------------------------------polygon_ctrl |
|
template<class ColorT> class polygon_ctrl : public polygon_ctrl_impl |
|
{ |
|
public: |
|
polygon_ctrl(unsigned np, double point_radius=5) : |
|
polygon_ctrl_impl(np, point_radius), |
|
m_color(rgba(0.0, 0.0, 0.0)) |
|
{ |
|
} |
|
|
|
void line_color(const ColorT& c) { m_color = c; } |
|
const ColorT& color(unsigned) const { return m_color; } |
|
|
|
private: |
|
polygon_ctrl(const polygon_ctrl<ColorT>&); |
|
const polygon_ctrl<ColorT>& operator = (const polygon_ctrl<ColorT>&); |
|
|
|
ColorT m_color; |
|
}; |
|
|
|
|
|
|
|
|
|
} |
|
|
|
#endif |
|
|
|
|