roadmap-commit — track CVS commits

[Roadmap-commit] roadmap_editor/src/agg23/src/platform Makefile.am,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/src/platform

Added Files:
	Makefile.am 
Log Message:
Import agg sources.

--- NEW FILE: Makefile.am ---
SUBDIRS = $(AGG_PLATFORM)

[Roadmap-commit] roadmap_editor/src/agg23/src/platform/X11 Makefile.am,NONE,1.1 agg_platform_support.cpp,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform/X11
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/src/platform/X11

Added Files:
	Makefile.am agg_platform_support.cpp 
Log Message:
Import agg sources.

--- NEW FILE: Makefile.am ---
INCLUDES = -I$(top_srcdir)/include $(AGG_PLATFORM_INC)

lib_LTLIBRARIES = libaggplatformX11.la

libaggplatformX11_la_LDFLAGS = -version-info 2:1:0
libaggplatformX11_la_SOURCES = agg_platform_support.cpp
libaggplatformX11_la_LIBADD = $(AGG_PLATFORM_LIB)

--- NEW FILE: agg_platform_support.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// class platform_support. X11 version.
//
//----------------------------------------------------------------------------

[...1256 lines suppressed...]
    void platform_support::on_post_draw(void* raw_handler) {}



}


int agg_main(int argc, char* argv[]);


int main(int argc, char* argv[])
{
    return agg_main(argc, argv);
}

[Roadmap-commit] roadmap_editor/src/agg23/include/ctrl Makefile.am,NONE,1.1 agg_bezier_ctrl.h,NONE,1.1 agg_cbox_ctrl.h,NONE,1.1 agg_ctrl.h,NONE,1.1 agg_gamma_ctrl.h,NONE,1.1 agg_gamma_spline.h,NONE,1.1 agg_polygon_ctrl.h,NONE,1.1 agg_rbox_ctrl.h,NONE,1.1 agg_scale_ctrl.h,NONE,1.1 agg_slider_ctrl.h,NONE,1.1 agg_spline_ctrl.h,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/include/ctrl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/include/ctrl

Added Files:
	Makefile.am agg_bezier_ctrl.h agg_cbox_ctrl.h agg_ctrl.h 
	agg_gamma_ctrl.h agg_gamma_spline.h agg_polygon_ctrl.h 
	agg_rbox_ctrl.h agg_scale_ctrl.h agg_slider_ctrl.h 
	agg_spline_ctrl.h 
Log Message:
Import agg sources.

--- NEW FILE: agg_slider_ctrl.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes slider_ctrl_impl, slider_ctrl
//
//----------------------------------------------------------------------------

#ifndef AGG_SLIDER_CTRL_INCLUDED
#define AGG_SLIDER_CTRL_INCLUDED

#include "agg_basics.h"
#include "agg_math.h"
#include "agg_ellipse.h"
#include "agg_trans_affine.h"
#include "agg_color_rgba.h"
#include "agg_gsv_text.h"
#include "agg_conv_stroke.h"
#include "agg_path_storage.h"
#include "agg_ctrl.h"


namespace agg
{

    //--------------------------------------------------------slider_ctrl_impl
    class slider_ctrl_impl : public ctrl
    {
    public:
        slider_ctrl_impl(double x1, double y1, double x2, double y2, bool flip_y=false);

        void border_width(double t, double extra=0.0);

        void range(double min, double max) { m_min = min; m_max = max; }
        void num_steps(unsigned num) { m_num_steps = num; }
        void label(const char* fmt);
        void text_thickness(double t) { m_text_thickness = t; }

        bool descending() const { return m_descending; }
        void descending(bool v) { m_descending = v; }

        double value() const { return m_value * (m_max - m_min) + m_min; }
        void value(double value);

        virtual bool in_rect(double x, double y) const;
        virtual bool on_mouse_button_down(double x, double y);
        virtual bool on_mouse_button_up(double x, double y);
        virtual bool on_mouse_move(double x, double y, bool button_flag);
        virtual bool on_arrow_keys(bool left, bool right, bool down, bool up);

        // Vertex source interface
        unsigned num_paths() { return 6; };
        void     rewind(unsigned path_id);
        unsigned vertex(double* x, double* y);

    private:
        void calc_box();
        bool normalize_value(bool preview_value_flag);

        double   m_border_width;
        double   m_border_extra;
        double   m_text_thickness;
        double   m_value;
        double   m_preview_value;
        double   m_min;
        double   m_max;
        unsigned m_num_steps;
        bool     m_descending;
        char     m_label[64];
        double   m_xs1;
        double   m_ys1;
        double   m_xs2;
        double   m_ys2;
        double   m_pdx;
        bool     m_mouse_move;
        double   m_vx[32];
        double   m_vy[32];

        ellipse  m_ellipse;

        unsigned m_idx;
        unsigned m_vertex;

        gsv_text              m_text;
        conv_stroke<gsv_text> m_text_poly;
        path_storage          m_storage;

    };



    //----------------------------------------------------------slider_ctrl
    template<class ColorT> class slider_ctrl : public slider_ctrl_impl
    {
    public:
        slider_ctrl(double x1, double y1, double x2, double y2, bool flip_y=false) :
            slider_ctrl_impl(x1, y1, x2, y2, flip_y),
            m_background_color(rgba(1.0, 0.9, 0.8)),
            m_triangle_color(rgba(0.7, 0.6, 0.6)),
            m_text_color(rgba(0.0, 0.0, 0.0)),
            m_pointer_preview_color(rgba(0.6, 0.4, 0.4, 0.4)),
            m_pointer_color(rgba(0.8, 0.0, 0.0, 0.6))
        {
            m_colors[0] = &m_background_color;
            m_colors[1] = &m_triangle_color;
            m_colors[2] = &m_text_color;
            m_colors[3] = &m_pointer_preview_color;
            m_colors[4] = &m_pointer_color;
            m_colors[5] = &m_text_color;
        }
          

        void background_color(const ColorT& c) { m_background_color = c; }
        void pointer_color(const ColorT& c) { m_pointer_color = c; }

        const ColorT& color(unsigned i) const { return *m_colors[i]; } 

    private:
        slider_ctrl(const slider_ctrl<ColorT>&);
        const slider_ctrl<ColorT>& operator = (const slider_ctrl<ColorT>&);

        ColorT m_background_color;
        ColorT m_triangle_color;
        ColorT m_text_color;
        ColorT m_pointer_preview_color;
        ColorT m_pointer_color;
        ColorT* m_colors[6];
    };





}



#endif


--- NEW FILE: agg_ctrl.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// Function render_ctrl
//
//----------------------------------------------------------------------------

#ifndef AGG_CTRL_INCLUDED
#define AGG_CTRL_INCLUDED

#include "agg_trans_affine.h"
#include "agg_renderer_scanline.h"

namespace agg
{

    //--------------------------------------------------------------------ctrl
    class ctrl
    {
    public:
        //--------------------------------------------------------------------
        virtual ~ctrl() {}
        ctrl(double x1, double y1, double x2, double y2, bool flip_y) :
            m_x1(x1), m_y1(y1), m_x2(x2), m_y2(y2), 
            m_flip_y(flip_y),
            m_mtx(0)
        {
        }

        //--------------------------------------------------------------------
        virtual bool in_rect(double x, double y) const = 0;
        virtual bool on_mouse_button_down(double x, double y) = 0;
        virtual bool on_mouse_button_up(double x, double y) = 0;
        virtual bool on_mouse_move(double x, double y, bool button_flag) = 0;
        virtual bool on_arrow_keys(bool left, bool right, bool down, bool up) = 0;

        //--------------------------------------------------------------------
        void transform(const trans_affine& mtx) { m_mtx = &mtx; }
        void no_transform() { m_mtx = 0; }

        //--------------------------------------------------------------------
        void transform_xy(double* x, double* y) const
        {
            if(m_flip_y) *y = m_y1 + m_y2 - *y;
            if(m_mtx) m_mtx->transform(x, y);
        }

        //--------------------------------------------------------------------
        void inverse_transform_xy(double* x, double* y) const
        {
            if(m_mtx) m_mtx->inverse_transform(x, y);
            if(m_flip_y) *y = m_y1 + m_y2 - *y;
        }

        //--------------------------------------------------------------------
        double scale() const { return m_mtx ? m_mtx->scale() : 1.0; }

    private:
        ctrl(const ctrl&);
        const ctrl& operator = (const ctrl&);

    protected:
        double m_x1;
        double m_y1;
        double m_x2;
        double m_y2;

    private:
        bool m_flip_y;
        const trans_affine* m_mtx;
    };


    //--------------------------------------------------------------------
    template<class Rasterizer, class Scanline, class Renderer, class Ctrl> 
    void render_ctrl(Rasterizer& ras, Scanline& sl, Renderer& r, Ctrl& c)
    {
        unsigned i;
        for(i = 0; i < c.num_paths(); i++)
        {
            ras.reset();
            ras.add_path(c, i);
            r.color(c.color(i));
            render_scanlines(ras, sl, r);
        }
    }


}


#endif

--- NEW FILE: agg_gamma_ctrl.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// class gamma_ctrl
//
//----------------------------------------------------------------------------

#ifndef AGG_GAMMA_CTRL_INCLUDED
#define AGG_GAMMA_CTRL_INCLUDED

#include "agg_basics.h"
#include "agg_gamma_spline.h"
#include "agg_ellipse.h"
#include "agg_conv_stroke.h"
#include "agg_gsv_text.h"
#include "agg_trans_affine.h"
#include "agg_color_rgba.h"
#include "agg_ctrl.h"

namespace agg
{
    //------------------------------------------------------------------------
    // Class that can be used to create an interactive control to set up 
    // gamma arrays.
    //------------------------------------------------------------------------
    class gamma_ctrl_impl : public ctrl
    {
    public:
        gamma_ctrl_impl(double x1, double y1, double x2, double y2, bool flip_y=false);

        // Set other parameters
        void border_width(double t, double extra=0.0);
        void curve_width(double t)         { m_curve_width = t; }
        void grid_width(double t)          { m_grid_width = t; }
        void text_thickness(double t)      { m_text_thickness = t; }
        void text_size(double h, double w=0.0);
        void point_size(double s)              { m_point_size = s; }

        // Event handlers. Just call them if the respective events
        // in your system occure. The functions return true if redrawing
        // is required.
        virtual bool in_rect(double x, double y) const;
        virtual bool on_mouse_button_down(double x, double y);
        virtual bool on_mouse_button_up(double x, double y);
        virtual bool on_mouse_move(double x, double y, bool button_flag);
        virtual bool on_arrow_keys(bool left, bool right, bool down, bool up);

        void change_active_point();

        // A copy of agg::gamma_spline interface
        void  values(double kx1, double ky1, double kx2, double ky2);
        void  values(double* kx1, double* ky1, double* kx2, double* ky2) const;
        const unsigned char* gamma() const { return m_gamma_spline.gamma(); }
        double y(double x) const { return m_gamma_spline.y(x); }
        double operator() (double x) const { return m_gamma_spline.y(x); }
        const gamma_spline& get_gamma_spline() const { return m_gamma_spline; }

        // Vertex soutce interface
        unsigned num_paths() { return 7; }
        void     rewind(unsigned idx);
        unsigned vertex(double* x, double* y);

    private:
        void calc_spline_box();
        void calc_points();
        void calc_values();

        gamma_spline  m_gamma_spline;
        double m_border_width;
        double m_border_extra;
        double m_curve_width;
        double m_grid_width;
        double m_text_thickness;
        double m_point_size;
        double m_text_height;
        double m_text_width;
        double m_xc1;
        double m_yc1;
        double m_xc2;
        double m_yc2;
        double m_xs1;
        double m_ys1;
        double m_xs2;
        double m_ys2;
        double m_xt1;
        double m_yt1;
        double m_xt2;
        double m_yt2;
        conv_stroke<gamma_spline> m_curve_poly;
        ellipse                   m_ellipse;
        gsv_text                  m_text;
        conv_stroke<gsv_text>     m_text_poly;
        unsigned m_idx;
        unsigned m_vertex;
        double   m_vx[32];
        double   m_vy[32];
        double   m_xp1;
        double   m_yp1;
        double   m_xp2;
        double   m_yp2;
        bool     m_p1_active;
        unsigned m_mouse_point;
        double   m_pdx;
        double   m_pdy;
    };



    template<class ColorT> class gamma_ctrl : public gamma_ctrl_impl
    {
    public:
        gamma_ctrl(double x1, double y1, double x2, double y2, bool flip_y=false) :
            gamma_ctrl_impl(x1, y1, x2, y2, flip_y),
            m_background_color(rgba(1.0, 1.0, 0.9)),
            m_border_color(rgba(0.0, 0.0, 0.0)),
            m_curve_color(rgba(0.0, 0.0, 0.0)),
            m_grid_color(rgba(0.2, 0.2, 0.0)),
            m_inactive_pnt_color(rgba(0.0, 0.0, 0.0)),
            m_active_pnt_color(rgba(1.0, 0.0, 0.0)),
            m_text_color(rgba(0.0, 0.0, 0.0))
        {
            m_colors[0] = &m_background_color;
            m_colors[1] = &m_border_color;
            m_colors[2] = &m_curve_color;
            m_colors[3] = &m_grid_color;
            m_colors[4] = &m_inactive_pnt_color;
            m_colors[5] = &m_active_pnt_color;
            m_colors[6] = &m_text_color;
        }

        // Set colors
        void background_color(const ColorT& c)   { m_background_color = c; }
        void border_color(const ColorT& c)       { m_border_color = c; }
        void curve_color(const ColorT& c)        { m_curve_color = c; }
        void grid_color(const ColorT& c)         { m_grid_color = c; }
        void inactive_pnt_color(const ColorT& c) { m_inactive_pnt_color = c; }
        void active_pnt_color(const ColorT& c)   { m_active_pnt_color = c; }
        void text_color(const ColorT& c)         { m_text_color = c; }
        const ColorT& color(unsigned i) const { return *m_colors[i]; } 

    private:
        gamma_ctrl(const gamma_ctrl<ColorT>&);
        const gamma_ctrl<ColorT>& operator = (const gamma_ctrl<ColorT>&);

        ColorT  m_background_color;
        ColorT  m_border_color;
        ColorT  m_curve_color;
        ColorT  m_grid_color;
        ColorT  m_inactive_pnt_color;
        ColorT  m_active_pnt_color;
        ColorT  m_text_color;
        ColorT* m_colors[7];
    };


}

#endif

--- NEW FILE: agg_spline_ctrl.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes spline_ctrl_impl, spline_ctrl
//
//----------------------------------------------------------------------------

#ifndef AGG_SPLINE_CTRL_INCLUDED
#define AGG_SPLINE_CTRL_INCLUDED

#include "agg_basics.h"
#include "agg_ellipse.h"
#include "agg_bspline.h"
#include "agg_conv_stroke.h"
#include "agg_path_storage.h"
#include "agg_trans_affine.h"
#include "agg_color_rgba.h"
#include "agg_ctrl.h"

namespace agg
{

    //------------------------------------------------------------------------
    // Class that can be used to create an interactive control to set up 
    // gamma arrays.
    //------------------------------------------------------------------------
    class spline_ctrl_impl : public ctrl
    {
    public:
        spline_ctrl_impl(double x1, double y1, double x2, double y2, 
                         unsigned num_pnt, bool flip_y=false);

        // Set other parameters
        void border_width(double t, double extra=0.0);
        void curve_width(double t) { m_curve_width = t; }
        void point_size(double s)  { m_point_size = s; }

        // Event handlers. Just call them if the respective events
        // in your system occure. The functions return true if redrawing
        // is required.
        virtual bool in_rect(double x, double y) const;
        virtual bool on_mouse_button_down(double x, double y);
        virtual bool on_mouse_button_up(double x, double y);
        virtual bool on_mouse_move(double x, double y, bool button_flag);
        virtual bool on_arrow_keys(bool left, bool right, bool down, bool up);

        void active_point(int i);

        const double* spline()  const { return m_spline_values;  }
        const int8u*  spline8() const { return m_spline_values8; }
        double value(double x) const;
        void   value(unsigned idx, double y);
        void   point(unsigned idx, double x, double y);
        void   x(unsigned idx, double x) { m_xp[idx] = x; }
        void   y(unsigned idx, double y) { m_yp[idx] = y; }
        double x(unsigned idx) const { return m_xp[idx]; }
        double y(unsigned idx) const { return m_yp[idx]; }
        void  update_spline();

        // Vertex soutce interface
        unsigned num_paths() { return 5; }
        void     rewind(unsigned path_id);
        unsigned vertex(double* x, double* y);

    private:
        void calc_spline_box();
        void calc_curve();
        double calc_xp(unsigned idx);
        double calc_yp(unsigned idx);
        void set_xp(unsigned idx, double val);
        void set_yp(unsigned idx, double val);

        unsigned m_num_pnt;
        double   m_xp[32];
        double   m_yp[32];
        bspline  m_spline;
        double   m_spline_values[256];
        int8u    m_spline_values8[256];
        double   m_border_width;
        double   m_border_extra;
        double   m_curve_width;
        double   m_point_size;
        double   m_xs1;
        double   m_ys1;
        double   m_xs2;
        double   m_ys2;
        path_storage              m_curve_pnt;
        conv_stroke<path_storage> m_curve_poly;
        ellipse                   m_ellipse;
        unsigned m_idx;
        unsigned m_vertex;
        double   m_vx[32];
        double   m_vy[32];
        int      m_active_pnt;
        int      m_move_pnt;
        double   m_pdx;
        double   m_pdy;
        const trans_affine* m_mtx;
    };


    template<class ColorT> class spline_ctrl : public spline_ctrl_impl
    {
    public:
        spline_ctrl(double x1, double y1, double x2, double y2, 
                    unsigned num_pnt, bool flip_y=false) :
            spline_ctrl_impl(x1, y1, x2, y2, num_pnt, flip_y),
            m_background_color(rgba(1.0, 1.0, 0.9)),
            m_border_color(rgba(0.0, 0.0, 0.0)),
            m_curve_color(rgba(0.0, 0.0, 0.0)),
            m_inactive_pnt_color(rgba(0.0, 0.0, 0.0)),
            m_active_pnt_color(rgba(1.0, 0.0, 0.0))
        {
            m_colors[0] = &m_background_color;
            m_colors[1] = &m_border_color;
            m_colors[2] = &m_curve_color;
            m_colors[3] = &m_inactive_pnt_color;
            m_colors[4] = &m_active_pnt_color;
        }

        // Set colors
        void background_color(const ColorT& c)   { m_background_color = c; }
        void border_color(const ColorT& c)       { m_border_color = c; }
        void curve_color(const ColorT& c)        { m_curve_color = c; }
        void inactive_pnt_color(const ColorT& c) { m_inactive_pnt_color = c; }
        void active_pnt_color(const ColorT& c)   { m_active_pnt_color = c; }
        const ColorT& color(unsigned i) const { return *m_colors[i]; } 

    private:
        spline_ctrl(const spline_ctrl<ColorT>&);
        const spline_ctrl<ColorT>& operator = (const spline_ctrl<ColorT>&);

        ColorT  m_background_color;
        ColorT  m_border_color;
        ColorT  m_curve_color;
        ColorT  m_inactive_pnt_color;
        ColorT  m_active_pnt_color;
        ColorT* m_colors[5];
    };




}


#endif

--- NEW FILE: agg_bezier_ctrl.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes bezier_ctrl_impl, bezier_ctrl
//
//----------------------------------------------------------------------------

#ifndef AGG_BEZIER_CTRL_INCLUDED
#define AGG_BEZIER_CTRL_INCLUDED

#include "agg_math.h"
#include "agg_ellipse.h"
#include "agg_trans_affine.h"
#include "agg_color_rgba.h"
#include "agg_conv_stroke.h"
#include "agg_conv_curve.h"
#include "agg_polygon_ctrl.h"


namespace agg
{

    //--------------------------------------------------------bezier_ctrl_impl
    class bezier_ctrl_impl : public ctrl
    {
    public:
        bezier_ctrl_impl();

        void curve(double x1, double y1, 
                   double x2, double y2, 
                   double x3, double y3,
                   double x4, double y4);
        curve4& curve();

        double x1() const { return m_poly.xn(0); }
        double y1() const { return m_poly.yn(0); }
        double x2() const { return m_poly.xn(1); }
        double y2() const { return m_poly.yn(1); }
        double x3() const { return m_poly.xn(2); }
        double y3() const { return m_poly.yn(2); }
        double x4() const { return m_poly.xn(3); }
        double y4() const { return m_poly.yn(3); }

        void x1(double x) { m_poly.xn(0) = x; }
        void y1(double y) { m_poly.yn(0) = y; }
        void x2(double x) { m_poly.xn(1) = x; }
        void y2(double y) { m_poly.yn(1) = y; }
        void x3(double x) { m_poly.xn(2) = x; }
        void y3(double y) { m_poly.yn(2) = y; }
        void x4(double x) { m_poly.xn(3) = x; }
        void y4(double y) { m_poly.yn(3) = y; }

        void   line_width(double w) { m_stroke.width(w); }
        double line_width() const   { return m_stroke.width(); }

        void   point_radius(double r) { m_poly.point_radius(r); }
        double point_radius() const   { return m_poly.point_radius(); }

        virtual bool in_rect(double x, double y) const;
        virtual bool on_mouse_button_down(double x, double y);
        virtual bool on_mouse_button_up(double x, double y);
        virtual bool on_mouse_move(double x, double y, bool button_flag);
        virtual bool on_arrow_keys(bool left, bool right, bool down, bool up);

        // Vertex source interface
        unsigned num_paths() { return 7; };
        void     rewind(unsigned path_id);
        unsigned vertex(double* x, double* y);


    private:
        curve4              m_curve;
        ellipse             m_ellipse;
        conv_stroke<curve4> m_stroke;
        polygon_ctrl_impl   m_poly;
        unsigned            m_idx;
    };



    //----------------------------------------------------------bezier_ctrl
    template<class ColorT> class bezier_ctrl : public bezier_ctrl_impl
    {
    public:
        bezier_ctrl() :
            m_color(rgba(0.0, 0.0, 0.0))
        {
        }
          
        void line_color(const ColorT& c) { m_color = c; }
        const ColorT& color(unsigned i) const { return m_color; } 

    private:
        bezier_ctrl(const bezier_ctrl<ColorT>&);
        const bezier_ctrl<ColorT>& operator = (const bezier_ctrl<ColorT>&);

        ColorT m_color;
    };





    //--------------------------------------------------------curve3_ctrl_impl
    class curve3_ctrl_impl : public ctrl
    {
    public:
        curve3_ctrl_impl();

        void curve(double x1, double y1, 
                   double x2, double y2, 
                   double x3, double y3);
        curve3& curve();

        double x1() const { return m_poly.xn(0); }
        double y1() const { return m_poly.yn(0); }
        double x2() const { return m_poly.xn(1); }
        double y2() const { return m_poly.yn(1); }
        double x3() const { return m_poly.xn(2); }
        double y3() const { return m_poly.yn(2); }

        void x1(double x) { m_poly.xn(0) = x; }
        void y1(double y) { m_poly.yn(0) = y; }
        void x2(double x) { m_poly.xn(1) = x; }
        void y2(double y) { m_poly.yn(1) = y; }
        void x3(double x) { m_poly.xn(2) = x; }
        void y3(double y) { m_poly.yn(2) = y; }

        void   line_width(double w) { m_stroke.width(w); }
        double line_width() const   { return m_stroke.width(); }

        void   point_radius(double r) { m_poly.point_radius(r); }
        double point_radius() const   { return m_poly.point_radius(); }

        virtual bool in_rect(double x, double y) const;
        virtual bool on_mouse_button_down(double x, double y);
        virtual bool on_mouse_button_up(double x, double y);
        virtual bool on_mouse_move(double x, double y, bool button_flag);
        virtual bool on_arrow_keys(bool left, bool right, bool down, bool up);

        // Vertex source interface
        unsigned num_paths() { return 6; };
        void     rewind(unsigned path_id);
        unsigned vertex(double* x, double* y);


    private:
        curve3              m_curve;
        ellipse             m_ellipse;
        conv_stroke<curve3> m_stroke;
        polygon_ctrl_impl   m_poly;
        unsigned            m_idx;
    };



    //----------------------------------------------------------curve3_ctrl
    template<class ColorT> class curve3_ctrl : public curve3_ctrl_impl
    {
    public:
        curve3_ctrl() :
            m_color(rgba(0.0, 0.0, 0.0))
        {
        }
          
        void line_color(const ColorT& c) { m_color = c; }
        const ColorT& color(unsigned i) const { return m_color; } 

    private:
        curve3_ctrl(const curve3_ctrl<ColorT>&);
        const curve3_ctrl<ColorT>& operator = (const curve3_ctrl<ColorT>&);

        ColorT m_color;
    };




}



#endif


--- NEW FILE: agg_rbox_ctrl.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes rbox_ctrl_impl, rbox_ctrl
//
//----------------------------------------------------------------------------

#ifndef AGG_RBOX_CTRL_INCLUDED
#define AGG_RBOX_CTRL_INCLUDED

#include "agg_basics.h"
#include "agg_ellipse.h"
#include "agg_conv_stroke.h"
#include "agg_gsv_text.h"
#include "agg_trans_affine.h"
#include "agg_color_rgba.h"
#include "agg_ctrl.h"



namespace agg
{

    //------------------------------------------------------------------------
    class rbox_ctrl_impl : public ctrl
    {
    public:
        ~rbox_ctrl_impl();
        rbox_ctrl_impl(double x1, double y1, double x2, double y2, bool flip_y=false);

        void border_width(double t, double extra=0.0);
        void text_thickness(double t)  { m_text_thickness = t; }
        void text_size(double h, double w=0.0);

        void add_item(const char* text);
        int  cur_item() const { return m_cur_item; }
        void cur_item(int i) { m_cur_item = i; }

        virtual bool in_rect(double x, double y) const;
        virtual bool on_mouse_button_down(double x, double y);
        virtual bool on_mouse_button_up(double x, double y);
        virtual bool on_mouse_move(double x, double y, bool button_flag);
        virtual bool on_arrow_keys(bool left, bool right, bool down, bool up);

        // Vertex soutce interface
        unsigned num_paths() { return 5; };
        void     rewind(unsigned path_id);
        unsigned vertex(double* x, double* y);

    private:
        void calc_rbox();

        double   m_border_width;
        double   m_border_extra;
        double   m_text_thickness;
        double   m_text_height;
        double   m_text_width;
        char*    m_items[32];
        unsigned m_num_items;
        int      m_cur_item;

        double   m_xs1;
        double   m_ys1;
        double   m_xs2;
        double   m_ys2;

        double   m_vx[32];
        double   m_vy[32];
        unsigned m_draw_item;
        double   m_dy;

        ellipse               m_ellipse;
        conv_stroke<ellipse>  m_ellipse_poly;
        gsv_text              m_text;
        conv_stroke<gsv_text> m_text_poly;

        unsigned m_idx;
        unsigned m_vertex;
    };



    //------------------------------------------------------------------------
    template<class ColorT> class rbox_ctrl : public rbox_ctrl_impl
    {
    public:
        rbox_ctrl(double x1, double y1, double x2, double y2, bool flip_y=false) :
            rbox_ctrl_impl(x1, y1, x2, y2, flip_y),
            m_background_color(rgba(1.0, 1.0, 0.9)),
            m_border_color(rgba(0.0, 0.0, 0.0)),
            m_text_color(rgba(0.0, 0.0, 0.0)),
            m_inactive_color(rgba(0.0, 0.0, 0.0)),
            m_active_color(rgba(0.4, 0.0, 0.0))
        {
            m_colors[0] = &m_background_color;
            m_colors[1] = &m_border_color;
            m_colors[2] = &m_text_color;
            m_colors[3] = &m_inactive_color;
            m_colors[4] = &m_active_color;
        }
          

        void background_color(const ColorT& c) { m_background_color = c; }
        void border_color(const ColorT& c) { m_border_color = c; }
        void text_color(const ColorT& c) { m_text_color = c; }
        void inactive_color(const ColorT& c) { m_inactive_color = c; }
        void active_color(const ColorT& c) { m_active_color = c; }

        const ColorT& color(unsigned i) const { return *m_colors[i]; } 

    private:
        rbox_ctrl(const rbox_ctrl<ColorT>&);
        const rbox_ctrl<ColorT>& operator = (const rbox_ctrl<ColorT>&);
       
        ColorT m_background_color;
        ColorT m_border_color;
        ColorT m_text_color;
        ColorT m_inactive_color;
        ColorT m_active_color;
        ColorT* m_colors[5];
    };



}



#endif


--- NEW FILE: agg_polygon_ctrl.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes polygon_ctrl_impl, polygon_ctrl
//
//----------------------------------------------------------------------------

#ifndef POLYGON_CTRL_INCLUDED
#define POLYGON_CTRL_INCLUDED

#include "agg_conv_stroke.h"
#include "agg_ellipse.h"
#include "agg_color_rgba.h"
#include "agg_ctrl.h"

namespace agg
{
    class simple_polygon_vertex_source
    {
    public:
        simple_polygon_vertex_source(const double* polygon, unsigned np, 
                                     bool roundoff = false,
                                     bool close = true) :
            m_polygon(polygon),
            m_num_points(np),
            m_vertex(0),
            m_roundoff(roundoff),
            m_close(close)
        {
        }

        void close(bool f) { m_close = f;    }
        bool close() const { return m_close; }

        void rewind(unsigned)
        {
            m_vertex = 0;
        }

        unsigned vertex(double* x, double* y)
        {
            if(m_vertex > m_num_points) return path_cmd_stop;
            if(m_vertex == m_num_points) 
            {
                ++m_vertex;
                return path_cmd_end_poly | (m_close ? path_flags_close : 0);
            }
            *x = m_polygon[m_vertex * 2];
            *y = m_polygon[m_vertex * 2 + 1];
            if(m_roundoff)
            {
                *x = floor(*x) + 0.5;
                *y = floor(*y) + 0.5;
            }
            ++m_vertex;
            return (m_vertex == 1) ? path_cmd_move_to : path_cmd_line_to;
        }

    private:
        const double* m_polygon;
        unsigned m_num_points;
        unsigned m_vertex;
        bool     m_roundoff;
        bool     m_close;
    };




