fixes #905 (Move clist_ng to deprecated)

10 files changed, 0 insertions, 3070 deletions

diff --git a/plugins/Clist_ng/AGG/src/ctrl/Makefile.am b/plugins/Clist_ng/AGG/src/ctrl/Makefile.am
deleted file mode 100644
index 2930b9dd5e..0000000000
--- a/plugins/Clist_ng/AGG/src/ctrl/Makefile.am
+++ /dev/null
@@ -1,11 +0,0 @@
-if ENABLE_CTRL

-INCLUDES = -I$(top_srcdir)/include

-

-noinst_LTLIBRARIES = libaggctrl.la

-

-libaggctrl_la_LDFLAGS = -no-undefined -version-info @AGG_LIB_VERSION@

-libaggctrl_la_SOURCES = agg_cbox_ctrl.cpp agg_gamma_ctrl.cpp agg_gamma_spline.cpp agg_rbox_ctrl.cpp \

-						agg_slider_ctrl.cpp agg_spline_ctrl.cpp agg_scale_ctrl.cpp \

-						agg_bezier_ctrl.cpp agg_polygon_ctrl.cpp 

-

-endif

diff --git a/plugins/Clist_ng/AGG/src/ctrl/agg_bezier_ctrl.cpp b/plugins/Clist_ng/AGG/src/ctrl/agg_bezier_ctrl.cpp
deleted file mode 100644
index ff278bd49a..0000000000
--- a/plugins/Clist_ng/AGG/src/ctrl/agg_bezier_ctrl.cpp
+++ /dev/null
@@ -1,375 +0,0 @@
-//----------------------------------------------------------------------------

-// 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.

-//----------------------------------------------------------------------------

-

-#include <string.h>

-#include <stdio.h>

-#include "ctrl/agg_bezier_ctrl.h"

-

-namespace agg

