/usr/include/agg2/ctrl/agg_spline_ctrl.h is in libagg-dev 2.5+dfsg1-9.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 | //----------------------------------------------------------------------------
// Anti-Grain Geometry (AGG) - Version 2.5
// A high quality rendering engine for C++
// Copyright (C) 2002-2006 Maxim Shemanarev
// Contact: mcseem@antigrain.com
// mcseemagg@yahoo.com
// http://antigrain.com
//
// AGG is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// AGG is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with AGG; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
// MA 02110-1301, USA.
//----------------------------------------------------------------------------
#ifndef AGG_SPLINE_CTRL_INCLUDED
#define AGG_SPLINE_CTRL_INCLUDED
#include "agg_basics.h"
#include "agg_ellipse.h"
#include "agg_bspline.h"
#include "agg_conv_stroke.h"
#include "agg_path_storage.h"
#include "agg_trans_affine.h"
#include "agg_color_rgba.h"
#include "agg_ctrl.h"
namespace agg
{
//------------------------------------------------------------------------
// Class that can be used to create an interactive control to set up
// gamma arrays.
//------------------------------------------------------------------------
class spline_ctrl_impl : public ctrl
{
public:
spline_ctrl_impl(double x1, double y1, double x2, double y2,
unsigned num_pnt, bool flip_y=false);
// Set other parameters
void border_width(double t, double extra=0.0);
void curve_width(double t) { m_curve_width = t; }
void point_size(double s) { m_point_size = s; }
// Event handlers. Just call them if the respective events
// in your system occure. The functions return true if redrawing
// is required.
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);
void active_point(int i);
const double* spline() const { return m_spline_values; }
const int8u* spline8() const { return m_spline_values8; }
double value(double x) const;
void value(unsigned idx, double y);
void point(unsigned idx, double x, double y);
void x(unsigned idx, double x) { m_xp[idx] = x; }
void y(unsigned idx, double y) { m_yp[idx] = y; }
double x(unsigned idx) const { return m_xp[idx]; }
double y(unsigned idx) const { return m_yp[idx]; }
void update_spline();
// Vertex soutce interface
unsigned num_paths() { return 5; }
void rewind(unsigned path_id);
unsigned vertex(double* x, double* y);
private:
void calc_spline_box();
void calc_curve();
double calc_xp(unsigned idx);
double calc_yp(unsigned idx);
void set_xp(unsigned idx, double val);
void set_yp(unsigned idx, double val);
unsigned m_num_pnt;
double m_xp[32];
double m_yp[32];
bspline m_spline;
double m_spline_values[256];
int8u m_spline_values8[256];
double m_border_width;
double m_border_extra;
double m_curve_width;
double m_point_size;
double m_xs1;
double m_ys1;
double m_xs2;
double m_ys2;
path_storage m_curve_pnt;
conv_stroke<path_storage> m_curve_poly;
ellipse m_ellipse;
unsigned m_idx;
unsigned m_vertex;
double m_vx[32];
double m_vy[32];
int m_active_pnt;
int m_move_pnt;
double m_pdx;
double m_pdy;
const trans_affine* m_mtx;
};
template<class ColorT> class spline_ctrl : public spline_ctrl_impl
{
public:
spline_ctrl(double x1, double y1, double x2, double y2,
unsigned num_pnt, bool flip_y=false) :
spline_ctrl_impl(x1, y1, x2, y2, num_pnt, flip_y),
m_background_color(rgba(1.0, 1.0, 0.9)),
m_border_color(rgba(0.0, 0.0, 0.0)),
m_curve_color(rgba(0.0, 0.0, 0.0)),
m_inactive_pnt_color(rgba(0.0, 0.0, 0.0)),
m_active_pnt_color(rgba(1.0, 0.0, 0.0))
{
m_colors[0] = &m_background_color;
m_colors[1] = &m_border_color;
m_colors[2] = &m_curve_color;
m_colors[3] = &m_inactive_pnt_color;
m_colors[4] = &m_active_pnt_color;
}
// Set colors
void background_color(const ColorT& c) { m_background_color = c; }
void border_color(const ColorT& c) { m_border_color = c; }
void curve_color(const ColorT& c) { m_curve_color = c; }
void inactive_pnt_color(const ColorT& c) { m_inactive_pnt_color = c; }
void active_pnt_color(const ColorT& c) { m_active_pnt_color = c; }
const ColorT& color(unsigned i) const { return *m_colors[i]; }
private:
spline_ctrl(const spline_ctrl<ColorT>&);
const spline_ctrl<ColorT>& operator = (const spline_ctrl<ColorT>&);
ColorT m_background_color;
ColorT m_border_color;
ColorT m_curve_color;
ColorT m_inactive_pnt_color;
ColorT m_active_pnt_color;
ColorT* m_colors[5];
};
}
#endif
|