    class polygon_ctrl_impl : public ctrl
    {
    public:
        ~polygon_ctrl_impl();
        polygon_ctrl_impl(unsigned np, double point_radius=5);

        unsigned num_points() const { return m_num_points; }
        double xn(unsigned n) const { return m_polygon[n * 2];     }
        double yn(unsigned n) const { return m_polygon[n * 2 + 1]; }
        double& xn(unsigned n) { return m_polygon[n * 2];     }
        double& yn(unsigned n) { return m_polygon[n * 2 + 1]; }
    
        const double* polygon() const { return m_polygon; }

        void   line_width(double w) { m_stroke.width(w); }
        double line_width() const   { return m_stroke.width(); }

        void   point_radius(double r) { m_point_radius = r; }
        double point_radius() const   { return m_point_radius; }

        void in_polygon_check(bool f) { m_in_polygon_check = f; }
        bool in_polygon_check() const { return m_in_polygon_check; }

        void close(bool f) { m_vs.close(f);       }
        bool close() const { return m_vs.close(); }

        // Vertex source interface
        unsigned num_paths() { return 1; }
        void     rewind(unsigned path_id);
        unsigned vertex(double* x, double* y);

        virtual bool in_rect(double x, double y) const;
        virtual bool on_mouse_button_down(double x, double y);
        virtual bool on_mouse_button_up(double x, double y);
        virtual bool on_mouse_move(double x, double y, bool button_flag);
        virtual bool on_arrow_keys(bool left, bool right, bool down, bool up);


    private:
        bool check_edge(unsigned i, double x, double y) const;
        bool point_in_polygon(double x, double y) const;

        double*  m_polygon;
        unsigned m_num_points;
        int      m_node;
        int      m_edge;
        simple_polygon_vertex_source m_vs;
        conv_stroke<simple_polygon_vertex_source> m_stroke;
        ellipse  m_ellipse;
        double   m_point_radius;
        unsigned m_status;
        double   m_dx;
        double   m_dy;
        bool     m_in_polygon_check;
    };



    //----------------------------------------------------------polygon_ctrl
    template<class ColorT> class polygon_ctrl : public polygon_ctrl_impl
    {
    public:
        polygon_ctrl(unsigned np, double point_radius=5) :
            polygon_ctrl_impl(np, point_radius),
            m_color(rgba(0.0, 0.0, 0.0))
        {
        }
          
        void line_color(const ColorT& c) { m_color = c; }
        const ColorT& color(unsigned i) const { return m_color; } 

    private:
        polygon_ctrl(const polygon_ctrl<ColorT>&);
        const polygon_ctrl<ColorT>& operator = (const polygon_ctrl<ColorT>&);

        ColorT m_color;
    };




}

#endif


--- NEW FILE: agg_gamma_spline.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// class gamma_spline
//
//----------------------------------------------------------------------------

#ifndef AGG_GAMMA_SPLINE_INCLUDED
#define AGG_GAMMA_SPLINE_INCLUDED

#include "agg_basics.h"
#include "agg_bspline.h"

namespace agg
{
    
    //------------------------------------------------------------------------
    // Class-helper for calculation gamma-correction arrays. A gamma-correction
    // array is an array of 256 unsigned chars that determine the actual values 
    // of Anti-Aliasing for each pixel coverage value from 0 to 255. If all the 
    // values in the array are equal to its index, i.e. 0,1,2,3,... there's
    // no gamma-correction. Class agg::polyfill allows you to use custom 
    // gamma-correction arrays. You can calculate it using any approach, and
    // class gamma_spline allows you to calculate almost any reasonable shape 
    // of the gamma-curve with using only 4 values - kx1, ky1, kx2, ky2.
    // 
    //                                      kx2
    //        +----------------------------------+
    //        |                 |        |    .  | 
    //        |                 |        | .     | ky2
    //        |                 |       .  ------|
    //        |                 |    .           |
    //        |                 | .              |
    //        |----------------.|----------------|
    //        |             .   |                |
    //        |          .      |                |
    //        |-------.         |                |
    //    ky1 |    .   |        |                |
    //        | .      |        |                |
    //        +----------------------------------+
    //            kx1
    // 
    // Each value can be in range [0...2]. Value 1.0 means one quarter of the
    // bounding rectangle. Function values() calculates the curve by these
    // 4 values. After calling it one can get the gamma-array with call gamma(). 
    // Class also supports the vertex source interface, i.e rewind() and
    // vertex(). It's made for convinience and used in class gamma_ctrl. 
    // Before calling rewind/vertex one must set the bounding box
    // box() using pixel coordinates. 
    //------------------------------------------------------------------------

    class gamma_spline
    {
    public:
        gamma_spline();

        void values(double kx1, double ky1, double kx2, double ky2);
        const unsigned char* gamma() const { return m_gamma; }
        double y(double x) const;
        void values(double* kx1, double* ky1, double* kx2, double* ky2) const;
        void box(double x1, double y1, double x2, double y2);

        void     rewind(unsigned);
        unsigned vertex(double* x, double* y);

    private:
        unsigned char m_gamma[256];
        double        m_x[4];
        double        m_y[4];
        bspline       m_spline;
        double        m_x1;
        double        m_y1;
        double        m_x2;
        double        m_y2;
        double        m_cur_x;
    };




}

#endif

--- NEW FILE: agg_cbox_ctrl.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes cbox_ctrl_impl, cbox_ctrl
//
//----------------------------------------------------------------------------

#ifndef AGG_CBOX_CTRL_INCLUDED
#define AGG_CBOX_CTRL_INCLUDED

#include "agg_basics.h"
#include "agg_conv_stroke.h"
#include "agg_gsv_text.h"
#include "agg_trans_affine.h"
#include "agg_color_rgba.h"
#include "agg_ctrl.h"



namespace agg
{

    //----------------------------------------------------------cbox_ctrl_impl
    class cbox_ctrl_impl : public ctrl
    {
    public:
        cbox_ctrl_impl(double x, double y, const char* label, bool flip_y=false);

        void text_thickness(double t)  { m_text_thickness = t; }
        void text_size(double h, double w=0.0);

        const char* label() { return m_label; }
        void label(const char* l);

        bool status() const { return m_status; }
        void status(bool st) { m_status = st; }

        virtual bool in_rect(double x, double y) const;
        virtual bool on_mouse_button_down(double x, double y);
        virtual bool on_mouse_button_up(double x, double y);
        virtual bool on_mouse_move(double x, double y, bool button_flag);
        virtual bool on_arrow_keys(bool left, bool right, bool down, bool up);

        // Vertex soutce interface
        unsigned num_paths() { return 3; };
        void     rewind(unsigned path_id);
        unsigned vertex(double* x, double* y);

    private:
        double   m_text_thickness;
        double   m_text_height;
        double   m_text_width;
        char     m_label[128];
        bool     m_status;
        double   m_vx[32];
        double   m_vy[32];

        gsv_text              m_text;
        conv_stroke<gsv_text> m_text_poly;

        unsigned m_idx;
        unsigned m_vertex;
    };


    //----------------------------------------------------------cbox_ctrl_impl
    template<class ColorT> class cbox_ctrl : public cbox_ctrl_impl
    {
    public:
        cbox_ctrl(double x, double y, const char* label, bool flip_y=false) :
            cbox_ctrl_impl(x, y, label, flip_y),
            m_text_color(rgba(0.0, 0.0, 0.0)),
            m_inactive_color(rgba(0.0, 0.0, 0.0)),
            m_active_color(rgba(0.4, 0.0, 0.0))
        {
            m_colors[0] = &m_inactive_color;
            m_colors[1] = &m_text_color;
            m_colors[2] = &m_active_color;
        }
          
        void text_color(const ColorT& c) { m_text_color = c; }
        void inactive_color(const ColorT& c) { m_inactive_color = c; }
        void active_color(const ColorT& c) { m_active_color = c; }

        const ColorT& color(unsigned i) const { return *m_colors[i]; } 

    private:
        cbox_ctrl(const cbox_ctrl<ColorT>&);
        const cbox_ctrl<ColorT>& operator = (const cbox_ctrl<ColorT>&);

        ColorT m_text_color;
        ColorT m_inactive_color;
        ColorT m_active_color;
        ColorT* m_colors[3];
    };


}

#endif

--- NEW FILE: Makefile.am ---
myincludedir = $(includedir)/agg2/ctrl
myinclude_HEADERS = agg_ctrl.h agg_gamma_spline.h agg_scale_ctrl.h agg_spline_ctrl.h \
					agg_cbox_ctrl.h agg_gamma_ctrl.h agg_rbox_ctrl.h agg_slider_ctrl.h \
					agg_bezier_ctrl.h agg_polygon_ctrl.h 

--- NEW FILE: agg_scale_ctrl.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes scale_ctrl_impl, scale_ctrl
//
//----------------------------------------------------------------------------

#ifndef AGG_SCALE_CTRL_INCLUDED
#define AGG_SCALE_CTRL_INCLUDED

#include "agg_basics.h"
#include "agg_math.h"
#include "agg_ellipse.h"
#include "agg_trans_affine.h"
#include "agg_color_rgba.h"
#include "agg_ctrl.h"


namespace agg
{

    //------------------------------------------------------------------------
    class scale_ctrl_impl : public ctrl
    {
        enum move_e
        {
            move_nothing,
            move_value1,
            move_value2,
            move_slider
        };

    public:
        scale_ctrl_impl(double x1, double y1, double x2, double y2, bool flip_y=false);

        void border_thickness(double t, double extra=0.0);
        void resize(double x1, double y1, double x2, double y2);
        
        double min_delta() const { return m_min_d; }
        void min_delta(double d) { m_min_d = d; }
        
        double value1() const { return m_value1; }
        void value1(double value);

        double value2() const { return m_value2; }
        void value2(double value);

        void move(double d);

        virtual bool in_rect(double x, double y) const;
        virtual bool on_mouse_button_down(double x, double y);
        virtual bool on_mouse_button_up(double x, double y);
        virtual bool on_mouse_move(double x, double y, bool button_flag);
        virtual bool on_arrow_keys(bool left, bool right, bool down, bool up);

        // Vertex soutce interface
        unsigned num_paths() { return 5; };
        void     rewind(unsigned path_id);
        unsigned vertex(double* x, double* y);

    private:
        void calc_box();

        double   m_border_thickness;
        double   m_border_extra;
        double   m_value1;
        double   m_value2;
        double   m_min_d;
        double   m_xs1;
        double   m_ys1;
        double   m_xs2;
        double   m_ys2;
        double   m_pdx;
        double   m_pdy;
        move_e   m_move_what;
        double   m_vx[32];
        double   m_vy[32];

        ellipse  m_ellipse;

        unsigned m_idx;
        unsigned m_vertex;

    };



    //------------------------------------------------------------------------
    template<class ColorT> class scale_ctrl : public scale_ctrl_impl
    {
    public:
        scale_ctrl(double x1, double y1, double x2, double y2, bool flip_y=false) :
            scale_ctrl_impl(x1, y1, x2, y2, flip_y),
            m_background_color(rgba(1.0, 0.9, 0.8)),
            m_border_color(rgba(0.0, 0.0, 0.0)),
            m_pointers_color(rgba(0.8, 0.0, 0.0, 0.8)),
            m_slider_color(rgba(0.2, 0.1, 0.0, 0.6))
        {
            m_colors[0] = &m_background_color;
            m_colors[1] = &m_border_color;
            m_colors[2] = &m_pointers_color;
            m_colors[3] = &m_pointers_color;
            m_colors[4] = &m_slider_color;
        }
          

        void background_color(const ColorT& c) { m_background_color = c; }
        void border_color(const ColorT& c)     { m_border_color = c; }
        void pointers_color(const ColorT& c)   { m_pointers_color = c; }
        void slider_color(const ColorT& c)     { m_slider_color = c; }

        const ColorT& color(unsigned i) const { return *m_colors[i]; } 

    private:
        scale_ctrl(const scale_ctrl<ColorT>&);
        const scale_ctrl<ColorT>& operator = (const scale_ctrl<ColorT>&);

        ColorT m_background_color;
        ColorT m_border_color;
        ColorT m_pointers_color;
        ColorT m_slider_color;
        ColorT* m_colors[5];
    };





}



#endif

[Roadmap-commit] roadmap_editor/src/agg23/include/util Makefile.am,NONE,1.1 agg_color_conv.h,NONE,1.1 agg_color_conv_rgb16.h,NONE,1.1 agg_color_conv_rgb8.h,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/include/util
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/include/util

Added Files:
	Makefile.am agg_color_conv.h agg_color_conv_rgb16.h 
	agg_color_conv_rgb8.h 
Log Message:
Import agg sources.

--- NEW FILE: Makefile.am ---
myincludedir = $(includedir)/agg2/util
myinclude_HEADERS = agg_color_conv.h agg_color_conv_rgb8.h agg_color_conv_rgb16.h

--- NEW FILE: agg_color_conv_rgb16.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// This part of the library has been sponsored by 
// Liberty Technology Systems, Inc., visit http://lib-sys.com
//
// Liberty Technology Systems, Inc. is the provider of
// PostScript and PDF technology for software developers.
// 
//----------------------------------------------------------------------------
//
// A set of functors used with color_conv(). See file agg_color_conv.h
// These functors can convert images with up to 8 bits per component.
// Use convertors in the following way:
//
// agg::color_conv(dst, src, agg::color_conv_XXXX_to_YYYY());
//----------------------------------------------------------------------------

#ifndef AGG_COLOR_CONV_RGB16_INCLUDED
#define AGG_COLOR_CONV_RGB16_INCLUDED

#include "agg_basics.h"
#include "agg_color_conv.h"

namespace agg
{

    //-------------------------------------------------color_conv_gray16_to_gray8
    class color_conv_gray16_to_gray8
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            int16u* s = (int16u*)src;
            do
            {
                *dst++ = *s++ >> 8;
            }
            while(--width);
        }
    };


    //-----------------------------------------------------color_conv_rgb24_rgb48
    template<int I1, int I3> class color_conv_rgb24_rgb48
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            int16u* d = (int16u*)dst;
            do
            {
                *d++ = (src[I1] << 8) | src[I1];
                *d++ = (src[1]  << 8) | src[1] ;
                *d++ = (src[I3] << 8) | src[I3];
                src += 3;
            }
            while(--width);
        }
    };

    typedef color_conv_rgb24_rgb48<0,2> color_conv_rgb24_to_rgb48;
    typedef color_conv_rgb24_rgb48<0,2> color_conv_bgr24_to_bgr48;
    typedef color_conv_rgb24_rgb48<2,0> color_conv_rgb24_to_bgr48;
    typedef color_conv_rgb24_rgb48<2,0> color_conv_bgr24_to_rgb48;


    //-----------------------------------------------------color_conv_rgb24_rgb48
    template<int I1, int I3> class color_conv_rgb48_rgb24
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            const int16u* s = (const int16u*)src;
            do
            {
                *dst++ = s[I1] >> 8;
                *dst++ = s[1]  >> 8;
                *dst++ = s[I3] >> 8;
                s += 3;
            }
            while(--width);
        }
    };

    typedef color_conv_rgb48_rgb24<0,2> color_conv_rgb48_to_rgb24;
    typedef color_conv_rgb48_rgb24<0,2> color_conv_bgr48_to_bgr24;
    typedef color_conv_rgb48_rgb24<2,0> color_conv_rgb48_to_bgr24;
    typedef color_conv_rgb48_rgb24<2,0> color_conv_bgr48_to_rgb24;


    //----------------------------------------------color_conv_rgbAAA_rgb24
    template<int R, int B> class color_conv_rgbAAA_rgb24
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                int32u rgb = *(int32u*)src;
                dst[R] = int8u(rgb >> 22);
                dst[1] = int8u(rgb >> 12);
                dst[B] = int8u(rgb >> 2);
                src += 4;
                dst += 3;
            }
            while(--width);
        }
    };

    typedef color_conv_rgbAAA_rgb24<0,2> color_conv_rgbAAA_to_rgb24;
    typedef color_conv_rgbAAA_rgb24<2,0> color_conv_rgbAAA_to_bgr24;
    typedef color_conv_rgbAAA_rgb24<2,0> color_conv_bgrAAA_to_rgb24;
    typedef color_conv_rgbAAA_rgb24<0,2> color_conv_bgrAAA_to_bgr24;


    //----------------------------------------------color_conv_rgbBBA_rgb24
    template<int R, int B> class color_conv_rgbBBA_rgb24
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                int32u rgb = *(int32u*)src;
                dst[R] = int8u(rgb >> 24);
                dst[1] = int8u(rgb >> 13);
                dst[B] = int8u(rgb >> 2);
                src += 4;
                dst += 3;
            }
            while(--width);
        }
    };

    typedef color_conv_rgbBBA_rgb24<0,2> color_conv_rgbBBA_to_rgb24;
    typedef color_conv_rgbBBA_rgb24<2,0> color_conv_rgbBBA_to_bgr24;


    //----------------------------------------------color_conv_bgrABB_rgb24
    template<int B, int R> class color_conv_bgrABB_rgb24
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                int32u bgr = *(int32u*)src;
                dst[R] = int8u(bgr >> 3);
                dst[1] = int8u(bgr >> 14);
                dst[B] = int8u(bgr >> 24);
                src += 4;
                dst += 3;
            }
            while(--width);
        }
    };

    typedef color_conv_bgrABB_rgb24<2,0> color_conv_bgrABB_to_rgb24;
    typedef color_conv_bgrABB_rgb24<0,2> color_conv_bgrABB_to_bgr24;


    //-------------------------------------------------color_conv_rgba64_rgba32
    template<int I1, int I2, int I3, int I4> class color_conv_rgba64_rgba32
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                *dst++ = int8u(((int16u*)src)[I1] >> 8);
                *dst++ = int8u(((int16u*)src)[I2] >> 8);
                *dst++ = int8u(((int16u*)src)[I3] >> 8);
                *dst++ = int8u(((int16u*)src)[I4] >> 8); 
                src += 8;
            }
            while(--width);
        }
    };

    //------------------------------------------------------------------------
    typedef color_conv_rgba64_rgba32<0,1,2,3> color_conv_rgba64_to_rgba32; //----color_conv_rgba64_to_rgba32
    typedef color_conv_rgba64_rgba32<0,1,2,3> color_conv_argb64_to_argb32; //----color_conv_argb64_to_argb32
    typedef color_conv_rgba64_rgba32<0,1,2,3> color_conv_bgra64_to_bgra32; //----color_conv_bgra64_to_bgra32
    typedef color_conv_rgba64_rgba32<0,1,2,3> color_conv_abgr64_to_abgr32; //----color_conv_abgr64_to_abgr32
    typedef color_conv_rgba64_rgba32<0,3,2,1> color_conv_argb64_to_abgr32; //----color_conv_argb64_to_abgr32
    typedef color_conv_rgba64_rgba32<3,2,1,0> color_conv_argb64_to_bgra32; //----color_conv_argb64_to_bgra32
    typedef color_conv_rgba64_rgba32<1,2,3,0> color_conv_argb64_to_rgba32; //----color_conv_argb64_to_rgba32
    typedef color_conv_rgba64_rgba32<3,0,1,2> color_conv_bgra64_to_abgr32; //----color_conv_bgra64_to_abgr32
    typedef color_conv_rgba64_rgba32<3,2,1,0> color_conv_bgra64_to_argb32; //----color_conv_bgra64_to_argb32
    typedef color_conv_rgba64_rgba32<2,1,0,3> color_conv_bgra64_to_rgba32; //----color_conv_bgra64_to_rgba32
    typedef color_conv_rgba64_rgba32<3,2,1,0> color_conv_rgba64_to_abgr32; //----color_conv_rgba64_to_abgr32
    typedef color_conv_rgba64_rgba32<3,0,1,2> color_conv_rgba64_to_argb32; //----color_conv_rgba64_to_argb32
    typedef color_conv_rgba64_rgba32<2,1,0,3> color_conv_rgba64_to_bgra32; //----color_conv_rgba64_to_bgra32
    typedef color_conv_rgba64_rgba32<0,3,2,1> color_conv_abgr64_to_argb32; //----color_conv_abgr64_to_argb32
    typedef color_conv_rgba64_rgba32<1,2,3,0> color_conv_abgr64_to_bgra32; //----color_conv_abgr64_to_bgra32
    typedef color_conv_rgba64_rgba32<3,2,1,0> color_conv_abgr64_to_rgba32; //----color_conv_abgr64_to_rgba32



    //--------------------------------------------color_conv_rgb24_rgba64
    template<int I1, int I2, int I3, int A> class color_conv_rgb24_rgba64
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            int16u* d = (int16u*)dst;
            do
            {
                d[I1] = (src[0] << 8) | src[0];
                d[I2] = (src[1] << 8) | src[1];
                d[I3] = (src[2] << 8) | src[2];
                d[A]  = 65535; 
                d   += 4;
                src += 3;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_rgb24_rgba64<1,2,3,0> color_conv_rgb24_to_argb64; //----color_conv_rgb24_to_argb64
    typedef color_conv_rgb24_rgba64<3,2,1,0> color_conv_rgb24_to_abgr64; //----color_conv_rgb24_to_abgr64
    typedef color_conv_rgb24_rgba64<2,1,0,3> color_conv_rgb24_to_bgra64; //----color_conv_rgb24_to_bgra64
    typedef color_conv_rgb24_rgba64<0,1,2,3> color_conv_rgb24_to_rgba64; //----color_conv_rgb24_to_rgba64
    typedef color_conv_rgb24_rgba64<3,2,1,0> color_conv_bgr24_to_argb64; //----color_conv_bgr24_to_argb64
    typedef color_conv_rgb24_rgba64<1,2,3,0> color_conv_bgr24_to_abgr64; //----color_conv_bgr24_to_abgr64
    typedef color_conv_rgb24_rgba64<0,1,2,3> color_conv_bgr24_to_bgra64; //----color_conv_bgr24_to_bgra64
    typedef color_conv_rgb24_rgba64<2,1,0,3> color_conv_bgr24_to_rgba64; //----color_conv_bgr24_to_rgba64


    template<int R, int B> class color_conv_rgb24_gray16
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            int16u* d = (int16u*)dst;
            do
            {
                *d++ = src[R]*77 + src[1]*150 + src[B]*29;
                src += 3;
            }
            while(--width);
        }
    };

    typedef color_conv_rgb24_gray16<0,2> color_conv_rgb24_to_gray16;
    typedef color_conv_rgb24_gray16<2,0> color_conv_bgr24_to_gray16;


}


#endif

--- NEW FILE: agg_color_conv.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// Conversion from one colorspace/pixel format to another
//
//----------------------------------------------------------------------------

#ifndef AGG_COLOR_CONV_INCLUDED
#define AGG_COLOR_CONV_INCLUDED

#include <string.h>
#include "agg_basics.h"
#include "agg_rendering_buffer.h"




namespace agg
{

    //--------------------------------------------------------------color_conv
    template<class CopyRow> 
    void color_conv(rendering_buffer* dst, 
                    const rendering_buffer* src,
                    CopyRow copy_row_functor)
    {
        unsigned width = src->width();
        unsigned height = src->height();

        if(dst->width()  < width)  width  = dst->width();
        if(dst->height() < height) height = dst->height();

        if(width)
        {
            unsigned y;
            for(y = 0; y < height; y++)
            {
                copy_row_functor(dst->row(y), src->row(y), width);
            }
        }
    }


    //---------------------------------------------------------color_conv_row
    template<class CopyRow> 
    void color_conv_row(int8u* dst, 
                        const int8u* src,
                        unsigned width,
                        CopyRow copy_row_functor)
    {
        copy_row_functor(dst, src, width);
    }


    //---------------------------------------------------------color_conv_same
    template<int BPP> class color_conv_same
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            memmove(dst, src, width*BPP);
        }
    };


}



#endif

--- NEW FILE: agg_color_conv_rgb8.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// A set of functors used with color_conv(). See file agg_color_conv.h
// These functors can convert images with up to 8 bits per component.
// Use convertors in the following way:
//
// agg::color_conv(dst, src, agg::color_conv_XXXX_to_YYYY());
// whare XXXX and YYYY can be any of:
//  rgb24
//  bgr24
//  rgba32
//  abgr32
//  argb32
//  bgra32
//  rgb555
//  rgb565
//----------------------------------------------------------------------------

#ifndef AGG_COLOR_CONV_RGB8_INCLUDED
#define AGG_COLOR_CONV_RGB8_INCLUDED

#include "agg_basics.h"
#include "agg_color_conv.h"

namespace agg
{