-{

-

-    //------------------------------------------------------------------------

-    bezier_ctrl_impl::bezier_ctrl_impl() :

-        ctrl(0,0,1,1,false),

-        m_stroke(m_curve),

-        m_poly(4, 5.0),

-        m_idx(0)

-    {

-        m_poly.in_polygon_check(false);

-        m_poly.xn(0) = 100.0;

-        m_poly.yn(0) =   0.0;

-        m_poly.xn(1) = 100.0;

-        m_poly.yn(1) =  50.0;

-        m_poly.xn(2) =  50.0;

-        m_poly.yn(2) = 100.0;

-        m_poly.xn(3) =   0.0;

-        m_poly.yn(3) = 100.0;

-    }

-

-

-    //------------------------------------------------------------------------

-    void bezier_ctrl_impl::curve(double x1, double y1, 

-                                 double x2, double y2, 

-                                 double x3, double y3,

-                                 double x4, double y4)

-    {

-        m_poly.xn(0) = x1;

-        m_poly.yn(0) = y1;

-        m_poly.xn(1) = x2;

-        m_poly.yn(1) = y2;

-        m_poly.xn(2) = x3;

-        m_poly.yn(2) = y3;

-        m_poly.xn(3) = x4;

-        m_poly.yn(3) = y4;

-        curve();

-    }

-

-    //------------------------------------------------------------------------

-    curve4& bezier_ctrl_impl::curve()

-    {

-        m_curve.init(m_poly.xn(0), m_poly.yn(0),

-                     m_poly.xn(1), m_poly.yn(1),

-                     m_poly.xn(2), m_poly.yn(2),

-                     m_poly.xn(3), m_poly.yn(3));

-        return m_curve;

-    }

-

-    //------------------------------------------------------------------------

-    void bezier_ctrl_impl::rewind(unsigned idx)

-    {

-        m_idx = idx;

-

-        m_curve.approximation_scale(scale());

-        switch(idx)

-        {

-        default:

-        case 0:                 // Control line 1

-            m_curve.init(m_poly.xn(0),  m_poly.yn(0), 

-                        (m_poly.xn(0) + m_poly.xn(1)) * 0.5,

-                        (m_poly.yn(0) + m_poly.yn(1)) * 0.5,

-                        (m_poly.xn(0) + m_poly.xn(1)) * 0.5,

-                        (m_poly.yn(0) + m_poly.yn(1)) * 0.5,

-                         m_poly.xn(1),  m_poly.yn(1));

-            m_stroke.rewind(0);

-            break;

-

-        case 1:                 // Control line 2

-            m_curve.init(m_poly.xn(2),  m_poly.yn(2), 

-                        (m_poly.xn(2) + m_poly.xn(3)) * 0.5,

-                        (m_poly.yn(2) + m_poly.yn(3)) * 0.5,

-                        (m_poly.xn(2) + m_poly.xn(3)) * 0.5,

-                        (m_poly.yn(2) + m_poly.yn(3)) * 0.5,

-                         m_poly.xn(3),  m_poly.yn(3));

-            m_stroke.rewind(0);

-            break;

-

-        case 2:                 // Curve itself

-            m_curve.init(m_poly.xn(0), m_poly.yn(0), 

-                         m_poly.xn(1), m_poly.yn(1),

-                         m_poly.xn(2), m_poly.yn(2),

-                         m_poly.xn(3), m_poly.yn(3));

-            m_stroke.rewind(0);

-            break;

-

-        case 3:                 // Point 1

-            m_ellipse.init(m_poly.xn(0), m_poly.yn(0), point_radius(), point_radius(), 20);

-            m_ellipse.rewind(0);

-            break;

-

-        case 4:                 // Point 2

-            m_ellipse.init(m_poly.xn(1), m_poly.yn(1), point_radius(), point_radius(), 20);

-            m_ellipse.rewind(0);

-            break;

-

-        case 5:                 // Point 3

-            m_ellipse.init(m_poly.xn(2), m_poly.yn(2), point_radius(), point_radius(), 20);

-            m_ellipse.rewind(0);

-            break;

-

-        case 6:                 // Point 4

-            m_ellipse.init(m_poly.xn(3), m_poly.yn(3), point_radius(), point_radius(), 20);

-            m_ellipse.rewind(0);

-            break;

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    unsigned bezier_ctrl_impl::vertex(double* x, double* y)

-    {

-        unsigned cmd = path_cmd_stop;

-        switch(m_idx)

-        {

-        case 0:

-        case 1:

-        case 2:

-            cmd = m_stroke.vertex(x, y);

-            break;

-

-        case 3:

-        case 4:

-        case 5:

-        case 6:

-        case 7:

-            cmd = m_ellipse.vertex(x, y);

-            break;

-        }

-

-        if(!is_stop(cmd))

-        {

-            transform_xy(x, y);

-        }

-        return cmd;

-    }

-

-

-

-    //------------------------------------------------------------------------

-    bool bezier_ctrl_impl::in_rect(double x, double y) const

-    {

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool bezier_ctrl_impl::on_mouse_button_down(double x, double y)

-    {

-        inverse_transform_xy(&x, &y);

-        return m_poly.on_mouse_button_down(x, y);

-    }

-

-

-    //------------------------------------------------------------------------

-    bool bezier_ctrl_impl::on_mouse_move(double x, double y, bool button_flag)

-    {

-        inverse_transform_xy(&x, &y);

-        return m_poly.on_mouse_move(x, y, button_flag);

-    }

-

-

-    //------------------------------------------------------------------------

-    bool bezier_ctrl_impl::on_mouse_button_up(double x, double y)

-    {

-        return m_poly.on_mouse_button_up(x, y);

-    }

-

-

-    //------------------------------------------------------------------------

-    bool bezier_ctrl_impl::on_arrow_keys(bool left, bool right, bool down, bool up)

-    {

-        return m_poly.on_arrow_keys(left, right, down, up);

-    }

-

-

-

-

-

-

-    //------------------------------------------------------------------------

-    curve3_ctrl_impl::curve3_ctrl_impl() :

-        ctrl(0,0,1,1,false),

-        m_stroke(m_curve),

-        m_poly(3, 5.0),

-        m_idx(0)

-    {

-        m_poly.in_polygon_check(false);

-        m_poly.xn(0) = 100.0;

-        m_poly.yn(0) =   0.0;

-        m_poly.xn(1) = 100.0;

-        m_poly.yn(1) =  50.0;

-        m_poly.xn(2) =  50.0;

-        m_poly.yn(2) = 100.0;

-    }

-

-

-    //------------------------------------------------------------------------

-    void curve3_ctrl_impl::curve(double x1, double y1, 

-                                 double x2, double y2, 

-                                 double x3, double y3)

-    {

-        m_poly.xn(0) = x1;

-        m_poly.yn(0) = y1;

-        m_poly.xn(1) = x2;

-        m_poly.yn(1) = y2;

-        m_poly.xn(2) = x3;

-        m_poly.yn(2) = y3;

-        curve();

-    }

-

-    //------------------------------------------------------------------------

-    curve3& curve3_ctrl_impl::curve()

-    {

-        m_curve.init(m_poly.xn(0), m_poly.yn(0),

-                     m_poly.xn(1), m_poly.yn(1),

-                     m_poly.xn(2), m_poly.yn(2));

-        return m_curve;

-    }

-

-    //------------------------------------------------------------------------

-    void curve3_ctrl_impl::rewind(unsigned idx)

-    {

-        m_idx = idx;

-

-        switch(idx)

-        {

-        default:

-        case 0:                 // Control line

-            m_curve.init(m_poly.xn(0),  m_poly.yn(0), 

-                        (m_poly.xn(0) + m_poly.xn(1)) * 0.5,

-                        (m_poly.yn(0) + m_poly.yn(1)) * 0.5,

-                         m_poly.xn(1),  m_poly.yn(1));

-            m_stroke.rewind(0);

-            break;

-

-        case 1:                 // Control line 2

-            m_curve.init(m_poly.xn(1),  m_poly.yn(1), 

-                        (m_poly.xn(1) + m_poly.xn(2)) * 0.5,

-                        (m_poly.yn(1) + m_poly.yn(2)) * 0.5,

-                         m_poly.xn(2),  m_poly.yn(2));

-            m_stroke.rewind(0);

-            break;

-

-        case 2:                 // Curve itself

-            m_curve.init(m_poly.xn(0), m_poly.yn(0), 

-                         m_poly.xn(1), m_poly.yn(1),

-                         m_poly.xn(2), m_poly.yn(2));

-            m_stroke.rewind(0);

-            break;

-

-        case 3:                 // Point 1

-            m_ellipse.init(m_poly.xn(0), m_poly.yn(0), point_radius(), point_radius(), 20);

-            m_ellipse.rewind(0);

-            break;

-

-        case 4:                 // Point 2

-            m_ellipse.init(m_poly.xn(1), m_poly.yn(1), point_radius(), point_radius(), 20);

-            m_ellipse.rewind(0);

-            break;

-

-        case 5:                 // Point 3

-            m_ellipse.init(m_poly.xn(2), m_poly.yn(2), point_radius(), point_radius(), 20);

-            m_ellipse.rewind(0);

-            break;

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    unsigned curve3_ctrl_impl::vertex(double* x, double* y)

-    {

-        unsigned cmd = path_cmd_stop;

-        switch(m_idx)

-        {

-        case 0:

-        case 1:

-        case 2:

-            cmd = m_stroke.vertex(x, y);

-            break;

-

-        case 3:

-        case 4:

-        case 5:

-        case 6:

-            cmd = m_ellipse.vertex(x, y);

-            break;

-        }

-

-        if(!is_stop(cmd))

-        {

-            transform_xy(x, y);

-        }

-        return cmd;

-    }

-

-

-

-    //------------------------------------------------------------------------

-    bool curve3_ctrl_impl::in_rect(double x, double y) const

-    {

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool curve3_ctrl_impl::on_mouse_button_down(double x, double y)

-    {

-        inverse_transform_xy(&x, &y);

-        return m_poly.on_mouse_button_down(x, y);

-    }

-

-

-    //------------------------------------------------------------------------

-    bool curve3_ctrl_impl::on_mouse_move(double x, double y, bool button_flag)

-    {

-        inverse_transform_xy(&x, &y);

-        return m_poly.on_mouse_move(x, y, button_flag);

-    }

-

-

-    //------------------------------------------------------------------------

-    bool curve3_ctrl_impl::on_mouse_button_up(double x, double y)

-    {

-        return m_poly.on_mouse_button_up(x, y);

-    }

-

-

-    //------------------------------------------------------------------------

-    bool curve3_ctrl_impl::on_arrow_keys(bool left, bool right, bool down, bool up)

-    {

-        return m_poly.on_arrow_keys(left, right, down, up);

-    }

-

-

-

-

-

-

-

-

-

-

-

-

-}

-

diff --git a/plugins/Clist_ng/AGG/src/ctrl/agg_cbox_ctrl.cpp b/plugins/Clist_ng/AGG/src/ctrl/agg_cbox_ctrl.cpp
deleted file mode 100644
index 3753475ca6..0000000000
--- a/plugins/Clist_ng/AGG/src/ctrl/agg_cbox_ctrl.cpp
+++ /dev/null
@@ -1,219 +0,0 @@
-//----------------------------------------------------------------------------

-// 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.

-//----------------------------------------------------------------------------

-

-#include <string.h>

-#include "ctrl/agg_cbox_ctrl.h"

-

-

-namespace agg

-{

-

-    //------------------------------------------------------------------------

-    cbox_ctrl_impl::cbox_ctrl_impl(double x, double y, 

-                                   const char* l, 

-                                   bool flip_y) :

-        ctrl(x, y, x + 9.0 * 1.5, y + 9.0 * 1.5, flip_y),

-        m_text_thickness(1.5),

-        m_text_height(9.0),

-        m_text_width(0.0),

-        m_status(false),

-        m_text_poly(m_text)

-    {

-        label(l);

-    }

-

-

-    //------------------------------------------------------------------------

-    void cbox_ctrl_impl::text_size(double h, double w)

-    {

-        m_text_width = w; 

-        m_text_height = h; 

-    }

-

-    //------------------------------------------------------------------------

-    void cbox_ctrl_impl::label(const char* l)

-    {

-        unsigned len = strlen(l);

-        if(len > 127) len = 127;

-        memcpy(m_label, l, len);

-        m_label[len] = 0;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool cbox_ctrl_impl::on_mouse_button_down(double x, double y)

-    {

-        inverse_transform_xy(&x, &y);

-        if(x >= m_x1 && y >= m_y1 && x <= m_x2 && y <= m_y2)

-        {

-            m_status = !m_status;

-            return true;

-        }

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool cbox_ctrl_impl::on_mouse_move(double, double, bool)

-    {

-        return false;

-    }

-

-    //------------------------------------------------------------------------

-    bool cbox_ctrl_impl::in_rect(double x, double y) const

-    {

-        inverse_transform_xy(&x, &y);

-        return x >= m_x1 && y >= m_y1 && x <= m_x2 && y <= m_y2;

-    }

-

-    //------------------------------------------------------------------------

-    bool cbox_ctrl_impl::on_mouse_button_up(double, double)

-    {

-        return false;

-    }

-

-    //------------------------------------------------------------------------

-    bool cbox_ctrl_impl::on_arrow_keys(bool, bool, bool, bool)

-    {

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    void cbox_ctrl_impl::rewind(unsigned idx)

-    {

-        m_idx = idx;

-

-        double d2;

-        double t;

-

-        switch(idx)

-        {

-        default:

-        case 0:                 // Border

-            m_vertex = 0;

-            m_vx[0] = m_x1; 

-            m_vy[0] = m_y1;

-            m_vx[1] = m_x2;

-            m_vy[1] = m_y1;

-            m_vx[2] = m_x2;

-            m_vy[2] = m_y2;

-            m_vx[3] = m_x1; 

-            m_vy[3] = m_y2;

-            m_vx[4] = m_x1 + m_text_thickness; 

-            m_vy[4] = m_y1 + m_text_thickness; 

-            m_vx[5] = m_x1 + m_text_thickness; 

-            m_vy[5] = m_y2 - m_text_thickness;

-            m_vx[6] = m_x2 - m_text_thickness;

-            m_vy[6] = m_y2 - m_text_thickness;

-            m_vx[7] = m_x2 - m_text_thickness;

-            m_vy[7] = m_y1 + m_text_thickness; 

-            break;

-

-        case 1:                 // Text

-            m_text.text(m_label);

-            m_text.start_point(m_x1 + m_text_height * 2.0, m_y1 + m_text_height / 5.0);

-            m_text.size(m_text_height, m_text_width);

-            m_text_poly.width(m_text_thickness);

-            m_text_poly.line_join(round_join);

-            m_text_poly.line_cap(round_cap);

-            m_text_poly.rewind(0);

-            break;

-

-        case 2:                 // Active item

-            m_vertex = 0;

-            d2 = (m_y2 - m_y1) / 2.0;

-            t = m_text_thickness * 1.5;

-            m_vx[0] = m_x1 + m_text_thickness;

-            m_vy[0] = m_y1 + m_text_thickness;

-            m_vx[1] = m_x1 + d2;

-            m_vy[1] = m_y1 + d2 - t;

-            m_vx[2] = m_x2 - m_text_thickness;

-            m_vy[2] = m_y1 + m_text_thickness;

-            m_vx[3] = m_x1 + d2 + t;

-            m_vy[3] = m_y1 + d2;

-            m_vx[4] = m_x2 - m_text_thickness;

-            m_vy[4] = m_y2 - m_text_thickness;

-            m_vx[5] = m_x1 + d2;

-            m_vy[5] = m_y1 + d2 + t;

-            m_vx[6] = m_x1 + m_text_thickness;

-            m_vy[6] = m_y2 - m_text_thickness;

-            m_vx[7] = m_x1 + d2 - t;

-            m_vy[7] = m_y1 + d2;

-            break;

-

-        }

-    }

-

-

-

-

-    //------------------------------------------------------------------------

-    unsigned cbox_ctrl_impl::vertex(double* x, double* y)

-    {

-        unsigned cmd = path_cmd_line_to;

-        switch(m_idx)

-        {

-        case 0:

-            if(m_vertex == 0 || m_vertex == 4) cmd = path_cmd_move_to;

-            if(m_vertex >= 8) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-            m_vertex++;

-            break;

-

-        case 1:

-            cmd = m_text_poly.vertex(x, y);

-            break;

-

-        case 2:

-            if(m_status)

-            {

-                if(m_vertex == 0) cmd = path_cmd_move_to;

-                if(m_vertex >= 8) cmd = path_cmd_stop;

-                *x = m_vx[m_vertex];

-                *y = m_vy[m_vertex];

-                m_vertex++;

-            }

-            else

-            {

-                cmd = path_cmd_stop;

-            }

-            break;

-

-        default:

-            cmd = path_cmd_stop;

-            break;

-        }

-

-        if(!is_stop(cmd))

-        {

-            transform_xy(x, y);

-        }

-        return cmd;

-    }

-}

-

-

-

diff --git a/plugins/Clist_ng/AGG/src/ctrl/agg_gamma_ctrl.cpp b/plugins/Clist_ng/AGG/src/ctrl/agg_gamma_ctrl.cpp
deleted file mode 100644
index 9521bab9fd..0000000000
--- a/plugins/Clist_ng/AGG/src/ctrl/agg_gamma_ctrl.cpp
+++ /dev/null
@@ -1,438 +0,0 @@
-//----------------------------------------------------------------------------

-// 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.

-//----------------------------------------------------------------------------

-

-#include <stdio.h>

-#include "agg_math.h"

-#include "ctrl/agg_gamma_ctrl.h"

-

-namespace agg

-{

-

-    //------------------------------------------------------------------------

-    gamma_ctrl_impl::gamma_ctrl_impl(double x1, double y1, double x2, double y2, bool flip_y) :

-        ctrl(x1, y1, x2, y2, flip_y),

-        m_border_width(2.0),

-        m_border_extra(0.0),

-        m_curve_width(2.0),

-        m_grid_width(0.2),

-        m_text_thickness(1.5),

-        m_point_size(5.0),

-        m_text_height(9.0),

-        m_text_width(0.0),

-        m_xc1(x1),

-        m_yc1(y1),

-        m_xc2(x2),

-        m_yc2(y2 - m_text_height * 2.0),

-        m_xt1(x1),

-        m_yt1(y2 - m_text_height * 2.0),

-        m_xt2(x2),

-        m_yt2(y2),

-        m_curve_poly(m_gamma_spline),

-        m_text_poly(m_text),

-        m_idx(0),

-        m_vertex(0),

-        m_p1_active(true),

-        m_mouse_point(0),

-        m_pdx(0.0),

-        m_pdy(0.0)

-    {

-        calc_spline_box();

-    }

-

-

-    //------------------------------------------------------------------------

-    void gamma_ctrl_impl::calc_spline_box()

-    {

-        m_xs1 = m_xc1 + m_border_width;

-        m_ys1 = m_yc1 + m_border_width;

-        m_xs2 = m_xc2 - m_border_width;

-        m_ys2 = m_yc2 - m_border_width * 0.5;

-    }

-

-

-    //------------------------------------------------------------------------

-    void gamma_ctrl_impl::calc_points()

-    {

-        double kx1, ky1, kx2, ky2;

-        m_gamma_spline.values(&kx1, &ky1, &kx2, &ky2);

-        m_xp1 = m_xs1 + (m_xs2 - m_xs1) * kx1 * 0.25;

-        m_yp1 = m_ys1 + (m_ys2 - m_ys1) * ky1 * 0.25;

-        m_xp2 = m_xs2 - (m_xs2 - m_xs1) * kx2 * 0.25;

-        m_yp2 = m_ys2 - (m_ys2 - m_ys1) * ky2 * 0.25;

-    }

-

-

-    //------------------------------------------------------------------------

-    void gamma_ctrl_impl::calc_values()

-    {

-        double kx1, ky1, kx2, ky2;

-

-        kx1 = (m_xp1 - m_xs1) * 4.0 / (m_xs2 - m_xs1);

-        ky1 = (m_yp1 - m_ys1) * 4.0 / (m_ys2 - m_ys1);

-        kx2 = (m_xs2 - m_xp2) * 4.0 / (m_xs2 - m_xs1);

-        ky2 = (m_ys2 - m_yp2) * 4.0 / (m_ys2 - m_ys1);

-        m_gamma_spline.values(kx1, ky1, kx2, ky2);

-    }

-

-

-    //------------------------------------------------------------------------

-    void gamma_ctrl_impl::text_size(double h, double w) 

-    { 

-        m_text_width = w; 

-        m_text_height = h; 

-        m_yc2 = m_y2 - m_text_height * 2.0;

-        m_yt1 = m_y2 - m_text_height * 2.0;

-        calc_spline_box();

-    }

-

-

-    //------------------------------------------------------------------------

-    void gamma_ctrl_impl::border_width(double t, double extra)

-    { 

-        m_border_width = t; 

-        m_border_extra = extra;

-        calc_spline_box(); 

-    }

-

-    //------------------------------------------------------------------------

-    void gamma_ctrl_impl::values(double kx1, double ky1, double kx2, double ky2)

-    {

-        m_gamma_spline.values(kx1, ky1, kx2, ky2);

-    }

-

-

-    //------------------------------------------------------------------------

-    void gamma_ctrl_impl::values(double* kx1, double* ky1, double* kx2, double* ky2) const

-    {

-        m_gamma_spline.values(kx1, ky1, kx2, ky2);

-    }

-

-    //------------------------------------------------------------------------

-    void  gamma_ctrl_impl::rewind(unsigned idx)

-    {

-        double kx1, ky1, kx2, ky2;

-        char tbuf[32];

-

-        m_idx = idx;

-

-        switch(idx)

-        {

-        default:

-

-        case 0:                 // Background

-            m_vertex = 0;

-            m_vx[0] = m_x1 - m_border_extra; 

-            m_vy[0] = m_y1 - m_border_extra;

-            m_vx[1] = m_x2 + m_border_extra; 

-            m_vy[1] = m_y1 - m_border_extra;

-            m_vx[2] = m_x2 + m_border_extra; 

-            m_vy[2] = m_y2 + m_border_extra;

-            m_vx[3] = m_x1 - m_border_extra; 

-            m_vy[3] = m_y2 + m_border_extra;

-            break;

-

-        case 1:                 // Border

-            m_vertex = 0;

-            m_vx[0] = m_x1; 

-            m_vy[0] = m_y1;

-            m_vx[1] = m_x2; 

-            m_vy[1] = m_y1;

-            m_vx[2] = m_x2; 

-            m_vy[2] = m_y2;

-            m_vx[3] = m_x1; 

-            m_vy[3] = m_y2;

-            m_vx[4] = m_x1 + m_border_width; 

-            m_vy[4] = m_y1 + m_border_width; 

-            m_vx[5] = m_x1 + m_border_width; 

-            m_vy[5] = m_y2 - m_border_width; 

-            m_vx[6] = m_x2 - m_border_width; 

-            m_vy[6] = m_y2 - m_border_width; 

-            m_vx[7] = m_x2 - m_border_width; 

-            m_vy[7] = m_y1 + m_border_width; 

-            m_vx[8] = m_xc1 + m_border_width;

-            m_vy[8] = m_yc2 - m_border_width * 0.5;

-            m_vx[9] = m_xc2 - m_border_width;

-            m_vy[9] = m_yc2 - m_border_width * 0.5;

-            m_vx[10] = m_xc2 - m_border_width;

-            m_vy[10] = m_yc2 + m_border_width * 0.5;

-            m_vx[11] = m_xc1 + m_border_width;

-            m_vy[11] = m_yc2 + m_border_width * 0.5;

-            break;

-

-        case 2:                 // Curve

-            m_gamma_spline.box(m_xs1, m_ys1, m_xs2, m_ys2);

-            m_curve_poly.width(m_curve_width);

-            m_curve_poly.rewind(0);

-            break;

-

-        case 3:                 // Grid

-            m_vertex = 0;

-            m_vx[0] = m_xs1;

-            m_vy[0] = (m_ys1 + m_ys2) * 0.5 - m_grid_width * 0.5;

-            m_vx[1] = m_xs2;

-            m_vy[1] = (m_ys1 + m_ys2) * 0.5 - m_grid_width * 0.5;

-            m_vx[2] = m_xs2;

-            m_vy[2] = (m_ys1 + m_ys2) * 0.5 + m_grid_width * 0.5;

-            m_vx[3] = m_xs1;

-            m_vy[3] = (m_ys1 + m_ys2) * 0.5 + m_grid_width * 0.5;

-            m_vx[4] = (m_xs1 + m_xs2) * 0.5 - m_grid_width * 0.5;

-            m_vy[4] = m_ys1;

-            m_vx[5] = (m_xs1 + m_xs2) * 0.5 - m_grid_width * 0.5;

-            m_vy[5] = m_ys2;

-            m_vx[6] = (m_xs1 + m_xs2) * 0.5 + m_grid_width * 0.5;

-            m_vy[6] = m_ys2;

-            m_vx[7] = (m_xs1 + m_xs2) * 0.5 + m_grid_width * 0.5;

-            m_vy[7] = m_ys1;

-            calc_points();

-            m_vx[8] = m_xs1;

-            m_vy[8] = m_yp1 - m_grid_width * 0.5;

-            m_vx[9] = m_xp1 - m_grid_width * 0.5;

-            m_vy[9] = m_yp1 - m_grid_width * 0.5;

-            m_vx[10] = m_xp1 - m_grid_width * 0.5;

-            m_vy[10] = m_ys1;

-            m_vx[11] = m_xp1 + m_grid_width * 0.5;

-            m_vy[11] = m_ys1;

-            m_vx[12] = m_xp1 + m_grid_width * 0.5;

-            m_vy[12] = m_yp1 + m_grid_width * 0.5;

-            m_vx[13] = m_xs1;

-            m_vy[13] = m_yp1 + m_grid_width * 0.5;

-            m_vx[14] = m_xs2;

-            m_vy[14] = m_yp2 + m_grid_width * 0.5;

-            m_vx[15] = m_xp2 + m_grid_width * 0.5;

-            m_vy[15] = m_yp2 + m_grid_width * 0.5;

-            m_vx[16] = m_xp2 + m_grid_width * 0.5;

-            m_vy[16] = m_ys2;

-            m_vx[17] = m_xp2 - m_grid_width * 0.5;

-            m_vy[17] = m_ys2;

-            m_vx[18] = m_xp2 - m_grid_width * 0.5;

-            m_vy[18] = m_yp2 - m_grid_width * 0.5;

-            m_vx[19] = m_xs2;

-            m_vy[19] = m_yp2 - m_grid_width * 0.5;

-            break;

-

-        case 4:                 // Point1

-            calc_points();

-            if(m_p1_active) m_ellipse.init(m_xp2, m_yp2, m_point_size, m_point_size, 32);

-            else            m_ellipse.init(m_xp1, m_yp1, m_point_size, m_point_size, 32);

-            break;

-

-        case 5:                 // Point2

-            calc_points();

-            if(m_p1_active) m_ellipse.init(m_xp1, m_yp1, m_point_size, m_point_size, 32);

-            else            m_ellipse.init(m_xp2, m_yp2, m_point_size, m_point_size, 32);

-            break;

-

-        case 6:                 // Text

-            m_gamma_spline.values(&kx1, &ky1, &kx2, &ky2);

-            sprintf(tbuf, "%5.3f %5.3f %5.3f %5.3f", kx1, ky1, kx2, ky2);

-            m_text.text(tbuf);

-            m_text.size(m_text_height, m_text_width);

-            m_text.start_point(m_xt1 + m_border_width * 2.0, (m_yt1 + m_yt2) * 0.5 - m_text_height * 0.5);

-            m_text_poly.width(m_text_thickness);

-            m_text_poly.line_join(round_join);

-            m_text_poly.line_cap(round_cap);

-            m_text_poly.rewind(0);

-            break;

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    unsigned gamma_ctrl_impl::vertex(double* x, double* y)

-    {

-        unsigned cmd = path_cmd_line_to;

-        switch(m_idx)

-        {

-        case 0:

-            if(m_vertex == 0) cmd = path_cmd_move_to;

-            if(m_vertex >= 4) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-            m_vertex++;

-            break;

-

-        case 1:

-            if(m_vertex == 0 || m_vertex == 4 || m_vertex == 8) cmd = path_cmd_move_to;

-            if(m_vertex >= 12) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-            m_vertex++;

-            break;

-

-        case 2:

-            cmd = m_curve_poly.vertex(x, y);

-            break;

-

-        case 3:

-            if(m_vertex == 0  || 

-               m_vertex == 4  || 

-               m_vertex == 8  ||

-               m_vertex == 14) cmd = path_cmd_move_to;

-

-            if(m_vertex >= 20) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-            m_vertex++;

-            break;

-

-        case 4:                 // Point1

-        case 5:                 // Point2

-            cmd = m_ellipse.vertex(x, y);

-            break;

-

-        case 6:

-            cmd = m_text_poly.vertex(x, y);

-            break;

-

-        default:

-            cmd = path_cmd_stop;

-            break;

-        }

-

-        if(!is_stop(cmd))

-        {

-            transform_xy(x, y);

-        }

-

-        return cmd;

-    }

-

-

-

-    //------------------------------------------------------------------------

-    bool gamma_ctrl_impl::on_arrow_keys(bool left, bool right, bool down, bool up)

-    {

-        double kx1, ky1, kx2, ky2;

-        bool ret = false;

-        m_gamma_spline.values(&kx1, &ky1, &kx2, &ky2);

-        if(m_p1_active)

-        {

-            if(left)  { kx1 -= 0.005; ret = true; }

-            if(right) { kx1 += 0.005; ret = true; }

-            if(down)  { ky1 -= 0.005; ret = true; }

-            if(up)    { ky1 += 0.005; ret = true; }

-        }

-        else

-        {

-            if(left)  { kx2 += 0.005; ret = true; }

-            if(right) { kx2 -= 0.005; ret = true; }

-            if(down)  { ky2 += 0.005; ret = true; }

-            if(up)    { ky2 -= 0.005; ret = true; }

-        }

-        if(ret)

-        {

-            m_gamma_spline.values(kx1, ky1, kx2, ky2);

-        }

-        return ret;

-    }

-

-

-    

-    //------------------------------------------------------------------------

-    void gamma_ctrl_impl::change_active_point()

-    {

-        m_p1_active = m_p1_active ? false : true;

-    }

-

-

-

-

-    //------------------------------------------------------------------------

-    bool gamma_ctrl_impl::in_rect(double x, double y) const

-    {

-        inverse_transform_xy(&x, &y);

-        return x >= m_x1 && x <= m_x2 && y >= m_y1 && y <= m_y2;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool gamma_ctrl_impl::on_mouse_button_down(double x, double y)

-    {

-        inverse_transform_xy(&x, &y);

-        calc_points();

-

-        if(calc_distance(x, y, m_xp1, m_yp1) <= m_point_size + 1)

-        {

-            m_mouse_point = 1;

-            m_pdx = m_xp1 - x;

-            m_pdy = m_yp1 - y;

-            m_p1_active = true;

-            return true;

-        }

-

-        if(calc_distance(x, y, m_xp2, m_yp2) <= m_point_size + 1)

-        {

-            m_mouse_point = 2;

-            m_pdx = m_xp2 - x;

-            m_pdy = m_yp2 - y;

-            m_p1_active = false;

-            return true;

-        }

-

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool gamma_ctrl_impl::on_mouse_button_up(double, double)

-    {

-        if(m_mouse_point)

-        {

-            m_mouse_point = 0;

-            return true;

-        }

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool gamma_ctrl_impl::on_mouse_move(double x, double y, bool button_flag)

-    {

-        inverse_transform_xy(&x, &y);

-        if(!button_flag)

-        {

-            return on_mouse_button_up(x, y);

-        }

-

-        if(m_mouse_point == 1)

-        {

-            m_xp1 = x + m_pdx;

-            m_yp1 = y + m_pdy;

-            calc_values();

-            return true;

-        }

-        if(m_mouse_point == 2)

-        {

-            m_xp2 = x + m_pdx;

-            m_yp2 = y + m_pdy;

-            calc_values();

-            return true;

-        }

-        return false;

-    }

-

-

-

-}

-

diff --git a/plugins/Clist_ng/AGG/src/ctrl/agg_gamma_spline.cpp b/plugins/Clist_ng/AGG/src/ctrl/agg_gamma_spline.cpp
deleted file mode 100644
index 10de9c397e..0000000000
--- a/plugins/Clist_ng/AGG/src/ctrl/agg_gamma_spline.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-//----------------------------------------------------------------------------

-// 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.

-//----------------------------------------------------------------------------

-

-#include "ctrl/agg_gamma_spline.h"

-

-namespace agg

-{

-

-    //------------------------------------------------------------------------

-    gamma_spline::gamma_spline() : 

-        m_x1(0), m_y1(0), m_x2(10), m_y2(10), m_cur_x(0.0)

-    {

-        values(1.0, 1.0, 1.0, 1.0);

-    }

-

-

-    //------------------------------------------------------------------------

-    double gamma_spline::y(double x) const 

-    { 

-        if(x < 0.0) x = 0.0;

-        if(x > 1.0) x = 1.0;

-        double val = m_spline.get(x);

-        if(val < 0.0) val = 0.0;

-        if(val > 1.0) val = 1.0;

-        return val;

-    }

-

-

-

-    //------------------------------------------------------------------------

-    void gamma_spline::values(double kx1, double ky1, double kx2, double ky2)

-    {

-        if(kx1 < 0.001) kx1 = 0.001;

-        if(kx1 > 1.999) kx1 = 1.999;

-        if(ky1 < 0.001) ky1 = 0.001;

-        if(ky1 > 1.999) ky1 = 1.999;

-        if(kx2 < 0.001) kx2 = 0.001;

-        if(kx2 > 1.999) kx2 = 1.999;

-        if(ky2 < 0.001) ky2 = 0.001;

-        if(ky2 > 1.999) ky2 = 1.999;

-

-        m_x[0] = 0.0;

-        m_y[0] = 0.0;

-        m_x[1] = kx1 * 0.25;

-        m_y[1] = ky1 * 0.25;

-        m_x[2] = 1.0 - kx2 * 0.25;

-        m_y[2] = 1.0 - ky2 * 0.25;

-        m_x[3] = 1.0;

-        m_y[3] = 1.0;

-

-        m_spline.init(4, m_x, m_y);

-

-        int i;

-        for(i = 0; i < 256; i++)

-        {

-            m_gamma[i] = (unsigned char)(y(double(i) / 255.0) * 255.0);

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    void gamma_spline::values(double* kx1, double* ky1, double* kx2, double* ky2) const

-    {

-        *kx1 = m_x[1] * 4.0;

-        *ky1 = m_y[1] * 4.0;

-        *kx2 = (1.0 - m_x[2]) * 4.0;

-        *ky2 = (1.0 - m_y[2]) * 4.0;

-    }

-

-

-    //------------------------------------------------------------------------

-    void gamma_spline::box(double x1, double y1, double x2, double y2)

-    {

-        m_x1 = x1;

-        m_y1 = y1;

-        m_x2 = x2;

-        m_y2 = y2;

-    }

-

-

-    //------------------------------------------------------------------------

-    void gamma_spline::rewind(unsigned)

-    {

-        m_cur_x = 0.0;

-    }

-

-

-    //------------------------------------------------------------------------

-    unsigned gamma_spline::vertex(double* vx, double* vy)

-    {

-        if(m_cur_x == 0.0) 

-        {

-            *vx = m_x1;

-            *vy = m_y1;

-            m_cur_x += 1.0 / (m_x2 - m_x1);

-            return path_cmd_move_to;

-        }

-

-        if(m_cur_x > 1.0) 

-        {

-            return path_cmd_stop;

-        }

-        

-        *vx = m_x1 + m_cur_x * (m_x2 - m_x1);

-        *vy = m_y1 + y(m_cur_x) * (m_y2 - m_y1);

-

-        m_cur_x += 1.0 / (m_x2 - m_x1);

-        return path_cmd_line_to;

-    }

-  

-

-

-}

-

diff --git a/plugins/Clist_ng/AGG/src/ctrl/agg_polygon_ctrl.cpp b/plugins/Clist_ng/AGG/src/ctrl/agg_polygon_ctrl.cpp
deleted file mode 100644
index 4dde1b7f89..0000000000
--- a/plugins/Clist_ng/AGG/src/ctrl/agg_polygon_ctrl.cpp
+++ /dev/null
@@ -1,337 +0,0 @@
-//----------------------------------------------------------------------------

-// 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.

-//----------------------------------------------------------------------------

-

-#include "ctrl/agg_polygon_ctrl.h"

-

-namespace agg

-{

-

-    polygon_ctrl_impl::polygon_ctrl_impl(unsigned np, double point_radius) :

-        ctrl(0, 0, 1, 1, false),

-        m_polygon(np * 2),

-        m_num_points(np),

-        m_node(-1),

-        m_edge(-1),

-        m_vs(&m_polygon[0], m_num_points, false),

-        m_stroke(m_vs),

-        m_point_radius(point_radius),

-        m_status(0),

-        m_dx(0.0),

-        m_dy(0.0),

-        m_in_polygon_check(true)

-    {

-        m_stroke.width(1.0);

-    }

-

-

-    void polygon_ctrl_impl::rewind(unsigned)

-    {

-        m_status = 0;

-        m_stroke.rewind(0);

-    }

-

-    unsigned polygon_ctrl_impl::vertex(double* x, double* y)

-    {

-        unsigned cmd = path_cmd_stop;

-        double r = m_point_radius;

-        if(m_status == 0)

-        {

-            cmd = m_stroke.vertex(x, y);

-            if(!is_stop(cmd)) 

-            {

-                transform_xy(x, y);

-                return cmd;

-            }

-            if(m_node >= 0 && m_node == int(m_status)) r *= 1.2;

-            m_ellipse.init(xn(m_status), yn(m_status), r, r, 32);

-            ++m_status;

-        }

-        cmd = m_ellipse.vertex(x, y);

-        if(!is_stop(cmd)) 

-        {

-            transform_xy(x, y);

-            return cmd;

-        }

-        if(m_status >= m_num_points) return path_cmd_stop;

-        if(m_node >= 0 && m_node == int(m_status)) r *= 1.2;

-        m_ellipse.init(xn(m_status), yn(m_status), r, r, 32);

-        ++m_status;

-        cmd = m_ellipse.vertex(x, y);

-        if(!is_stop(cmd)) 

-        {

-            transform_xy(x, y);

-        }

-        return cmd;

-    }

-

-

-    bool polygon_ctrl_impl::check_edge(unsigned i, double x, double y) const

-    {

-       bool ret = false;

-

-       unsigned n1 = i;

-       unsigned n2 = (i + m_num_points - 1) % m_num_points;

-       double x1 = xn(n1);

-       double y1 = yn(n1);

-       double x2 = xn(n2);

-       double y2 = yn(n2);

-

-       double dx = x2 - x1;

-       double dy = y2 - y1;

-

-       if(sqrt(dx*dx + dy*dy) > 0.0000001)

-       {

-          double x3 = x;

-          double y3 = y;

-          double x4 = x3 - dy;

-          double y4 = y3 + dx;

-

-          double den = (y4-y3) * (x2-x1) - (x4-x3) * (y2-y1);

-          double u1 = ((x4-x3) * (y1-y3) - (y4-y3) * (x1-x3)) / den;

-

-          double xi = x1 + u1 * (x2 - x1);

-          double yi = y1 + u1 * (y2 - y1);

-

-          dx = xi - x;

-          dy = yi - y;

-

-          if (u1 > 0.0 && u1 < 1.0 && sqrt(dx*dx + dy*dy) <= m_point_radius)

-          {

-             ret = true;

-          }

-       }

-       return ret;

-    }

-

-

-

-    bool polygon_ctrl_impl::in_rect(double x, double y) const

-    {

-        return false;

-    }

-

-

-    bool polygon_ctrl_impl::on_mouse_button_down(double x, double y)

-    {

-        unsigned i;

-        bool ret = false;

-        m_node = -1;

-        m_edge = -1;

-        inverse_transform_xy(&x, &y);

-        for (i = 0; i < m_num_points; i++)

-        {

-            if(sqrt( (x-xn(i)) * (x-xn(i)) + (y-yn(i)) * (y-yn(i)) ) < m_point_radius)

-            {

-                m_dx = x - xn(i);

-                m_dy = y - yn(i);

-                m_node = int(i);

-                ret = true;

-                break;

-            }

-        }

-

-        if(!ret)

-        {

-            for (i = 0; i < m_num_points; i++)

-            {

-                if(check_edge(i, x, y))

-                {

-                    m_dx = x;

-                    m_dy = y;

-                    m_edge = int(i);

-                    ret = true;

-                    break;

-                }

-            }

-        }

-

-        if(!ret)

-        {

-            if(point_in_polygon(x, y))

-            {

-                m_dx = x;

-                m_dy = y;

-                m_node = int(m_num_points);

-                ret = true;

-            }

-        }

-        return ret;

-    }

-

-

-    bool polygon_ctrl_impl::on_mouse_move(double x, double y, bool button_flag)

-    {

-        bool ret = false;

-        double dx;

-        double dy;

-        inverse_transform_xy(&x, &y);

-        if(m_node == int(m_num_points))

-        {

-            dx = x - m_dx;

-            dy = y - m_dy;

-            unsigned i;

-            for(i = 0; i < m_num_points; i++)

-            {

-                xn(i) += dx;

-                yn(i) += dy;

-            }

-            m_dx = x;

-            m_dy = y;

-            ret = true;

-        }

-        else

-        {

-            if(m_edge >= 0)

-            {

-                unsigned n1 = m_edge;

-                unsigned n2 = (n1 + m_num_points - 1) % m_num_points;

-                dx = x - m_dx;

-                dy = y - m_dy;

-                xn(n1) += dx;

-                yn(n1) += dy;

-                xn(n2) += dx;

-                yn(n2) += dy;

-                m_dx = x;

-                m_dy = y;

-                ret = true;

-            }

-            else

-            {

-                if(m_node >= 0)

-                {

-                    xn(m_node) = x - m_dx;

-                    yn(m_node) = y - m_dy;

-                    ret = true;

-                }

-            }

-        }

-        return ret;

-    }

-

-    bool polygon_ctrl_impl::on_mouse_button_up(double x, double y)

-    {

-        bool ret = (m_node >= 0) || (m_edge >= 0);

-        m_node = -1;

-        m_edge = -1;

-        return ret;

-    }

-

-

-    bool polygon_ctrl_impl::on_arrow_keys(bool left, bool right, bool down, bool up)

-    {

-        return false;

-    }

-

-

-    //======= Crossings Multiply algorithm of InsideTest ======================== 

-    //

-    // By Eric Haines, 3D/Eye Inc, erich@eye.com

-    //

-    // This version is usually somewhat faster than the original published in

-    // Graphics Gems IV; by turning the division for testing the X axis crossing

-    // into a tricky multiplication test this part of the test became faster,

-    // which had the additional effect of making the test for "both to left or

-    // both to right" a bit slower for triangles than simply computing the

-    // intersection each time.  The main increase is in triangle testing speed,

-    // which was about 15% faster; all other polygon complexities were pretty much

-    // the same as before.  On machines where division is very expensive (not the

-    // case on the HP 9000 series on which I tested) this test should be much

-    // faster overall than the old code.  Your mileage may (in fact, will) vary,

-    // depending on the machine and the test data, but in general I believe this

-    // code is both shorter and faster.  This test was inspired by unpublished

-    // Graphics Gems submitted by Joseph Samosky and Mark Haigh-Hutchinson.

-    // Related work by Samosky is in:

-    //

-    // Samosky, Joseph, "SectionView: A system for interactively specifying and

-    // visualizing sections through three-dimensional medical image data",

-    // M.S. Thesis, Department of Electrical Engineering and Computer Science,

-    // Massachusetts Institute of Technology, 1993.

-    //

-    // Shoot a test ray along +X axis.  The strategy is to compare vertex Y values

-    // to the testing point's Y and quickly discard edges which are entirely to one

-    // side of the test ray.  Note that CONVEX and WINDING code can be added as

-    // for the CrossingsTest() code; it is left out here for clarity.

-    //

-    // Input 2D polygon _pgon_ with _numverts_ number of vertices and test point

-    // _point_, returns 1 if inside, 0 if outside.

-    bool polygon_ctrl_impl::point_in_polygon(double tx, double ty) const

-    {

-        if(m_num_points < 3) return false;

-        if(!m_in_polygon_check) return false;

-

-        unsigned j;

-        int yflag0, yflag1, inside_flag;

-        double  vtx0, vty0, vtx1, vty1;

-

-        vtx0 = xn(m_num_points - 1);

-        vty0 = yn(m_num_points - 1);

-

-        // get test bit for above/below X axis

-        yflag0 = (vty0 >= ty);

-

-        vtx1 = xn(0);

-        vty1 = yn(0);

-

-        inside_flag = 0;

-        for (j = 1; j <= m_num_points; ++j) 

-        {

-            yflag1 = (vty1 >= ty);

-            // Check if endpoints straddle (are on opposite sides) of X axis

-            // (i.e. the Y's differ); if so, +X ray could intersect this edge.

-            // The old test also checked whether the endpoints are both to the

-            // right or to the left of the test point.  However, given the faster

-            // intersection point computation used below, this test was found to

-            // be a break-even proposition for most polygons and a loser for

-            // triangles (where 50% or more of the edges which survive this test

-            // will cross quadrants and so have to have the X intersection computed

-            // anyway).  I credit Joseph Samosky with inspiring me to try dropping

-            // the "both left or both right" part of my code.

-            if (yflag0 != yflag1) 

-            {

-                // Check intersection of pgon segment with +X ray.

-                // Note if >= point's X; if so, the ray hits it.

-                // The division operation is avoided for the ">=" test by checking

-                // the sign of the first vertex wrto the test point; idea inspired

-                // by Joseph Samosky's and Mark Haigh-Hutchinson's different

-                // polygon inclusion tests.

-                if ( ((vty1-ty) * (vtx0-vtx1) >=

-                      (vtx1-tx) * (vty0-vty1)) == yflag1 ) 

-                {

-                    inside_flag ^= 1;

-                }

-            }

-

-            // Move to the next pair of vertices, retaining info as possible.

-            yflag0 = yflag1;

-            vtx0 = vtx1;

-            vty0 = vty1;

-

-            unsigned k = (j >= m_num_points) ? j - m_num_points : j;

-            vtx1 = xn(k);

-            vty1 = yn(k);

-        }

-        return inside_flag != 0;

-    }

-}

-

diff --git a/plugins/Clist_ng/AGG/src/ctrl/agg_rbox_ctrl.cpp b/plugins/Clist_ng/AGG/src/ctrl/agg_rbox_ctrl.cpp
deleted file mode 100644
index c643fec387..0000000000
--- a/plugins/Clist_ng/AGG/src/ctrl/agg_rbox_ctrl.cpp
+++ /dev/null
@@ -1,330 +0,0 @@
-//----------------------------------------------------------------------------

-// 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.

-//----------------------------------------------------------------------------

-

-#include <string.h>

-#include "ctrl/agg_rbox_ctrl.h"

-

-namespace agg

-{

-  

-    //------------------------------------------------------------------------

-    rbox_ctrl_impl::rbox_ctrl_impl(double x1, double y1, 

-                                   double x2, double y2, bool flip_y) :

-        ctrl(x1, y1, x2, y2, flip_y),

-        m_border_width(1.0),

-        m_border_extra(0.0),

-        m_text_thickness(1.5),

-        m_text_height(9.0),

-        m_text_width(0.0),

-        m_num_items(0),

-        m_cur_item(-1),

-        m_ellipse_poly(m_ellipse),

-        m_text_poly(m_text),

-        m_idx(0),

-        m_vertex(0)

-    {

-        calc_rbox();

-    }

-

-

-    //------------------------------------------------------------------------

-    void rbox_ctrl_impl::calc_rbox()

-    {

-        m_xs1 = m_x1 + m_border_width;

-        m_ys1 = m_y1 + m_border_width;

-        m_xs2 = m_x2 - m_border_width;

-        m_ys2 = m_y2 - m_border_width;

-    }

-

-

-    //------------------------------------------------------------------------

-    void rbox_ctrl_impl::add_item(const char* text)

-    {

-        if(m_num_items < 32)

-        {

-            m_items[m_num_items].resize(strlen(text) + 1);

-            strcpy(&m_items[m_num_items][0], text);

-            m_num_items++;

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    void rbox_ctrl_impl::border_width(double t, double extra)

-    { 

-        m_border_width = t; 

-        m_border_extra = extra;

-        calc_rbox(); 

-    }

-

-

-    //------------------------------------------------------------------------

-    void rbox_ctrl_impl::text_size(double h, double w) 

-    { 

-        m_text_width = w; 

-        m_text_height = h; 

-    }

-

-

-

-    //------------------------------------------------------------------------

-    void rbox_ctrl_impl::rewind(unsigned idx)

-    {

-        m_idx = idx;

-        m_dy = m_text_height * 2.0;

-        m_draw_item = 0;

-

-        switch(idx)

-        {

-        default:

-

-        case 0:                 // Background

-            m_vertex = 0;

-            m_vx[0] = m_x1 - m_border_extra; 

-            m_vy[0] = m_y1 - m_border_extra;

-            m_vx[1] = m_x2 + m_border_extra; 

-            m_vy[1] = m_y1 - m_border_extra;

-            m_vx[2] = m_x2 + m_border_extra; 

-            m_vy[2] = m_y2 + m_border_extra;

-            m_vx[3] = m_x1 - m_border_extra; 

-            m_vy[3] = m_y2 + m_border_extra;

-            break;

-

-        case 1:                 // Border

-            m_vertex = 0;

-            m_vx[0] = m_x1; 

-            m_vy[0] = m_y1;

-            m_vx[1] = m_x2; 

-            m_vy[1] = m_y1;

-            m_vx[2] = m_x2; 

-            m_vy[2] = m_y2;

-            m_vx[3] = m_x1; 

-            m_vy[3] = m_y2;

-            m_vx[4] = m_x1 + m_border_width; 

-            m_vy[4] = m_y1 + m_border_width; 

-            m_vx[5] = m_x1 + m_border_width; 

-            m_vy[5] = m_y2 - m_border_width; 

-            m_vx[6] = m_x2 - m_border_width; 

-            m_vy[6] = m_y2 - m_border_width; 

-            m_vx[7] = m_x2 - m_border_width; 

-            m_vy[7] = m_y1 + m_border_width; 

-            break;

-

-        case 2:                 // Text

-            m_text.text(&m_items[0][0]);

-            m_text.start_point(m_xs1 + m_dy * 1.5, m_ys1 + m_dy / 2.0);

-            m_text.size(m_text_height, m_text_width);

-            m_text_poly.width(m_text_thickness);

-            m_text_poly.line_join(round_join);

-            m_text_poly.line_cap(round_cap);

-            m_text_poly.rewind(0);

-            break;

-

-        case 3:                 // Inactive items

-            m_ellipse.init(m_xs1 + m_dy / 1.3, 

-                           m_ys1 + m_dy / 1.3,

-                           m_text_height / 1.5, 

-                           m_text_height / 1.5, 32);

-            m_ellipse_poly.width(m_text_thickness);

-            m_ellipse_poly.rewind(0);

-            break;

-

-

-        case 4:                 // Active Item

-            if(m_cur_item >= 0)

-            {

-                m_ellipse.init(m_xs1 + m_dy / 1.3, 

-                               m_ys1 + m_dy * m_cur_item + m_dy / 1.3,

-                               m_text_height / 2.0, 

-                               m_text_height / 2.0, 32);

-                m_ellipse.rewind(0);

-            }

-            break;

-

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    unsigned rbox_ctrl_impl::vertex(double* x, double* y)

-    {

-        unsigned cmd = path_cmd_line_to;

-        switch(m_idx)

-        {

-        case 0:

-            if(m_vertex == 0) cmd = path_cmd_move_to;

-            if(m_vertex >= 4) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-            m_vertex++;

-            break;

-

-        case 1:

-            if(m_vertex == 0 || m_vertex == 4) cmd = path_cmd_move_to;

-            if(m_vertex >= 8) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-            m_vertex++;

-            break;

-

-        case 2:

-            cmd = m_text_poly.vertex(x, y);

-            if(is_stop(cmd))

-            {

-                m_draw_item++;

-                if(m_draw_item >= m_num_items)

-                {

-                    break;

-                }

-                else

-                {

-                    m_text.text(&m_items[m_draw_item][0]);

-                    m_text.start_point(m_xs1 + m_dy * 1.5, 

-                                       m_ys1 + m_dy * (m_draw_item + 1) - m_dy / 2.0);

-

-                    m_text_poly.rewind(0);

-                    cmd = m_text_poly.vertex(x, y);

-                }

-            }

-            break;

-

-        case 3:

-            cmd = m_ellipse_poly.vertex(x, y);

-            if(is_stop(cmd))

-            {

-                m_draw_item++;

-                if(m_draw_item >= m_num_items)

-                {

-                    break;

-                }

-                else

-                {

-                    m_ellipse.init(m_xs1 + m_dy / 1.3, 

-                                   m_ys1 + m_dy * m_draw_item + m_dy / 1.3,

-                                   m_text_height / 1.5, 

-                                   m_text_height / 1.5, 32);

-                    m_ellipse_poly.rewind(0);

-                    cmd = m_ellipse_poly.vertex(x, y);

-                }

-            }

-            break;

-

-

-        case 4:

-            if(m_cur_item >= 0)

-            {

-                cmd = m_ellipse.vertex(x, y);

-            }

-            else

-            {

-                cmd = path_cmd_stop;

-            }

-            break;

-

-        default:

-            cmd = path_cmd_stop;

-            break;

-        }

-

-        if(!is_stop(cmd))

-        {

-            transform_xy(x, y);

-        }

-

-        return cmd;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool rbox_ctrl_impl::in_rect(double x, double y) const

-    {

-        inverse_transform_xy(&x, &y);

-        return x >= m_x1 && x <= m_x2 && y >= m_y1 && y <= m_y2;

-    }

-

-

-

-    //------------------------------------------------------------------------

-    bool rbox_ctrl_impl::on_mouse_button_down(double x, double y)

-    {

-        inverse_transform_xy(&x, &y);

-        unsigned i;

-        for(i = 0; i < m_num_items; i++)  

-        {

-            double xp = m_xs1 + m_dy / 1.3;

-            double yp = m_ys1 + m_dy * i + m_dy / 1.3;

-            if(calc_distance(x, y, xp, yp) <= m_text_height / 1.5)

-            {

-                m_cur_item = int(i);

-                return true;

-            }

-        }

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool rbox_ctrl_impl::on_mouse_move(double, double, bool)

-    {

-        return false;

-    }

-

-    //------------------------------------------------------------------------

-    bool rbox_ctrl_impl::on_mouse_button_up(double, double)

-    {

-        return false;

-    }

-

-    //------------------------------------------------------------------------

-    bool rbox_ctrl_impl::on_arrow_keys(bool left, bool right, bool down, bool up)

-    {

-        if(m_cur_item >= 0)

-        {

-            if(up || right) 

-            {

-                m_cur_item++;

-                if(m_cur_item >= int(m_num_items))

-                {

-                    m_cur_item = 0;

-                }

-                return true;

-            }

-

-            if(down || left) 

-            {

-                m_cur_item--;

-                if(m_cur_item < 0)

-                {

-                    m_cur_item = m_num_items - 1;

-                }

-                return true;

-            }

-        }

-        return false;

-    }

-

-

-}

-

-

diff --git a/plugins/Clist_ng/AGG/src/ctrl/agg_scale_ctrl.cpp b/plugins/Clist_ng/AGG/src/ctrl/agg_scale_ctrl.cpp
deleted file mode 100644
index 974a4fc727..0000000000
--- a/plugins/Clist_ng/AGG/src/ctrl/agg_scale_ctrl.cpp
+++ /dev/null
@@ -1,459 +0,0 @@
-//----------------------------------------------------------------------------

-// 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.

-//----------------------------------------------------------------------------

-

-#include "ctrl/agg_scale_ctrl.h"

-

-namespace agg

-{

-

-    //------------------------------------------------------------------------

-    scale_ctrl_impl::scale_ctrl_impl(double x1, double y1, 

-                                     double x2, double y2, bool flip_y) :

-        ctrl(x1, y1, x2, y2, flip_y),

-        m_border_thickness(1.0),

-        m_border_extra((fabs(x2 - x1) > fabs(y2 - y1)) ? (y2 - y1) / 2 : (x2 - x1) / 2),

-        m_pdx(0.0),

-        m_pdy(0.0),

-        m_move_what(move_nothing),

-        m_value1(0.3),

-        m_value2(0.7),

-        m_min_d(0.01)

-    {

-        calc_box();

-    }

-

-

-    //------------------------------------------------------------------------

-    void scale_ctrl_impl::calc_box()

-    {

-        m_xs1 = m_x1 + m_border_thickness;

-        m_ys1 = m_y1 + m_border_thickness;

-        m_xs2 = m_x2 - m_border_thickness;

-        m_ys2 = m_y2 - m_border_thickness;

-    }

-

-

-    //------------------------------------------------------------------------

-    void scale_ctrl_impl::border_thickness(double t, double extra)

-    { 

-        m_border_thickness = t; 

-        m_border_extra = extra;

-        calc_box(); 

-    }

-

-

-    //------------------------------------------------------------------------

-    void scale_ctrl_impl::resize(double x1, double y1, double x2, double y2)

-    {

-        m_x1 = x1;

-        m_y1 = y1;

-        m_x2 = x2;

-        m_y2 = y2;

-        calc_box(); 

-        m_border_extra = (fabs(x2 - x1) > fabs(y2 - y1)) ? 

-                            (y2 - y1) / 2 : 

-                            (x2 - x1) / 2;

-    }

-

-

-    //------------------------------------------------------------------------

-    void scale_ctrl_impl::value1(double value) 

-    { 

-        if(value < 0.0) value = 0.0;

-        if(value > 1.0) value = 1.0;

-        if(m_value2 - value < m_min_d) value = m_value2 - m_min_d;

-        m_value1 = value; 

-    }

-

-

-    //------------------------------------------------------------------------

-    void scale_ctrl_impl::value2(double value) 

-    { 

-        if(value < 0.0) value = 0.0;

-        if(value > 1.0) value = 1.0;

-        if(m_value1 + value < m_min_d) value = m_value1 + m_min_d;

-        m_value2 = value; 

-    }

-

-

-    //------------------------------------------------------------------------

-    void scale_ctrl_impl::move(double d)

-    {

-        m_value1 += d;

-        m_value2 += d;

-        if(m_value1 < 0.0)

-        {

-            m_value2 -= m_value1;

-            m_value1 = 0.0;

-        }

-        if(m_value2 > 1.0)

-        {

-            m_value1 -= m_value2 - 1.0;

-            m_value2 = 1.0;

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    void scale_ctrl_impl::rewind(unsigned idx)

-    {

-        m_idx = idx;

-

-        switch(idx)

-        {

-        default:

-

-        case 0:                 // Background

-            m_vertex = 0;

-            m_vx[0] = m_x1 - m_border_extra; 

-            m_vy[0] = m_y1 - m_border_extra;

-            m_vx[1] = m_x2 + m_border_extra; 

-            m_vy[1] = m_y1 - m_border_extra;

-            m_vx[2] = m_x2 + m_border_extra; 

-            m_vy[2] = m_y2 + m_border_extra;

-            m_vx[3] = m_x1 - m_border_extra; 

-            m_vy[3] = m_y2 + m_border_extra;

-            break;

-

-        case 1:                 // Border

-            m_vertex = 0;

-            m_vx[0] = m_x1; 

-            m_vy[0] = m_y1;

-            m_vx[1] = m_x2; 

-            m_vy[1] = m_y1;

-            m_vx[2] = m_x2; 

-            m_vy[2] = m_y2;

-            m_vx[3] = m_x1; 

-            m_vy[3] = m_y2;

-            m_vx[4] = m_x1 + m_border_thickness; 

-            m_vy[4] = m_y1 + m_border_thickness; 

-            m_vx[5] = m_x1 + m_border_thickness; 

-            m_vy[5] = m_y2 - m_border_thickness; 

-            m_vx[6] = m_x2 - m_border_thickness; 

-            m_vy[6] = m_y2 - m_border_thickness; 

-            m_vx[7] = m_x2 - m_border_thickness; 

-            m_vy[7] = m_y1 + m_border_thickness; 

-            break;

-

-        case 2:                 // pointer1

-            if(fabs(m_x2 - m_x1) > fabs(m_y2 - m_y1))

-            {

-                m_ellipse.init(m_xs1 + (m_xs2 - m_xs1) * m_value1,

-                               (m_ys1 + m_ys2) / 2.0,

-                               m_y2 - m_y1,

-                               m_y2 - m_y1, 

-                               32);

-            }

-            else

-            {

-                m_ellipse.init((m_xs1 + m_xs2) / 2.0,

-                               m_ys1 + (m_ys2 - m_ys1) * m_value1,

-                               m_x2 - m_x1,

-                               m_x2 - m_x1, 

-                               32);

-            }

-            m_ellipse.rewind(0);

-            break;

-

-        case 3:                 // pointer2

-            if(fabs(m_x2 - m_x1) > fabs(m_y2 - m_y1))

-            {

-                m_ellipse.init(m_xs1 + (m_xs2 - m_xs1) * m_value2,

-                               (m_ys1 + m_ys2) / 2.0,

-                               m_y2 - m_y1,

-                               m_y2 - m_y1, 

-                               32);

-            }

-            else

-            {

-                m_ellipse.init((m_xs1 + m_xs2) / 2.0,

-                               m_ys1 + (m_ys2 - m_ys1) * m_value2,

-                               m_x2 - m_x1,

-                               m_x2 - m_x1, 

-                               32);

-            }

-            m_ellipse.rewind(0);

-            break;

-

-        case 4:                 // slider

-            m_vertex = 0;

-            if(fabs(m_x2 - m_x1) > fabs(m_y2 - m_y1))

-            {

-                m_vx[0] = m_xs1 + (m_xs2 - m_xs1) * m_value1;

-                m_vy[0] = m_y1 - m_border_extra / 2.0;

-                m_vx[1] = m_xs1 + (m_xs2 - m_xs1) * m_value2; 

-                m_vy[1] = m_vy[0];

-                m_vx[2] = m_vx[1]; 

-                m_vy[2] = m_y2 + m_border_extra / 2.0;

-                m_vx[3] = m_vx[0]; 

-                m_vy[3] = m_vy[2];

-            }

-            else

-            {

-                m_vx[0] = m_x1 - m_border_extra / 2.0;

-                m_vy[0] = m_ys1 + (m_ys2 - m_ys1) * m_value1;

-                m_vx[1] = m_vx[0];

-                m_vy[1] = m_ys1 + (m_ys2 - m_ys1) * m_value2; 

-                m_vx[2] = m_x2 + m_border_extra / 2.0;

-                m_vy[2] = m_vy[1]; 

-                m_vx[3] = m_vx[2];

-                m_vy[3] = m_vy[0]; 

-            }

-            break;

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    unsigned scale_ctrl_impl::vertex(double* x, double* y)

-    {

-        unsigned cmd = path_cmd_line_to;

-        switch(m_idx)

-        {

-        case 0:

-        case 4:

-            if(m_vertex == 0) cmd = path_cmd_move_to;

-            if(m_vertex >= 4) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-            m_vertex++;

-            break;

-

-        case 1:

-            if(m_vertex == 0 || m_vertex == 4) cmd = path_cmd_move_to;

-            if(m_vertex >= 8) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-            m_vertex++;

-            break;

-

-        case 2:

-        case 3:

-            cmd = m_ellipse.vertex(x, y);

-            break;

-

-        default:

-            cmd = path_cmd_stop;

-            break;

-        }

-

-        if(!is_stop(cmd))

-        {

-            transform_xy(x, y);

-        }

-

-        return cmd;

-    }

-

-

-

-    //------------------------------------------------------------------------

-    bool scale_ctrl_impl::in_rect(double x, double y) const

-    {

-        inverse_transform_xy(&x, &y);

-        return x >= m_x1 && x <= m_x2 && y >= m_y1 && y <= m_y2;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool scale_ctrl_impl::on_mouse_button_down(double x, double y)

-    {

-        inverse_transform_xy(&x, &y);

-

-        double xp1;

-        double xp2;

-        double ys1;

-        double ys2;

-        double xp;

-        double yp;

-

-        if(fabs(m_x2 - m_x1) > fabs(m_y2 - m_y1))

-        {

-            xp1 = m_xs1 + (m_xs2 - m_xs1) * m_value1;

-            xp2 = m_xs1 + (m_xs2 - m_xs1) * m_value2;

-            ys1 = m_y1  - m_border_extra / 2.0;

-            ys2 = m_y2  + m_border_extra / 2.0;

-            yp = (m_ys1 + m_ys2) / 2.0;

-

-            if(x > xp1 && y > ys1 && x < xp2 && y < ys2)

-            {

-                m_pdx = xp1 - x;

-                m_move_what = move_slider;

-                return true;

-            }

-

-            //if(x < xp1 && calc_distance(x, y, xp1, yp) <= m_y2 - m_y1)

-            if(calc_distance(x, y, xp1, yp) <= m_y2 - m_y1)

-            {

-                m_pdx = xp1 - x;

-                m_move_what = move_value1;

-                return true;

-            }

-

-            //if(x > xp2 && calc_distance(x, y, xp2, yp) <= m_y2 - m_y1)

-            if(calc_distance(x, y, xp2, yp) <= m_y2 - m_y1)

-            {

-                m_pdx = xp2 - x;

-                m_move_what = move_value2;

-                return true;

-            }

-        }

-        else

-        {

-            xp1 = m_x1  - m_border_extra / 2.0;

-            xp2 = m_x2  + m_border_extra / 2.0;

-            ys1 = m_ys1 + (m_ys2 - m_ys1) * m_value1;

-            ys2 = m_ys1 + (m_ys2 - m_ys1) * m_value2;

-            xp = (m_xs1 + m_xs2) / 2.0;

-

-            if(x > xp1 && y > ys1 && x < xp2 && y < ys2)

-            {

-                m_pdy = ys1 - y;

-                m_move_what = move_slider;

-                return true;

-            }

-

-            //if(y < ys1 && calc_distance(x, y, xp, ys1) <= m_x2 - m_x1)

-            if(calc_distance(x, y, xp, ys1) <= m_x2 - m_x1)

-            {

-                m_pdy = ys1 - y;

-                m_move_what = move_value1;

-                return true;

-            }

-

-            //if(y > ys2 && calc_distance(x, y, xp, ys2) <= m_x2 - m_x1)

-            if(calc_distance(x, y, xp, ys2) <= m_x2 - m_x1)

-            {

-                m_pdy = ys2 - y;

-                m_move_what = move_value2;

-                return true;

-            }

-        }

-

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool scale_ctrl_impl::on_mouse_move(double x, double y, bool button_flag)

-    {

-        inverse_transform_xy(&x, &y);

-        if(!button_flag)

-        {

-            return on_mouse_button_up(x, y);

-        }

-

-        double xp = x + m_pdx;

-        double yp = y + m_pdy;

-        double dv;

-

-        switch(m_move_what)

-        {

-        case move_value1:

-            if(fabs(m_x2 - m_x1) > fabs(m_y2 - m_y1))

-            {

-                m_value1 = (xp - m_xs1) / (m_xs2 - m_xs1);

-            }

-            else

-            {

-                m_value1 = (yp - m_ys1) / (m_ys2 - m_ys1);

-            }

-            if(m_value1 < 0.0) m_value1 = 0.0;

-            if(m_value1 > m_value2 - m_min_d) m_value1 = m_value2 - m_min_d;

-            return true;

-

-        case move_value2:

-            if(fabs(m_x2 - m_x1) > fabs(m_y2 - m_y1))

-            {

-                m_value2 = (xp - m_xs1) / (m_xs2 - m_xs1);

-            }

-            else

-            {

-                m_value2 = (yp - m_ys1) / (m_ys2 - m_ys1);

-            }

-            if(m_value2 > 1.0) m_value2 = 1.0;

-            if(m_value2 < m_value1 + m_min_d) m_value2 = m_value1 + m_min_d;

-            return true;

-

-        case move_slider:

-            dv = m_value2 - m_value1;

-            if(fabs(m_x2 - m_x1) > fabs(m_y2 - m_y1))

-            {

-                m_value1 = (xp - m_xs1) / (m_xs2 - m_xs1);

-            }

-            else

-            {

-                m_value1 = (yp - m_ys1) / (m_ys2 - m_ys1);

-            }

-            m_value2 = m_value1 + dv;

-            if(m_value1 < 0.0)

-            {

-                dv = m_value2 - m_value1;

-                m_value1 = 0.0;

-                m_value2 = m_value1 + dv;

-            }

-            if(m_value2 > 1.0)

-            {

-                dv = m_value2 - m_value1;

-                m_value2 = 1.0;

-                m_value1 = m_value2 - dv;

-            }

-            return true;

-        }

-

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool scale_ctrl_impl::on_mouse_button_up(double, double)

-    {

-        m_move_what = move_nothing;

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool scale_ctrl_impl::on_arrow_keys(bool left, bool right, bool down, bool up)

-    {

-/*

-        if(right || up)

-        {

-            m_value += 0.005;

-            if(m_value > 1.0) m_value = 1.0;

-            return true;

-        }

-

-        if(left || down)

-        {

-            m_value -= 0.005;

-            if(m_value < 0.0) m_value = 0.0;

-            return true;

-        }

-*/

-        return false;

-    }

-

-}

-

diff --git a/plugins/Clist_ng/AGG/src/ctrl/agg_slider_ctrl.cpp b/plugins/Clist_ng/AGG/src/ctrl/agg_slider_ctrl.cpp
deleted file mode 100644
index 113b7ac08e..0000000000
--- a/plugins/Clist_ng/AGG/src/ctrl/agg_slider_ctrl.cpp
+++ /dev/null
@@ -1,354 +0,0 @@
-//----------------------------------------------------------------------------

-// 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.

-//----------------------------------------------------------------------------

-

-#include <string.h>

-#include <stdio.h>

-#include "ctrl/agg_slider_ctrl.h"

-

-namespace agg

-{

-

-    //------------------------------------------------------------------------

-    slider_ctrl_impl::slider_ctrl_impl(double x1, double y1, 

-                                       double x2, double y2, bool flip_y) :

-        ctrl(x1, y1, x2, y2, flip_y),

-        m_border_width(1.0),

-        m_border_extra((y2 - y1) / 2),

-        m_text_thickness(1.0),

-        m_pdx(0.0),

-        m_mouse_move(false),

-        m_value(0.5),

-        m_preview_value(0.5),

-        m_min(0.0),

-        m_max(1.0),

-        m_num_steps(0),

-        m_descending(false),

-        m_text_poly(m_text)

-    {

-        m_label[0] = 0;

-        calc_box();

-    }

-

-

-    //------------------------------------------------------------------------

-    void slider_ctrl_impl::calc_box()

-    {

-        m_xs1 = m_x1 + m_border_width;

-        m_ys1 = m_y1 + m_border_width;

-        m_xs2 = m_x2 - m_border_width;

-        m_ys2 = m_y2 - m_border_width;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool slider_ctrl_impl::normalize_value(bool preview_value_flag)

-    {

-        bool ret = true;

-        if(m_num_steps)

-        {

-            int step = int(m_preview_value * m_num_steps + 0.5);

-            ret = m_value != step / double(m_num_steps);

-            m_value = step / double(m_num_steps);

-        }

-        else

-        {

-            m_value = m_preview_value;

-        }

-

-        if(preview_value_flag)

-        {

-            m_preview_value = m_value;

-        }

-        return ret;

-    }

-

-

-    //------------------------------------------------------------------------

-    void slider_ctrl_impl::border_width(double t, double extra)

-    { 

-        m_border_width = t; 

-        m_border_extra = extra;

-        calc_box(); 

-    }

-

-

-    //------------------------------------------------------------------------

-    void slider_ctrl_impl::value(double value) 

-    { 

-        m_preview_value = (value - m_min) / (m_max - m_min); 

-        if(m_preview_value > 1.0) m_preview_value = 1.0;

-        if(m_preview_value < 0.0) m_preview_value = 0.0;

-        normalize_value(true);

-    }

-

-    //------------------------------------------------------------------------

-    void slider_ctrl_impl::label(const char* fmt)

-    {

-        m_label[0] = 0;

-        if(fmt)

-        {

-            unsigned len = strlen(fmt);

-            if(len > 63) len = 63;

-            memcpy(m_label, fmt, len);

-            m_label[len] = 0;

-        }

-    }

-

-    //------------------------------------------------------------------------

-    void slider_ctrl_impl::rewind(unsigned idx)

-    {

-        m_idx = idx;

-

-        switch(idx)

-        {

-        default:

-

-        case 0:                 // Background

-            m_vertex = 0;

-            m_vx[0] = m_x1 - m_border_extra; 

-            m_vy[0] = m_y1 - m_border_extra;

-            m_vx[1] = m_x2 + m_border_extra; 

-            m_vy[1] = m_y1 - m_border_extra;

-            m_vx[2] = m_x2 + m_border_extra; 

-            m_vy[2] = m_y2 + m_border_extra;

-            m_vx[3] = m_x1 - m_border_extra; 

-            m_vy[3] = m_y2 + m_border_extra;

-            break;

-

-        case 1:                 // Triangle

-            m_vertex = 0;

-            if(m_descending)

-            {

-                m_vx[0] = m_x1; 

-                m_vy[0] = m_y1;

-                m_vx[1] = m_x2; 

-                m_vy[1] = m_y1;

-                m_vx[2] = m_x1; 

-                m_vy[2] = m_y2;

-                m_vx[3] = m_x1; 

-                m_vy[3] = m_y1;

-            }

-            else

-            {

-                m_vx[0] = m_x1; 

-                m_vy[0] = m_y1;

-                m_vx[1] = m_x2; 

-                m_vy[1] = m_y1;

-                m_vx[2] = m_x2; 

-                m_vy[2] = m_y2;

-                m_vx[3] = m_x1; 

-                m_vy[3] = m_y1;

-            }

-            break;

-

-        case 2:

-            m_text.text(m_label);

-            if(m_label[0])

-            {

-                char buf[256];

-                sprintf(buf, m_label, value());

-                m_text.text(buf);

-            }

-            m_text.start_point(m_x1, m_y1);

-            m_text.size((m_y2 - m_y1) * 1.2, m_y2 - m_y1);

-            m_text_poly.width(m_text_thickness);

-            m_text_poly.line_join(round_join);

-            m_text_poly.line_cap(round_cap);

-            m_text_poly.rewind(0);

-            break;

-

-        case 3:                 // pointer preview

-            m_ellipse.init(m_xs1 + (m_xs2 - m_xs1) * m_preview_value,

-                           (m_ys1 + m_ys2) / 2.0,

-                           m_y2 - m_y1,

-                           m_y2 - m_y1, 

-                           32);

-            break;

-

-

-        case 4:                 // pointer

-            normalize_value(false);

-            m_ellipse.init(m_xs1 + (m_xs2 - m_xs1) * m_value,

-                           (m_ys1 + m_ys2) / 2.0,

-                           m_y2 - m_y1,

-                           m_y2 - m_y1, 

-                           32);

-            m_ellipse.rewind(0);

-            break;

-

-        case 5:

-            m_storage.remove_all();

-            if(m_num_steps)

-            {

-                unsigned i;

-                double d = (m_xs2 - m_xs1) / m_num_steps;

-                if(d > 0.004) d = 0.004;

-                for(i = 0; i < m_num_steps + 1; i++)

-                {

-                    double x = m_xs1 + (m_xs2 - m_xs1) * i / m_num_steps;

-                    m_storage.move_to(x, m_y1);

-                    m_storage.line_to(x - d * (m_x2 - m_x1), m_y1 - m_border_extra);

-                    m_storage.line_to(x + d * (m_x2 - m_x1), m_y1 - m_border_extra);

-                }

-            }

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    unsigned slider_ctrl_impl::vertex(double* x, double* y)

-    {

-        unsigned cmd = path_cmd_line_to;

-        switch(m_idx)

-        {

-        case 0:

-            if(m_vertex == 0) cmd = path_cmd_move_to;

-            if(m_vertex >= 4) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-            m_vertex++;

-            break;

-

-        case 1:

-            if(m_vertex == 0) cmd = path_cmd_move_to;

-            if(m_vertex >= 4) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-             m_vertex++;

-            break;

-

-        case 2:

-            cmd = m_text_poly.vertex(x, y);

-            break;

-

-        case 3:

-        case 4:

-            cmd = m_ellipse.vertex(x, y);

-            break;

-

-        case 5:

-            cmd = m_storage.vertex(x, y);

-            break;

-

-        default:

-            cmd = path_cmd_stop;

-            break;

-        }

-

-        if(!is_stop(cmd))

-        {

-            transform_xy(x, y);

-        }

-

-        return cmd;

-    }

-

-

-

-    //------------------------------------------------------------------------

-    bool slider_ctrl_impl::in_rect(double x, double y) const

-    {

-        inverse_transform_xy(&x, &y);

-        return x >= m_x1 && x <= m_x2 && y >= m_y1 && y <= m_y2;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool slider_ctrl_impl::on_mouse_button_down(double x, double y)

-    {

-        inverse_transform_xy(&x, &y);

-

-        double xp = m_xs1 + (m_xs2 - m_xs1) * m_value;

-        double yp = (m_ys1 + m_ys2) / 2.0;

-

-        if(calc_distance(x, y, xp, yp) <= m_y2 - m_y1)

-        {

-            m_pdx = xp - x;

-            m_mouse_move = true;

-            return true;

-        }

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool slider_ctrl_impl::on_mouse_move(double x, double y, bool button_flag)

-    {

-        inverse_transform_xy(&x, &y);

-        if(!button_flag)

-        {

-            on_mouse_button_up(x, y);

-            return false;

-        }

-

-        if(m_mouse_move)

-        {

-            double xp = x + m_pdx;

-            m_preview_value = (xp - m_xs1) / (m_xs2 - m_xs1);

-            if(m_preview_value < 0.0) m_preview_value = 0.0;

-            if(m_preview_value > 1.0) m_preview_value = 1.0;

-            return true;

-        }

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool slider_ctrl_impl::on_mouse_button_up(double, double)

-    {

-        m_mouse_move = false;

-        normalize_value(true);

-        return true;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool slider_ctrl_impl::on_arrow_keys(bool left, bool right, bool down, bool up)

-    {

-        double d = 0.005;

-        if(m_num_steps)

-        {

-            d = 1.0 / m_num_steps;

-        }

-        

-        if(right || up)

-        {

-            m_preview_value += d;

-            if(m_preview_value > 1.0) m_preview_value = 1.0;

-            normalize_value(true);

-            return true;

-        }

-

-        if(left || down)

-        {

-            m_preview_value -= d;

-            if(m_preview_value < 0.0) m_preview_value = 0.0;

-            normalize_value(true);

-            return true;

-        }

-        return false;

-    }

-

-}

-

diff --git a/plugins/Clist_ng/AGG/src/ctrl/agg_spline_ctrl.cpp b/plugins/Clist_ng/AGG/src/ctrl/agg_spline_ctrl.cpp
deleted file mode 100644
index 6716607c65..0000000000
--- a/plugins/Clist_ng/AGG/src/ctrl/agg_spline_ctrl.cpp
+++ /dev/null
@@ -1,412 +0,0 @@
-//----------------------------------------------------------------------------

-// 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.

-//----------------------------------------------------------------------------

-

-#include "ctrl/agg_spline_ctrl.h"

-

-

-namespace agg

-{

-

-    //------------------------------------------------------------------------

-    spline_ctrl_impl::spline_ctrl_impl(double x1, double y1, double x2, double y2, 

-                                       unsigned num_pnt, bool flip_y) :

-        ctrl(x1, y1, x2, y2, flip_y),

-        m_num_pnt(num_pnt),

-        m_border_width(1.0),

-        m_border_extra(0.0),

-        m_curve_width(1.0),

-        m_point_size(3.0),

-        m_curve_poly(m_curve_pnt),

-        m_idx(0),

-        m_vertex(0),

-        m_active_pnt(-1),

-        m_move_pnt(-1),

-        m_pdx(0.0),

-        m_pdy(0.0)

-    {

-        if(m_num_pnt < 4)  m_num_pnt = 4;

-        if(m_num_pnt > 32) m_num_pnt = 32;

-

-        unsigned i;

-        for(i = 0; i < m_num_pnt; i++)

-        {

-            m_xp[i] = double(i) / double(m_num_pnt - 1);

-            m_yp[i] = 0.5;

-        }

-        calc_spline_box();

-        update_spline();

-    }

-

-

-    //------------------------------------------------------------------------

-    void spline_ctrl_impl::border_width(double t, double extra)

-    { 

-        m_border_width = t; 

-        m_border_extra = extra;

-        calc_spline_box(); 

-    }

-

-

-    //------------------------------------------------------------------------

-    void spline_ctrl_impl::calc_spline_box()

-    {

-        m_xs1 = m_x1 + m_border_width;

-        m_ys1 = m_y1 + m_border_width;

-        m_xs2 = m_x2 - m_border_width;

-        m_ys2 = m_y2 - m_border_width;

-    }

-

-

-    //------------------------------------------------------------------------

-    void spline_ctrl_impl::update_spline()

-    {

-        int i;

-        m_spline.init(m_num_pnt, m_xp, m_yp);

-        for(i = 0; i < 256; i++)

-        {

-            m_spline_values[i] = m_spline.get(double(i) / 255.0);

-            if(m_spline_values[i] < 0.0) m_spline_values[i] = 0.0;

-            if(m_spline_values[i] > 1.0) m_spline_values[i] = 1.0;

-            m_spline_values8[i] = (int8u)(m_spline_values[i] * 255.0);

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    void spline_ctrl_impl::calc_curve()

-    {

-        int i;

-        m_curve_pnt.remove_all();

-        m_curve_pnt.move_to(m_xs1, m_ys1 + (m_ys2 - m_ys1) * m_spline_values[0]);

-        for(i = 1; i < 256; i++)

-        {

-            m_curve_pnt.line_to(m_xs1 + (m_xs2 - m_xs1) * double(i) / 255.0, 

-                                m_ys1 + (m_ys2 - m_ys1) * m_spline_values[i]);

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    double spline_ctrl_impl::calc_xp(unsigned idx)

-    {

-        return m_xs1 + (m_xs2 - m_xs1) * m_xp[idx];

-    }

-

-

-    //------------------------------------------------------------------------

-    double spline_ctrl_impl::calc_yp(unsigned idx)

-    {

-        return m_ys1 + (m_ys2 - m_ys1) * m_yp[idx];

-    }

-

-

-    //------------------------------------------------------------------------

-    void spline_ctrl_impl::set_xp(unsigned idx, double val)

-    {

-        if(val < 0.0) val = 0.0;

-        if(val > 1.0) val = 1.0;

-

-        if(idx == 0)

-        {

-            val = 0.0;

-        }

-        else if(idx == m_num_pnt - 1)

-        {

-            val = 1.0;

-        }

-        else

-        {

-            if(val < m_xp[idx - 1] + 0.001) val = m_xp[idx - 1] + 0.001;

-            if(val > m_xp[idx + 1] - 0.001) val = m_xp[idx + 1] - 0.001;

-        }

-        m_xp[idx] = val;

-    }

-

-    //------------------------------------------------------------------------

-    void spline_ctrl_impl::set_yp(unsigned idx, double val)

-    {

-        if(val < 0.0) val = 0.0;

-        if(val > 1.0) val = 1.0;

-        m_yp[idx] = val;

-    }

-

-

-    //------------------------------------------------------------------------

-    void spline_ctrl_impl::point(unsigned idx, double x, double y)

-    {

-        if(idx < m_num_pnt) 

-        {

-            set_xp(idx, x);

-            set_yp(idx, y);

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    void spline_ctrl_impl::value(unsigned idx, double y)

-    {

-        if(idx < m_num_pnt) 

-        {

-            set_yp(idx, y);

-        }

-    }

-

-    //------------------------------------------------------------------------

-    double spline_ctrl_impl::value(double x) const

-    { 

-        x = m_spline.get(x);

-        if(x < 0.0) x = 0.0;

-        if(x > 1.0) x = 1.0;

-        return x;

-    }

-

-

-    //------------------------------------------------------------------------

-    void spline_ctrl_impl::rewind(unsigned idx)

-    {

-        unsigned i;

-

-        m_idx = idx;

-

-        switch(idx)

-        {

-        default:

-

-        case 0:                 // Background

-            m_vertex = 0;

-            m_vx[0] = m_x1 - m_border_extra; 

-            m_vy[0] = m_y1 - m_border_extra;

-            m_vx[1] = m_x2 + m_border_extra; 

-            m_vy[1] = m_y1 - m_border_extra;

-            m_vx[2] = m_x2 + m_border_extra; 

-            m_vy[2] = m_y2 + m_border_extra;

-            m_vx[3] = m_x1 - m_border_extra; 

-            m_vy[3] = m_y2 + m_border_extra;

-            break;

-

-        case 1:                 // Border

-            m_vertex = 0;

-            m_vx[0] = m_x1; 

-            m_vy[0] = m_y1;

-            m_vx[1] = m_x2; 

-            m_vy[1] = m_y1;

-            m_vx[2] = m_x2; 

-            m_vy[2] = m_y2;

-            m_vx[3] = m_x1; 

-            m_vy[3] = m_y2;

-            m_vx[4] = m_x1 + m_border_width; 

-            m_vy[4] = m_y1 + m_border_width; 

-            m_vx[5] = m_x1 + m_border_width; 

-            m_vy[5] = m_y2 - m_border_width; 

-            m_vx[6] = m_x2 - m_border_width; 

-            m_vy[6] = m_y2 - m_border_width; 

-            m_vx[7] = m_x2 - m_border_width; 

-            m_vy[7] = m_y1 + m_border_width; 

-            break;

-

-        case 2:                 // Curve

-            calc_curve();

-            m_curve_poly.width(m_curve_width);

-            m_curve_poly.rewind(0);

-            break;

-

-

-        case 3:                 // Inactive points

-            m_curve_pnt.remove_all();

-            for(i = 0; i < m_num_pnt; i++)

-            {

-                if(int(i) != m_active_pnt)

-                {

-                    m_ellipse.init(calc_xp(i), calc_yp(i), 

-                                   m_point_size, m_point_size, 32);

-                    m_curve_pnt.concat_path(m_ellipse);

-                }

-            }

-            m_curve_poly.rewind(0);

-            break;

-

-

-        case 4:                 // Active point

-            m_curve_pnt.remove_all();

-            if(m_active_pnt >= 0)

-            {

-                m_ellipse.init(calc_xp(m_active_pnt), calc_yp(m_active_pnt), 

-                               m_point_size, m_point_size, 32);

-

-                m_curve_pnt.concat_path(m_ellipse);

-            }

-            m_curve_poly.rewind(0);

-            break;

-

-        }

-    }

-

-

-    //------------------------------------------------------------------------

-    unsigned spline_ctrl_impl::vertex(double* x, double* y)

-    {

-        unsigned cmd = path_cmd_line_to;

-        switch(m_idx)

-        {

-        case 0:

-            if(m_vertex == 0) cmd = path_cmd_move_to;

-            if(m_vertex >= 4) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-            m_vertex++;

-            break;

-

-        case 1:

-            if(m_vertex == 0 || m_vertex == 4) cmd = path_cmd_move_to;

-            if(m_vertex >= 8) cmd = path_cmd_stop;

-            *x = m_vx[m_vertex];

-            *y = m_vy[m_vertex];

-            m_vertex++;

-            break;

-

-        case 2:

-            cmd = m_curve_poly.vertex(x, y);

-            break;

-

-        case 3:

-        case 4:

-            cmd = m_curve_pnt.vertex(x, y);

-            break;

-

-        default:

-            cmd = path_cmd_stop;

-            break;

-        }

-

-        if(!is_stop(cmd))

-        {

-            transform_xy(x, y);

-        }

-

-        return cmd;

-    }

-

-

-    

-    //------------------------------------------------------------------------

-    void spline_ctrl_impl::active_point(int i)

-    {

-        m_active_pnt = i;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool spline_ctrl_impl::in_rect(double x, double y) const

-    {

-        inverse_transform_xy(&x, &y);

-        return x >= m_x1 && x <= m_x2 && y >= m_y1 && y <= m_y2;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool spline_ctrl_impl::on_mouse_button_down(double x, double y)

-    {

-        inverse_transform_xy(&x, &y);

-        unsigned i;

-        for(i = 0; i < m_num_pnt; i++)  

-        {

-            double xp = calc_xp(i);

-            double yp = calc_yp(i);

-            if(calc_distance(x, y, xp, yp) <= m_point_size + 1)

-            {

-                m_pdx = xp - x;

-                m_pdy = yp - y;

-                m_active_pnt = m_move_pnt = int(i);

-                return true;

-            }

-        }

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool spline_ctrl_impl::on_mouse_button_up(double, double)

-    {

-        if(m_move_pnt >= 0)

-        {

-            m_move_pnt = -1;

-            return true;

-        }

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool spline_ctrl_impl::on_mouse_move(double x, double y, bool button_flag)

-    {

-        inverse_transform_xy(&x, &y);

-        if(!button_flag)

-        {

-            return on_mouse_button_up(x, y);

-        }

-

-        if(m_move_pnt >= 0)

-        {

-            double xp = x + m_pdx;

-            double yp = y + m_pdy;

-

-            set_xp(m_move_pnt, (xp - m_xs1) / (m_xs2 - m_xs1));

-            set_yp(m_move_pnt, (yp - m_ys1) / (m_ys2 - m_ys1));

-

-            update_spline();

-            return true;

-        }

-        return false;

-    }

-

-

-    //------------------------------------------------------------------------

-    bool spline_ctrl_impl::on_arrow_keys(bool left, bool right, bool down, bool up)

-    {

-        double kx = 0.0;

-        double ky = 0.0;

-        bool ret = false;

-        if(m_active_pnt >= 0)

-        {

-            kx = m_xp[m_active_pnt];

-            ky = m_yp[m_active_pnt];

-            if(left)  { kx -= 0.001; ret = true; }

-            if(right) { kx += 0.001; ret = true; }

-            if(down)  { ky -= 0.001; ret = true; }

-            if(up)    { ky += 0.001; ret = true; }

-        }

-        if(ret)

-        {

-            set_xp(m_active_pnt, kx);

-            set_yp(m_active_pnt, ky);

-            update_spline();

-        }

-        return ret;

-    }

-

-

-

-

-}

-