    //-----------------------------------------------------color_conv_rgb24
    class color_conv_rgb24
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                *dst++ = src[2];
                *dst++ = src[1];
                *dst++ = src[0];
                src += 3;
            }
            while(--width);
        }
    };

    typedef color_conv_rgb24 color_conv_rgb24_to_bgr24;
    typedef color_conv_rgb24 color_conv_bgr24_to_rgb24;

    typedef color_conv_same<3> color_conv_bgr24_to_bgr24;
    typedef color_conv_same<3> color_conv_rgb24_to_rgb24;



    //------------------------------------------------------color_conv_rgba32
    template<int I1, int I2, int I3, int I4> class color_conv_rgba32
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                *dst++ = src[I1];
                *dst++ = src[I2];
                *dst++ = src[I3];
                *dst++ = src[I4]; 
                src += 4;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_rgba32<0,3,2,1> color_conv_argb32_to_abgr32; //----color_conv_argb32_to_abgr32
    typedef color_conv_rgba32<3,2,1,0> color_conv_argb32_to_bgra32; //----color_conv_argb32_to_bgra32
    typedef color_conv_rgba32<1,2,3,0> color_conv_argb32_to_rgba32; //----color_conv_argb32_to_rgba32
    typedef color_conv_rgba32<3,0,1,2> color_conv_bgra32_to_abgr32; //----color_conv_bgra32_to_abgr32
    typedef color_conv_rgba32<3,2,1,0> color_conv_bgra32_to_argb32; //----color_conv_bgra32_to_argb32
    typedef color_conv_rgba32<2,1,0,3> color_conv_bgra32_to_rgba32; //----color_conv_bgra32_to_rgba32
    typedef color_conv_rgba32<3,2,1,0> color_conv_rgba32_to_abgr32; //----color_conv_rgba32_to_abgr32
    typedef color_conv_rgba32<3,0,1,2> color_conv_rgba32_to_argb32; //----color_conv_rgba32_to_argb32
    typedef color_conv_rgba32<2,1,0,3> color_conv_rgba32_to_bgra32; //----color_conv_rgba32_to_bgra32
    typedef color_conv_rgba32<0,3,2,1> color_conv_abgr32_to_argb32; //----color_conv_abgr32_to_argb32
    typedef color_conv_rgba32<1,2,3,0> color_conv_abgr32_to_bgra32; //----color_conv_abgr32_to_bgra32
    typedef color_conv_rgba32<3,2,1,0> color_conv_abgr32_to_rgba32; //----color_conv_abgr32_to_rgba32

    //------------------------------------------------------------------------
    typedef color_conv_same<4> color_conv_rgba32_to_rgba32; //----color_conv_rgba32_to_rgba32
    typedef color_conv_same<4> color_conv_argb32_to_argb32; //----color_conv_argb32_to_argb32
    typedef color_conv_same<4> color_conv_bgra32_to_bgra32; //----color_conv_bgra32_to_bgra32
    typedef color_conv_same<4> color_conv_abgr32_to_abgr32; //----color_conv_abgr32_to_abgr32


    //--------------------------------------------color_conv_rgb24_rgba32
    template<int I1, int I2, int I3, int A> class color_conv_rgb24_rgba32
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                dst[I1] = *src++;
                dst[I2] = *src++;
                dst[I3] = *src++;
                dst[A]  = 255; 
                dst += 4;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_rgb24_rgba32<1,2,3,0> color_conv_rgb24_to_argb32; //----color_conv_rgb24_to_argb32
    typedef color_conv_rgb24_rgba32<3,2,1,0> color_conv_rgb24_to_abgr32; //----color_conv_rgb24_to_abgr32
    typedef color_conv_rgb24_rgba32<2,1,0,3> color_conv_rgb24_to_bgra32; //----color_conv_rgb24_to_bgra32
    typedef color_conv_rgb24_rgba32<0,1,2,3> color_conv_rgb24_to_rgba32; //----color_conv_rgb24_to_rgba32
    typedef color_conv_rgb24_rgba32<3,2,1,0> color_conv_bgr24_to_argb32; //----color_conv_bgr24_to_argb32
    typedef color_conv_rgb24_rgba32<1,2,3,0> color_conv_bgr24_to_abgr32; //----color_conv_bgr24_to_abgr32
    typedef color_conv_rgb24_rgba32<0,1,2,3> color_conv_bgr24_to_bgra32; //----color_conv_bgr24_to_bgra32
    typedef color_conv_rgb24_rgba32<2,1,0,3> color_conv_bgr24_to_rgba32; //----color_conv_bgr24_to_rgba32

    

    //-------------------------------------------------color_conv_rgba32_rgb24
    template<int I1, int I2, int I3> class color_conv_rgba32_rgb24
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                *dst++ = src[I1];
                *dst++ = src[I2];
                *dst++ = src[I3];
                src += 4;
            }
            while(--width);
        }
    };



    //------------------------------------------------------------------------
    typedef color_conv_rgba32_rgb24<1,2,3> color_conv_argb32_to_rgb24; //----color_conv_argb32_to_rgb24
    typedef color_conv_rgba32_rgb24<3,2,1> color_conv_abgr32_to_rgb24; //----color_conv_abgr32_to_rgb24
    typedef color_conv_rgba32_rgb24<2,1,0> color_conv_bgra32_to_rgb24; //----color_conv_bgra32_to_rgb24
    typedef color_conv_rgba32_rgb24<0,1,2> color_conv_rgba32_to_rgb24; //----color_conv_rgba32_to_rgb24
    typedef color_conv_rgba32_rgb24<3,2,1> color_conv_argb32_to_bgr24; //----color_conv_argb32_to_bgr24
    typedef color_conv_rgba32_rgb24<1,2,3> color_conv_abgr32_to_bgr24; //----color_conv_abgr32_to_bgr24
    typedef color_conv_rgba32_rgb24<0,1,2> color_conv_bgra32_to_bgr24; //----color_conv_bgra32_to_bgr24
    typedef color_conv_rgba32_rgb24<2,1,0> color_conv_rgba32_to_bgr24; //----color_conv_rgba32_to_bgr24


    //------------------------------------------------color_conv_rgb555_rgb24
    template<int R, int B> class color_conv_rgb555_rgb24
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                unsigned rgb = *(int16u*)src;
                dst[R] = (int8u)((rgb >> 7) & 0xF8);
                dst[1] = (int8u)((rgb >> 2) & 0xF8);
                dst[B] = (int8u)((rgb << 3) & 0xF8);
                src += 2;
                dst += 3;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_rgb555_rgb24<2,0> color_conv_rgb555_to_bgr24; //----color_conv_rgb555_to_bgr24
    typedef color_conv_rgb555_rgb24<0,2> color_conv_rgb555_to_rgb24; //----color_conv_rgb555_to_rgb24


    //-------------------------------------------------color_conv_rgb24_rgb555
    template<int R, int B> class color_conv_rgb24_rgb555
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                *(int16u*)dst = (int16u)(((unsigned(src[R]) << 7) & 0x7C00) | 
                                         ((unsigned(src[1]) << 2) & 0x3E0)  |
                                         ((unsigned(src[B]) >> 3)));
                src += 3;
                dst += 2;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_rgb24_rgb555<2,0> color_conv_bgr24_to_rgb555; //----color_conv_bgr24_to_rgb555
    typedef color_conv_rgb24_rgb555<0,2> color_conv_rgb24_to_rgb555; //----color_conv_rgb24_to_rgb555


    //-------------------------------------------------color_conv_rgb565_rgb24
    template<int R, int B> class color_conv_rgb565_rgb24
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                unsigned rgb = *(int16u*)src;
                dst[R] = (rgb >> 8) & 0xF8;
                dst[1] = (rgb >> 3) & 0xFC;
                dst[B] = (rgb << 3) & 0xF8;
                src += 2;
                dst += 3;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_rgb565_rgb24<2,0> color_conv_rgb565_to_bgr24; //----color_conv_rgb565_to_bgr24
    typedef color_conv_rgb565_rgb24<0,2> color_conv_rgb565_to_rgb24; //----color_conv_rgb565_to_rgb24


    //-------------------------------------------------color_conv_rgb24_rgb565
    template<int R, int B> class color_conv_rgb24_rgb565
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                *(int16u*)dst = (int16u)(((unsigned(src[R]) << 8) & 0xF800) | 
                                         ((unsigned(src[1]) << 3) & 0x7E0)  |
                                         ((unsigned(src[B]) >> 3)));
                src += 3;
                dst += 2;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_rgb24_rgb565<2,0> color_conv_bgr24_to_rgb565; //----color_conv_bgr24_to_rgb565
    typedef color_conv_rgb24_rgb565<0,2> color_conv_rgb24_to_rgb565; //----color_conv_rgb24_to_rgb565



    //-------------------------------------------------color_conv_rgb555_rgba32
    template<int R, int G, int B, int A> class color_conv_rgb555_rgba32
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                int rgb = *(int16*)src;
                dst[R] = (int8u)((rgb >> 7) & 0xF8);
                dst[G] = (int8u)((rgb >> 2) & 0xF8);
                dst[B] = (int8u)((rgb << 3) & 0xF8);
                dst[A] = (int8u)(rgb >> 15);
                src += 2;
                dst += 4;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_rgb555_rgba32<1,2,3,0> color_conv_rgb555_to_argb32; //----color_conv_rgb555_to_argb32
    typedef color_conv_rgb555_rgba32<3,2,1,0> color_conv_rgb555_to_abgr32; //----color_conv_rgb555_to_abgr32
    typedef color_conv_rgb555_rgba32<2,1,0,3> color_conv_rgb555_to_bgra32; //----color_conv_rgb555_to_bgra32
    typedef color_conv_rgb555_rgba32<0,1,2,3> color_conv_rgb555_to_rgba32; //----color_conv_rgb555_to_rgba32


    //------------------------------------------------color_conv_rgba32_rgb555
    template<int R, int G, int B, int A> class color_conv_rgba32_rgb555
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                *(int16u*)dst = (int16u)(((unsigned(src[R]) << 7) & 0x7C00) | 
                                         ((unsigned(src[G]) << 2) & 0x3E0)  |
                                         ((unsigned(src[B]) >> 3)) |
                                         ((unsigned(src[A]) << 8) & 0x8000));
                src += 4;
                dst += 2;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_rgba32_rgb555<1,2,3,0> color_conv_argb32_to_rgb555; //----color_conv_argb32_to_rgb555
    typedef color_conv_rgba32_rgb555<3,2,1,0> color_conv_abgr32_to_rgb555; //----color_conv_abgr32_to_rgb555
    typedef color_conv_rgba32_rgb555<2,1,0,3> color_conv_bgra32_to_rgb555; //----color_conv_bgra32_to_rgb555
    typedef color_conv_rgba32_rgb555<0,1,2,3> color_conv_rgba32_to_rgb555; //----color_conv_rgba32_to_rgb555



    //------------------------------------------------color_conv_rgb565_rgba32
    template<int R, int G, int B, int A> class color_conv_rgb565_rgba32
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                int rgb = *(int16*)src;
                dst[R] = (rgb >> 8) & 0xF8;
                dst[G] = (rgb >> 3) & 0xFC;
                dst[B] = (rgb << 3) & 0xF8;
                dst[A] = 255;
                src += 2;
                dst += 4;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_rgb565_rgba32<1,2,3,0> color_conv_rgb565_to_argb32; //----color_conv_rgb565_to_argb32
    typedef color_conv_rgb565_rgba32<3,2,1,0> color_conv_rgb565_to_abgr32; //----color_conv_rgb565_to_abgr32
    typedef color_conv_rgb565_rgba32<2,1,0,3> color_conv_rgb565_to_bgra32; //----color_conv_rgb565_to_bgra32
    typedef color_conv_rgb565_rgba32<0,1,2,3> color_conv_rgb565_to_rgba32; //----color_conv_rgb565_to_rgba32


    //------------------------------------------------color_conv_rgba32_rgb565
    template<int R, int G, int B> class color_conv_rgba32_rgb565
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                *(int16u*)dst = (int16u)(((unsigned(src[R]) << 8) & 0xF800) | 
                                         ((unsigned(src[G]) << 3) & 0x7E0)  |
                                         ((unsigned(src[B]) >> 3)));
                src += 4;
                dst += 2;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_rgba32_rgb565<1,2,3> color_conv_argb32_to_rgb565; //----color_conv_argb32_to_rgb565
    typedef color_conv_rgba32_rgb565<3,2,1> color_conv_abgr32_to_rgb565; //----color_conv_abgr32_to_rgb565
    typedef color_conv_rgba32_rgb565<2,1,0> color_conv_bgra32_to_rgb565; //----color_conv_bgra32_to_rgb565
    typedef color_conv_rgba32_rgb565<0,1,2> color_conv_rgba32_to_rgb565; //----color_conv_rgba32_to_rgb565


    //---------------------------------------------color_conv_rgb555_to_rgb565
    class color_conv_rgb555_to_rgb565
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                unsigned rgb = *(int16u*)src;
                *(int16u*)dst = (int16u)(((rgb << 1) & 0xFFC0) | (rgb & 0x1F));
                src += 2;
                dst += 2;
            }
            while(--width);
        }
    };


    //----------------------------------------------color_conv_rgb565_to_rgb555
    class color_conv_rgb565_to_rgb555
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                unsigned rgb = *(int16u*)src;
                *(int16u*)dst = (int16u)(((rgb >> 1) & 0x7FE0) | (rgb & 0x1F));
                src += 2;
                dst += 2;
            }
            while(--width);
        }
    };


    //------------------------------------------------------------------------
    typedef color_conv_same<2> color_conv_rgb555_to_rgb555; //----color_conv_rgb555_to_rgb555
    typedef color_conv_same<2> color_conv_rgb565_to_rgb565; //----color_conv_rgb565_to_rgb565

    
    template<int R, int B> class color_conv_rgb24_gray8
    {
    public:
        void operator () (int8u* dst, 
                          const int8u* src,
                          unsigned width) const
        {
            do
            {
                *dst++ = (src[R]*77 + src[1]*150 + src[B]*29) >> 8;
                src += 3;
            }
            while(--width);
        }
    };

    typedef color_conv_rgb24_gray8<0,2> color_conv_rgb24_to_gray8; //----color_conv_rgb24_to_gray8
    typedef color_conv_rgb24_gray8<2,0> color_conv_bgr24_to_gray8; //----color_conv_bgr24_to_gray8


}



#endif

[Roadmap-commit] roadmap_editor/src/agg23/font_win32_tt agg_font_win32_tt.cpp,NONE,1.1 agg_font_win32_tt.h,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/font_win32_tt
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/font_win32_tt

Added Files:
	agg_font_win32_tt.cpp agg_font_win32_tt.h 
Log Message:
Import agg sources.

--- NEW FILE: agg_font_win32_tt.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------

#include <stdio.h>
#include "agg_font_win32_tt.h"
#include "agg_bitset_iterator.h"
#include "agg_renderer_scanline.h"

#ifdef AGG_WIN9X_COMPLIANT
#define GetGlyphOutlineX GetGlyphOutline
#else
#define GetGlyphOutlineX GetGlyphOutlineW
#endif

namespace agg
{

    //------------------------------------------------------------------------------
    //
    // This code implements the AUTODIN II polynomial
    // The variable corresponding to the macro argument "crc" should
    // be an unsigned long.
    // Oroginal code  by Spencer Garrett <sr...@qu...>
    //

    // generated using the AUTODIN II polynomial
    //   x^32 + x^26 + x^23 + x^22 + x^16 +
    //   x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x^1 + 1
    //
    //------------------------------------------------------------------------------

    static const unsigned crc32tab[256] = 
    {
       0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
       0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
       0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
       0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
       0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
       0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
       0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
       0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
       0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
       0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
       0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
       0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
       0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
       0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
       0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
       0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
       0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
       0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
       0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
       0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
       0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
       0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
       0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
       0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
       0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
       0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
       0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
       0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
       0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
       0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
       0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
       0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
       0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
       0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
       0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
       0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
       0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
       0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
       0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
       0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
       0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
       0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
       0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
       0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
       0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
       0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
       0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
       0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
       0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
       0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
       0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
       0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
       0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
       0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
       0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
       0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
       0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
       0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
       0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
       0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
       0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
       0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
       0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
       0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
    };

    //------------------------------------------------------------------------------
    static unsigned calc_crc32(const unsigned char* buf, unsigned size)
    {
        unsigned crc = (unsigned)~0;
        const unsigned char* p;
        unsigned len = 0; 
        unsigned nr = size;

        for (len += nr, p = buf; nr--; ++p) 
        {
            crc = (crc >> 8) ^ crc32tab[(crc ^ *p) & 0xff];
        }
        return ~crc;
    }

    //------------------------------------------------------------------------
    static inline FIXED dbl_to_fx(double d)
    {
        int l;
        l = int(d * 65536.0);
        return *(FIXED*)&l;
    }

    //------------------------------------------------------------------------
    static inline int dbl_to_plain_fx(double d)
    {
        return int(d * 65536.0);
    }

    //------------------------------------------------------------------------
    static inline FIXED negate_fx(const FIXED& fx)
    {
        int l = -(*(int*)(&fx));
        return *(FIXED*)&l;
    }

    //------------------------------------------------------------------------
    static inline double fx_to_dbl(const FIXED& p)
    {
        return double(p.value) + double(p.fract) * (1.0 / 65536.0);
    }

    //------------------------------------------------------------------------
    static inline int fx_to_plain_int(const FIXED& fx)
    {
        return *(int*)(&fx);
    }

    //------------------------------------------------------------------------
    static inline int fx_to_int26p6(const FIXED& p)
    {
        return (int(p.value) << 6) + (int(p.fract) >> 10);
    }

    //------------------------------------------------------------------------
    static inline int dbl_to_int26p6(double p)
    {
        return int(p * 64.0 + 0.5);
    }

    //------------------------------------------------------------------------
    template<class Scanline, class ScanlineStorage>
    void decompose_win32_glyph_bitmap_mono(const char* gbuf, 
                                           int w, int h,
                                           int x, int y,
                                           bool flip_y,
                                           Scanline& sl,
                                           ScanlineStorage& storage)
    {
        int i;
        int pitch = ((w + 31) >> 5) << 2;
        const int8u* buf = (const int8u*)gbuf;
        sl.reset(x, x + w);
        storage.prepare(w + 2);
        if(flip_y)
        {
            buf += pitch * (h - 1);
            y += h;
            pitch = -pitch;
        }
        for(i = 0; i < h; i++)
        {
            sl.reset_spans();
            bitset_iterator bits(buf, 0);
            int j;
            for(j = 0; j < w; j++)
            {
                if(bits.bit()) sl.add_cell(x + j, cover_full);
                ++bits;
            }
            buf += pitch;
            if(sl.num_spans())
            {
                sl.finalize(y - i - 1);
                storage.render(sl);
            }
        }
    }



    //------------------------------------------------------------------------
    template<class Rasterizer, class Scanline, class ScanlineStorage>
    void decompose_win32_glyph_bitmap_gray8(const char* gbuf, 
                                            int w, int h,
                                            int x, int y,
                                            bool flip_y,
                                            Rasterizer& ras,
                                            Scanline& sl,
                                            ScanlineStorage& storage)
    {
        int i, j;
        int pitch = ((w + 3) >> 2) << 2;
        const int8u* buf = (const int8u*)gbuf;
        sl.reset(x, x + w);
        storage.prepare(w + 2);
        if(flip_y)
        {
            buf += pitch * (h - 1);
            y += h;
            pitch = -pitch;
        }
        for(i = 0; i < h; i++)
        {
            sl.reset_spans();
            const int8u* p = buf;
            for(j = 0; j < w; j++)
            {
                if(*p) 
                {
                    unsigned v = *p;
                    if(v == 64) v = 255;
                    else v <<= 2;
                    sl.add_cell(x + j, ras.apply_gamma(v));
                }
                ++p;
            }
            buf += pitch;
            if(sl.num_spans())
            {
                sl.finalize(y - i - 1);
                storage.render(sl);
            }
        }
    }



    //------------------------------------------------------------------------
    template<class PathStorage>
    bool decompose_win32_glyph_outline(const char* gbuf,
                                       unsigned total_size,
                                       bool flip_y, 
                                       const trans_affine& mtx,
                                       PathStorage& path)
    {
        const char* cur_glyph = gbuf;
        const char* end_glyph = gbuf + total_size;
        double x, y;
        typedef typename PathStorage::value_type value_type;
        
        while(cur_glyph < end_glyph)
        {
            const TTPOLYGONHEADER* th = (TTPOLYGONHEADER*)cur_glyph;
            
            const char* end_poly = cur_glyph + th->cb;
            const char* cur_poly = cur_glyph + sizeof(TTPOLYGONHEADER);

            x = fx_to_dbl(th->pfxStart.x);
            y = fx_to_dbl(th->pfxStart.y);
            if(flip_y) y = -y;
            mtx.transform(&x, &y);
            path.move_to(value_type(dbl_to_int26p6(x)), 
                         value_type(dbl_to_int26p6(y)));

            while(cur_poly < end_poly)
            {
                const TTPOLYCURVE* pc = (const TTPOLYCURVE*)cur_poly;
                
                if (pc->wType == TT_PRIM_LINE)
                {
                    int i;
                    for (i = 0; i < pc->cpfx; i++)
                    {
                        x = fx_to_dbl(pc->apfx[i].x);
                        y = fx_to_dbl(pc->apfx[i].y);
                        if(flip_y) y = -y;
                        mtx.transform(&x, &y);
                        path.line_to(value_type(dbl_to_int26p6(x)), 
                                     value_type(dbl_to_int26p6(y)));
                    }
                }
                
                if (pc->wType == TT_PRIM_QSPLINE)
                {
                    int u;
                    for (u = 0; u < pc->cpfx - 1; u++)  // Walk through points in spline
                    {
                        POINTFX pnt_b = pc->apfx[u];    // B is always the current point
                        POINTFX pnt_c = pc->apfx[u+1];
                        
                        if (u < pc->cpfx - 2)           // If not on last spline, compute C
                        {
                            // midpoint (x,y)
                            *(int*)&pnt_c.x = (*(int*)&pnt_b.x + *(int*)&pnt_c.x) / 2;
                            *(int*)&pnt_c.y = (*(int*)&pnt_b.y + *(int*)&pnt_c.y) / 2;
                        }
                        
                        double x2, y2;
                        x  = fx_to_dbl(pnt_b.x);
                        y  = fx_to_dbl(pnt_b.y);
                        x2 = fx_to_dbl(pnt_c.x);
                        y2 = fx_to_dbl(pnt_c.y);
                        if(flip_y) { y = -y; y2 = -y2; }
                        mtx.transform(&x,  &y);
                        mtx.transform(&x2, &y2);
                        path.curve3(value_type(dbl_to_int26p6(x)), 
                                    value_type(dbl_to_int26p6(y)),
                                    value_type(dbl_to_int26p6(x2)), 
                                    value_type(dbl_to_int26p6(y2)));
                    }
                }
                cur_poly += sizeof(WORD) * 2 + sizeof(POINTFX) * pc->cpfx;
            }
            cur_glyph += th->cb;
        }
        return true;
    }




    //------------------------------------------------------------------------
    font_engine_win32_tt_base::~font_engine_win32_tt_base()
    {
        delete [] m_kerning_pairs;
        delete [] m_gbuf;
        delete [] m_signature;
        delete [] m_typeface;
        if(m_dc && m_old_font) ::SelectObject(m_dc, m_old_font);
        unsigned i;
        for(i = 0; i < m_num_fonts; ++i)
        {
            delete [] m_font_names[i];
            ::DeleteObject(m_fonts[i]);
        }
        delete [] m_font_names;
        delete [] m_fonts;
    }



    //------------------------------------------------------------------------
    font_engine_win32_tt_base::font_engine_win32_tt_base(bool flag32, 
                                                         HDC dc, 
                                                         unsigned max_fonts) :
        m_flag32(flag32),
        m_dc(dc),
        m_old_font(m_dc ? (HFONT)::GetCurrentObject(m_dc, OBJ_FONT) : 0),
        m_fonts(new HFONT [max_fonts]),
        m_num_fonts(0),
        m_max_fonts(max_fonts),
        m_font_names(new char* [max_fonts]),
        m_cur_font(0),

        m_change_stamp(0),
        m_typeface(new char [256-16]),
        m_typeface_len(256-16-1),
        m_signature(new char [256+256-16]),
        m_height(0),
        m_width(0),
        m_weight(FW_REGULAR),
        m_italic(false),
        m_char_set(DEFAULT_CHARSET),
        m_pitch_and_family(FF_DONTCARE),
        m_hinting(true),
        m_flip_y(false),
        m_font_created(false),
        m_resolution(0),
        m_glyph_rendering(glyph_ren_native_gray8),
        m_glyph_index(0),
        m_data_size(0),
        m_data_type(glyph_data_invalid),
        m_bounds(1,1,0,0),
        m_advance_x(0.0),
        m_advance_y(0.0),
        m_gbuf(new char [buf_size]),
        m_kerning_pairs(0),
        m_num_kerning_pairs(0),
        m_max_kerning_pairs(0),

        m_path16(),
        m_path32(),
        m_curves16(m_path16),
        m_curves32(m_path32),
        m_scanline_aa(),
        m_scanline_bin(),
        m_scanlines_aa(),
        m_scanlines_bin(),
        m_rasterizer()
    {
        m_curves16.approximation_scale(4.0);
        m_curves32.approximation_scale(4.0);
        memset(&m_matrix, 0, sizeof(m_matrix));
        m_matrix.eM11.value = 1;
        m_matrix.eM22.value = 1;
    }



    //------------------------------------------------------------------------
    int font_engine_win32_tt_base::find_font(const char* name) const
    {
        unsigned i;
        for(i = 0; i < m_num_fonts; ++i)
        {
            if(strcmp(name, m_font_names[i]) == 0) return i;
        }
        return -1;
    }

    //------------------------------------------------------------------------
    bool font_engine_win32_tt_base::create_font(const char* typeface_, 
                                                glyph_rendering ren_type)
    {
        if(m_dc)
        {
            unsigned len = strlen(typeface_);
            if(len > m_typeface_len)
            {
                delete [] m_signature;
                delete [] m_typeface;
                m_typeface  = new char [len + 32];
                m_signature = new char [len + 32 + 256];
                m_typeface_len = len + 32 - 1;
            }

            strcpy(m_typeface, typeface_);

            int h = m_height;
            int w = m_width;

            if(m_resolution)
            {
                h = ::MulDiv(m_height, m_resolution, 72);
                w = ::MulDiv(m_width,  m_resolution, 72);
            }

            m_glyph_rendering = ren_type;
            update_signature();
            int idx = find_font(m_signature);
            if(idx >= 0)
            {
                m_cur_font = m_fonts[idx];
                ::SelectObject(m_dc, m_cur_font);
                m_num_kerning_pairs = 0;
                return true;
            }
            else
            {
                m_cur_font = ::CreateFont(-h,                     // height of font
                                          w,                      // average character width
                                          0,                      // angle of escapement
                                          0,                      // base-line orientation angle
                                          m_weight,               // font weight
                                          m_italic,               // italic attribute option
                                          0,                      // underline attribute option
                                          0,                      // strikeout attribute option
                                          m_char_set,             // character set identifier
                                          OUT_DEFAULT_PRECIS,     // output precision
                                          CLIP_DEFAULT_PRECIS,    // clipping precision
                                          ANTIALIASED_QUALITY,    // output quality
                                          m_pitch_and_family,     // pitch and family
                                          m_typeface);            // typeface name
                if(m_cur_font)
                {
                    if(m_num_fonts >= m_max_fonts)
                    {
                        delete [] m_font_names[0];
                        if(m_old_font) ::SelectObject(m_dc, m_old_font);
                        ::DeleteObject(m_fonts[0]);
                        memcpy(m_fonts, 
                               m_fonts + 1, 
                               (m_max_fonts - 1) * sizeof(HFONT));
                        memcpy(m_font_names, 
                               m_font_names + 1, 
                               (m_max_fonts - 1) * sizeof(char*));
                        m_num_fonts = m_max_fonts - 1;
                    }

                    update_signature();
                    m_font_names[m_num_fonts] = new char[strlen(m_signature) + 1];
                    strcpy(m_font_names[m_num_fonts], m_signature);
                    m_fonts[m_num_fonts] = m_cur_font;
                    ++m_num_fonts;
                    ::SelectObject(m_dc, m_cur_font);
                    m_num_kerning_pairs = 0;
                    return true;
                }
            }
        }
        return false;
    }





    //------------------------------------------------------------------------
    bool font_engine_win32_tt_base::create_font(const char* typeface_, 
                                                glyph_rendering ren_type,
                                                double height_,
                                                double width_,
                                                int weight_,
                                                bool italic_,
                                                DWORD char_set_,
                                                DWORD pitch_and_family_)
    {
        height(height_);
        width(width_);
        weight(weight_);
        italic(italic_);
        char_set(char_set_);
        pitch_and_family(pitch_and_family_);
        return create_font(typeface_, ren_type);
    }




    //------------------------------------------------------------------------
    void font_engine_win32_tt_base::update_signature()
    {
        m_signature[0] = 0;
        if(m_dc && m_cur_font)
        {
            unsigned gamma_hash = 0;
            if(m_glyph_rendering == glyph_ren_native_gray8 ||
               m_glyph_rendering == glyph_ren_agg_mono || 
               m_glyph_rendering == glyph_ren_agg_gray8)
            {
                unsigned char gamma_table[rasterizer_scanline_aa<>::aa_num];
                unsigned i;
                for(i = 0; i < rasterizer_scanline_aa<>::aa_num; ++i)
                {
                    gamma_table[i] = m_rasterizer.apply_gamma(i);
                }
                gamma_hash = calc_crc32(gamma_table, sizeof(gamma_table));
            }
      
            sprintf(m_signature, 
                    "%s,%u,%d,%d:%dx%d,%d,%d,%d,%d,%d,%08X", 
                    m_typeface,
                    m_char_set,
                    int(m_glyph_rendering),
                    m_resolution,
                    m_height,
                    m_width,
                    m_weight,
                    int(m_italic),
                    int(m_hinting),
                    int(m_flip_y),
                    int(m_pitch_and_family),
                    gamma_hash);

            if(m_glyph_rendering == glyph_ren_outline ||
               m_glyph_rendering == glyph_ren_agg_mono ||
               m_glyph_rendering == glyph_ren_agg_gray8)
            {
                double mtx[6];
                char buf[100];
                m_affine.store_to(mtx);
                sprintf(buf, ",%08X%08X%08X%08X%08X%08X", 
                    dbl_to_plain_fx(mtx[0]), 
                    dbl_to_plain_fx(mtx[1]), 
                    dbl_to_plain_fx(mtx[2]), 
                    dbl_to_plain_fx(mtx[3]), 
                    dbl_to_plain_fx(mtx[4]), 
                    dbl_to_plain_fx(mtx[5]));
                strcat(m_signature, buf);
            }
            ++m_change_stamp;
        }
    }



    //------------------------------------------------------------------------
    bool font_engine_win32_tt_base::prepare_glyph(unsigned glyph_code)
    {
        if(m_dc && m_cur_font)
        {
            int format = GGO_BITMAP;

            switch(m_glyph_rendering)
            {
            case glyph_ren_native_gray8: 
                format = GGO_GRAY8_BITMAP;
                break;

            case glyph_ren_outline:
            case glyph_ren_agg_mono:
            case glyph_ren_agg_gray8:
                format = GGO_NATIVE;
                break;
            }

#ifndef GGO_UNHINTED         // For compatibility with old SDKs.
#define GGO_UNHINTED 0x0100
#endif
            if(!m_hinting) format |= GGO_UNHINTED;
        
            GLYPHMETRICS gm;
            int total_size = GetGlyphOutlineX(m_dc,
                                              glyph_code,
                                              format,
                                              &gm,
                                              buf_size,
                                              (void*)m_gbuf,
                                              &m_matrix);

            if(total_size < 0) 
            {
                // GetGlyphOutline() fails when being called for
                // GGO_GRAY8_BITMAP and white space (stupid Microsoft).
                // It doesn't even initialize the glyph metrics
                // structure. So, we have to query the metrics
                // separately (basically we need gmCellIncX).
                int total_size = GetGlyphOutlineX(m_dc,
                                                  glyph_code,
                                                  GGO_METRICS,
                                                  &gm,
                                                  buf_size,
                                                  (void*)m_gbuf,
                                                  &m_matrix);

                if(total_size < 0) return false;
                gm.gmBlackBoxX = gm.gmBlackBoxY = 0;
                total_size = 0;
            }

            m_glyph_index = glyph_code;
            m_advance_x =  gm.gmCellIncX;
            m_advance_y = -gm.gmCellIncY;

            switch(m_glyph_rendering)
            {
            case glyph_ren_native_mono: 
                decompose_win32_glyph_bitmap_mono(m_gbuf, 
                                                  gm.gmBlackBoxX,
                                                  gm.gmBlackBoxY,
                                                  gm.gmptGlyphOrigin.x,
                                                  m_flip_y ? -gm.gmptGlyphOrigin.y : 
                                                              gm.gmptGlyphOrigin.y,
                                                  m_flip_y,
                                                  m_scanline_bin,
                                                  m_scanlines_bin);
                m_bounds.x1 = m_scanlines_bin.min_x();
                m_bounds.y1 = m_scanlines_bin.min_y();
                m_bounds.x2 = m_scanlines_bin.max_x();
                m_bounds.y2 = m_scanlines_bin.max_y();
                m_data_size = m_scanlines_bin.byte_size(); 
                m_data_type = glyph_data_mono;
                return true;

            case glyph_ren_native_gray8:
                decompose_win32_glyph_bitmap_gray8(m_gbuf, 
                                                   gm.gmBlackBoxX,
                                                   gm.gmBlackBoxY,
                                                   gm.gmptGlyphOrigin.x,
                                                   m_flip_y ? -gm.gmptGlyphOrigin.y : 
                                                               gm.gmptGlyphOrigin.y,
                                                   m_flip_y,
                                                   m_rasterizer,
                                                   m_scanline_aa,
                                                   m_scanlines_aa);
                m_bounds.x1 = m_scanlines_aa.min_x();
                m_bounds.y1 = m_scanlines_aa.min_y();
                m_bounds.x2 = m_scanlines_aa.max_x();
                m_bounds.y2 = m_scanlines_aa.max_y();
                m_data_size = m_scanlines_aa.byte_size(); 
                m_data_type = glyph_data_gray8;
                return true;

            case glyph_ren_outline:
                m_affine.transform(&m_advance_x, &m_advance_y);
                if(m_flag32)
                {
                    m_path32.remove_all();
                    if(decompose_win32_glyph_outline(m_gbuf,
                                                     total_size,
                                                     m_flip_y, 
                                                     m_affine,
                                                     m_path32))
                    {
                        rect_d bnd  = m_path32.bounding_rect();
                        m_data_size = m_path32.byte_size();
                        m_data_type = glyph_data_outline;
                        m_bounds.x1 = int(floor(bnd.x1));
                        m_bounds.y1 = int(floor(bnd.y1));
                        m_bounds.x2 = int(ceil(bnd.x2));
                        m_bounds.y2 = int(ceil(bnd.y2));
                        return true;
                    }
                }
                else
                {
                    m_path16.remove_all();
                    if(decompose_win32_glyph_outline(m_gbuf,
                                                     total_size,
                                                     m_flip_y, 
                                                     m_affine,
                                                     m_path16))
                    {
                        rect_d bnd  = m_path16.bounding_rect();
                        m_data_size = m_path16.byte_size();
                        m_data_type = glyph_data_outline;
                        m_bounds.x1 = int(floor(bnd.x1));
                        m_bounds.y1 = int(floor(bnd.y1));
                        m_bounds.x2 = int(ceil(bnd.x2));
                        m_bounds.y2 = int(ceil(bnd.y2));
                        return true;
                    }
                }
                break;

            case glyph_ren_agg_mono:
                m_rasterizer.reset();
                m_affine.transform(&m_advance_x, &m_advance_y);
                if(m_flag32)
                {
                    m_path32.remove_all();
                    decompose_win32_glyph_outline(m_gbuf,
                                                  total_size,
                                                  m_flip_y, 
                                                  m_affine,
                                                  m_path32);
                    m_rasterizer.add_path(m_curves32);
                }
                else
                {
                    m_path16.remove_all();
                    decompose_win32_glyph_outline(m_gbuf,
                                                  total_size,
                                                  m_flip_y, 
                                                  m_affine,
                                                  m_path16);
                    m_rasterizer.add_path(m_curves16);
                }
                m_scanlines_bin.prepare(1); // Remove all 
                render_scanlines(m_rasterizer, m_scanline_bin, m_scanlines_bin);
                m_bounds.x1 = m_scanlines_bin.min_x();
                m_bounds.y1 = m_scanlines_bin.min_y();
                m_bounds.x2 = m_scanlines_bin.max_x();
                m_bounds.y2 = m_scanlines_bin.max_y();
                m_data_size = m_scanlines_bin.byte_size(); 
                m_data_type = glyph_data_mono;
                return true;

            case glyph_ren_agg_gray8:
                m_rasterizer.reset();
                m_affine.transform(&m_advance_x, &m_advance_y);
                if(m_flag32)
                {
                    m_path32.remove_all();
                    decompose_win32_glyph_outline(m_gbuf,
                                                  total_size,
                                                  m_flip_y, 
                                                  m_affine,
                                                  m_path32);
                    m_rasterizer.add_path(m_curves32);
                }
                else
                {
                    m_path16.remove_all();
                    decompose_win32_glyph_outline(m_gbuf,
                                                  total_size,
                                                  m_flip_y, 
                                                  m_affine,
                                                  m_path16);
                    m_rasterizer.add_path(m_curves16);
                }
                m_scanlines_aa.prepare(1); // Remove all 
                render_scanlines(m_rasterizer, m_scanline_aa, m_scanlines_aa);
                m_bounds.x1 = m_scanlines_aa.min_x();
                m_bounds.y1 = m_scanlines_aa.min_y();
                m_bounds.x2 = m_scanlines_aa.max_x();
                m_bounds.y2 = m_scanlines_aa.max_y();
                m_data_size = m_scanlines_aa.byte_size(); 
                m_data_type = glyph_data_gray8;
                return true;
            }
        }
        return false;
    }



    //------------------------------------------------------------------------
    void font_engine_win32_tt_base::write_glyph_to(int8u* data) const
    {
        if(data && m_data_size)
        {
            switch(m_data_type)
            {
            case glyph_data_mono:    m_scanlines_bin.serialize(data); break;
            case glyph_data_gray8:   m_scanlines_aa.serialize(data);  break;
            case glyph_data_outline:
                if(m_flag32)
                {
                    m_path32.serialize(data);
                }
                else
                {
                    m_path16.serialize(data);
                }
                break;
            }
        }
    }



    //------------------------------------------------------------------------
    bool font_engine_win32_tt_base::pair_less(const KERNINGPAIR v1, 
                                              const KERNINGPAIR v2)
    {
        if(v1.wFirst != v2.wFirst) return v1.wFirst < v2.wFirst;
        return v1.wSecond < v2.wSecond;
    }


    //------------------------------------------------------------------------
    void font_engine_win32_tt_base::sort_kerning_pairs()
    {
        pod_array_adaptor<KERNINGPAIR> pairs(m_kerning_pairs, m_num_kerning_pairs);
        quick_sort(pairs, pair_less);
    }



    //------------------------------------------------------------------------
    void font_engine_win32_tt_base::load_kerning_pairs()
    {
        if(m_dc && m_cur_font)
        {
            if(m_kerning_pairs == 0)
            {
                m_kerning_pairs = new KERNINGPAIR [16384-16];
                m_max_kerning_pairs = 16384-16;
            }
            m_num_kerning_pairs = ::GetKerningPairs(m_dc, 
                                                    m_max_kerning_pairs,
                                                    m_kerning_pairs);

            if(m_num_kerning_pairs)
            {
                // Check to see if the kerning pairs are sorted and
                // sort them if they are not.
                //----------------
                unsigned i;
                for(i = 1; i < m_num_kerning_pairs; ++i)
                {
                    if(!pair_less(m_kerning_pairs[i - 1], m_kerning_pairs[i]))
                    {
                        sort_kerning_pairs();
                        break;
                    }
                }
            }
        }
    }


    //------------------------------------------------------------------------
    bool font_engine_win32_tt_base::add_kerning(unsigned first, unsigned second,
                                                double* x, double* y)
    {
        if(m_dc && m_cur_font)
        {
            if(m_num_kerning_pairs == 0)
            {
                load_kerning_pairs();
            }

            int end = m_num_kerning_pairs - 1;
            int beg = 0;
            KERNINGPAIR t;
            t.wFirst = (WORD)first;
            t.wSecond = (WORD)second;
            while(beg <= end)
            {
                int mid = (end + beg) / 2;
                if(m_kerning_pairs[mid].wFirst  == t.wFirst &&
                   m_kerning_pairs[mid].wSecond == t.wSecond)
                {
                    double dx = m_kerning_pairs[mid].iKernAmount;
                    double dy = 0.0;
                    if(m_glyph_rendering == glyph_ren_outline ||
                       m_glyph_rendering == glyph_ren_agg_mono ||
                       m_glyph_rendering == glyph_ren_agg_gray8)
                    {
                        m_affine.transform_2x2(&dx, &dy);
                    }
                    *x += dx;
                    *y += dy;
                    return true;
                }
                else
                if(pair_less(t, m_kerning_pairs[mid]))
                {
                    end = mid - 1;
                }
                else
                {
                    beg = mid + 1;
                }
            }
            return false;
        }
        return false;
    }



}


--- NEW FILE: agg_font_win32_tt.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------

#ifndef AGG_FONT_WIN32_TT_INCLUDED
#define AGG_FONT_WIN32_TT_INCLUDED

#include <windows.h>
#include "agg_scanline_storage_aa.h"
#include "agg_scanline_storage_bin.h"
#include "agg_scanline_u.h"
#include "agg_scanline_bin.h"
#include "agg_path_storage_integer.h"
#include "agg_rasterizer_scanline_aa.h"
#include "agg_conv_curve.h"
#include "agg_trans_affine.h"
#include "agg_font_cache_manager.h"

namespace agg
{

    //-----------------------------------------------font_engine_win32_tt_base
    class font_engine_win32_tt_base
    {
       enum { buf_size = 32768-32 };

    public:
        //--------------------------------------------------------------------
        typedef serialized_scanlines_adaptor_aa<int8u>    gray8_adaptor_type;
        typedef serialized_scanlines_adaptor_bin          mono_adaptor_type;
        typedef scanline_storage_aa8                      scanlines_aa_type;
        typedef scanline_storage_bin                      scanlines_bin_type;

        //--------------------------------------------------------------------
        ~font_engine_win32_tt_base();
        font_engine_win32_tt_base(bool flag32, HDC dc, unsigned max_fonts = 32);

        // Set font parameters
        //--------------------------------------------------------------------
        void resolution(unsigned dpi) { m_resolution = unsigned(dpi); }
        void height(double h)         { m_height = unsigned(h);  }
        void width(double w)          { m_width = unsigned(w);   }
        void weight(int w)            { m_weight = w;            }
        void italic(bool it)          { m_italic = it;           }
        void char_set(DWORD c)        { m_char_set = c;          }
        void pitch_and_family(DWORD p){ m_pitch_and_family = p; }
        void flip_y(bool flip)        { m_flip_y = flip;         }
        void hinting(bool h)          { m_hinting = h;           }
        bool create_font(const char* typeface_, glyph_rendering ren_type);

        bool create_font(const char* typeface_, 
                         glyph_rendering ren_type,
                         double height_,
                         double width_=0.0,
                         int weight_=FW_REGULAR,
                         bool italic_=false,
                         DWORD char_set_=ANSI_CHARSET,
                         DWORD pitch_and_family_=FF_DONTCARE);

        // Set Gamma
        //--------------------------------------------------------------------
        template<class GammaF> void gamma(const GammaF& f)
        {
            m_rasterizer.gamma(f);
        }

        //--------------------------------------------------------------------
        void transform(const agg::trans_affine& mtx)
        {
            m_affine = mtx;
        }

        // Accessors
        //--------------------------------------------------------------------
        unsigned    resolution()   const { return m_resolution; }
        const char* typeface()     const { return m_typeface;   }
        double      height()       const { return m_height;     }
        double      width()        const { return m_width;      }
        int         weight()       const { return m_weight;     }
        bool        italic()       const { return m_italic;     }
        DWORD       char_set()     const { return m_char_set;   }
        DWORD       pitch_and_family() const { return m_pitch_and_family; }
        bool        hinting()      const { return m_hinting;    }
        bool        flip_y()       const { return m_flip_y;     }


        // Interface mandatory to implement for font_cache_manager
        //--------------------------------------------------------------------
        const char*     font_signature() const { return m_signature;    }
        int             change_stamp()   const { return m_change_stamp; }

        bool            prepare_glyph(unsigned glyph_code);
        unsigned        glyph_index() const { return m_glyph_index; }
        unsigned        data_size()   const { return m_data_size;   }
        glyph_data_type data_type()   const { return m_data_type;   }
        const rect&     bounds()      const { return m_bounds;      }
        double          advance_x()   const { return m_advance_x;   }
        double          advance_y()   const { return m_advance_y;   }
        void            write_glyph_to(int8u* data) const;
        bool            add_kerning(unsigned first, unsigned second,
                                    double* x, double* y);

    private:
        font_engine_win32_tt_base(const font_engine_win32_tt_base&);
        const font_engine_win32_tt_base& operator = (const font_engine_win32_tt_base&);

        void update_signature();
        static bool pair_less(const KERNINGPAIR v1, const KERNINGPAIR v2);
        void load_kerning_pairs();
        void sort_kerning_pairs();
        int  find_font(const char* name) const;

        bool            m_flag32;
        HDC             m_dc;
        HFONT           m_old_font;
        HFONT*          m_fonts;
        unsigned        m_num_fonts;
        unsigned        m_max_fonts;
        char**          m_font_names;
        HFONT           m_cur_font;

        int             m_change_stamp;
        char*           m_typeface;
        unsigned        m_typeface_len;
        char*           m_signature;
        unsigned        m_height;
        unsigned        m_width;
        int             m_weight;
        bool            m_italic;
        DWORD           m_char_set;
        DWORD           m_pitch_and_family;
        bool            m_hinting;
        bool            m_flip_y;

        bool            m_font_created;
        unsigned        m_resolution;
        glyph_rendering m_glyph_rendering;
        unsigned        m_glyph_index;
        unsigned        m_data_size;
        glyph_data_type m_data_type;
        rect            m_bounds;
        double          m_advance_x;
        double          m_advance_y;
        MAT2            m_matrix;
        char*           m_gbuf;
        KERNINGPAIR*    m_kerning_pairs;
        unsigned        m_num_kerning_pairs;
        unsigned        m_max_kerning_pairs;
        trans_affine    m_affine;

        path_storage_integer<int16, 6>              m_path16;
        path_storage_integer<int32, 6>              m_path32;
        conv_curve<path_storage_integer<int16, 6> > m_curves16;
        conv_curve<path_storage_integer<int32, 6> > m_curves32;
        scanline_u8              m_scanline_aa;
        scanline_bin             m_scanline_bin;
        scanlines_aa_type        m_scanlines_aa;
        scanlines_bin_type       m_scanlines_bin;
        rasterizer_scanline_aa<> m_rasterizer;
    };




    //------------------------------------------------font_engine_win32_tt_int16
    // This class uses values of type int16 (10.6 format) for the vector cache. 
    // The vector cache is compact, but when rendering glyphs of height
    // more that 200 there integer overflow can occur.
    //
    class font_engine_win32_tt_int16 : public font_engine_win32_tt_base
    {
    public:
        typedef serialized_integer_path_adaptor<int16, 6>     path_adaptor_type;
        typedef font_engine_win32_tt_base::gray8_adaptor_type gray8_adaptor_type;
        typedef font_engine_win32_tt_base::mono_adaptor_type  mono_adaptor_type;
        typedef font_engine_win32_tt_base::scanlines_aa_type  scanlines_aa_type;
        typedef font_engine_win32_tt_base::scanlines_bin_type scanlines_bin_type;

        font_engine_win32_tt_int16(HDC dc, unsigned max_fonts = 32) : 
            font_engine_win32_tt_base(false, dc, max_fonts) {}
    };

    //------------------------------------------------font_engine_win32_tt_int32
    // This class uses values of type int32 (26.6 format) for the vector cache. 
    // The vector cache is twice larger than in font_engine_win32_tt_int16, 
    // but it allows you to render glyphs of very large sizes.
    //
    class font_engine_win32_tt_int32 : public font_engine_win32_tt_base
    {
    public:
        typedef serialized_integer_path_adaptor<int32, 6>     path_adaptor_type;
        typedef font_engine_win32_tt_base::gray8_adaptor_type gray8_adaptor_type;
        typedef font_engine_win32_tt_base::mono_adaptor_type  mono_adaptor_type;
        typedef font_engine_win32_tt_base::scanlines_aa_type  scanlines_aa_type;
        typedef font_engine_win32_tt_base::scanlines_bin_type scanlines_bin_type;

        font_engine_win32_tt_int32(HDC dc, unsigned max_fonts = 32) : 
            font_engine_win32_tt_base(true, dc, max_fonts) {}
    };


}

#endif

[Roadmap-commit] roadmap_editor/src/agg23/src/platform/sdl agg_platform_support.cpp,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform/sdl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/src/platform/sdl

Added Files:
	agg_platform_support.cpp 
Log Message:
Import agg sources.

--- NEW FILE: agg_platform_support.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// class platform_support. SDL version.
//
//----------------------------------------------------------------------------

#include <string.h>
#include "platform/agg_platform_support.h"
#include "SDL.h"
#include "SDL_byteorder.h"


namespace agg
{

    //------------------------------------------------------------------------
    class platform_specific
    {
    public:
        platform_specific(pix_format_e format, bool flip_y);
        ~platform_specific();

        pix_format_e  m_format;
        pix_format_e  m_sys_format;
        bool          m_flip_y;
        unsigned      m_bpp;
        unsigned      m_sys_bpp;
        unsigned      m_rmask;
        unsigned      m_gmask;
        unsigned      m_bmask;
        unsigned      m_amask;
        bool          m_update_flag;
        bool          m_resize_flag;
        bool          m_initialized;
        SDL_Surface*  m_surf_screen;
        SDL_Surface*  m_surf_window;
        SDL_Surface*  m_surf_img[platform_support::max_images];
        int           m_cur_x;
        int           m_cur_y;
	int          m_sw_start;
    };



    //------------------------------------------------------------------------
    platform_specific::platform_specific(pix_format_e format, bool flip_y) :
        m_format(format),
        m_sys_format(pix_format_undefined),
        m_flip_y(flip_y),
        m_bpp(0),
        m_sys_bpp(0),
        m_update_flag(true), 
        m_resize_flag(true),
        m_initialized(false),
        m_surf_screen(0),
        m_surf_window(0),
        m_cur_x(0),
        m_cur_y(0)
    {
        memset(m_surf_img, 0, sizeof(m_surf_img));

        switch(m_format)
        {
			case pix_format_gray8:
            m_bpp = 8;
            break;

        case pix_format_rgb565:
            m_rmask = 0xF800;
            m_gmask = 0x7E0;
            m_bmask = 0x1F;
            m_amask = 0;
            m_bpp = 16;
            break;

        case pix_format_rgb555:
            m_rmask = 0x7C00;
            m_gmask = 0x3E0;
            m_bmask = 0x1F;
            m_amask = 0;
            m_bpp = 16;
            break;
			
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
        case pix_format_rgb24:
			m_rmask = 0xFF;
            m_gmask = 0xFF00;
            m_bmask = 0xFF0000;
            m_amask = 0;
            m_bpp = 24;
            break;

        case pix_format_bgr24:
            m_rmask = 0xFF0000;
            m_gmask = 0xFF00;
            m_bmask = 0xFF;
            m_amask = 0;
            m_bpp = 24;
            break;

        case pix_format_bgra32:
            m_rmask = 0xFF0000;
            m_gmask = 0xFF00;
            m_bmask = 0xFF;
            m_amask = 0xFF000000;
            m_bpp = 32;
            break;

        case pix_format_abgr32:
            m_rmask = 0xFF000000;
            m_gmask = 0xFF0000;
            m_bmask = 0xFF00;
            m_amask = 0xFF;
            m_bpp = 32;
            break;

        case pix_format_argb32:
            m_rmask = 0xFF00;
            m_gmask = 0xFF0000;
            m_bmask = 0xFF000000;
            m_amask = 0xFF;
            m_bpp = 32;
            break;

        case pix_format_rgba32:
            m_rmask = 0xFF;
            m_gmask = 0xFF00;
            m_bmask = 0xFF0000;
            m_amask = 0xFF000000;
            m_bpp = 32;
            break;
#else //SDL_BIG_ENDIAN (PPC)
        case pix_format_rgb24:
			m_rmask = 0xFF0000;
            m_gmask = 0xFF00;
            m_bmask = 0xFF;
            m_amask = 0;
            m_bpp = 24;
            break;

        case pix_format_bgr24:
            m_rmask = 0xFF;
            m_gmask = 0xFF00;
            m_bmask = 0xFF0000;
            m_amask = 0;
            m_bpp = 24;
            break;

        case pix_format_bgra32:
            m_rmask = 0xFF00;
            m_gmask = 0xFF0000;
            m_bmask = 0xFF000000;
            m_amask = 0xFF;
            m_bpp = 32;
            break;

        case pix_format_abgr32:
            m_rmask = 0xFF;
            m_gmask = 0xFF00;
            m_bmask = 0xFF0000;
            m_amask = 0xFF000000;
            m_bpp = 32;
            break;

        case pix_format_argb32:
            m_rmask = 0xFF0000;
            m_gmask = 0xFF00;
            m_bmask = 0xFF;
            m_amask = 0xFF000000;
            m_bpp = 32;
            break;

        case pix_format_rgba32:
            m_rmask = 0xFF000000;
            m_gmask = 0xFF0000;
            m_bmask = 0xFF00;
            m_amask = 0xFF;
            m_bpp = 32;
            break;
#endif
        }
    }

    //------------------------------------------------------------------------
    platform_specific::~platform_specific()
    {
        int i;
        for(i = platform_support::max_images - 1; i >= 0; --i)
        {
            if(m_surf_img[i]) SDL_FreeSurface(m_surf_img[i]);
        }
        if(m_surf_window) SDL_FreeSurface(m_surf_window);
        if(m_surf_screen) SDL_FreeSurface(m_surf_screen);
    }



    //------------------------------------------------------------------------
    platform_support::platform_support(pix_format_e format, bool flip_y) :
        m_specific(new platform_specific(format, flip_y)),
        m_format(format),
        m_bpp(m_specific->m_bpp),
        m_window_flags(0),
        m_wait_mode(true),
        m_flip_y(flip_y)
    {
        SDL_Init(SDL_INIT_VIDEO);
        strcpy(m_caption, "Anti-Grain Geometry Application");
    }


    //------------------------------------------------------------------------
    platform_support::~platform_support()
    {
        delete m_specific;
    }



    //------------------------------------------------------------------------
    void platform_support::caption(const char* cap)
    {
        strcpy(m_caption, cap);
        if(m_specific->m_initialized)
        {
            SDL_WM_SetCaption(cap, 0);
        }
    }
    




    //------------------------------------------------------------------------
    bool platform_support::init(unsigned width, unsigned height, unsigned flags)
    {
        m_window_flags = flags;
        unsigned wflags = SDL_SWSURFACE;

        if(m_window_flags & window_hw_buffer)
        {
            wflags = SDL_HWSURFACE;
        }

        if(m_window_flags & window_resize)
        {
            wflags |= SDL_RESIZABLE;
        }

        if(m_specific->m_surf_screen) SDL_FreeSurface(m_specific->m_surf_screen);

        m_specific->m_surf_screen = SDL_SetVideoMode(width, height, m_bpp, wflags);
        if(m_specific->m_surf_screen == 0) 
        {
            fprintf(stderr, 
                    "Unable to set %dx%d %d bpp video: %s\n", 
                    width, 
                    height, 
                    m_bpp, 
                    ::SDL_GetError());
            return false;
        }

        SDL_WM_SetCaption(m_caption, 0);

        if(m_specific->m_surf_window) SDL_FreeSurface(m_specific->m_surf_window);

        m_specific->m_surf_window = 
            SDL_CreateRGBSurface(SDL_HWSURFACE, 
                                 m_specific->m_surf_screen->w, 
                                 m_specific->m_surf_screen->h,
                                 m_specific->m_surf_screen->format->BitsPerPixel,
                                 m_specific->m_rmask, 
                                 m_specific->m_gmask, 
                                 m_specific->m_bmask, 
                                 m_specific->m_amask);

        if(m_specific->m_surf_window == 0) 
        {
            fprintf(stderr, 
                    "Unable to create image buffer %dx%d %d bpp: %s\n", 
                    width, 
                    height, 
                    m_bpp, 
                    SDL_GetError());
            return false;
        }

        m_rbuf_window.attach((unsigned char*)m_specific->m_surf_window->pixels, 
                             m_specific->m_surf_window->w, 
                             m_specific->m_surf_window->h, 
                             m_flip_y ? -m_specific->m_surf_window->pitch : 
                                         m_specific->m_surf_window->pitch);

        if(!m_specific->m_initialized)
        {
            m_initial_width = width;
            m_initial_height = height;
            on_init();
            m_specific->m_initialized = true;
        }
        on_resize(m_rbuf_window.width(), m_rbuf_window.height());
        m_specific->m_update_flag = true;
        return true;
    }



    //------------------------------------------------------------------------
    void platform_support::update_window()
    {
        SDL_BlitSurface(m_specific->m_surf_window, 0, m_specific->m_surf_screen, 0);
        SDL_UpdateRect(m_specific->m_surf_screen, 0, 0, 0, 0);
    }


    //------------------------------------------------------------------------
    int platform_support::run()
    {
        SDL_Event event;
        bool ev_flag = false;

        for(;;)
        {
            if(m_specific->m_update_flag)
            {
                on_draw();
                update_window();
                m_specific->m_update_flag = false;
            }

            ev_flag = false;
            if(m_wait_mode)
            {
                SDL_WaitEvent(&event);
                ev_flag = true;
            }
            else
            {
                if(SDL_PollEvent(&event))
                {
                    ev_flag = true;
                }
                else
                {
                    on_idle();
                }
            }

            if(ev_flag)
            {
                if(event.type == SDL_QUIT)
                {
                    break;
                }

                int y;
                unsigned flags = 0;

                switch (event.type) 
                {
                case SDL_VIDEORESIZE:
                    if(!init(event.resize.w, event.resize.h, m_window_flags)) return false;
                    on_resize(m_rbuf_window.width(), m_rbuf_window.height());
                    trans_affine_resizing(event.resize.w, event.resize.h);
                    m_specific->m_update_flag = true;
                    break;

                case SDL_KEYDOWN:
                    {
                        flags = 0;
                        if(event.key.keysym.mod & KMOD_SHIFT) flags |= kbd_shift;
                        if(event.key.keysym.mod & KMOD_CTRL)  flags |= kbd_ctrl;

                        bool left  = false;
                        bool up    = false;
                        bool right = false;
                        bool down  = false;

                        switch(event.key.keysym.sym)
                        {
                        case key_left:
                            left = true;
                            break;

                        case key_up:
                            up = true;
                            break;

                        case key_right:
                            right = true;
                            break;

                        case key_down:
                            down = true;
                            break;
                        }

                        if(m_ctrls.on_arrow_keys(left, right, down, up))
                        {
                            on_ctrl_change();
                            force_redraw();
                        }
                        else
                        {
                            on_key(m_specific->m_cur_x,
                                   m_specific->m_cur_y,
                                   event.key.keysym.sym,
                                   flags);
                        }
                    }
                    break;

                case SDL_MOUSEMOTION:
                    y = m_flip_y ? 
                        m_rbuf_window.height() - event.motion.y : 
                        event.motion.y;

                    m_specific->m_cur_x = event.motion.x;
                    m_specific->m_cur_y = y;
                    flags = 0;
                    if(event.motion.state & SDL_BUTTON_LMASK) flags |= mouse_left;
                    if(event.motion.state & SDL_BUTTON_RMASK) flags |= mouse_right;

                    if(m_ctrls.on_mouse_move(m_specific->m_cur_x, 
                                             m_specific->m_cur_y,
                                             (flags & mouse_left) != 0))
                    {
                        on_ctrl_change();
                        force_redraw();
                    }
                    else
                    {
                        on_mouse_move(m_specific->m_cur_x, 
                                      m_specific->m_cur_y, 
                                      flags);
                    }
		    SDL_Event eventtrash;
		    while (SDL_PeepEvents(&eventtrash, 1, SDL_GETEVENT, SDL_EVENTMASK(SDL_MOUSEMOTION))!=0){;}
                    break;

		case SDL_MOUSEBUTTONDOWN:
                    y = m_flip_y
                        ? m_rbuf_window.height() - event.button.y
                        : event.button.y;

                    m_specific->m_cur_x = event.button.x;
                    m_specific->m_cur_y = y;
                    flags = 0;
                    switch(event.button.button)
                    {
                    case SDL_BUTTON_LEFT:
                        {
                            flags = mouse_left;

if(m_ctrls.on_mouse_button_down(m_specific->m_cur_x,
                                m_specific->m_cur_y))
                            {
                                m_ctrls.set_cur(m_specific->m_cur_x, 
                                    m_specific->m_cur_y);
                                on_ctrl_change();
                                force_redraw();
                            }
                            else
                            {
                                if(m_ctrls.in_rect(m_specific->m_cur_x, 
                                    m_specific->m_cur_y))
                                {
                                    if(m_ctrls.set_cur(m_specific->m_cur_x, 
                                        m_specific->m_cur_y))
                                    {
                                        on_ctrl_change();
                                        force_redraw();
                                    }
                                }
                                else
                                {
                                    on_mouse_button_down(m_specific->m_cur_x, 
                                        m_specific->m_cur_y, 
                                        flags);
                                }
                            }
                        }
                        break;
                    case SDL_BUTTON_RIGHT:
                        flags = mouse_right;
                        on_mouse_button_down(m_specific->m_cur_x, 
                            m_specific->m_cur_y, 
                            flags);
                        break;
                    } //switch(event.button.button)
                    break;
		    
                case SDL_MOUSEBUTTONUP:
                    y = m_flip_y
                        ? m_rbuf_window.height() - event.button.y
                        : event.button.y;

                    m_specific->m_cur_x = event.button.x;
                    m_specific->m_cur_y = y;
                    flags = 0;
                    if(m_ctrls.on_mouse_button_up(m_specific->m_cur_x, 
                                                  m_specific->m_cur_y))
                    {
                        on_ctrl_change();
                        force_redraw();
                    }
                    on_mouse_button_up(m_specific->m_cur_x, 
                                       m_specific->m_cur_y, 
                                       flags);
                    break;
                }
            }
        }
        return 0;
    }



    //------------------------------------------------------------------------
    const char* platform_support::img_ext() const { return ".bmp"; }

    //------------------------------------------------------------------------
    const char* platform_support::full_file_name(const char* file_name)
    {
        return file_name;
    }

    //------------------------------------------------------------------------
    bool platform_support::load_img(unsigned idx, const char* file)
    {
        if(idx < max_images)
        {
            if(m_specific->m_surf_img[idx]) SDL_FreeSurface(m_specific->m_surf_img[idx]);

            char fn[1024];
            strcpy(fn, file);
            int len = strlen(fn);
            if(len < 4 || strcmp(fn + len - 4, ".bmp") != 0)
            {
                strcat(fn, ".bmp");
            }

            SDL_Surface* tmp_surf = SDL_LoadBMP(fn);
            if (tmp_surf == 0) 
            {
                fprintf(stderr, "Couldn't load %s: %s\n", fn, SDL_GetError());
                return false;
            }

            SDL_PixelFormat format;
            format.palette = 0;
            format.BitsPerPixel = m_bpp;
            format.BytesPerPixel = m_bpp >> 8;
            format.Rmask = m_specific->m_rmask;
            format.Gmask = m_specific->m_gmask;
            format.Bmask = m_specific->m_bmask;
            format.Amask = m_specific->m_amask;
            format.Rshift = 0;
            format.Gshift = 0;
            format.Bshift = 0;
            format.Ashift = 0;
            format.Rloss = 0;
            format.Gloss = 0;
            format.Bloss = 0;
            format.Aloss = 0;
            format.colorkey = 0;
            format.alpha = 0;

            m_specific->m_surf_img[idx] = 
                SDL_ConvertSurface(tmp_surf, 
                                   &format, 
                                   SDL_SWSURFACE);

            SDL_FreeSurface(tmp_surf);
            
            if(m_specific->m_surf_img[idx] == 0) return false;

            m_rbuf_img[idx].attach((unsigned char*)m_specific->m_surf_img[idx]->pixels, 
                                   m_specific->m_surf_img[idx]->w, 
                                   m_specific->m_surf_img[idx]->h, 
                                   m_flip_y ? -m_specific->m_surf_img[idx]->pitch : 
                                               m_specific->m_surf_img[idx]->pitch);
            return true;

        }
        return false;
    }




    //------------------------------------------------------------------------
    bool platform_support::save_img(unsigned idx, const char* file)
    {
        if(idx < max_images && m_specific->m_surf_img[idx])
        {
            char fn[1024];
            strcpy(fn, file);
            int len = strlen(fn);
            if(len < 4 || strcmp(fn + len - 4, ".bmp") != 0)
            {
                strcat(fn, ".bmp");
            }
            return SDL_SaveBMP(m_specific->m_surf_img[idx], fn) == 0;
        }
        return false;
    }



    //------------------------------------------------------------------------
    bool platform_support::create_img(unsigned idx, unsigned width, unsigned height)
    {
        if(idx < max_images)
        {

            if(m_specific->m_surf_img[idx]) SDL_FreeSurface(m_specific->m_surf_img[idx]);

             m_specific->m_surf_img[idx] = 
                 SDL_CreateRGBSurface(SDL_SWSURFACE, 
                                      width, 
                                      height,
                                      m_specific->m_surf_screen->format->BitsPerPixel,
                                      m_specific->m_rmask, 
                                      m_specific->m_gmask, 
                                      m_specific->m_bmask, 
                                      m_specific->m_amask);
            if(m_specific->m_surf_img[idx] == 0) 
            {
                fprintf(stderr, "Couldn't create image: %s\n", SDL_GetError());
                return false;
            }

            m_rbuf_img[idx].attach((unsigned char*)m_specific->m_surf_img[idx]->pixels, 
                                   m_specific->m_surf_img[idx]->w, 
                                   m_specific->m_surf_img[idx]->h, 
                                   m_flip_y ? -m_specific->m_surf_img[idx]->pitch : 
                                               m_specific->m_surf_img[idx]->pitch);

            return true;
        }

        return false;
    }
    
    //------------------------------------------------------------------------
    void platform_support::start_timer()
    {
        m_specific->m_sw_start = SDL_GetTicks();
    }

    //------------------------------------------------------------------------
    double platform_support::elapsed_time() const
    {
        int stop = SDL_GetTicks();
        return double(stop - m_specific->m_sw_start);
    }

    //------------------------------------------------------------------------
    void platform_support::message(const char* msg)
    {
        fprintf(stderr, "%s\n", msg);
    }

    //------------------------------------------------------------------------
    void platform_support::force_redraw()
    {
        m_specific->m_update_flag = true;
    }


    //------------------------------------------------------------------------
    void platform_support::on_init() {}
    void platform_support::on_resize(int sx, int sy) {}
    void platform_support::on_idle() {}
    void platform_support::on_mouse_move(int x, int y, unsigned flags) {}
    void platform_support::on_mouse_button_down(int x, int y, unsigned flags) {}
    void platform_support::on_mouse_button_up(int x, int y, unsigned flags) {}
    void platform_support::on_key(int x, int y, unsigned key, unsigned flags) {}
    void platform_support::on_ctrl_change() {}
    void platform_support::on_draw() {}
    void platform_support::on_post_draw(void* raw_handler) {}


}


int agg_main(int argc, char* argv[]);

int main(int argc, char* argv[])
{
    return agg_main(argc, argv);
}

[Roadmap-commit] roadmap_editor/src/agg23/src/platform/win32 agg_platform_support.cpp,NONE,1.1 agg_win32_bmp.cpp,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform/win32
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/src/platform/win32

Added Files:
	agg_platform_support.cpp agg_win32_bmp.cpp 
Log Message:
Import agg sources.

--- NEW FILE: agg_platform_support.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// class platform_support
//
//----------------------------------------------------------------------------

[...1434 lines suppressed...]
        agg::tokenizer::token tok = cmd_line.next_token();
        if(tok.ptr == 0) break;
        if(tok.len)
        {
            memcpy(argv_ptr, tok.ptr, tok.len);
            argv[argc++] = argv_ptr;
            argv_ptr += tok.len;
            *argv_ptr++ = 0;
        }
    }

    int ret = agg_main(argc, argv);
    delete [] argv_str;

    return ret;
}





--- NEW FILE: agg_win32_bmp.cpp ---
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
// Contact: mcs...@ya...
//----------------------------------------------------------------------------
//
// class pixel_map
//
//----------------------------------------------------------------------------

#include "platform/win32/agg_win32_bmp.h"
#include "agg_basics.h"

namespace agg
{

    //------------------------------------------------------------------------
    pixel_map::~pixel_map()
    {
        destroy();
    }


    //------------------------------------------------------------------------
    pixel_map::pixel_map() :
        m_bmp(0),
        m_buf(0),
        m_bpp(0),
        m_is_internal(false),
        m_img_size(0),
        m_full_size(0)

    {
    }


    //------------------------------------------------------------------------
    void pixel_map::destroy()
    {
        if(m_bmp && m_is_internal) delete [] (unsigned char*)m_bmp;
        m_bmp  = 0;
        m_is_internal = false;
        m_buf = 0;
    }


    //------------------------------------------------------------------------
    void pixel_map::create(unsigned width, 
                           unsigned height, 
                           org_e    org,
                           unsigned clear_val)
    {
        destroy();
        if(width == 0)  width = 1;
        if(height == 0) height = 1;
        m_bpp = org;
        create_from_bmp(create_bitmap_info(width, height, m_bpp));
        create_gray_scale_palette(m_bmp);
        m_is_internal = true;
        if(clear_val <= 255)
        {
            memset(m_buf, clear_val, m_img_size);
        }
    }


    //------------------------------------------------------------------------
    HBITMAP pixel_map::create_dib_section(HDC h_dc,
                                          unsigned width, 
                                          unsigned height, 
                                          org_e    org,
                                          unsigned clear_val)
    {
        destroy();
        if(width == 0)  width = 1;
        if(height == 0) height = 1;
        m_bpp = org;
        HBITMAP h_bitmap = create_dib_section_from_args(h_dc, width, height, m_bpp);
        create_gray_scale_palette(m_bmp);
        m_is_internal = true;
        if(clear_val <= 255)
        {
            memset(m_buf, clear_val, m_img_size);
        }
        return h_bitmap;
    }



    //------------------------------------------------------------------------
    void pixel_map::clear(unsigned clear_val)
    {
        if(m_buf) memset(m_buf, clear_val, m_img_size);
    }


    //------------------------------------------------------------------------
    void pixel_map::attach_to_bmp(BITMAPINFO *bmp)
    {
        if(bmp)
        {
            destroy();
            create_from_bmp(bmp);
            m_is_internal = false;
        }
    }



    //static
    //------------------------------------------------------------------------
    unsigned pixel_map::calc_full_size(BITMAPINFO *bmp)
    {
        if(bmp == 0) return 0;

        return sizeof(BITMAPINFOHEADER) +
               sizeof(RGBQUAD) * calc_palette_size(bmp) +
               bmp->bmiHeader.biSizeImage;
    }

    //static
    //------------------------------------------------------------------------
    unsigned pixel_map::calc_header_size(BITMAPINFO *bmp)
    {
        if(bmp == 0) return 0;
        return sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * calc_palette_size(bmp);
    }


    //static
    //------------------------------------------------------------------------
    unsigned  pixel_map::calc_palette_size(unsigned  clr_used, unsigned bits_per_pixel)
    {
        int palette_size = 0;

        if(bits_per_pixel <= 8)
        {
            palette_size = clr_used;
            if(palette_size == 0)
            {
                palette_size = 1 << bits_per_pixel;
            }
        }
        return palette_size;
    }

    //static
    //------------------------------------------------------------------------
    unsigned pixel_map::calc_palette_size(BITMAPINFO *bmp)
    {
        if(bmp == 0) return 0;
        return calc_palette_size(bmp->bmiHeader.biClrUsed, bmp->bmiHeader.biBitCount);
    }


    //static
    //------------------------------------------------------------------------
    unsigned char * pixel_map::calc_img_ptr(BITMAPINFO *bmp)
    {
        if(bmp == 0) return 0;
        return ((unsigned char*)bmp) + calc_header_size(bmp);
    }

    //static
    //------------------------------------------------------------------------
    BITMAPINFO* pixel_map::create_bitmap_info(unsigned width, 
                                              unsigned height, 
                                              unsigned bits_per_pixel)
    {
        unsigned line_len = calc_row_len(width, bits_per_pixel);
        unsigned img_size = line_len * height;
        unsigned rgb_size = calc_palette_size(0, bits_per_pixel) * sizeof(RGBQUAD);
        unsigned full_size = sizeof(BITMAPINFOHEADER) + rgb_size + img_size;

        BITMAPINFO *bmp = (BITMAPINFO *) new unsigned char[full_size];

        bmp->bmiHeader.biSize   = sizeof(BITMAPINFOHEADER);
        bmp->bmiHeader.biWidth  = width;
        bmp->bmiHeader.biHeight = height;
        bmp->bmiHeader.biPlanes = 1;
        bmp->bmiHeader.biBitCount = (unsigned short)bits_per_pixel;
        bmp->bmiHeader.biCompression = 0;
        bmp->bmiHeader.biSizeImage = img_size;
        bmp->bmiHeader.biXPelsPerMeter = 0;
        bmp->bmiHeader.biYPelsPerMeter = 0;
        bmp->bmiHeader.biClrUsed = 0;
        bmp->bmiHeader.biClrImportant = 0;

        return bmp;
    }


    //static
    //------------------------------------------------------------------------
    void pixel_map::create_gray_scale_palette(BITMAPINFO *bmp)
    {
        if(bmp == 0) return;

        unsigned rgb_size = calc_palette_size(bmp);
        RGBQUAD *rgb = (RGBQUAD*)(((unsigned char*)bmp) + sizeof(BITMAPINFOHEADER));
        unsigned brightness;
        unsigned i;

        for(i = 0; i < rgb_size; i++)
        {
            brightness = (255 * i) / (rgb_size - 1);
            rgb->rgbBlue =
            rgb->rgbGreen =  
            rgb->rgbRed = (unsigned char)brightness; 
            rgb->rgbReserved = 0;
            rgb++;
        }
    }



    //static
    //------------------------------------------------------------------------
    unsigned pixel_map::calc_row_len(unsigned width, unsigned bits_per_pixel)
    {
        unsigned n = width;
        unsigned k;

        switch(bits_per_pixel)
        {
            case  1: k = n;
                     n = n >> 3;
                     if(k & 7) n++; 
                     break;

            case  4: k = n;
                     n = n >> 1;
                     if(k & 3) n++; 
                     break;

            case  8:
                     break;

            case 16: n *= 2;
                     break;

            case 24: n *= 3; 
                     break;

            case 32: n *= 4;
                     break;

            case 48: n *= 6; 
                     break;

            case 64: n *= 8; 
                     break;

            default: n = 0;
                     break;
        }
        return ((n + 3) >> 2) << 2;
    }





    //------------------------------------------------------------------------
    void pixel_map::draw(HDC h_dc, const RECT *device_rect, const RECT *bmp_rect) const
    {
        if(m_bmp == 0 || m_buf == 0) return;

        unsigned bmp_x = 0;
        unsigned bmp_y = 0;
        unsigned bmp_width  = m_bmp->bmiHeader.biWidth;
        unsigned bmp_height = m_bmp->bmiHeader.biHeight;
        unsigned dvc_x = 0;
        unsigned dvc_y = 0; 
        unsigned dvc_width  = m_bmp->bmiHeader.biWidth;
        unsigned dvc_height = m_bmp->bmiHeader.biHeight;
        
        if(bmp_rect) 
        {
            bmp_x      = bmp_rect->left;
            bmp_y      = bmp_rect->top;
            bmp_width  = bmp_rect->right  - bmp_rect->left;
            bmp_height = bmp_rect->bottom - bmp_rect->top;
        } 

        dvc_x      = bmp_x;
        dvc_y      = bmp_y;
        dvc_width  = bmp_width;
        dvc_height = bmp_height;

        if(device_rect) 
        {
            dvc_x      = device_rect->left;
            dvc_y      = device_rect->top;
            dvc_width  = device_rect->right  - device_rect->left;
            dvc_height = device_rect->bottom - device_rect->top;
        }

        if(dvc_width != bmp_width || dvc_height != bmp_height)
        {
            ::SetStretchBltMode(h_dc, COLORONCOLOR);
            ::StretchDIBits(
                h_dc,            // handle of device context 
                dvc_x,           // x-coordinate of upper-left corner of source rect. 
                dvc_y,           // y-coordinate of upper-left corner of source rect. 
                dvc_width,       // width of source rectangle 
                dvc_height,      // height of source rectangle 
                bmp_x,
                bmp_y,           // x, y -coordinates of upper-left corner of dest. rect. 
                bmp_width,       // width of destination rectangle 
                bmp_height,      // height of destination rectangle 
                m_buf,           // address of bitmap bits 
                m_bmp,           // address of bitmap data 
                DIB_RGB_COLORS,  // usage 
                SRCCOPY          // raster operation code 
            );
        }
        else
        {
            ::SetDIBitsToDevice(
                h_dc,            // handle to device context
                dvc_x,           // x-coordinate of upper-left corner of 
                dvc_y,           // y-coordinate of upper-left corner of 
                dvc_width,       // source rectangle width
                dvc_height,      // source rectangle height
                bmp_x,           // x-coordinate of lower-left corner of 
                bmp_y,           // y-coordinate of lower-left corner of 
                0,               // first scan line in array
                bmp_height,      // number of scan lines
                m_buf,           // address of array with DIB bits
                m_bmp,           // address of structure with bitmap info.
                DIB_RGB_COLORS   // RGB or palette indexes
            );
        }
    }


    //------------------------------------------------------------------------
    void pixel_map::draw(HDC h_dc, int x, int y, double scale) const
    {
        if(m_bmp == 0 || m_buf == 0) return;

        unsigned width  = unsigned(m_bmp->bmiHeader.biWidth * scale);
        unsigned height = unsigned(m_bmp->bmiHeader.biHeight * scale);
        RECT rect;
        rect.left   = x;
        rect.top    = y;
        rect.right  = x + width;
        rect.bottom = y + height;
        draw(h_dc, &rect);
    }




    //------------------------------------------------------------------------
    void pixel_map::blend(HDC h_dc, const RECT *device_rect, const RECT *bmp_rect) const
    {
#if !defined(AGG_BMP_ALPHA_BLEND)
        draw(h_dc, device_rect, bmp_rect);
        return;
#else
        if(m_bpp != 32)
        {
            draw(h_dc, device_rect, bmp_rect);
            return;
        }

        if(m_bmp == 0 || m_buf == 0) return;

        unsigned bmp_x = 0;
        unsigned bmp_y = 0;
        unsigned bmp_width  = m_bmp->bmiHeader.biWidth;
        unsigned bmp_height = m_bmp->bmiHeader.biHeight;
        unsigned dvc_x = 0;
        unsigned dvc_y = 0; 
        unsigned dvc_width  = m_bmp->bmiHeader.biWidth;
        unsigned dvc_height = m_bmp->bmiHeader.biHeight;
        
        if(bmp_rect) 
        {
            bmp_x      = bmp_rect->left;
            bmp_y      = bmp_rect->top;
            bmp_width  = bmp_rect->right  - bmp_rect->left;
            bmp_height = bmp_rect->bottom - bmp_rect->top;
        } 

        dvc_x      = bmp_x;
        dvc_y      = bmp_y;
        dvc_width  = bmp_width;
        dvc_height = bmp_height;

        if(device_rect) 
        {
            dvc_x      = device_rect->left;
            dvc_y      = device_rect->top;
            dvc_width  = device_rect->right  - device_rect->left;
            dvc_height = device_rect->bottom - device_rect->top;
        }

        HDC mem_dc = ::CreateCompatibleDC(h_dc);
        void* buf = 0;
        HBITMAP bmp = ::CreateDIBSection(
            mem_dc, 
            m_bmp,  
            DIB_RGB_COLORS,
            &buf,
            0,
            0
        );
        memcpy(buf, m_buf, m_bmp->bmiHeader.biSizeImage);

        HBITMAP temp = (HBITMAP)::SelectObject(mem_dc, bmp);

        BLENDFUNCTION blend;
        blend.BlendOp = AC_SRC_OVER;
        blend.BlendFlags = 0;

#if defined(AC_SRC_ALPHA)
        blend.AlphaFormat = AC_SRC_ALPHA;
//#elif defined(AC_SRC_NO_PREMULT_ALPHA)
//        blend.AlphaFormat = AC_SRC_NO_PREMULT_ALPHA;
#else 
#error "No appropriate constant for alpha format. Check version of wingdi.h, There must be AC_SRC_ALPHA or AC_SRC_NO_PREMULT_ALPHA"
#endif

        blend.SourceConstantAlpha = 255;
        ::AlphaBlend(
          h_dc,      
          dvc_x,      
          dvc_y,      
          dvc_width,  
          dvc_height, 
          mem_dc,
          bmp_x,
          bmp_y,     
          bmp_width, 
          bmp_height,
          blend
        );

        ::SelectObject(mem_dc, temp);
        ::DeleteObject(bmp);
        ::DeleteObject(mem_dc);
#endif //defined(AGG_BMP_ALPHA_BLEND)
    }


    //------------------------------------------------------------------------
    void pixel_map::blend(HDC h_dc, int x, int y, double scale) const
    {
        if(m_bmp == 0 || m_buf == 0) return;
        unsigned width  = unsigned(m_bmp->bmiHeader.biWidth * scale);
        unsigned height = unsigned(m_bmp->bmiHeader.biHeight * scale);
        RECT rect;
        rect.left   = x;
        rect.top    = y;
        rect.right  = x + width;
        rect.bottom = y + height;
        blend(h_dc, &rect);
    }


    //------------------------------------------------------------------------
    bool pixel_map::load_from_bmp(FILE *fd)
    {
        BITMAPFILEHEADER  bmf;
        BITMAPINFO       *bmi = 0;
        unsigned          bmp_size;

        fread(&bmf, sizeof(bmf), 1, fd);
        if(bmf.bfType != 0x4D42) goto bmperr;

        bmp_size = bmf.bfSize - sizeof(BITMAPFILEHEADER);

        bmi = (BITMAPINFO*) new unsigned char [bmp_size];
        if(fread(bmi, 1, bmp_size, fd) != bmp_size) goto bmperr;
        destroy();
        m_bpp = bmi->bmiHeader.biBitCount;
        create_from_bmp(bmi);
        m_is_internal = 1;
        return true;

    bmperr:
        if(bmi) delete [] (unsigned char*) bmi;
        return false;
    }



    //------------------------------------------------------------------------
    bool pixel_map::load_from_bmp(const char *filename)
    {
        FILE *fd = fopen(filename, "rb");
        bool ret = false;
        if(fd)
        {
            ret = load_from_bmp(fd);
            fclose(fd);
        }
        return ret;
    }



    //------------------------------------------------------------------------
    bool pixel_map::save_as_bmp(FILE *fd) const
    {
        if(m_bmp == 0) return 0;

        BITMAPFILEHEADER bmf;

        bmf.bfType      = 0x4D42;
        bmf.bfOffBits   = calc_header_size(m_bmp) + sizeof(bmf);
        bmf.bfSize      = bmf.bfOffBits + m_img_size;
        bmf.bfReserved1 = 0;
        bmf.bfReserved2 = 0;

        fwrite(&bmf, sizeof(bmf), 1, fd);
        fwrite(m_bmp, m_full_size, 1, fd);
        return true;
    }



    //------------------------------------------------------------------------
    bool pixel_map::save_as_bmp(const char *filename) const
    {
        FILE *fd = fopen(filename, "wb");
        bool ret = false;
        if(fd)
        {
            ret = save_as_bmp(fd);
            fclose(fd);
        }
        return ret;
    }


    //------------------------------------------------------------------------
    unsigned char* pixel_map::buf()
    {
        return m_buf;
    }

    //------------------------------------------------------------------------
    unsigned pixel_map::width() const
    {
        return m_bmp->bmiHeader.biWidth;
    }

    //------------------------------------------------------------------------
    unsigned pixel_map::height() const
    {
        return m_bmp->bmiHeader.biHeight;
    }

    //------------------------------------------------------------------------
    int pixel_map::stride() const
    {
        return calc_row_len(m_bmp->bmiHeader.biWidth, 
                            m_bmp->bmiHeader.biBitCount);
    }


    //private
    //------------------------------------------------------------------------
    void pixel_map::create_from_bmp(BITMAPINFO *bmp)
    {
        if(bmp)
        {
            m_img_size  = calc_row_len(bmp->bmiHeader.biWidth, 
                                       bmp->bmiHeader.biBitCount) * 
                          bmp->bmiHeader.biHeight;

            m_full_size = calc_full_size(bmp);
            m_bmp       = bmp;
            m_buf       = calc_img_ptr(bmp);
        }
    }


    //private
    //------------------------------------------------------------------------
    HBITMAP pixel_map::create_dib_section_from_args(HDC h_dc,
                                                    unsigned width, 
                                                    unsigned height, 
                                                    unsigned bits_per_pixel)
    {
        unsigned line_len  = calc_row_len(width, bits_per_pixel);
        unsigned img_size  = line_len * height;
        unsigned rgb_size  = calc_palette_size(0, bits_per_pixel) * sizeof(RGBQUAD);
        unsigned full_size = sizeof(BITMAPINFOHEADER) + rgb_size;
        
        BITMAPINFO *bmp = (BITMAPINFO *) new unsigned char[full_size];
        
        bmp->bmiHeader.biSize   = sizeof(BITMAPINFOHEADER);
        bmp->bmiHeader.biWidth  = width;
        bmp->bmiHeader.biHeight = height;
        bmp->bmiHeader.biPlanes = 1;
        bmp->bmiHeader.biBitCount = (unsigned short)bits_per_pixel;
        bmp->bmiHeader.biCompression = 0;
        bmp->bmiHeader.biSizeImage = img_size;
        bmp->bmiHeader.biXPelsPerMeter = 0;
        bmp->bmiHeader.biYPelsPerMeter = 0;
        bmp->bmiHeader.biClrUsed = 0;
        bmp->bmiHeader.biClrImportant = 0;
        
        void*   img_ptr  = 0;
        HBITMAP h_bitmap = ::CreateDIBSection(h_dc, bmp, DIB_RGB_COLORS, &img_ptr, NULL, 0);
        
        if(img_ptr)
        {
            m_img_size  = calc_row_len(width, bits_per_pixel) * height;
            m_full_size = 0;
            m_bmp       = bmp;
            m_buf       = (unsigned char *) img_ptr;
        }
        
        return h_bitmap;
    }
}

[Roadmap-commit] roadmap_editor/src/agg23/include/platform/win32 agg_win32_bmp.h,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/include/platform/win32
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/include/platform/win32

Added Files:
	agg_win32_bmp.h 
Log Message:
Import agg sources.

--- NEW FILE: agg_win32_bmp.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// class pixel_map
//
//----------------------------------------------------------------------------
#ifndef AGG_WIN32_BMP_INCLUDED
#define AGG_WIN32_BMP_INCLUDED


#include <windows.h>
#include <stdio.h>


namespace agg
{
    enum org_e
    {
        org_mono8   = 8,
        org_color16 = 16,
        org_color24 = 24,
        org_color32 = 32,
        org_color48 = 48,
        org_color64 = 64
    };

    class pixel_map
    {
    public:
        ~pixel_map();
        pixel_map();

    public:
        void        destroy();
        void        create(unsigned width, 
                           unsigned height, 
                           org_e    org,
                           unsigned clear_val=256);
        HBITMAP     create_dib_section(HDC h_dc,
                                       unsigned width, 
                                       unsigned height, 
                                       org_e    org,
                                       unsigned clear_val=256);

        void        clear(unsigned clear_val=256);
        void        attach_to_bmp(BITMAPINFO* bmp);
        BITMAPINFO* bitmap_info() { return m_bmp; }
        bool        load_from_bmp(FILE* fd);
        bool        save_as_bmp(FILE* fd) const;
        bool        load_from_bmp(const char* filename);
        bool        save_as_bmp(const char* filename) const;

        void        draw(HDC h_dc, 
                         const RECT* device_rect=0, 
                         const RECT* bmp_rect=0) const;
        void        draw(HDC h_dc, int x, int y, double scale=1.0) const;

        void        blend(HDC h_dc, 
                          const RECT* device_rect=0, 
                          const RECT* bmp_rect=0) const;
        void        blend(HDC h_dc, int x, int y, double scale=1.0) const;


        unsigned char* buf();
        unsigned       width() const;
        unsigned       height() const;
        int            stride() const;
        unsigned       bpp() const { return m_bpp; }

        //Auxiliary static functions
        static unsigned calc_full_size(BITMAPINFO *bmp);
        static unsigned calc_header_size(BITMAPINFO *bmp);
        static unsigned calc_palette_size(unsigned clr_used, 
                                          unsigned bits_per_pixel);
        static unsigned calc_palette_size(BITMAPINFO *bmp);
        static unsigned char* calc_img_ptr(BITMAPINFO *bmp);
        static BITMAPINFO* create_bitmap_info(unsigned width, 
                                              unsigned height, 
                                              unsigned bits_per_pixel);
        static void     create_gray_scale_palette(BITMAPINFO *bmp);
        static unsigned calc_row_len(unsigned width, unsigned bits_per_pixel);
        
    private:
        pixel_map(const pixel_map&);
        const pixel_map& operator = (const pixel_map&);
        void create_from_bmp(BITMAPINFO *bmp);
        
        HBITMAP create_dib_section_from_args(HDC h_dc,
                                             unsigned width,
                                             unsigned height,
                                             unsigned bits_per_pixel);

    private:
        BITMAPINFO*    m_bmp;
        unsigned char* m_buf;
        unsigned       m_bpp;
        bool           m_is_internal;
        unsigned       m_img_size;
        unsigned       m_full_size;
    };

}


#endif

[Roadmap-commit] roadmap_editor/src/agg23/src/ctrl Makefile.am,NONE,1.1 agg_bezier_ctrl.cpp,NONE,1.1 agg_cbox_ctrl.cpp,NONE,1.1 agg_gamma_ctrl.cpp,NONE,1.1 agg_gamma_spline.cpp,NONE,1.1 agg_polygon_ctrl.cpp,NONE,1.1 agg_rbox_ctrl.cpp,NONE,1.1 agg_scale_ctrl.cpp,NONE,1.1 agg_slider_ctrl.cpp,NONE,1.1 agg_spline_ctrl.cpp,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src/ctrl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/src/ctrl

Added Files:
	Makefile.am agg_bezier_ctrl.cpp agg_cbox_ctrl.cpp 
	agg_gamma_ctrl.cpp agg_gamma_spline.cpp agg_polygon_ctrl.cpp 
	agg_rbox_ctrl.cpp agg_scale_ctrl.cpp agg_slider_ctrl.cpp 
	agg_spline_ctrl.cpp 
Log Message:
Import agg sources.

--- NEW FILE: agg_bezier_ctrl.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes bezier_ctrl_impl, bezier_ctrl
//
//----------------------------------------------------------------------------

#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);
    }












}


--- NEW FILE: agg_rbox_ctrl.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes rbox_ctrl_impl, rbox_ctrl
//
//----------------------------------------------------------------------------

#include <string.h>
#include "ctrl/agg_rbox_ctrl.h"

namespace agg
{

    //------------------------------------------------------------------------
    rbox_ctrl_impl::~rbox_ctrl_impl()
    {
        if(m_num_items)
        {
            char** item = m_items + m_num_items - 1;
            while(m_num_items--)
            {
                delete *item;
                --item;
            }
        }
    }

    
    //------------------------------------------------------------------------
    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] = new char[strlen(text) + 1];
            strcpy(m_items[m_num_items], 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]);
            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]);
                    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;
    }


}



--- NEW FILE: agg_gamma_ctrl.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// class gamma_ctrl_impl
//
//----------------------------------------------------------------------------

#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;
    }



}


--- NEW FILE: agg_cbox_ctrl.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes rbox_ctrl_impl, rbox_ctrl
//
//----------------------------------------------------------------------------

#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;
    }
}




--- NEW FILE: agg_polygon_ctrl.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes polygon_ctrl_impl
//
//----------------------------------------------------------------------------

#include "ctrl/agg_polygon_ctrl.h"

namespace agg
{

    polygon_ctrl_impl::~polygon_ctrl_impl()
    {
        delete [] m_polygon;
    }


    polygon_ctrl_impl::polygon_ctrl_impl(unsigned np, double point_radius) :
        ctrl(0, 0, 1, 1, false),
        m_polygon(new double[np * 2]),
        m_num_points(np),
        m_node(-1),
        m_edge(-1),
        m_vs(m_polygon, 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_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, er...@ey...
    //
    // 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;
    }
}


--- NEW FILE: agg_gamma_spline.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// class gamma_spline
//
//----------------------------------------------------------------------------

#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;
    }
  


}


--- NEW FILE: agg_spline_ctrl.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// classes spline_ctrl_impl, spline_ctrl
//
//----------------------------------------------------------------------------

#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 ...
 
[truncated message content]

[Roadmap-commit] roadmap_editor/src/agg23/font_freetype Makefile.am,NONE,1.1 agg_font_freetype.cpp,NONE,1.1 agg_font_freetype.h,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/font_freetype
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/font_freetype

Added Files:
	Makefile.am agg_font_freetype.cpp agg_font_freetype.h 
Log Message:
Import agg sources.

--- NEW FILE: agg_font_freetype.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------


#include <stdio.h>
#include "agg_font_freetype.h"
#include "agg_bitset_iterator.h"
[...1108 lines suppressed...]
            double dy = int26p6_to_dbl(delta.y);
            if(m_glyph_rendering == glyph_ren_outline ||
               m_glyph_rendering == glyph_ren_agg_mono ||
               m_glyph_rendering == glyph_ren_agg_gray8)
            {
                m_affine.transform_2x2(&dx, &dy);
            }
            *x += dx;
            *y += dy;

            return true;
        }
        return false;
    }



}



--- NEW FILE: Makefile.am ---
INCLUDES = -I$(top_srcdir)/include `freetype-config --cflags`

noinst_LTLIBRARIES = libaggfontfreetype.la

libaggfontfreetype_la_LDFLAGS = -version-info 2:1:0 `freetype-config --libs`
libaggfontfreetype_la_SOURCES = agg_font_freetype.cpp

--- NEW FILE: agg_font_freetype.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// See implementation agg_font_freetype.cpp
//
//----------------------------------------------------------------------------

#ifndef AGG_FONT_FREETYPE_INCLUDED
#define AGG_FONT_FREETYPE_INCLUDED

#include <ft2build.h>
#include FT_FREETYPE_H


#include "agg_scanline_storage_aa.h"
#include "agg_scanline_storage_bin.h"
#include "agg_scanline_u.h"
#include "agg_scanline_bin.h"
#include "agg_path_storage_integer.h"
#include "agg_rasterizer_scanline_aa.h"
#include "agg_conv_curve.h"
#include "agg_font_cache_manager.h"
#include "agg_trans_affine.h"

namespace agg
{


    //-----------------------------------------------font_engine_freetype_base
    class font_engine_freetype_base
    {
    public:
        //--------------------------------------------------------------------
        typedef serialized_scanlines_adaptor_aa<int8u>    gray8_adaptor_type;
        typedef serialized_scanlines_adaptor_bin          mono_adaptor_type;
        typedef scanline_storage_aa8                      scanlines_aa_type;
        typedef scanline_storage_bin                      scanlines_bin_type;

        //--------------------------------------------------------------------
        ~font_engine_freetype_base();
        font_engine_freetype_base(bool flag32, unsigned max_faces = 32);

        // Set font parameters
        //--------------------------------------------------------------------
        void resolution(unsigned dpi);
        bool load_font(const char* font_name, unsigned face_index, glyph_rendering ren_type,
                       const char* font_mem = 0, const long font_mem_size = 0);
        bool attach(const char* file_name);
        bool char_map(FT_Encoding map);
        bool height(double h);
        bool width(double w);
        void hinting(bool h);
        void flip_y(bool f);
        void transform(const trans_affine& affine);

        // Set Gamma
        //--------------------------------------------------------------------
        template<class GammaF> void gamma(const GammaF& f)
        {
            m_rasterizer.gamma(f);
        }

        // Accessors
        //--------------------------------------------------------------------
        int         last_error()   const { return m_last_error; }
        unsigned    resolution()   const { return m_resolution; }
        const char* name()         const { return m_name;       }
        unsigned    num_faces()    const;
        FT_Encoding char_map()     const { return m_char_map;   }
        double      height()       const { return double(m_height) / 64.0;    }
        double      width()        const { return double(m_width) / 64.0;     }
        double      ascender()     const;
        double      descender()    const;
        bool        hinting()      const { return m_hinting;    }
        bool        flip_y()       const { return m_flip_y;     }


        // Interface mandatory to implement for font_cache_manager
        //--------------------------------------------------------------------
        const char*     font_signature() const { return m_signature;    }
        int             change_stamp()   const { return m_change_stamp; }

        bool            prepare_glyph(unsigned glyph_code);
        unsigned        glyph_index() const { return m_glyph_index; }
        unsigned        data_size()   const { return m_data_size;   }
        glyph_data_type data_type()   const { return m_data_type;   }
        const rect&     bounds()      const { return m_bounds;      }
        double          advance_x()   const { return m_advance_x;   }
        double          advance_y()   const { return m_advance_y;   }
        void            write_glyph_to(int8u* data) const;
        bool            add_kerning(unsigned first, unsigned second,
                                    double* x, double* y);

    private:
        font_engine_freetype_base(const font_engine_freetype_base&);
        const font_engine_freetype_base& operator = (const font_engine_freetype_base&);

        void update_char_size();
        void update_signature();
        int  find_face(const char* face_name) const;

        bool            m_flag32;
        int             m_change_stamp;
        int             m_last_error;
        char*           m_name;
        unsigned        m_name_len;
        unsigned        m_face_index;
        FT_Encoding     m_char_map;
        char*           m_signature;
        unsigned        m_height;
        unsigned        m_width;
        bool            m_hinting;
        bool            m_flip_y;
        bool            m_library_initialized;
        FT_Library      m_library;    // handle to library    
        FT_Face*        m_faces;      // A pool of font faces
        char**          m_face_names; 
        unsigned        m_num_faces;
        unsigned        m_max_faces;
        FT_Face         m_cur_face;  // handle to the current face object
        int             m_resolution;
        glyph_rendering m_glyph_rendering;
        unsigned        m_glyph_index;
        unsigned        m_data_size;
        glyph_data_type m_data_type;
        rect            m_bounds;
        double          m_advance_x;
        double          m_advance_y;
        trans_affine    m_affine;

        path_storage_integer<int16, 6>              m_path16;
        path_storage_integer<int32, 6>              m_path32;
        conv_curve<path_storage_integer<int16, 6> > m_curves16;
        conv_curve<path_storage_integer<int32, 6> > m_curves32;
        scanline_u8              m_scanline_aa;
        scanline_bin             m_scanline_bin;
        scanlines_aa_type        m_scanlines_aa;
        scanlines_bin_type       m_scanlines_bin;
        rasterizer_scanline_aa<> m_rasterizer;
    };




    //------------------------------------------------font_engine_freetype_int16
    // This class uses values of type int16 (10.6 format) for the vector cache. 
    // The vector cache is compact, but when rendering glyphs of height
    // more that 200 there integer overflow can occur.
    //
    class font_engine_freetype_int16 : public font_engine_freetype_base
    {
    public:
        typedef serialized_integer_path_adaptor<int16, 6>     path_adaptor_type;
        typedef font_engine_freetype_base::gray8_adaptor_type gray8_adaptor_type;
        typedef font_engine_freetype_base::mono_adaptor_type  mono_adaptor_type;
        typedef font_engine_freetype_base::scanlines_aa_type  scanlines_aa_type;
        typedef font_engine_freetype_base::scanlines_bin_type scanlines_bin_type;

        font_engine_freetype_int16(unsigned max_faces = 32) : 
            font_engine_freetype_base(false, max_faces) {}
    };

    //------------------------------------------------font_engine_freetype_int32
    // This class uses values of type int32 (26.6 format) for the vector cache. 
    // The vector cache is twice larger than in font_engine_freetype_int16, 
    // but it allows you to render glyphs of very large sizes.
    //
    class font_engine_freetype_int32 : public font_engine_freetype_base
    {
    public:
        typedef serialized_integer_path_adaptor<int32, 6>     path_adaptor_type;
        typedef font_engine_freetype_base::gray8_adaptor_type gray8_adaptor_type;
        typedef font_engine_freetype_base::mono_adaptor_type  mono_adaptor_type;
        typedef font_engine_freetype_base::scanlines_aa_type  scanlines_aa_type;
        typedef font_engine_freetype_base::scanlines_bin_type scanlines_bin_type;

        font_engine_freetype_int32(unsigned max_faces = 32) : 
            font_engine_freetype_base(true, max_faces) {}
    };


}

#endif

[Roadmap-commit] roadmap_editor/src/agg23/src ChangeLog,NONE,1.1 Makefile,NONE,1.1 Makefile.am,NONE,1.1 agg_arc.cpp,NONE,1.1 agg_arrowhead.cpp,NONE,1.1 agg_bezier_arc.cpp,NONE,1.1 agg_bspline.cpp,NONE,1.1 agg_curves.cpp,NONE,1.1 agg_embedded_raster_fonts.cpp,NONE,1.1 agg_gsv_text.cpp,NONE,1.1 agg_image_filters.cpp,NONE,1.1 agg_line_aa_basics.cpp,NONE,1.1 agg_line_profile_aa.cpp,NONE,1.1 agg_path_storage.cpp,NONE,1.1 agg_rasterizer_scanline_aa.cpp,NONE,1.1 agg_rounded_rect.cpp,NONE,1.1 agg_sqrt_tables.cpp,NONE,1.1 agg_trans_affine.cpp,NONE,1.1 agg_trans_double_path.cpp,NONE,1.1 agg_trans_single_path.cpp,NONE,1.1 agg_trans_warp_magnifier.cpp,NONE,1.1 agg_vcgen_bspline.cpp,NONE,1.1 agg_vcgen_contour.cpp,NONE,1.1 agg_vcgen_dash.cpp,NONE,1.1 agg_vcgen_markers_term.cpp,NONE,1.1 agg_vcgen_smooth_poly1.cpp,NONE,1.1 agg_vcgen_stroke.cpp,NONE,1.1 agg_vpgen_clip_polygon.cpp,NONE,1.1 agg_vpgen_clip_polyline.cpp,NONE,1.1 agg_vpgen_segmentator.cpp,NONE,1.1 authors,NONE,1.1 autogen.sh,NONE,1.1 configure.in,NONE,1.1 copying,NONE,1.1 install,NONE,1.1 news,NONE,1.1 readme,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/src

Added Files:
	ChangeLog Makefile Makefile.am agg_arc.cpp agg_arrowhead.cpp 
	agg_bezier_arc.cpp agg_bspline.cpp agg_curves.cpp 
	agg_embedded_raster_fonts.cpp agg_gsv_text.cpp 
	agg_image_filters.cpp agg_line_aa_basics.cpp 
	agg_line_profile_aa.cpp agg_path_storage.cpp 
	agg_rasterizer_scanline_aa.cpp agg_rounded_rect.cpp 
	agg_sqrt_tables.cpp agg_trans_affine.cpp 
	agg_trans_double_path.cpp agg_trans_single_path.cpp 
	agg_trans_warp_magnifier.cpp agg_vcgen_bspline.cpp 
	agg_vcgen_contour.cpp agg_vcgen_dash.cpp 
	agg_vcgen_markers_term.cpp agg_vcgen_smooth_poly1.cpp 
	agg_vcgen_stroke.cpp agg_vpgen_clip_polygon.cpp 
	agg_vpgen_clip_polyline.cpp agg_vpgen_segmentator.cpp authors 
	autogen.sh configure.in copying install news readme 
Log Message:
Import agg sources.

--- NEW FILE: agg_vpgen_segmentator.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------

#include <math.h>
#include "agg_vpgen_segmentator.h"

namespace agg
{

    void vpgen_segmentator::move_to(double x, double y)
    {
        m_x1 = x;
        m_y1 = y;
        m_dx = 0.0;
        m_dy = 0.0;
        m_dl = 2.0;
        m_ddl = 2.0;
        m_cmd = path_cmd_move_to;
    }

    void vpgen_segmentator::line_to(double x, double y)
    {
        m_x1 += m_dx;
        m_y1 += m_dy;
        m_dx  = x - m_x1;
        m_dy  = y - m_y1;
        double len = sqrt(m_dx * m_dx + m_dy * m_dy) * m_approximation_scale;
        if(len < 1e-30) len = 1e-30;
        m_ddl = 1.0 / len;
        m_dl  = (m_cmd == path_cmd_move_to) ? 0.0 : m_ddl;
        if(m_cmd == path_cmd_stop) m_cmd = path_cmd_line_to;
    }

    unsigned vpgen_segmentator::vertex(double* x, double* y)
    {
        if(m_cmd == path_cmd_stop) return path_cmd_stop;

        unsigned cmd = m_cmd;
        m_cmd = path_cmd_line_to;
        if(m_dl >= 1.0 - m_ddl)
        {
            m_dl = 1.0;
            m_cmd = path_cmd_stop;
            *x = m_x1 + m_dx;
            *y = m_y1 + m_dy;
            return cmd;
        }
        *x = m_x1 + m_dx * m_dl;
        *y = m_y1 + m_dy * m_dl;
        m_dl += m_ddl;
        return cmd;
    }

}


--- NEW FILE: agg_image_filters.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// Filtering class image_filter_lut implemantation
//
//----------------------------------------------------------------------------


#include "agg_image_filters.h"


namespace agg
{

    //--------------------------------------------------------------------
    image_filter_lut::~image_filter_lut()
    {
        delete [] m_weight_array;
    }


    //--------------------------------------------------------------------
    image_filter_lut::image_filter_lut() :
        m_weight_array(0),
        m_max_size(0)
    {}

    //--------------------------------------------------------------------
    void image_filter_lut::realloc_lut(double radius)
    {
        m_radius = radius;
        m_diameter = unsigned(ceil(radius)) * 2;
        m_start = -int(m_diameter / 2 - 1);
        unsigned size = m_diameter << image_subpixel_shift;
        if(size > m_max_size)
        {
            delete [] m_weight_array;
            m_weight_array = new int16 [size];
            m_max_size = size;
        }
    }



    //--------------------------------------------------------------------
    // This function normalizes integer values and corrects the rounding 
    // errors. It doesn't do anything with the source floating point values
    // (m_weight_array_dbl), it corrects only integers according to the rule 
    // of 1.0 which means that any sum of pixel weights must be equal to 1.0.
    // So, the filter function must produce a graph of the proper shape.
    //--------------------------------------------------------------------
    void image_filter_lut::normalize()
    {
        unsigned i;
        int flip = 1;

        for(i = 0; i < image_subpixel_size; i++)
        {
            for(;;)
            {
                int sum = 0;
                unsigned j;
                for(j = 0; j < m_diameter; j++)
                {
                    sum += m_weight_array[j * image_subpixel_size + i];
                }

                if(sum == image_filter_size) break;

                double k = double(image_filter_size) / double(sum);
                sum = 0;
                for(j = 0; j < m_diameter; j++)
                {
                    sum += m_weight_array[j * image_subpixel_size + i] = 
                        int(m_weight_array[j * image_subpixel_size + i] * k);
                }

                sum -= image_filter_size;
                int inc = (sum > 0) ? -1 : 1;

                for(j = 0; j < m_diameter && sum; j++)
                {
                    flip ^= 1;
                    unsigned idx = flip ? m_diameter/2 + j/2 : m_diameter/2 - j/2;
                    int v = m_weight_array[idx * image_subpixel_size + i];
                    if(v < image_filter_size)
                    {
                        m_weight_array[idx * image_subpixel_size + i] += inc;
                        sum += inc;
                    }
                }
            }
        }

        unsigned pivot = m_diameter << (image_subpixel_shift - 1);

        for(i = 0; i < pivot; i++)
        {
            m_weight_array[pivot + i] = m_weight_array[pivot - i];
        }
        unsigned end = (diameter() << image_subpixel_shift) - 1;
        m_weight_array[0] = m_weight_array[end];
    }


}


--- NEW FILE: agg_rounded_rect.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// Rounded rectangle vertex generator
//
//----------------------------------------------------------------------------

#include <math.h>
#include "agg_rounded_rect.h"


namespace agg
{
    //------------------------------------------------------------------------
    rounded_rect::rounded_rect(double x1, double y1, double x2, double y2, double r) :
        m_x1(x1), m_y1(y1), m_x2(x2), m_y2(y2),
        m_rx1(r), m_ry1(r), m_rx2(r), m_ry2(r), 
        m_rx3(r), m_ry3(r), m_rx4(r), m_ry4(r)
    {
        if(x1 > x2) { m_x1 = x2; m_x2 = x1; }
        if(y1 > y2) { m_y1 = y2; m_y2 = y1; }
    }

    //--------------------------------------------------------------------
    void rounded_rect::rect(double x1, double y1, double x2, double y2)
    {
        m_x1 = x1;
        m_y1 = y1;
        m_x2 = x2;
        m_y2 = y2;
        if(x1 > x2) { m_x1 = x2; m_x2 = x1; }
        if(y1 > y2) { m_y1 = y2; m_y2 = y1; }
    }

    //--------------------------------------------------------------------
    void rounded_rect::radius(double r)
    {
        m_rx1 = m_ry1 = m_rx2 = m_ry2 = m_rx3 = m_ry3 = m_rx4 = m_ry4 = r; 
    }

    //--------------------------------------------------------------------
    void rounded_rect::radius(double rx, double ry)
    {
        m_rx1 = m_rx2 = m_rx3 = m_rx4 = rx; 
        m_ry1 = m_ry2 = m_ry3 = m_ry4 = ry; 
    }

    //--------------------------------------------------------------------
    void rounded_rect::radius(double rx_bottom, double ry_bottom, 
                              double rx_top,    double ry_top)
    {
        m_rx1 = m_rx2 = rx_bottom; 
        m_rx3 = m_rx4 = rx_top; 
        m_ry1 = m_ry2 = ry_bottom; 
        m_ry3 = m_ry4 = ry_top; 
    }

    //--------------------------------------------------------------------
    void rounded_rect::radius(double rx1, double ry1, double rx2, double ry2, 
                              double rx3, double ry3, double rx4, double ry4)
    {
        m_rx1 = rx1; m_ry1 = ry1; m_rx2 = rx2; m_ry2 = ry2; 
        m_rx3 = rx3; m_ry3 = ry3; m_rx4 = rx4; m_ry4 = ry4;
    }

    //--------------------------------------------------------------------
    void rounded_rect::normalize_radius()
    {
        double dx = fabs(m_y2 - m_y1);
        double dy = fabs(m_x2 - m_x1);

        double k = 1.0;
        double t;
        t = dx / (m_rx1 + m_rx2); if(t < k) k = t; 
        t = dx / (m_rx3 + m_rx4); if(t < k) k = t; 
        t = dy / (m_ry1 + m_ry2); if(t < k) k = t; 
        t = dy / (m_ry3 + m_ry4); if(t < k) k = t; 

        if(k < 1.0)
        {
            m_rx1 *= k; m_ry1 *= k; m_rx2 *= k; m_ry2 *= k;
            m_rx3 *= k; m_ry3 *= k; m_rx4 *= k; m_ry4 *= k;
        }
    }

    //--------------------------------------------------------------------
    void rounded_rect::rewind(unsigned)
    {
        m_status = 0;
    }

    //--------------------------------------------------------------------
    unsigned rounded_rect::vertex(double* x, double* y)
    {
        unsigned cmd = path_cmd_stop;
        switch(m_status)
        {
        case 0:
            m_arc.init(m_x1 + m_rx1, m_y1 + m_ry1, m_rx1, m_ry1,
                       pi, pi+pi*0.5);
            m_arc.rewind(0);
            m_status++;

        case 1:
            cmd = m_arc.vertex(x, y);
            if(is_stop(cmd)) m_status++;
            else return cmd;

        case 2:
            m_arc.init(m_x2 - m_rx2, m_y1 + m_ry2, m_rx2, m_ry2,
                       pi+pi*0.5, 0.0);
            m_arc.rewind(0);
            m_status++;

        case 3:
            cmd = m_arc.vertex(x, y);
            if(is_stop(cmd)) m_status++;
            else return path_cmd_line_to;

        case 4:
            m_arc.init(m_x2 - m_rx3, m_y2 - m_ry3, m_rx3, m_ry3,
                       0.0, pi*0.5);
            m_arc.rewind(0);
            m_status++;

        case 5:
            cmd = m_arc.vertex(x, y);
            if(is_stop(cmd)) m_status++;
            else return path_cmd_line_to;

        case 6:
            m_arc.init(m_x1 + m_rx4, m_y2 - m_ry4, m_rx4, m_ry4,
                       pi*0.5, pi);
            m_arc.rewind(0);
            m_status++;

        case 7:
            cmd = m_arc.vertex(x, y);
            if(is_stop(cmd)) m_status++;
            else return path_cmd_line_to;

        case 8:
            cmd = path_cmd_end_poly | path_flags_close | path_flags_ccw;
            m_status++;
            break;
        }
        return cmd;
    }


}


--- NEW FILE: configure.in ---
AC_INIT(src/agg_arc.cpp) # give me a source file, any source file...
AM_INIT_AUTOMAKE(agg, 2.0.0)

AC_PROG_LN_S
AC_PROG_CC
AC_PROG_CPP
AC_PROG_CXX
AC_PROG_LIBTOOL

AC_OUTPUT(
   Makefile 
   gpc/Makefile
   src/Makefile
   src/ctrl/Makefile
) 

--- NEW FILE: authors ---

--- NEW FILE: Makefile ---
include ../Makefile.in.$(shell uname)

CXXFLAGS= $(AGGCXXFLAGS) -I../include -L./

SRC_CXX=\
agg_arc.cpp \
agg_arrowhead.cpp \
agg_bezier_arc.cpp \
agg_bspline.cpp \
agg_curves.cpp \
agg_vcgen_contour.cpp \
agg_vcgen_dash.cpp \
agg_vcgen_markers_term.cpp \
agg_vcgen_smooth_poly1.cpp \
agg_vcgen_stroke.cpp \
agg_vcgen_bspline.cpp \
agg_gsv_text.cpp \
agg_image_filters.cpp \
agg_path_storage.cpp \
agg_rasterizer_scanline_aa.cpp \
agg_line_aa_basics.cpp \
agg_line_profile_aa.cpp \
agg_rounded_rect.cpp \
agg_sqrt_tables.cpp \
agg_embedded_raster_fonts.cpp \
agg_trans_affine.cpp \
agg_trans_warp_magnifier.cpp \
agg_trans_single_path.cpp \
agg_trans_double_path.cpp \
agg_vpgen_clip_polygon.cpp \
agg_vpgen_clip_polyline.cpp \
agg_vpgen_segmentator.cpp \
ctrl/agg_cbox_ctrl.cpp \
ctrl/agg_gamma_ctrl.cpp \
ctrl/agg_gamma_spline.cpp \
ctrl/agg_rbox_ctrl.cpp \
ctrl/agg_slider_ctrl.cpp \
ctrl/agg_spline_ctrl.cpp \
ctrl/agg_scale_ctrl.cpp \
ctrl/agg_polygon_ctrl.cpp \
ctrl/agg_bezier_ctrl.cpp

SRC_C=\
../gpc/gpc.c


OBJ=$(SRC_CXX:.cpp=.o) $(SRC_C:.c=.o)

all:	$(OBJ)
	$(LIB) libagg.a $(OBJ) 

clean:
	rm -f *.o *.a ctrl/*.o ../gpc/*.o
	rm -rf SunWS_cache
	rm -rf ctrl/SunWS_cache

%.o: %.cpp
	$(CXX) -c $(CXXFLAGS) $*.cpp -o $@

%.o: %.c
	$(C) -c $(CXXFLAGS) $*.c -o $@

--- NEW FILE: agg_sqrt_tables.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// static tables for fast integer sqrt
//
//----------------------------------------------------------------------------

#include "agg_basics.h"

namespace agg
{
    int16u g_sqrt_table[1024] = 
    {
        0,
        2048,2896,3547,4096,4579,5017,5418,5793,6144,6476,6792,7094,7384,7663,7932,8192,8444,
        8689,8927,9159,9385,9606,9822,10033,10240,10443,10642,10837,11029,11217,11403,11585,
        11765,11942,12116,12288,12457,12625,12790,12953,13114,13273,13430,13585,13738,13890,
        14040,14189,14336,14482,14626,14768,14910,15050,15188,15326,15462,15597,15731,15864,
        15995,16126,16255,16384,16512,16638,16764,16888,17012,17135,17257,17378,17498,17618,
        17736,17854,17971,18087,18203,18318,18432,18545,18658,18770,18882,18992,19102,19212,
        19321,19429,19537,19644,19750,19856,19961,20066,20170,20274,20377,20480,20582,20684,
        20785,20886,20986,21085,21185,21283,21382,21480,21577,21674,21771,21867,21962,22058,
        22153,22247,22341,22435,22528,22621,22713,22806,22897,22989,23080,23170,23261,23351,
        23440,23530,23619,23707,23796,23884,23971,24059,24146,24232,24319,24405,24491,24576,
        24661,24746,24831,24915,24999,25083,25166,25249,25332,25415,25497,25580,25661,25743,
        25824,25905,25986,26067,26147,26227,26307,26387,26466,26545,26624,26703,26781,26859,
        26937,27015,27092,27170,27247,27324,27400,27477,27553,27629,27705,27780,27856,27931,
        28006,28081,28155,28230,28304,28378,28452,28525,28599,28672,28745,28818,28891,28963,
        29035,29108,29180,29251,29323,29394,29466,29537,29608,29678,29749,29819,29890,29960,
        30030,30099,30169,30238,30308,30377,30446,30515,30583,30652,30720,30788,30856,30924,
        30992,31059,31127,31194,31261,31328,31395,31462,31529,31595,31661,31727,31794,31859,
        31925,31991,32056,32122,32187,32252,32317,32382,32446,32511,32575,32640,32704,32768,
        32832,32896,32959,33023,33086,33150,33213,33276,33339,33402,33465,33527,33590,33652,
        33714,33776,33839,33900,33962,34024,34086,34147,34208,34270,34331,34392,34453,34514,
        34574,34635,34695,34756,34816,34876,34936,34996,35056,35116,35176,35235,35295,35354,
        35413,35472,35531,35590,35649,35708,35767,35825,35884,35942,36001,36059,36117,36175,
        36233,36291,36348,36406,36464,36521,36578,36636,36693,36750,36807,36864,36921,36978,
        37034,37091,37147,37204,37260,37316,37372,37429,37485,37540,37596,37652,37708,37763,
        37819,37874,37929,37985,38040,38095,38150,38205,38260,38315,38369,38424,38478,38533,
        38587,38642,38696,38750,38804,38858,38912,38966,39020,39073,39127,39181,39234,39287,
        39341,39394,39447,39500,39553,39606,39659,39712,39765,39818,39870,39923,39975,40028,
        40080,40132,40185,40237,40289,40341,40393,40445,40497,40548,40600,40652,40703,40755,
        40806,40857,40909,40960,41011,41062,41113,41164,41215,41266,41317,41368,41418,41469,
        41519,41570,41620,41671,41721,41771,41821,41871,41922,41972,42021,42071,42121,42171,
        42221,42270,42320,42369,42419,42468,42518,42567,42616,42665,42714,42763,42813,42861,
        42910,42959,43008,43057,43105,43154,43203,43251,43300,43348,43396,43445,43493,43541,
        43589,43637,43685,43733,43781,43829,43877,43925,43972,44020,44068,44115,44163,44210,
        44258,44305,44352,44400,44447,44494,44541,44588,44635,44682,44729,44776,44823,44869,
        44916,44963,45009,45056,45103,45149,45195,45242,45288,45334,45381,45427,45473,45519,
        45565,45611,45657,45703,45749,45795,45840,45886,45932,45977,46023,46069,46114,46160,
        46205,46250,46296,46341,46386,46431,46477,46522,46567,46612,46657,46702,46746,46791,
        46836,46881,46926,46970,47015,47059,47104,47149,47193,47237,47282,47326,47370,47415,
        47459,47503,47547,47591,47635,47679,47723,47767,47811,47855,47899,47942,47986,48030,
        48074,48117,48161,48204,48248,48291,48335,48378,48421,48465,48508,48551,48594,48637,
        48680,48723,48766,48809,48852,48895,48938,48981,49024,49067,49109,49152,49195,49237,
        49280,49322,49365,49407,49450,49492,49535,49577,49619,49661,49704,49746,49788,49830,
        49872,49914,49956,49998,50040,50082,50124,50166,50207,50249,50291,50332,50374,50416,
        50457,50499,50540,50582,50623,50665,50706,50747,50789,50830,50871,50912,50954,50995,
        51036,51077,51118,51159,51200,51241,51282,51323,51364,51404,51445,51486,51527,51567,
        51608,51649,51689,51730,51770,51811,51851,51892,51932,51972,52013,52053,52093,52134,
        52174,52214,52254,52294,52334,52374,52414,52454,52494,52534,52574,52614,52654,52694,
        52734,52773,52813,52853,52892,52932,52972,53011,53051,53090,53130,53169,53209,53248,
        53287,53327,53366,53405,53445,53484,53523,53562,53601,53640,53679,53719,53758,53797,
        53836,53874,53913,53952,53991,54030,54069,54108,54146,54185,54224,54262,54301,54340,
        54378,54417,54455,54494,54532,54571,54609,54647,54686,54724,54762,54801,54839,54877,
        54915,54954,54992,55030,55068,55106,55144,55182,55220,55258,55296,55334,55372,55410,
        55447,55485,55523,55561,55599,55636,55674,55712,55749,55787,55824,55862,55900,55937,
        55975,56012,56049,56087,56124,56162,56199,56236,56273,56311,56348,56385,56422,56459,
        56497,56534,56571,56608,56645,56682,56719,56756,56793,56830,56867,56903,56940,56977,
        57014,57051,57087,57124,57161,57198,57234,57271,57307,57344,57381,57417,57454,57490,
        57527,57563,57599,57636,57672,57709,57745,57781,57817,57854,57890,57926,57962,57999,
        58035,58071,58107,58143,58179,58215,58251,58287,58323,58359,58395,58431,58467,58503,
        58538,58574,58610,58646,58682,58717,58753,58789,58824,58860,58896,58931,58967,59002,
        59038,59073,59109,59144,59180,59215,59251,59286,59321,59357,59392,59427,59463,59498,
        59533,59568,59603,59639,59674,59709,59744,59779,59814,59849,59884,59919,59954,59989,
        60024,60059,60094,60129,60164,60199,60233,60268,60303,60338,60373,60407,60442,60477,
        60511,60546,60581,60615,60650,60684,60719,60753,60788,60822,60857,60891,60926,60960,
        60995,61029,61063,61098,61132,61166,61201,61235,61269,61303,61338,61372,61406,61440,
        61474,61508,61542,61576,61610,61644,61678,61712,61746,61780,61814,61848,61882,61916,
        61950,61984,62018,62051,62085,62119,62153,62186,62220,62254,62287,62321,62355,62388,
        62422,62456,62489,62523,62556,62590,62623,62657,62690,62724,62757,62790,62824,62857,
        62891,62924,62957,62991,63024,63057,63090,63124,63157,63190,63223,63256,63289,63323,
        63356,63389,63422,63455,63488,63521,63554,63587,63620,63653,63686,63719,63752,63785,
        63817,63850,63883,63916,63949,63982,64014,64047,64080,64113,64145,64178,64211,64243,
        64276,64309,64341,64374,64406,64439,64471,64504,64536,64569,64601,64634,64666,64699,
        64731,64763,64796,64828,64861,64893,64925,64957,64990,65022,65054,65086,65119,65151,
        65183,65215,65247,65279,65312,65344,65376,65408,65440,65472,65504
    };


    int8 g_elder_bit_table[256] = 
    {
        0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
        5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
        6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
        6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
        7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
        7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
        7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
        7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
    };
 
}

--- NEW FILE: agg_vpgen_clip_polygon.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------

#include "agg_vpgen_clip_polygon.h"
#include "agg_clip_liang_barsky.h"

namespace agg
{

    //------------------------------------------------------------------------
    // Determine the clipping code of the vertex according to the 
    // Cyrus-Beck line clipping algorithm
    //
    //        |        |
    //  0110  |  0010  | 0011
    //        |        |
    // -------+--------+-------- clip_box.y2
    //        |        |
    //  0100  |  0000  | 0001
    //        |        |
    // -------+--------+-------- clip_box.y1
    //        |        |
    //  1100  |  1000  | 1001
    //        |        |
    //  clip_box.x1  clip_box.x2
    //
    // 
    unsigned vpgen_clip_polygon::clipping_flags(double x, double y)
    {
        if(x < m_clip_box.x1) 
        {
            if(y > m_clip_box.y2) return 6;
            if(y < m_clip_box.y1) return 12;
            return 4;
        }

        if(x > m_clip_box.x2) 
        {
            if(y > m_clip_box.y2) return 3;
            if(y < m_clip_box.y1) return 9;
            return 1;
        }

        if(y > m_clip_box.y2) return 2;
        if(y < m_clip_box.y1) return 8;

        return 0;
    }

    //----------------------------------------------------------------------------
    void vpgen_clip_polygon::reset()
    {
        m_vertex = 0;
        m_num_vertices = 0;
    }

    //----------------------------------------------------------------------------
    void vpgen_clip_polygon::move_to(double x, double y)
    {
        m_vertex = 0;
        m_num_vertices = 0;
        m_clip_flags = clipping_flags(x, y);
        if(m_clip_flags == 0)
        {
            m_x[0] = x;
            m_y[0] = y;
            m_num_vertices = 1;
        }
        m_x1  = x;
        m_y1  = y;
        m_cmd = path_cmd_move_to;
    }


    //----------------------------------------------------------------------------
    void vpgen_clip_polygon::line_to(double x, double y)
    {
        m_vertex = 0;
        m_num_vertices = 0;
        unsigned flags = clipping_flags(x, y);

        if(m_clip_flags == flags)
        {
            if(flags == 0)
            {
                m_x[0] = x;
                m_y[0] = y;
                m_num_vertices = 1;
            }
        }
        else
        {
            m_num_vertices = clip_liang_barsky(m_x1, m_y1, 
                                               x, y, 
                                               m_clip_box, 
                                               m_x, m_y);
        }

        m_clip_flags = flags;
        m_x1 = x;
        m_y1 = y;
    }


    //----------------------------------------------------------------------------
    unsigned vpgen_clip_polygon::vertex(double* x, double* y)
    {
        if(m_vertex < m_num_vertices)
        {
            *x = m_x[m_vertex];
            *y = m_y[m_vertex];
            ++m_vertex;
            unsigned cmd = m_cmd;
            m_cmd = path_cmd_line_to;
            return cmd;
        }
        return path_cmd_stop;
    }


}

--- NEW FILE: agg_vpgen_clip_polyline.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------

#include <math.h>
#include "agg_vpgen_clip_polyline.h"

namespace agg
{
    static double clip_epsilon = 1e-10;


    //----------------------------------------------------------------------------
    void vpgen_clip_polyline::reset()
    {
        m_vertex = 0;
        m_num_vertices = 0;
    }

    //----------------------------------------------------------------------------
    void vpgen_clip_polyline::move_to(double x, double y)
    {
        m_vertex = 0;
        m_num_vertices = 0;
        m_f1 = clipping_flags(x, y);
        if(m_f1 == 0)
        {
            m_x[0] = x;
            m_y[0] = y;
            m_cmd[0] = path_cmd_move_to;
            m_num_vertices = 1;
        }
        m_x1 = x;
        m_y1 = y;
    }


    //----------------------------------------------------------------------------
    bool vpgen_clip_polyline::move_point(double& x, double& y, unsigned& flags)
    {
       double bound;

       if(flags & (clip_x1 | clip_x2)) 
       {
           bound = (flags & clip_x1) ? m_clip_box.x1 : m_clip_box.x2;
           y = (bound - m_x1) * (m_y2 - m_y1) / (m_x2 - m_x1) + m_y1;
           x = bound;
           flags = clipping_flags_y(y);
       }
       if(fabs(m_y2 - m_y1) < clip_epsilon && fabs(m_x2 - m_x1) < clip_epsilon) 
       {
           return false;
       }
       if(flags & (clip_y1 | clip_y2)) 
       {
           bound = (flags & clip_y1) ? m_clip_box.y1 : m_clip_box.y2;
           x = (bound - m_y1) * (m_x2 - m_x1) / (m_y2 - m_y1) + m_x1;
           y = bound;
       }
       flags = 0;
       return true;
    }

    //----------------------------------------------------------------------------
    void vpgen_clip_polyline::clip_line_segment()
    {
        if((m_f1 & m_f2) == 0)
        {
            if(m_f1) 
            {   
                if(!move_point(m_x1, m_y1, m_f1)) return;
                if(m_f1) return;
                m_x[0] = m_x1;
                m_y[0] = m_y1;
                m_cmd[0] = path_cmd_move_to;
                m_num_vertices = 1;
            }
            if(m_f2) 
            {                    // Move Point 2
                if(!move_point(m_x2, m_y2, m_f2)) return;
            }
            m_x[m_num_vertices] = m_x2;
            m_y[m_num_vertices] = m_y2;
            m_cmd[m_num_vertices++] = path_cmd_line_to;
        }
    }



    //----------------------------------------------------------------------------
    void vpgen_clip_polyline::line_to(double x, double y)
    {
        m_vertex = 0;
        m_num_vertices = 0;
        unsigned f = m_f2 = clipping_flags(m_x2 = x, m_y2 = y);

        if(m_f2 == m_f1)
        {
            if(m_f2 == 0)
            {
                m_x[0] = x;
                m_y[0] = y;
                m_cmd[0] = path_cmd_line_to;
                m_num_vertices = 1;
            }
        }
        else
        {
            clip_line_segment();
        }

        m_f1 = f;
        m_x1 = x;
        m_y1 = y;
    }


    //----------------------------------------------------------------------------
    unsigned vpgen_clip_polyline::vertex(double* x, double* y)
    {
        if(m_vertex < m_num_vertices)
        {
            *x = m_x[m_vertex];
            *y = m_y[m_vertex];
            return m_cmd[m_vertex++];
        }
        return path_cmd_stop;
    }


}

--- NEW FILE: agg_gsv_text.cpp ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//----------------------------------------------------------------------------
//
// Class gsv_text
//
//----------------------------------------------------------------------------
#include <string.h>
#include <stdio.h>
#include "agg_gsv_text.h"


namespace agg
{
    int8u gsv_default_font[] = 
    {
        0x40,0x00,0x6c,0x0f,0x15,0x00,0x0e,0x00,0xf9,0xff,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x0d,0x0a,0x0d,0x0a,0x46,0x6f,0x6e,0x74,0x20,0x28,
        0x63,0x29,0x20,0x4d,0x69,0x63,0x72,0x6f,0x50,0x72,
        0x6f,0x66,0x20,0x32,0x37,0x20,0x53,0x65,0x70,0x74,
        0x65,0x6d,0x62,0x2e,0x31,0x39,0x38,0x39,0x00,0x0d,
        0x0a,0x0d,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
        0x02,0x00,0x12,0x00,0x34,0x00,0x46,0x00,0x94,0x00,
        0xd0,0x00,0x2e,0x01,0x3e,0x01,0x64,0x01,0x8a,0x01,
        0x98,0x01,0xa2,0x01,0xb4,0x01,0xba,0x01,0xc6,0x01,
        0xcc,0x01,0xf0,0x01,0xfa,0x01,0x18,0x02,0x38,0x02,
        0x44,0x02,0x68,0x02,0x98,0x02,0xa2,0x02,0xde,0x02,
        0x0e,0x03,0x24,0x03,0x40,0x03,0x48,0x03,0x52,0x03,
        0x5a,0x03,0x82,0x03,0xec,0x03,0xfa,0x03,0x26,0x04,
        0x4c,0x04,0x6a,0x04,0x7c,0x04,0x8a,0x04,0xb6,0x04,
        0xc4,0x04,0xca,0x04,0xe0,0x04,0xee,0x04,0xf8,0x04,
        0x0a,0x05,0x18,0x05,0x44,0x05,0x5e,0x05,0x8e,0x05,
        0xac,0x05,0xd6,0x05,0xe0,0x05,0xf6,0x05,0x00,0x06,
        0x12,0x06,0x1c,0x06,0x28,0x06,0x36,0x06,0x48,0x06,
        0x4e,0x06,0x60,0x06,0x6e,0x06,0x74,0x06,0x84,0x06,
        0xa6,0x06,0xc8,0x06,0xe6,0x06,0x08,0x07,0x2c,0x07,
        0x3c,0x07,0x68,0x07,0x7c,0x07,0x8c,0x07,0xa2,0x07,
        0xb0,0x07,0xb6,0x07,0xd8,0x07,0xec,0x07,0x10,0x08,
        0x32,0x08,0x54,0x08,0x64,0x08,0x88,0x08,0x98,0x08,
        0xac,0x08,0xb6,0x08,0xc8,0x08,0xd2,0x08,0xe4,0x08,
        0xf2,0x08,0x3e,0x09,0x48,0x09,0x94,0x09,0xc2,0x09,
        0xc4,0x09,0xd0,0x09,0xe2,0x09,0x04,0x0a,0x0e,0x0a,
        0x26,0x0a,0x34,0x0a,0x4a,0x0a,0x66,0x0a,0x70,0x0a,
        0x7e,0x0a,0x8e,0x0a,0x9a,0x0a,0xa6,0x0a,0xb4,0x0a,
        0xd8,0x0a,0xe2,0x0a,0xf6,0x0a,0x18,0x0b,0x22,0x0b,
        0x32,0x0b,0x56,0x0b,0x60,0x0b,0x6e,0x0b,0x7c,0x0b,
        0x8a,0x0b,0x9c,0x0b,0x9e,0x0b,0xb2,0x0b,0xc2,0x0b,
        0xd8,0x0b,0xf4,0x0b,0x08,0x0c,0x30,0x0c,0x56,0x0c,
        0x72,0x0c,0x90,0x0c,0xb2,0x0c,0xce,0x0c,0xe2,0x0c,
        0xfe,0x0c,0x10,0x0d,0x26,0x0d,0x36,0x0d,0x42,0x0d,
        0x4e,0x0d,0x5c,0x0d,0x78,0x0d,0x8c,0x0d,0x8e,0x0d,
        0x90,0x0d,0x92,0x0d,0x94,0x0d,0x96,0x0d,0x98,0x0d,
        0x9a,0x0d,0x9c,0x0d,0x9e,0x0d,0xa0,0x0d,0xa2,0x0d,
        0xa4,0x0d,0xa6,0x0d,0xa8,0x0d,0xaa,0x0d,0xac,0x0d,
        0xae,0x0d,0xb0,0x0d,0xb2,0x0d,0xb4,0x0d,0xb6,0x0d,
        0xb8,0x0d,0xba,0x0d,0xbc,0x0d,0xbe,0x0d,0xc0,0x0d,
        0xc2,0x0d,0xc4,0x0d,0xc6,0x0d,0xc8,0x0d,0xca,0x0d,
        0xcc,0x0d,0xce,0x0d,0xd0,0x0d,0xd2,0x0d,0xd4,0x0d,
        0xd6,0x0d,0xd8,0x0d,0xda,0x0d,0xdc,0x0d,0xde,0x0d,
        0xe0,0x0d,0xe2,0x0d,0xe4,0x0d,0xe6,0x0d,0xe8,0x0d,
        0xea,0x0d,0xec,0x0d,0x0c,0x0e,0x26,0x0e,0x48,0x0e,
        0x64,0x0e,0x88,0x0e,0x92,0x0e,0xa6,0x0e,0xb4,0x0e,
        0xd0,0x0e,0xee,0x0e,0x02,0x0f,0x16,0x0f,0x26,0x0f,
        0x3c,0x0f,0x58,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,
        0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,
        0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,
        0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x6c,0x0f,0x10,0x80,
        0x05,0x95,0x00,0x72,0x00,0xfb,0xff,0x7f,0x01,0x7f,
        0x01,0x01,0xff,0x01,0x05,0xfe,0x05,0x95,0xff,0x7f,
        0x00,0x7a,0x01,0x86,0xff,0x7a,0x01,0x87,0x01,0x7f,
        0xfe,0x7a,0x0a,0x87,0xff,0x7f,0x00,0x7a,0x01,0x86,
        0xff,0x7a,0x01,0x87,0x01,0x7f,0xfe,0x7a,0x05,0xf2,
        0x0b,0x95,0xf9,0x64,0x0d,0x9c,0xf9,0x64,0xfa,0x91,
        0x0e,0x00,0xf1,0xfa,0x0e,0x00,0x04,0xfc,0x08,0x99,
        0x00,0x63,0x04,0x9d,0x00,0x63,0x04,0x96,0xff,0x7f,
        0x01,0x7f,0x01,0x01,0x00,0x01,0xfe,0x02,0xfd,0x01,
        0xfc,0x00,0xfd,0x7f,0xfe,0x7e,0x00,0x7e,0x01,0x7e,
        0x01,0x7f,0x02,0x7f,0x06,0x7e,0x02,0x7f,0x02,0x7e,
        0xf2,0x89,0x02,0x7e,0x02,0x7f,0x06,0x7e,0x02,0x7f,
        0x01,0x7f,0x01,0x7e,0x00,0x7c,0xfe,0x7e,0xfd,0x7f,
        0xfc,0x00,0xfd,0x01,0xfe,0x02,0x00,0x01,0x01,0x01,
        0x01,0x7f,0xff,0x7f,0x10,0xfd,0x15,0x95,0xee,0x6b,
        0x05,0x95,0x02,0x7e,0x00,0x7e,0xff,0x7e,0xfe,0x7f,
        0xfe,0x00,0xfe,0x02,0x00,0x02,0x01,0x02,0x02,0x01,
        0x02,0x00,0x02,0x7f,0x03,0x7f,0x03,0x00,0x03,0x01,
        0x02,0x01,0xfc,0xf2,0xfe,0x7f,0xff,0x7e,0x00,0x7e,
        0x02,0x7e,0x02,0x00,0x02,0x01,0x01,0x02,0x00,0x02,
        0xfe,0x02,0xfe,0x00,0x07,0xf9,0x15,0x8d,0xff,0x7f,
        0x01,0x7f,0x01,0x01,0x00,0x01,0xff,0x01,0xff,0x00,
        0xff,0x7f,0xff,0x7e,0xfe,0x7b,0xfe,0x7d,0xfe,0x7e,
        0xfe,0x7f,0xfd,0x00,0xfd,0x01,0xff,0x02,0x00,0x03,
        0x01,0x02,0x06,0x04,0x02,0x02,0x01,0x02,0x00,0x02,
        0xff,0x02,0xfe,0x01,0xfe,0x7f,0xff,0x7e,0x00,0x7e,
        0x01,0x7d,0x02,0x7d,0x05,0x79,0x02,0x7e,0x03,0x7f,
        0x01,0x00,0x01,0x01,0x00,0x01,0xf1,0xfe,0xfe,0x01,
        0xff,0x02,0x00,0x03,0x01,0x02,0x02,0x02,0x00,0x86,
        0x01,0x7e,0x08,0x75,0x02,0x7e,0x02,0x7f,0x05,0x80,
        0x05,0x93,0xff,0x01,0x01,0x01,0x01,0x7f,0x00,0x7e,
        0xff,0x7e,0xff,0x7f,0x06,0xf1,0x0b,0x99,0xfe,0x7e,
        0xfe,0x7d,0xfe,0x7c,0xff,0x7b,0x00,0x7c,0x01,0x7b,
        0x02,0x7c,0x02,0x7d,0x02,0x7e,0xfe,0x9e,0xfe,0x7c,
        0xff,0x7d,0xff,0x7b,0x00,0x7c,0x01,0x7b,0x01,0x7d,
        0x02,0x7c,0x05,0x85,0x03,0x99,0x02,0x7e,0x02,0x7d,
        0x02,0x7c,0x01,0x7b,0x00,0x7c,0xff,0x7b,0xfe,0x7c,
        0xfe,0x7d,0xfe,0x7e,0x02,0x9e,0x02,0x7c,0x01,0x7d,
        0x01,0x7b,0x00,0x7c,0xff,0x7b,0xff,0x7d,0xfe,0x7c,
        0x09,0x85,0x08,0x95,0x00,0x74,0xfb,0x89,0x0a,0x7a,
        0x00,0x86,0xf6,0x7a,0x0d,0xf4,0x0d,0x92,0x00,0x6e,
        0xf7,0x89,0x12,0x00,0x04,0xf7,0x06,0x81,0xff,0x7f,
        0xff,0x01,0x01,0x01,0x01,0x7f,0x00,0x7e,0xff,0x7e,
        0xff,0x7f,0x06,0x84,0x04,0x89,0x12,0x00,0x04,0xf7,
        0x05,0x82,0xff,0x7f,0x01,0x7f,0x01,0x01,0xff,0x01,
        0x05,0xfe,0x00,0xfd,0x0e,0x18,0x00,0xeb,0x09,0x95,
        0xfd,0x7f,0xfe,0x7d,0xff,0x7b,0x00,0x7d,0x01,0x7b,
        0x02,0x7d,0x03,0x7f,0x02,0x00,0x03,0x01,0x02,0x03,
        0x01,0x05,0x00,0x03,0xff,0x05,0xfe,0x03,0xfd,0x01,
        0xfe,0x00,0x0b,0xeb,0x06,0x91,0x02,0x01,0x03,0x03,
        0x00,0x6b,0x09,0x80,0x04,0x90,0x00,0x01,0x01,0x02,
        0x01,0x01,0x02,0x01,0x04,0x00,0x02,0x7f,0x01,0x7f,
        0x01,0x7e,0x00,0x7e,0xff,0x7e,0xfe,0x7d,0xf6,0x76,
        0x0e,0x00,0x03,0x80,0x05,0x95,0x0b,0x00,0xfa,0x78,
        0x03,0x00,0x02,0x7f,0x01,0x7f,0x01,0x7d,0x00,0x7e,
        0xff,0x7d,0xfe,0x7e,0xfd,0x7f,0xfd,0x00,0xfd,0x01,
        0xff,0x01,0xff,0x02,0x11,0xfc,0x0d,0x95,0xf6,0x72,
        0x0f,0x00,0xfb,0x8e,0x00,0x6b,0x07,0x80,0x0f,0x95,
        0xf6,0x00,0xff,0x77,0x01,0x01,0x03,0x01,0x03,0x00,
        0x03,0x7f,0x02,0x7e,0x01,0x7d,0x00,0x7e,0xff,0x7d,
        0xfe,0x7e,0xfd,0x7f,0xfd,0x00,0xfd,0x01,0xff,0x01,
        0xff,0x02,0x11,0xfc,0x10,0x92,0xff,0x02,0xfd,0x01,
        0xfe,0x00,0xfd,0x7f,0xfe,0x7d,0xff,0x7b,0x00,0x7b,
        0x01,0x7c,0x02,0x7e,0x03,0x7f,0x01,0x00,0x03,0x01,
        0x02,0x02,0x01,0x03,0x00,0x01,0xff,0x03,0xfe,0x02,
        0xfd,0x01,0xff,0x00,0xfd,0x7f,0xfe,0x7e,0xff,0x7d,
        0x10,0xf9,0x11,0x95,0xf6,0x6b,0xfc,0x95,0x0e,0x00,
        0x03,0xeb,0x08,0x95,0xfd,0x7f,0xff,0x7e,0x00,0x7e,
        0x01,0x7e,0x02,0x7f,0x04,0x7f,0x03,0x7f,0x02,0x7e,
        0x01,0x7e,0x00,0x7d,0xff,0x7e,0xff,0x7f,0xfd,0x7f,
        0xfc,0x00,0xfd,0x01,0xff,0x01,0xff,0x02,0x00,0x03,
        0x01,0x02,0x02,0x02,0x03,0x01,0x04,0x01,0x02,0x01,
        0x01,0x02,0x00,0x02,0xff,0x02,0xfd,0x01,0xfc,0x00,
        0x0c,0xeb,0x10,0x8e,0xff,0x7d,0xfe,0x7e,0xfd,0x7f,
        0xff,0x00,0xfd,0x01,0xfe,0x02,0xff,0x03,0x00,0x01,
        0x01,0x03,0x02,0x02,0x03,0x01,0x01,0x00,0x03,0x7f,
        0x02,0x7e,0x01,0x7c,0x00,0x7b,0xff,0x7b,0xfe,0x7d,
        0xfd,0x7f,0xfe,0x00,0xfd,0x01,0xff,0x02,0x10,0xfd,
        0x05,0x8e,0xff,0x7f,0x01,0x7f,0x01,0x01,0xff,0x01,
        0x00,0xf4,0xff,0x7f,0x01,0x7f,0x01,0x01,0xff,0x01,
        0x05,0xfe,0x05,0x8e,0xff,0x7f,0x01,0x7f,0x01,0x01,
        0xff,0x01,0x01,0xf3,0xff,0x7f,0xff,0x01,0x01,0x01,
        0x01,0x7f,0x00,0x7e,0xff,0x7e,0xff,0x7f,0x06,0x84,
        0x14,0x92,0xf0,0x77,0x10,0x77,0x04,0x80,0x04,0x8c,
        0x12,0x00,0xee,0xfa,0x12,0x00,0x04,0xfa,0x04,0x92,
        0x10,0x77,0xf0,0x77,0x14,0x80,0x03,0x90,0x00,0x01,
        0x01,0x02,0x01,0x01,0x02,0x01,0x04,0x00,0x02,0x7f,
        0x01,0x7f,0x01,0x7e,0x00,0x7e,0xff,0x7e,0xff,0x7f,
        0xfc,0x7e,0x00,0x7d,0x00,0xfb,0xff,0x7f,0x01,0x7f,
        0x01,0x01,0xff,0x01,0x09,0xfe,0x12,0x8d,0xff,0x02,
        0xfe,0x01,0xfd,0x00,0xfe,0x7f,0xff,0x7f,0xff,0x7d,
        0x00,0x7d,0x01,0x7e,0x02,0x7f,0x03,0x00,0x02,0x01,
        0x01,0x02,0xfb,0x88,0xfe,0x7e,0xff,0x7d,0x00,0x7d,
        0x01,0x7e,0x01,0x7f,0x07,0x8b,0xff,0x78,0x00,0x7e,
        0x02,0x7f,0x02,0x00,0x02,0x02,0x01,0x03,0x00,0x02,
        0xff,0x03,0xff,0x02,0xfe,0x02,0xfe,0x01,0xfd,0x01,
        0xfd,0x00,0xfd,0x7f,0xfe,0x7f,0xfe,0x7e,0xff,0x7e,
        0xff,0x7d,0x00,0x7d,0x01,0x7d,0x01,0x7e,0x02,0x7e,
        0x02,0x7f,0x03,0x7f,0x03,0x00,0x03,0x01,0x02,0x01,
        0x01,0x01,0xfe,0x8d,0xff,0x78,0x00,0x7e,0x01,0x7f,
        0x08,0xfb,0x09,0x95,0xf8,0x6b,0x08,0x95,0x08,0x6b,
        0xf3,0x87,0x0a,0x00,0x04,0xf9,0x04,0x95,0x00,0x6b,
        0x00,0x95,0x09,0x00,0x03,0x7f,0x01,0x7f,0x01,0x7e,
        0x00,0x7e,0xff,0x7e,0xff,0x7f,0xfd,0x7f,0xf7,0x80,
        0x09,0x00,0x03,0x7f,0x01,0x7f,0x01,0x7e,0x00,0x7d,
        0xff,0x7e,0xff,0x7f,0xfd,0x7f,0xf7,0x00,0x11,0x80,
        0x12,0x90,0xff,0x02,0xfe,0x02,0xfe,0x01,0xfc,0x00,
        0xfe,0x7f,0xfe,0x7e,0xff,0x7e,0xff,0x7d,0x00,0x7b,
        0x01,0x7d,0x01,0x7e,0x02,0x7e,0x02,0x7f,0x04,0x00,
        0x02,0x01,0x02,0x02,0x01,0x02,0x03,0xfb,0x04,0x95,
        0x00,0x6b,0x00,0x95,0x07,0x00,0x03,0x7f,0x02,0x7e,
        0x01,0x7e,0x01,0x7d,0x00,0x7b,0xff,0x7d,0xff,0x7e,
        0xfe,0x7e,0xfd,0x7f,0xf9,0x00,0x11,0x80,0x04,0x95,
        0x00,0x6b,0x00,0x95,0x0d,0x00,0xf3,0xf6,0x08,0x00,
        0xf8,0xf5,0x0d,0x00,0x02,0x80,0x04,0x95,0x00,0x6b,
        0x00,0x95,0x0d,0x00,0xf3,0xf6,0x08,0x00,0x06,0xf5,
        0x12,0x90,0xff,0x02,0xfe,0x02,0xfe,0x01,0xfc,0x00,
        0xfe,0x7f,0xfe,0x7e,0xff,0x7e,0xff,0x7d,0x00,0x7b,
        0x01,0x7d,0x01,0x7e,0x02,0x7e,0x02,0x7f,0x04,0x00,
        0x02,0x01,0x02,0x02,0x01,0x02,0x00,0x03,0xfb,0x80,
        0x05,0x00,0x03,0xf8,0x04,0x95,0x00,0x6b,0x0e,0x95,
        0x00,0x6b,0xf2,0x8b,0x0e,0x00,0x04,0xf5,0x04,0x95,
        0x00,0x6b,0x04,0x80,0x0c,0x95,0x00,0x70,0xff,0x7d,
        0xff,0x7f,0xfe,0x7f,0xfe,0x00,0xfe,0x01,0xff,0x01,
        0xff,0x03,0x00,0x02,0x0e,0xf9,0x04,0x95,0x00,0x6b,
        0x0e,0x95,0xf2,0x72,0x05,0x85,0x09,0x74,0x03,0x80,
        0x04,0x95,0x00,0x6b,0x00,0x80,0x0c,0x00,0x01,0x80,
        0x04,0x95,0x00,0x6b,0x00,0x95,0x08,0x6b,0x08,0x95,
        0xf8,0x6b,0x08,0x95,0x00,0x6b,0x04,0x80,0x04,0x95,
        0x00,0x6b,0x00,0x95,0x0e,0x6b,0x00,0x95,0x00,0x6b,
        0x04,0x80,0x09,0x95,0xfe,0x7f,0xfe,0x7e,0xff,0x7e,
        0xff,0x7d,0x00,0x7b,0x01,0x7d,0x01,0x7e,0x02,0x7e,
        0x02,0x7f,0x04,0x00,0x02,0x01,0x02,0x02,0x01,0x02,
        0x01,0x03,0x00,0x05,0xff,0x03,0xff,0x02,0xfe,0x02,
        0xfe,0x01,0xfc,0x00,0x0d,0xeb,0x04,0x95,0x00,0x6b,
        0x00,0x95,0x09,0x00,0x03,0x7f,0x01,0x7f,0x01,0x7e,
        0x00,0x7d,0xff,0x7e,0xff,0x7f,0xfd,0x7f,0xf7,0x00,
        0x11,0xf6,0x09,0x95,0xfe,0x7f,0xfe,0x7e,0xff,0x7e,
        0xff,0x7d,0x00,0x7b,0x01,0x7d,0x01,0x7e,0x02,0x7e,
        0x02,0x7f,0x04,0x00,0x02,0x01,0x02,0x02,0x01,0x02,
        0x01,0x03,0x00,0x05,0xff,0x03,0xff,0x02,0xfe,0x02,
        0xfe,0x01,0xfc,0x00,0x03,0xef,0x06,0x7a,0x04,0x82,
        0x04,0x95,0x00,0x6b,0x00,0x95,0x09,0x00,0x03,0x7f,
        0x01,0x7f,0x01,0x7e,0x00,0x7e,0xff,0x7e,0xff,0x7f,
        0xfd,0x7f,0xf7,0x00,0x07,0x80,0x07,0x75,0x03,0x80,
        0x11,0x92,0xfe,0x02,0xfd,0x01,0xfc,0x00,0xfd,0x7f,
        0xfe,0x7e,0x00,0x7e,0x01,0x7e,0x01,0x7f,0x02,0x7f,
        0x06,0x7e,0x02,0x7f,0x01,0x7f,0x01,0x7e,0x00,0x7d,
        0xfe,0x7e,0xfd,0x7f,0xfc,0x00,0xfd,0x01,0xfe,0x02,
        0x11,0xfd,0x08,0x95,0x00,0x6b,0xf9,0x95,0x0e,0x00,
        0x01,0xeb,0x04,0x95,0x00,0x71,0x01,0x7d,0x02,0x7e,
        0x03,0x7f,0x02,0x00,0x03,0x01,0x02,0x02,0x01,0x03,
        0x00,0x0f,0x04,0xeb,0x01,0x95,0x08,0x6b,0x08,0x95,
        0xf8,0x6b,0x09,0x80,0x02,0x95,0x05,0x6b,0x05,0x95,
        0xfb,0x6b,0x05,0x95,0x05,0x6b,0x05,0x95,0xfb,0x6b,
        0x07,0x80,0x03,0x95,0x0e,0x6b,0x00,0x95,0xf2,0x6b,
        0x11,0x80,0x01,0x95,0x08,0x76,0x00,0x75,0x08,0x95,
        0xf8,0x76,0x09,0xf5,0x11,0x95,0xf2,0x6b,0x00,0x95,
        0x0e,0x00,0xf2,0xeb,0x0e,0x00,0x03,0x80,0x03,0x93,
        0x00,0x6c,0x01,0x94,0x00,0x6c,0xff,0x94,0x05,0x00,
        0xfb,0xec,0x05,0x00,0x02,0x81,0x00,0x95,0x0e,0x68,
        0x00,0x83,0x06,0x93,0x00,0x6c,0x01,0x94,0x00,0x6c,
        0xfb,0x94,0x05,0x00,0xfb,0xec,0x05,0x00,0x03,0x81,
        0x03,0x87,0x08,0x05,0x08,0x7b,0xf0,0x80,0x08,0x04,
        0x08,0x7c,0x03,0xf9,0x01,0x80,0x10,0x00,0x01,0x80,
        0x06,0x95,0xff,0x7f,0xff,0x7e,0x00,0x7e,0x01,0x7f,
        0x01,0x01,0xff,0x01,0x05,0xef,0x0f,0x8e,0x00,0x72,
        0x00,0x8b,0xfe,0x02,0xfe,0x01,0xfd,0x00,0xfe,0x7f,
        0xfe,0x7e,0xff,0x7d,0x00,0x7e,0x01,0x7d,0x02,0x7e,
        0x02,0x7f,0x03,0x00,0x02,0x01,0x02,0x02,0x04,0xfd,
        0x04,0x95,0x00,0x6b,0x00,0x8b,0x02,0x02,0x02,0x01,
        0x03,0x00,0x02,0x7f,0x02,0x7e,0x01,0x7d,0x00,0x7e,
        0xff,0x7d,0xfe,0x7e,0xfe,0x7f,0xfd,0x00,0xfe,0x01,
        0xfe,0x02,0x0f,0xfd,0x0f,0x8b,0xfe,0x02,0xfe,0x01,
        0xfd,0x00,0xfe,0x7f,0xfe,0x7e,0xff,0x7d,0x00,0x7e,
        0x01,0x7d,0x02,0x7e,0x02,0x7f,0x03,0x00,0x02,0x01,
        0x02,0x02,0x03,0xfd,0x0f,0x95,0x00,0x6b,0x00,0x8b,
        0xfe,0x02,0xfe,0x01,0xfd,0x00,0xfe,0x7f,0xfe,0x7e,
        0xff,0x7d,0x00,0x7e,0x01,0x7d,0x02,0x7e,0x02,0x7f,
        0x03,0x00,0x02,0x01,0x02,0x02,0x04,0xfd,0x03,0x88,
        0x0c,0x00,0x00,0x02,0xff,0x02,0xff,0x01,0xfe,0x01,
        0xfd,0x00,0xfe,0x7f,0xfe,0x7e,0xff,0x7d,0x00,0x7e,
        0x01,0x7d,0x02,0x7e,0x02,0x7f,0x03,0x00,0x02,0x01,
        0x02,0x02,0x03,0xfd,0x0a,0x95,0xfe,0x00,0xfe,0x7f,
        0xff,0x7d,0x00,0x6f,0xfd,0x8e,0x07,0x00,0x03,0xf2,
        0x0f,0x8e,0x00,0x70,0xff,0x7d,0xff,0x7f,0xfe,0x7f,
        0xfd,0x00,0xfe,0x01,0x09,0x91,0xfe,0x02,0xfe,0x01,
        0xfd,0x00,0xfe,0x7f,0xfe,0x7e,0xff,0x7d,0x00,0x7e,
        0x01,0x7d,0x02,0x7e,0x02,0x7f,0x03,0x00,0x02,0x01,
        0x02,0x02,0x04,0xfd,0x04,0x95,0x00,0x6b,0x00,0x8a,
        0x03,0x03,0x02,0x01,0x03,0x00,0x02,0x7f,0x01,0x7d,
        0x00,0x76,0x04,0x80,0x03,0x95,0x01,0x7f,0x01,0x01,
        0xff,0x01,0xff,0x7f,0x01,0xf9,0x00,0x72,0x04,0x80,
        0x05,0x95,0x01,0x7f,0x01,0x01,0xff,0x01,0xff,0x7f,
        0x01,0xf9,0x00,0x6f,0xff,0x7d,0xfe,0x7f,0xfe,0x00,
        0x09,0x87,0x04,0x95,0x00,0x6b,0x0a,0x8e,0xf6,0x76,
        0x04,0x84,0x07,0x78,0x02,0x80,0x04,0x95,0x00,0x6b,
        0x04,0x80,0x04,0x8e,0x00,0x72,0x00,0x8a,0x03,0x03,
        0x02,0x01,0x03,0x00,0x02,0x7f,0x01,0x7d,0x00,0x76,
        0x00,0x8a,0x03,0x03,0x02,0x01,0x03,0x00,0x02,0x7f,
        0x01,0x7d,0x00,0x76,0x04,0x80,0x04,0x8e,0x00,0x72,
        0x00,0x8a,0x03,0x03,0x02,0x01,0x03,0x00,0x02,0x7f,
        0x01,0x7d,0x00,0x76,0x04,0x80,0x08,0x8e,0xfe,0x7f,
        0xfe,0x7e,0xff,0x7d,0x00,0x7e,0x01,0x7d,0x02,0x7e,
        0x02,0x7f,0x03,0x00,0x02,0x01,0x02,0x02,0x01,0x03,
        0x00,0x02,0xff,0x03,0xfe,0x02,0xfe,0x01,0xfd,0x00,
        0x0b,0xf2,0x04,0x8e,0x00,0x6b,0x00,0x92,0x02,0x02,
        0x02,0x01,0x03,0x00,0x02,0x7f,0x02,0x7e,0x01,0x7d,
        0x00,0x7e,0xff,0x7d,0xfe,0x7e,0xfe,0x7f,0xfd,0x00,
        0xfe,0x01,0xfe,0x02,0x0f,0xfd,0x0f,0x8e,0x00,0x6b,
        0x00,0x92,0xfe,0x02,0xfe,0x01,0xfd,0x00,0xfe,0x7f,
        0xfe,0x7e,0xff,0x7d,0x00,0x7e,0x01,0x7d,0x02,0x7e,
        0x02,0x7f,0x03,0x00,0x02,0x01,0x02,0x02,0x04,0xfd,
        0x04,0x8e,0x00,0x72,0x00,0x88,0x01,0x03,0x02,0x02,
        0x02,0x01,0x03,0x00,0x01,0xf2,0x0e,0x8b,0xff,0x02,
        0xfd,0x01,0xfd,0x00,0xfd,0x7f,0xff,0x7e,0x01,0x7e,
        0x02,0x7f,0x05,0x7f,0x02,0x7f,0x01,0x7e,0x00,0x7f,
        0xff,0x7e,0xfd,0x7f,0xfd,0x00,0xfd,0x01,0xff,0x02,
        0x0e,0xfd,0x05,0x95,0x00,0x6f,0x01,0x7d,0x02,0x7f,
        0x02,0x00,0xf8,0x8e,0x07,0x00,0x03,0xf2,0x04,0x8e,
        0x00,0x76,0x01,0x7d,0x02,0x7f,0x03,0x00,0x02,0x01,
        0x03,0x03,0x00,0x8a,0x00,0x72,0x04,0x80,0x02,0x8e,
        0x06,0x72,0x06,0x8e,0xfa,0x72,0x08,0x80,0x03,0x8e,
        0x04,0x72,0x04,0x8e,0xfc,0x72,0x04,0x8e,0x04,0x72,
        0x04,0x8e,0xfc,0x72,0x07,0x80,0x03,0x8e,0x0b,0x72,
        0x00,0x8e,0xf5,0x72,0x0e,0x80,0x02,0x8e,0x06,0x72,
        0x06,0x8e,0xfa,0x72,0xfe,0x7c,0xfe,0x7e,0xfe,0x7f,
        0xff,0x00,0x0f,0x87,0x0e,0x8e,0xf5,0x72,0x00,0x8e,
        0x0b,0x00,0xf5,0xf2,0x0b,0x00,0x03,0x80,0x09,0x99,
        0xfe,0x7f,0xff,0x7f,0xff,0x7e,0x00,0x7e,0x01,0x7e,
        0x01,0x7f,0x01,0x7e,0x00,0x7e,0xfe,0x7e,0x01,0x8e,
        0xff,0x7e,0x00,0x7e,0x01,0x7e,0x01,0x7f,0x01,0x7e,
        0x00,0x7e,0xff,0x7e,0xfc,0x7e,0x04,0x7e,0x01,0x7e,
        0x00,0x7e,0xff,0x7e,0xff,0x7f,0xff,0x7e,0x00,0x7e,
        0x01,0x7e,0xff,0x8e,0x02,0x7e,0x00,0x7e,0xff,0x7e,
        0xff,0x7f,0xff,0x7e,0x00,0x7e,0x01,0x7e,0x01,0x7f,
        0x02,0x7f,0x05,0x87,0x04,0x95,0x00,0x77,0x00,0xfd,
        0x00,0x77,0x04,0x80,0x05,0x99,0x02,0x7f,0x01,0x7f,
        0x01,0x7e,0x00,0x7e,0xff,0x7e,0xff,0x7f,0xff,0x7e,
        0x00,0x7e,0x02,0x7e,0xff,0x8e,0x01,0x7e,0x00,0x7e,
        0xff,0x7e,0xff,0x7f,0xff,0x7e,0x00,0x7e,0x01,0x7e,
        0x04,0x7e,0xfc,0x7e,0xff,0x7e,0x00,0x7e,0x01,0x7e,
        0x01,0x7f,0x01,0x7e,0x00,0x7e,0xff,0x7e,0x01,0x8e,
        0xfe,0x7e,0x00,0x7e,0x01,0x7e,0x01,0x7f,0x01,0x7e,
        0x00,0x7e,0xff,0x7e,0xff,0x7f,0xfe,0x7f,0x09,0x87,
        0x03,0x86,0x00,0x02,0x01,0x03,0x02,0x01,0x02,0x00,
        0x02,0x7f,0x04,0x7d,0x02,0x7f,0x02,0x00,0x02,0x01,
        0x01,0x02,0xee,0xfe,0x01,0x02,0x02,0x01,0x02,0x00,
        0x02,0x7f,0x04,0x7d,0x02,0x7f,0x02,0x00,0x02,0x01,
        0x01,0x03,0x00,0x02,0x03,0xf4,0x10,0x80,0x03,0x80,
        0x07,0x15,0x08,0x6b,0xfe,0x85,0xf5,0x00,0x10,0xfb,
        0x0d,0x95,0xf6,0x00,0x00,0x6b,0x0a,0x00,0x02,0x02,
        0x00,0x08,0xfe,0x02,0xf6,0x00,0x0e,0xf4,0x03,0x80,
        0x00,0x15,0x0a,0x00,0x02,0x7e,0x00,0x7e,0x00,0x7d,
        0x00,0x7e,0xfe,0x7f,0xf6,0x00,0x0a,0x80,0x02,0x7e,
        0x01,0x7e,0x00,0x7d,0xff,0x7d,0xfe,0x7f,0xf6,0x00,
        0x10,0x80,0x03,0x80,0x00,0x15,0x0c,0x00,0xff,0x7e,
        0x03,0xed,0x03,0xfd,0x00,0x03,0x02,0x00,0x00,0x12,
        0x02,0x03,0x0a,0x00,0x00,0x6b,0x02,0x00,0x00,0x7d,
        0xfe,0x83,0xf4,0x00,0x11,0x80,0x0f,0x80,0xf4,0x00,
        0x00,0x15,0x0c,0x00,0xff,0xf6,0xf5,0x00,0x0f,0xf5,
        0x04,0x95,0x07,0x76,0x00,0x0a,0x07,0x80,0xf9,0x76,
        0x00,0x75,0xf8,0x80,0x07,0x0c,0x09,0xf4,0xf9,0x0c,
        0x09,0xf4,0x03,0x92,0x02,0x03,0x07,0x00,0x03,0x7d,
        0x00,0x7b,0xfc,0x7e,0x04,0x7d,0x00,0x7a,0xfd,0x7e,
        0xf9,0x00,0xfe,0x02,0x06,0x89,0x02,0x00,0x06,0xf5,
        0x03,0x95,0x00,0x6b,0x0c,0x15,0x00,0x6b,0x02,0x80,
        0x03,0x95,0x00,0x6b,0x0c,0x15,0x00,0x6b,0xf8,0x96,
        0x03,0x00,0x07,0xea,0x03,0x80,0x00,0x15,0x0c,0x80,
        0xf7,0x76,0xfd,0x00,0x03,0x80,0x0a,0x75,0x03,0x80,
        0x03,0x80,0x07,0x13,0x02,0x02,0x03,0x00,0x00,0x6b,
        0x02,0x80,0x03,0x80,0x00,0x15,0x09,0x6b,0x09,0x15,
        0x00,0x6b,0x03,0x80,0x03,0x80,0x00,0x15,0x00,0xf6,
        0x0d,0x00,0x00,0x8a,0x00,0x6b,0x03,0x80,0x07,0x80,
        0xfd,0x00,0xff,0x03,0x00,0x04,0x00,0x07,0x00,0x04,
        0x01,0x02,0x03,0x01,0x06,0x00,0x03,0x7f,0x01,0x7e,
        0x01,0x7c,0x00,0x79,0xff,0x7c,0xff,0x7d,0xfd,0x00,
        0xfa,0x00,0x0e,0x80,0x03,0x80,0x00,0x15,0x0c,0x00,
        0x00,0x6b,0x02,0x80,0x03,0x80,0x00,0x15,0x0a,0x00,
        0x02,0x7f,0x01,0x7d,0x00,0x7b,0xff,0x7e,0xfe,0x7f,
        0xf6,0x00,0x10,0xf7,0x11,0x8f,0xff,0x03,0xff,0x02,
        0xfe,0x01,0xfa,0x00,0xfd,0x7f,0xff,0x7e,0x00,0x7c,
        0x00,0x79,0x00,0x7b,0x01,0x7e,0x03,0x00,0x06,0x00,
        0x02,0x00,0x01,0x03,0x01,0x02,0x03,0xfb,0x03,0x95,
        0x0c,0x00,0xfa,0x80,0x00,0x6b,0x09,0x80,0x03,0x95,
        0x00,0x77,0x06,0x7a,0x06,0x06,0x00,0x09,0xfa,0xf1,
        0xfa,0x7a,0x0e,0x80,0x03,0x87,0x00,0x0b,0x02,0x02,
        0x03,0x00,0x02,0x7e,0x01,0x02,0x04,0x00,0x02,0x7e,
        0x00,0x75,0xfe,0x7e,0xfc,0x00,0xff,0x01,0xfe,0x7f,
        0xfd,0x00,0xfe,0x02,0x07,0x8e,0x00,0x6b,0x09,0x80,
        0x03,0x80,0x0e,0x15,0xf2,0x80,0x0e,0x6b,0x03,0x80,
        0x03,0x95,0x00,0x6b,0x0e,0x00,0x00,0x7d,0xfe,0x98,
        0x00,0x6b,0x05,0x80,0x03,0x95,0x00,0x75,0x02,0x7d,
        0x0a,0x00,0x00,0x8e,0x00,0x6b,0x02,0x80,0x03,0x95,
        0x00,0x6b,0x10,0x00,0x00,0x15,0xf8,0x80,0x00,0x6b,
        0x0a,0x80,0x03,0x95,0x00,0x6b,0x10,0x00,0x00,0x15,
        0xf8,0x80,0x00,0x6b,0x0a,0x00,0x00,0x7d,0x02,0x83,
        0x10,0x80,0x03,0x95,0x00,0x6b,0x09,0x00,0x03,0x02,
        0x00,0x08,0xfd,0x02,0xf7,0x00,0x0e,0x89,0x00,0x6b,
        0x03,0x80,0x03,0x95,0x00,0x6b,0x09,0x00,0x03,0x02,
        0x00,0x08,0xfd,0x02,0xf7,0x00,0x0e,0xf4,0x03,0x92,
        0x02,0x03,0x07,0x00,0x03,0x7d,0x00,0x70,0xfd,0x7e,
        0xf9,0x00,0xfe,0x02,0x03,0x89,0x09,0x00,0x02,0xf5,
        0x03,0x80,0x00,0x15,0x00,0xf5,0x07,0x00,0x00,0x08,
        0x02,0x03,0x06,0x00,0x02,0x7d,0x00,0x70,0xfe,0x7e,
        0xfa,0x00,0xfe,0x02,0x00,0x08,0x0c,0xf6,0x0f,0x80,
        0x00,0x15,0xf6,0x00,0xfe,0x7d,0x00,0x79,0x02,0x7e,
        0x0a,0x00,0xf4,0xf7,0x07,0x09,0x07,0xf7,0x03,0x8c,
        0x01,0x02,0x01,0x01,0x05,0x00,0x02,0x7f,0x01,0x7e,
        0x00,0x74,0x00,0x86,0xff,0x01,0xfe,0x01,0xfb,0x00,
        0xff,0x7f,0xff,0x7f,0x00,0x7c,0x01,0x7e,0x01,0x00,
        0x05,0x00,0x02,0x00,0x01,0x02,0x03,0xfe,0x04,0x8e,
        0x02,0x01,0x04,0x00,0x02,0x7f,0x01,0x7e,0x00,0x77,
        0xff,0x7e,0xfe,0x7f,0xfc,0x00,0xfe,0x01,0xff,0x02,
        0x00,0x09,0x01,0x02,0x02,0x02,0x03,0x01,0x02,0x01,
        0x01,0x01,0x01,0x02,0x02,0xeb,0x03,0x80,0x00,0x15,
        0x03,0x00,0x02,0x7e,0x00,0x7b,0xfe,0x7e,0xfd,0x00,
        0x03,0x80,0x04,0x00,0x03,0x7e,0x00,0x78,0xfd,0x7e,
        0xf9,0x00,0x0c,0x80,0x03,0x8c,0x02,0x02,0x02,0x01,
        0x03,0x00,0x02,0x7f,0x01,0x7d,0xfe,0x7e,0xf9,0x7d,
        0xff,0x7e,0x00,0x7d,0x03,0x7f,0x02,0x00,0x03,0x01,
        0x02,0x01,0x02,0xfe,0x0d,0x8c,0xff,0x02,0xfe,0x01,
        0xfc,0x00,0xfe,0x7f,0xff,0x7e,0x00,0x77,0x01,0x7e,
        0x02,0x7f,0x04,0x00,0x02,0x01,0x01,0x02,0x00,0x0f,
        0xff,0x02,0xfe,0x01,0xf9,0x00,0x0c,0xeb,0x03,0x88,
        0x0a,0x00,0x00,0x02,0x00,0x03,0xfe,0x02,0xfa,0x00,
        0xff,0x7e,0xff,0x7d,0x00,0x7b,0x01,0x7c,0x01,0x7f,
        0x06,0x00,0x02,0x02,0x03,0xfe,0x03,0x8f,0x06,0x77,
        0x06,0x09,0xfa,0x80,0x00,0x71,0xff,0x87,0xfb,0x79,
        0x07,0x87,0x05,0x79,0x02,0x80,0x03,0x8d,0x02,0x02,
        0x06,0x00,0x02,0x7e,0x00,0x7d,0xfc,0x7d,0x04,0x7e,
        0x00,0x7d,0xfe,0x7e,0xfa,0x00,0xfe,0x02,0x04,0x85,
        0x02,0x00,0x06,0xf9,0x03,0x8f,0x00,0x73,0x01,0x7e,
        0x07,0x00,0x02,0x02,0x00,0x0d,0x00,0xf3,0x01,0x7e,
        0x03,0x80,0x03,0x8f,0x00,0x73,0x01,0x7e,0x07,0x00,
        0x02,0x02,0x00,0x0d,0x00,0xf3,0x01,0x7e,0xf8,0x90,
        0x03,0x00,0x08,0xf0,0x03,0x80,0x00,0x15,0x00,0xf3,
        0x02,0x00,0x06,0x07,0xfa,0xf9,0x07,0x78,0x03,0x80,
        0x03,0x80,0x04,0x0c,0x02,0x03,0x04,0x00,0x00,0x71,
        0x02,0x80,0x03,0x80,0x00,0x0f,0x06,0x77,0x06,0x09,
        0x00,0x71,0x02,0x80,0x03,0x80,0x00,0x0f,0x0a,0xf1,
        0x00,0x0f,0xf6,0xf8,0x0a,0x00,0x02,0xf9,0x05,0x80,
        0xff,0x01,0xff,0x04,0x00,0x05,0x01,0x03,0x01,0x02,
        0x06,0x00,0x02,0x7e,0x00,0x7d,0x00,0x7b,0x00,0x7c,
        0xfe,0x7f,0xfa,0x00,0x0b,0x80,0x03,0x80,0x00,0x0f,
        0x00,0xfb,0x01,0x03,0x01,0x02,0x05,0x00,0x02,0x7e,
        0x01,0x7d,0x00,0x76,0x03,0x80,0x10,0x80,0x10,0x80,
        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
        0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,0x10,0x80,
        0x10,0x80,0x0a,0x8f,0x02,0x7f,0x01,0x7e,0x00,0x76,
        0xff,0x7f,0xfe,0x7f,0xfb,0x00,0xff,0x01,0xff,0x01,
        0x00,0x0a,0x01,0x02,0x01,0x01,0x05,0x00,0xf9,0x80,
        0x00,0x6b,0x0c,0x86,0x0d,0x8a,0xff,0x03,0xfe,0x02,
        0xfb,0x00,0xff,0x7e,0xff,0x7d,0x00,0x7b,0x01,0x7c,
        0x01,0x7f,0x05,0x00,0x02,0x01,0x01,0x03,0x03,0xfc,
        0x03,0x80,0x00,0x0f,0x00,0xfb,0x01,0x03,0x01,0x02,
        0x04,0x00,0x01,0x7e,0x01,0x7d,0x00,0x76,0x00,0x8a,
        0x01,0x03,0x02,0x02,0x03,0x00,0x02,0x7e,0x01,0x7d,
        0x00,0x76,0x03,0x80,0x03,0x8f,0x00,0x74,0x01,0x7e,
        0x02,0x7f,0x04,0x00,0x02,0x01,0x01,0x01,0x00,0x8d,
        0x00,0x6e,0xff,0x7e,0xfe,0x7f,0xfb,0x00,0xfe,0x01,
        0x0c,0x85,0x03,0x8d,0x01,0x02,0x03,0x00,0x02,0x7e,
        0x01,0x02,0x03,0x00,0x02,0x7e,0x00,0x74,0xfe,0x7f,
        0xfd,0x00,0xff,0x01,0xfe,0x7f,0xfd,0x00,0xff,0x01,
        0x00,0x0c,0x06,0x82,0x00,0x6b,0x08,0x86,0x03,0x80,
        0x0a,0x0f,0xf6,0x80,0x0a,0x71,0x03,0x80,0x03,0x8f,
        0x00,0x73,0x01,0x7e,0x07,0x00,0x02,0x02,0x00,0x0d,
        0x00,0xf3,0x01,0x7e,0x00,0x7e,0x03,0x82,0x03,0x8f,
        0x00,0x79,0x02,0x7e,0x08,0x00,0x00,0x89,0x00,0x71,
        0x02,0x80,0x03,0x8f,0x00,0x73,0x01,0x7e,0x03,0x00,
        0x02,0x02,0x00,0x0d,0x00,0xf3,0x01,0x7e,0x03,0x00,
        0x02,0x02,0x00,0x0d,0x00,0xf3,0x01,0x7e,0x03,0x80,
        0x03,0x8f,0x00,0x73,0x01,0x7e,0x03,0x00,0x02,0x02,
        0x00,0x0d,0x00,0xf3,0x01,0x7e,0x03,0x00,0x02,0x02,
        0x00,0x0d,0x00,0xf3,0x01,0x7e,0x00,0x7e,0x03,0x82,
        0x03,0x8d,0x00,0x02,0x02,0x00,0x00,0x71,0x08,0x00,
        0x02,0x02,0x00,0x06,0xfe,0x02,0xf8,0x00,0x0c,0xf6,
        0x03,0x8f,0x00,0x71,0x07,0x00,0x02,0x02,0x00,0x06,
        0xfe,0x02,0xf9,0x00,0x0c,0x85,0x00,0x71,0x02,0x80,
        0x03,0x8f,0x00,0x71,0x07,0x00,0x03,0x02,0x00,0x06,
        0xfd,0x02,0xf9,0x00,0x0c,0xf6,0x03,0x8d,0x02,0x02,
        0x06,0x00,0x02,0x7e,0x00,0x75,0xfe,0x7e,0xfa,0x00,
        0xfe,0x02,0x04,0x85,0x06,0x00,0x02,0xf9,0x03,0x80,
        0x00,0x0f,0x00,0xf8,0x04,0x00,0x00,0x06,0x02,0x02,
        0x04,0x00,0x02,0x7e,0x00,0x75,0xfe,0x7e,0xfc,0x00,
        0xfe,0x02,0x00,0x05,0x0a,0xf9,0x0d,0x80,0x00,0x0f,
        0xf7,0x00,0xff,0x7e,0x00,0x7b,0x01,0x7e,0x09,0x00,
        0xf6,0xfa,0x04,0x06,0x08,0xfa
    };



    //-------------------------------------------------------------------------
    gsv_text::~gsv_text()
    {
        if(m_loaded_font) delete [] m_loaded_font;
        if(m_text_buf)    delete [] m_text_buf;
    }


    //-------------------------------------------------------------------------
    gsv_text::gsv_text() :
      m_x(0.0),
      m_y(0.0),
      m_start_x(0.0),
      m_width(10.0),
      m_height(0.0),
      m_space(0.0),
      m_line_space(0.0),
      m_text(m_chr),
      m_text_buf(0),
      m_buf_size(0), 
      m_cur_chr(m_chr),
      m_font(gsv_default_font),
      m_loaded_font(0),
      m_status(initial),
      m_big_endian(false),
      m_flip(false)
    {
        m_chr[0] = m_chr[1] = 0;

        int t = 1;
        if(*(char*)&t == 0) m_big_endian = true;
    }



    //-------------------------------------------------------------------------
    void gsv_text::font(const void* font)
    {
        m_font = font;
        if(m_font == 0) m_font = m_loaded_font;
    }

    //-------------------------------------------------------------------------
    void gsv_text::size(double height, double width)
    {
        m_height = height;
        m_width  = width;
    }

    //-------------------------------------------------------------------------
    void gsv_text::space(double space)
    {
        m_space = space;
    }

    //-------------------------------------------------------------------------
    void gsv_text::line_space(double line_space)
    {
        m_line_space = line_space;
    }

    //-------------------------------------------------------------------------
    void gsv_text::start_point(double x, double y)
    {
        m_x = m_start_x = x;
        m_y = y;
        //if(m_flip) m_y += m_height;
    }


    //-------------------------------------------------------------------------
    void gsv_text::load_font(const char* file)
    {
        if(m_loaded_font) delete [] m_loaded_font;
        m_loaded_font = 0;

        FILE* fd = fopen(file, "rb");
        if(fd)
        {
            unsigned len;

            fseek(fd, 0l, SEEK_END);
            len = ftell(fd);
            fseek(fd, 0l, SEEK_SET);
            if(len > 0)
            {
                m_loaded_font = new char [len];
                fread(m_loaded_font, 1, len, fd);
                m_font = m_loaded_font;
            }
            fclose(fd);
        }
    }


    //-------------------------------------------------------------------------
    void gsv_text::text(const char* text)
    {
        if(text == 0)
        {
            m_chr[0] = 0;
            m_text = m_chr;
            return;
        }
        unsigned new_size = strlen(text) + 1;
        if(new_size > m_buf_size)
        {
            if(m_text_buf) delete [] m_text_buf;
            m_text_buf = new char [m_buf_size = new_size];
        }
        memcpy(m_text_buf, text, new_size);
        m_text = m_text_buf;
    }



    //----------------------------------------------...
 
[truncated message content]

[Roadmap-commit] roadmap_editor/src/agg23/include/platform/mac agg_mac_pmap.h,NONE,1.1

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/include/platform/mac
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv6842/include/platform/mac

Added Files:
	agg_mac_pmap.h 
Log Message:
Import agg sources.

--- NEW FILE: agg_mac_pmap.h ---
//----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3 
// Copyright (C) 2002-2005 Maxim Shemanarev (McSeem)
// Copyright (C) 2002 Hansruedi Baer (MacOS support)
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: mc...@an...
//          mcs...@ya...
//          http://www.antigrain.com
//			ba...@ka...
//----------------------------------------------------------------------------
//
// class pixel_map
//
//----------------------------------------------------------------------------
#ifndef AGG_MAC_PMAP_INCLUDED
#define AGG_MAC_PMAP_INCLUDED


#include <stdio.h>
#include <Carbon.h>


namespace agg
{
    enum org_e
    {
        org_mono8   = 8,
        org_color16 = 16,
        org_color24 = 24,
        org_color32 = 32
    };

    class pixel_map
    {
    public:
        ~pixel_map();
        pixel_map();

    public:
        void        destroy();
        void        create(unsigned width, 
                           unsigned height, 
                           org_e    org,
                           unsigned clear_val=255);

        void        clear(unsigned clear_val=255);
        bool        load_from_qt(const char* filename);
        bool        save_as_qt(const char* filename) const;

        void        draw(WindowRef window, 
                         const Rect* device_rect=0, 
                         const Rect* bmp_rect=0) const;
        void        draw(WindowRef window, int x, int y, double scale=1.0) const;
        void        blend(WindowRef window, 
                          const Rect* device_rect=0, 
                          const Rect* bmp_rect=0) const;
        void        blend(WindowRef window, int x, int y, double scale=1.0) const;

        unsigned char* buf();
        unsigned       width() const;
        unsigned       height() const;
        int            row_bytes() const;
        unsigned       bpp() const { return m_bpp; }

        //Auxiliary static functions
        static unsigned calc_row_len(unsigned width, unsigned bits_per_pixel);
    private:
        pixel_map(const pixel_map&);
        const pixel_map& operator = (const pixel_map&);

    private:
        GWorldPtr      m_pmap;
        unsigned char* m_buf;
        unsigned       m_bpp;
        unsigned       m_img_size;
    };

}


#endif

[Roadmap-commit] roadmap_editor/src/agg23/src/platform/win32 - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform/win32
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv4688/win32

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform/win32 added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/src/platform/X11 - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform/X11
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv4688/X11

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform/X11 added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/src/platform/sdl - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform/sdl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv4688/sdl

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform/sdl added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/src/platform - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv4177/platform

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/src/platform added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/src/ctrl - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src/ctrl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv4177/ctrl

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/src/ctrl added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/include/platform/mac - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/include/platform/mac
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2974/mac

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/include/platform/mac added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/include/platform/win32 - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/include/platform/win32
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2974/win32

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/include/platform/win32 added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/include/util - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/include/util
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2475/util

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/include/util added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/include/platform - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/include/platform
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2475/platform

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/include/platform added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/include/ctrl - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/include/ctrl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2475/ctrl

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/include/ctrl added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/src - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1797/src

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/src added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/font_win32_tt - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/font_win32_tt
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1797/font_win32_tt

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/font_win32_tt added to the repository

[Roadmap-commit] roadmap_editor/src/agg23/include - New directory

[Ehud S. <esh...@us...>]

Update of /cvsroot/roadmap/roadmap_editor/src/agg23/include
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1797/include

Log Message:
Directory /cvsroot/roadmap/roadmap_editor/src/agg23/include added to the repository