wxcurve.h

/*************************************************************************************
 * MechSys - A C++ library to simulate (Continuum) Mechanical Systems                *
 * Copyright (C) 2005 Dorival de Moraes Pedroso <dorival.pedroso at gmail.com>       *
 * Copyright (C) 2005 Raul Dario Durand Farfan  <raul.durand at gmail.com>           *
 *                                                                                   *
 * This file is part of MechSys.                                                     *
 *                                                                                   *
 * MechSys is free software; you can redistribute it and/or modify it under the      *
 * terms of the GNU General Public License as published by the Free Software         *
 * Foundation; either version 2 of the License, or (at your option) any later        *
 * version.                                                                          *
 *                                                                                   *
 * MechSys is distributed in the hope that it will be useful, but WITHOUT ANY        *
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A   *
 * PARTICULAR PURPOSE. See the GNU General Public License for more details.          *
 *                                                                                   *
 * You should have received a copy of the GNU General Public License along with      *
 * MechSys; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, *
 * Fifth Floor, Boston, MA 02110-1301, USA                                           *
 *************************************************************************************/

#ifndef MECHSYS_WXCURVE_H
#define MECHSYS_WXCURVE_H

#include <sstream>
#include <iomanip>
#include <wx/dcbuffer.h>
#include <wx/icon.h>

#ifdef HAVE_CONFIG_H
  #include "config.h"
#else
  #ifndef REAL
    #define REAL double
  #endif
#endif

#include "util/array.h"
#include "gui/wxtransform.h"
#include "gui/conrec.h"

class WxCurve
{
public:
    // Point styles
    enum PointShape
    { // {{{
        WxCurve_PS_NONE           , 
        WxCurve_PS_DOT            , 
        WxCurve_PS_CIRC           , 
        WxCurve_PS_CIRC_MED       , 
        WxCurve_PS_CIRC_BIG       , 
        WxCurve_PS_CROSS_BIG      , 
        WxCurve_PS_SQUARE_MED     , 
        WxCurve_PS_SQUARE_BIG     , 
        WxCurve_PS_CIRC_CROSS_BIG , 
        WxCurve_PS_TARGET_BIG     , 
        WxCurve_PS_DONUT
    }; // enum PointShape // }}}

    // Constructor & Destructor
     WxCurve (Array<REAL> const & X, Array<REAL> const & Y);
     WxCurve (REAL const * X, REAL const * Y, int Size);
     WxCurve (REAL x_min, REAL x_max, REAL y_min, REAL y_max, int nDiv, REAL DelPctX=0.1, REAL DelPctY=0.1);
    ~WxCurve ();

    // Config Methods
    WxCurve & Enable        (bool             Val=true ) { _enabled=Val; return (*this); }
    WxCurve & LineColour    (wxString const & Clr      );
    WxCurve & LineStyle     (int              LineStyle);
    WxCurve & PointFGColour (wxString const & Clr      );
    WxCurve & PointBGColour (wxString const & Clr      );
    WxCurve & PointType     (PointShape       PS       );

    // Methods
    void   UpdateSize (WxTransformData const & TD);
    void   GetRange   (REAL & MinX, REAL & MaxX,  REAL & MinY, REAL & MaxY) const;
    void   DrawLine   (wxDC & DC);
    void   DrawPoints (wxDC & DC);
    void   ResetData  (REAL const * X, REAL const * Y, int Size);
    void   ResetData  (Array<REAL> const & X, Array<REAL> const & Y);
    void   ResetData  (REAL x_min, REAL x_max, REAL y_min, REAL y_max, int nDiv, REAL DelPctX=0.1, REAL DelPctY=0.1);
    int    GridSize   ()      const  { return _grid_size;    }
    REAL   GridX      (int i) const  { return _grid_x[i];    }
    REAL   GridY      (int i) const  { return _grid_y[i];    }
    REAL & GridFunc   (int i, int j) { return _grid_f[i][j]; }
    void   SetContour (int nLevels, REAL const * Levels);

private:
    // Data - general
    REAL       * _x;
    REAL       * _y;
    int          _size;
    bool         _enabled;
    REAL         _min_x;
    REAL         _max_x;
    REAL         _min_y;
    REAL         _max_y;
    REAL         _x_range;
    REAL         _y_range;
    REAL         _sf_x;       // scale factor - x direction
    REAL         _sf_y;       // scale factor - y direction
    PointShape   _point_type;
    char      ** _point_xpm;
    bool         _is_contour;
    int          _grid_size;
    REAL       * _grid_x;
    REAL       * _grid_y;
    REAL      ** _grid_f;

    // Data - wxWidgets
    wxPoint    * _points;  // device coordinates
    wxPen        _line_pen;
    wxPen        _point_pen;
    wxBrush      _point_brush;

    // Private Methods
    void _init_pen_brush();
    void _bounding_box  ();
    void _allocate_xpm  ();
    void _colour_to_hex (wxColour const & Col, char * HexBufferSizeEq8);
}; // class WxCurve




inline WxCurve::WxCurve(Array<REAL> const & X, Array<REAL> const & Y) // {{{
    : _size         (X.size()),
      _enabled      (true),
      _point_xpm    (NULL),
      _is_contour   (false),
      _grid_size    (0)
{
    // Init pens and brushes
    _init_pen_brush();
    
    // Allocate arrays of data
         _x = new REAL    [_size];
         _y = new REAL    [_size];
    _points = new wxPoint [_size];
    for (int i=0; i<_size; ++i)
    {
             _x[i]   = X[i];
             _y[i]   = Y[i];
        _points[i].x = 0;
        _points[i].y = 0;
    }

    // Get bounding box
    _bounding_box();

    // Allocate XPM
    _allocate_xpm();
} // }}}

inline WxCurve::WxCurve(REAL const * X, REAL const * Y, int Size) // {{{
    : _size         (Size),
      _enabled      (true),
      _point_xpm    (NULL),
      _is_contour   (false),
      _grid_size    (0)
{
    // Init pens and brushes
    _init_pen_brush();
    
    // Allocate arrays of data
         _x = new REAL    [_size];
         _y = new REAL    [_size];
    _points = new wxPoint [_size];
    for (int i=0; i<_size; ++i)
    {
             _x[i]   = X[i];
             _y[i]   = Y[i];
        _points[i].x = 0;
        _points[i].y = 0;
    }

    // Get bounding box
    _bounding_box();

    // Allocate XPM
    _allocate_xpm();
} // }}}

inline WxCurve::WxCurve(REAL x_min, REAL x_max, REAL y_min, REAL y_max, int nDiv, REAL DelPctX, REAL DelPctY) // {{{
    : _size         (0),
      _enabled      (false),
      _point_xpm    (NULL),
      _is_contour   (true),
      _grid_size    (nDiv)
{
    // Init pens and brushes
    _init_pen_brush();
    
    // Set limits
    _min_x=x_min; _max_x=x_max;
    _min_y=y_min; _max_y=y_max;
    _x_range = _max_x - _min_x;
    _y_range = _max_y - _min_y;

    // Allocate and generate grid
    REAL         dx = DelPctX*_x_range;
    REAL         dy = DelPctY*_y_range;
    REAL    start_x = _min_x-dx;
    REAL      end_x = _max_x+dx;
    REAL    start_y = _min_y-dy;
    REAL      end_y = _max_y+dy;
            _grid_x = new REAL [_grid_size];
            _grid_y = new REAL [_grid_size];
    REAL     step_x = (end_x-start_x)/(_grid_size-1.0);
    REAL     step_y = (end_y-start_y)/(_grid_size-1.0);
         _grid_x[0] = start_x;
         _grid_y[0] = start_y;
    for (int i=1; i<_grid_size; ++i)  _grid_x[i]=_grid_x[i-1]+step_x;
    for (int i=1; i<_grid_size; ++i)  _grid_y[i]=_grid_y[i-1]+step_y;

    // Allocate (void) function values
     _grid_f    = new REAL * [_grid_size];  for (int i=0; i<_grid_size; ++i)
     _grid_f[i] = new REAL   [_grid_size];

    // Allocate XPM
    _allocate_xpm();
} // }}}

inline WxCurve::~WxCurve() // {{{
{
    // Delete arrays of data
    if (_size>0)
    {
        delete [] _x;
        delete [] _y;
        delete [] _points;
    }
    if (_grid_size>0)
    {
        delete [] _grid_x;
        delete [] _grid_y;  for (int i=0; i<_grid_size; ++i)
        delete [] _grid_f[i];
        delete [] _grid_f;
    }

    // Delete XPM
    delete [] _point_xpm[0]; // width height num_colors chars_per_pixel
    delete [] _point_xpm[1]; // colors - none
    delete [] _point_xpm[2]; // colors - pen
    delete [] _point_xpm[3]; // colors - brush
    for (int i=0; i<20; ++i)
        delete [] _point_xpm[4+i]; // pixels
} // }}}

inline WxCurve & WxCurve::LineColour(wxString const & Clr) // {{{
{
    _line_pen.SetColour(Clr);
    return (*this);
} // }}}

inline WxCurve & WxCurve::LineStyle(int wxLineStyle) // {{{
{
    _line_pen.SetStyle (wxLineStyle);
    return (*this);
} // }}}

inline WxCurve & WxCurve::PointFGColour(wxString const & Clr) // {{{
{
    _point_pen.SetColour(Clr);
    return (*this);
} // }}}

inline WxCurve & WxCurve::PointBGColour(wxString const & Clr) // {{{
{
    _point_brush.SetColour(Clr);
    return (*this);
} // }}}

inline WxCurve & WxCurve::PointType(WxCurve::PointShape PS) // {{{
{
    // No change
    if (PS==_point_type) return (*this);

    // Set colour
    char pen_hex  [8];
    char brush_hex[8];
    _colour_to_hex(_point_pen  .GetColour(), pen_hex  );
    _colour_to_hex(_point_brush.GetColour(), brush_hex);
    std::strncpy(_point_xpm[ 2]+5, pen_hex  , 7);
    std::strncpy(_point_xpm[ 3]+5, brush_hex, 7);
    
    // Set pixels
    switch (PS)
    {
        case WxCurve_PS_NONE:
            break;
        case WxCurve_PS_DOT:
        {
            /*                           0         1         2         3         4
                                         01234567890123456789012345678901234567890             00 */
            std::strncpy(_point_xpm[ 4], "........................................", 20*2); /*  1 */
            std::strncpy(_point_xpm[ 5], "........................................", 20*2); /*  2 */
            std::strncpy(_point_xpm[ 6], "........................................", 20*2); /*  3 */
            std::strncpy(_point_xpm[ 7], "........................................", 20*2); /*  4 */
            std::strncpy(_point_xpm[ 8], "........................................", 20*2); /*  5 */
            std::strncpy(_point_xpm[ 9], "........................................", 20*2); /*  6 */
            std::strncpy(_point_xpm[10], "........................................", 20*2); /*  7 */
            std::strncpy(_point_xpm[11], ".................#.#.#..................", 20*2); /*  8 */
            std::strncpy(_point_xpm[12], "...............#.#.#.#.#................", 20*2); /*  9 */
            std::strncpy(_point_xpm[13], "...............#.#.#.#.#................", 20*2); /* 10 */
            std::strncpy(_point_xpm[14], "...............#.#.#.#.#................", 20*2); /*  1 */
            std::strncpy(_point_xpm[15], ".................#.#.#..................", 20*2); /*  2 */
            std::strncpy(_point_xpm[16], "........................................", 20*2); /*  3 */
            std::strncpy(_point_xpm[17], "........................................", 20*2); /*  4 */
            std::strncpy(_point_xpm[18], "........................................", 20*2); /*  5 */
            std::strncpy(_point_xpm[19], "........................................", 20*2); /*  6 */
            std::strncpy(_point_xpm[20], "........................................", 20*2); /*  7 */
            std::strncpy(_point_xpm[21], "........................................", 20*2); /*  8 */
            std::strncpy(_point_xpm[22], "........................................", 20*2); /*  9 */
            std::strncpy(_point_xpm[23], "........................................", 20*2); /* 20 */
            break;
        }
        case WxCurve_PS_CIRC:
        {
            /*                           0         1         2         3         4
                                         01234567890123456789012345678901234567890             00 */
            std::strncpy(_point_xpm[ 4], "........................................", 20*2); /*  1 */
            std::strncpy(_point_xpm[ 5], "........................................", 20*2); /*  2 */
            std::strncpy(_point_xpm[ 6], "........................................", 20*2); /*  3 */
            std::strncpy(_point_xpm[ 7], "........................................", 20*2); /*  4 */
            std::strncpy(_point_xpm[ 8], "........................................", 20*2); /*  5 */
            std::strncpy(_point_xpm[ 9], "........................................", 20*2); /*  6 */
            std::strncpy(_point_xpm[10], ".................#.#.#..................", 20*2); /*  7 */
            std::strncpy(_point_xpm[11], "...............#.......#................", 20*2); /*  8 */
            std::strncpy(_point_xpm[12], ".............#...........#..............", 20*2); /*  9 */
            std::strncpy(_point_xpm[13], ".............#...........#..............", 20*2); /* 10 */
            std::strncpy(_point_xpm[14], ".............#...........#..............", 20*2); /*  1 */
            std::strncpy(_point_xpm[15], "...............#.......#................", 20*2); /*  2 */
            std::strncpy(_point_xpm[16], ".................#.#.#..................", 20*2); /*  3 */
            std::strncpy(_point_xpm[17], "........................................", 20*2); /*  4 */
            std::strncpy(_point_xpm[18], "........................................", 20*2); /*  5 */
            std::strncpy(_point_xpm[19], "........................................", 20*2); /*  6 */
            std::strncpy(_point_xpm[20], "........................................", 20*2); /*  7 */
            std::strncpy(_point_xpm[21], "........................................", 20*2); /*  8 */
            std::strncpy(_point_xpm[22], "........................................", 20*2); /*  9 */
            std::strncpy(_point_xpm[23], "........................................", 20*2); /* 20 */
            break;
        }
        case WxCurve_PS_CIRC_MED:
        {
            /*                           0         1         2         3         4
                                         01234567890123456789012345678901234567890             00 */
            std::strncpy(_point_xpm[ 4], "........................................", 20*2); /*  1 */
            std::strncpy(_point_xpm[ 5], "........................................", 20*2); /*  2 */
            std::strncpy(_point_xpm[ 6], "........................................", 20*2); /*  3 */
            std::strncpy(_point_xpm[ 7], "........................................", 20*2); /*  4 */
            std::strncpy(_point_xpm[ 8], "...............#.#.#.#.#................", 20*2); /*  5 */
            std::strncpy(_point_xpm[ 9], "...........#.#.;.;.;.;.;.#.#............", 20*2); /*  6 */
            std::strncpy(_point_xpm[10], "...........#.;.;.;.;.;.;.;.#............", 20*2); /*  7 */
            std::strncpy(_point_xpm[11], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  8 */
            std::strncpy(_point_xpm[12], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  9 */
            std::strncpy(_point_xpm[13], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /* 10 */
            std::strncpy(_point_xpm[14], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  1 */
            std::strncpy(_point_xpm[15], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  2 */
            std::strncpy(_point_xpm[16], "...........#.;.;.;.;.;.;.;.#............", 20*2); /*  3 */
            std::strncpy(_point_xpm[17], "...........#.#.;.;.;.;.;.#.#............", 20*2); /*  4 */
            std::strncpy(_point_xpm[18], "...............#.#.#.#.#................", 20*2); /*  5 */
            std::strncpy(_point_xpm[19], "........................................", 20*2); /*  6 */
            std::strncpy(_point_xpm[20], "........................................", 20*2); /*  7 */
            std::strncpy(_point_xpm[21], "........................................", 20*2); /*  8 */
            std::strncpy(_point_xpm[22], "........................................", 20*2); /*  9 */
            std::strncpy(_point_xpm[23], "........................................", 20*2); /* 20 */
            break;
        }
        case WxCurve_PS_CIRC_BIG:
        {
            /*                           0         1         2         3         4
                                         01234567890123456789012345678901234567890             00 */
            std::strncpy(_point_xpm[ 4], "........................................", 20*2); /*  1 */
            std::strncpy(_point_xpm[ 5], "........................................", 20*2); /*  2 */
            std::strncpy(_point_xpm[ 6], ".............#.#.#.#.#.#.#..............", 20*2); /*  3 */
            std::strncpy(_point_xpm[ 7], "...........#...............#............", 20*2); /*  4 */
            std::strncpy(_point_xpm[ 8], ".........#...................#..........", 20*2); /*  5 */
            std::strncpy(_point_xpm[ 9], ".......#.......................#........", 20*2); /*  6 */
            std::strncpy(_point_xpm[10], ".......#.......................#........", 20*2); /*  7 */
            std::strncpy(_point_xpm[11], ".....#...........................#......", 20*2); /*  8 */
            std::strncpy(_point_xpm[12], ".....#...........................#......", 20*2); /*  9 */
            std::strncpy(_point_xpm[13], ".....#.............#.............#......", 20*2); /* 10 */
            std::strncpy(_point_xpm[14], ".....#...........................#......", 20*2); /*  1 */
            std::strncpy(_point_xpm[15], ".....#...........................#......", 20*2); /*  2 */
            std::strncpy(_point_xpm[16], ".......#.......................#........", 20*2); /*  3 */
            std::strncpy(_point_xpm[17], ".......#.......................#........", 20*2); /*  4 */
            std::strncpy(_point_xpm[18], ".........#...................#..........", 20*2); /*  5 */
            std::strncpy(_point_xpm[19], "...........#...............#............", 20*2); /*  6 */
            std::strncpy(_point_xpm[20], ".............#.#.#.#.#.#.#..............", 20*2); /*  7 */
            std::strncpy(_point_xpm[21], "........................................", 20*2); /*  8 */
            std::strncpy(_point_xpm[22], "........................................", 20*2); /*  9 */
            std::strncpy(_point_xpm[23], "........................................", 20*2); /* 20 */
            break;
        }
        case WxCurve_PS_CROSS_BIG:
        {
            /*                           0         1         2         3         4
                                         01234567890123456789012345678901234567890             00 */
            std::strncpy(_point_xpm[ 4], "........................................", 20*2); /*  1 */
            std::strncpy(_point_xpm[ 5], "........................................", 20*2); /*  2 */
            std::strncpy(_point_xpm[ 6], "...................#....................", 20*2); /*  3 */
            std::strncpy(_point_xpm[ 7], "...................#....................", 20*2); /*  4 */
            std::strncpy(_point_xpm[ 8], "...................#....................", 20*2); /*  5 */
            std::strncpy(_point_xpm[ 9], "...................#....................", 20*2); /*  6 */
            std::strncpy(_point_xpm[10], "...................#....................", 20*2); /*  7 */
            std::strncpy(_point_xpm[11], "...................#....................", 20*2); /*  8 */
            std::strncpy(_point_xpm[12], "...................#....................", 20*2); /*  9 */
            std::strncpy(_point_xpm[13], ".....#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#....", 20*2); /* 10 */
            std::strncpy(_point_xpm[14], "...................#....................", 20*2); /*  1 */
            std::strncpy(_point_xpm[15], "...................#....................", 20*2); /*  2 */
            std::strncpy(_point_xpm[16], "...................#....................", 20*2); /*  3 */
            std::strncpy(_point_xpm[17], "...................#....................", 20*2); /*  4 */
            std::strncpy(_point_xpm[18], "...................#....................", 20*2); /*  5 */
            std::strncpy(_point_xpm[19], "...................#....................", 20*2); /*  6 */
            std::strncpy(_point_xpm[20], "...................#....................", 20*2); /*  7 */
            std::strncpy(_point_xpm[21], "........................................", 20*2); /*  8 */
            std::strncpy(_point_xpm[22], "........................................", 20*2); /*  9 */
            std::strncpy(_point_xpm[23], "........................................", 20*2); /* 20 */
            break;
        }
        case WxCurve_PS_SQUARE_MED:
        {
            /*                           0         1         2         3         4
                                         01234567890123456789012345678901234567890             00 */
            std::strncpy(_point_xpm[ 4], "........................................", 20*2); /*  1 */
            std::strncpy(_point_xpm[ 5], "........................................", 20*2); /*  2 */
            std::strncpy(_point_xpm[ 6], "........................................", 20*2); /*  3 */
            std::strncpy(_point_xpm[ 7], "........................................", 20*2); /*  4 */
            std::strncpy(_point_xpm[ 8], ".........#.#.#.#.#.#.#.#.#.#.#..........", 20*2); /*  5 */
            std::strncpy(_point_xpm[ 9], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  6 */
            std::strncpy(_point_xpm[10], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  7 */
            std::strncpy(_point_xpm[11], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  8 */
            std::strncpy(_point_xpm[12], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  9 */
            std::strncpy(_point_xpm[13], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /* 10 */
            std::strncpy(_point_xpm[14], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  1 */
            std::strncpy(_point_xpm[15], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  2 */
            std::strncpy(_point_xpm[16], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  3 */
            std::strncpy(_point_xpm[17], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  4 */
            std::strncpy(_point_xpm[18], ".........#.#.#.#.#.#.#.#.#.#.#..........", 20*2); /*  5 */
            std::strncpy(_point_xpm[19], "........................................", 20*2); /*  6 */
            std::strncpy(_point_xpm[20], "........................................", 20*2); /*  7 */
            std::strncpy(_point_xpm[21], "........................................", 20*2); /*  8 */
            std::strncpy(_point_xpm[22], "........................................", 20*2); /*  9 */
            std::strncpy(_point_xpm[23], "........................................", 20*2); /* 20 */
            break;
        }
        case WxCurve_PS_SQUARE_BIG:
        {
            /*                           0         1         2         3         4
                                         01234567890123456789012345678901234567890             00 */
            std::strncpy(_point_xpm[ 4], "........................................", 20*2); /*  1 */
            std::strncpy(_point_xpm[ 5], "........................................", 20*2); /*  2 */
            std::strncpy(_point_xpm[ 6], ".....#.#.#.#.#.#.#.#.#.#.#.#.#.#.#......", 20*2); /*  3 */
            std::strncpy(_point_xpm[ 7], ".....#.............#.............#......", 20*2); /*  4 */
            std::strncpy(_point_xpm[ 8], ".....#.............#.............#......", 20*2); /*  5 */
            std::strncpy(_point_xpm[ 9], ".....#.............#.............#......", 20*2); /*  6 */
            std::strncpy(_point_xpm[10], ".....#.............#.............#......", 20*2); /*  7 */
            std::strncpy(_point_xpm[11], ".....#.............#.............#......", 20*2); /*  8 */
            std::strncpy(_point_xpm[12], ".....#.............#.............#......", 20*2); /*  9 */
            std::strncpy(_point_xpm[13], ".....#.#.#.#.#.#.#.#.#.#.#.#.#.#.#......", 20*2); /* 10 */
            std::strncpy(_point_xpm[14], ".....#.............#.............#......", 20*2); /*  1 */
            std::strncpy(_point_xpm[15], ".....#.............#.............#......", 20*2); /*  2 */
            std::strncpy(_point_xpm[16], ".....#.............#.............#......", 20*2); /*  3 */
            std::strncpy(_point_xpm[17], ".....#.............#.............#......", 20*2); /*  4 */
            std::strncpy(_point_xpm[18], ".....#.............#.............#......", 20*2); /*  5 */
            std::strncpy(_point_xpm[19], ".....#.............#.............#......", 20*2); /*  6 */
            std::strncpy(_point_xpm[20], ".....#.#.#.#.#.#.#.#.#.#.#.#.#.#.#......", 20*2); /*  7 */
            std::strncpy(_point_xpm[21], "........................................", 20*2); /*  8 */
            std::strncpy(_point_xpm[22], "........................................", 20*2); /*  9 */
            std::strncpy(_point_xpm[23], "........................................", 20*2); /* 20 */
            break;
        }
        case WxCurve_PS_CIRC_CROSS_BIG:
        {
            /*                           0         1         2         3         4
                                         01234567890123456789012345678901234567890             00 */
            std::strncpy(_point_xpm[ 4], "........................................", 20*2); /*  1 */
            std::strncpy(_point_xpm[ 5], "........................................", 20*2); /*  2 */
            std::strncpy(_point_xpm[ 6], ".............#.#.#.#.#.#.#..............", 20*2); /*  3 */
            std::strncpy(_point_xpm[ 7], "...........#.......#.......#............", 20*2); /*  4 */
            std::strncpy(_point_xpm[ 8], ".........#.........#.........#..........", 20*2); /*  5 */
            std::strncpy(_point_xpm[ 9], ".......#...........#...........#........", 20*2); /*  6 */
            std::strncpy(_point_xpm[10], ".......#...........#...........#........", 20*2); /*  7 */
            std::strncpy(_point_xpm[11], ".....#.............#.............#......", 20*2); /*  8 */
            std::strncpy(_point_xpm[12], ".....#.............#.............#......", 20*2); /*  9 */
            std::strncpy(_point_xpm[13], ".....#.#.#.#.#.#.#.#.#.#.#.#.#.#.#......", 20*2); /* 10 */
            std::strncpy(_point_xpm[14], ".....#.............#.............#......", 20*2); /*  1 */
            std::strncpy(_point_xpm[15], ".....#.............#.............#......", 20*2); /*  2 */
            std::strncpy(_point_xpm[16], ".......#...........#...........#........", 20*2); /*  3 */
            std::strncpy(_point_xpm[17], ".......#...........#...........#........", 20*2); /*  4 */
            std::strncpy(_point_xpm[18], ".........#.........#.........#..........", 20*2); /*  5 */
            std::strncpy(_point_xpm[19], "...........#.......#.......#............", 20*2); /*  6 */
            std::strncpy(_point_xpm[20], ".............#.#.#.#.#.#.#..............", 20*2); /*  7 */
            std::strncpy(_point_xpm[21], "........................................", 20*2); /*  8 */
            std::strncpy(_point_xpm[22], "........................................", 20*2); /*  9 */
            std::strncpy(_point_xpm[23], "........................................", 20*2); /* 20 */
            break;
        }
        case WxCurve_PS_TARGET_BIG:
        {
            /*                           0         1         2         3         4
                                         01234567890123456789012345678901234567890             00 */
            std::strncpy(_point_xpm[ 4], "........................................", 20*2); /*  1 */
            std::strncpy(_point_xpm[ 5], "........................................", 20*2); /*  2 */
            std::strncpy(_point_xpm[ 6], ".............#.#.#.#.#.#.#..............", 20*2); /*  3 */
            std::strncpy(_point_xpm[ 7], "...........#.;.;.;.;.;.;.;.#............", 20*2); /*  4 */
            std::strncpy(_point_xpm[ 8], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  5 */
            std::strncpy(_point_xpm[ 9], ".......#.;.;.;.;.;.;.;.;.;.;.;.#........", 20*2); /*  6 */
            std::strncpy(_point_xpm[10], ".......#.;.;.;.;.#.#.#.;.;.;.;.#........", 20*2); /*  7 */
            std::strncpy(_point_xpm[11], ".....#.;.;.;.;.#.;.;.;.#.;.;.;.;.#......", 20*2); /*  8 */
            std::strncpy(_point_xpm[12], ".....#.;.;.;.#.;.;.;.;.;.#.;.;.;.#......", 20*2); /*  9 */
            std::strncpy(_point_xpm[13], ".....#.;.;.;.#.;.;.;.;.;.#.;.;.;.#......", 20*2); /* 10 */
            std::strncpy(_point_xpm[14], ".....#.;.;.;.#.;.;.;.;.;.#.;.;.;.#......", 20*2); /*  1 */
            std::strncpy(_point_xpm[15], ".....#.;.;.;.;.#.;.;.;.#.;.;.;.;.#......", 20*2); /*  2 */
            std::strncpy(_point_xpm[16], ".......#.;.;.;.;.#.#.#.;.;.;.;.#........", 20*2); /*  3 */
            std::strncpy(_point_xpm[17], ".......#.;.;.;.;.;.;.;.;.;.;.;.#........", 20*2); /*  4 */
            std::strncpy(_point_xpm[18], ".........#.;.;.;.;.;.;.;.;.;.#..........", 20*2); /*  5 */
            std::strncpy(_point_xpm[19], "...........#.;.;.;.;.;.;.;.#............", 20*2); /*  6 */
            std::strncpy(_point_xpm[20], ".............#.#.#.#.#.#.#..............", 20*2); /*  7 */
            std::strncpy(_point_xpm[21], "........................................", 20*2); /*  8 */
            std::strncpy(_point_xpm[22], "........................................", 20*2); /*  9 */
            std::strncpy(_point_xpm[23], "........................................", 20*2); /* 20 */
            break;
        }
        case WxCurve_PS_DONUT:
        {
            /*                           0         1         2         3         4
                                         01234567890123456789012345678901234567890             00 */
            std::strncpy(_point_xpm[ 4], "........................................", 20*2); /*  1 */
            std::strncpy(_point_xpm[ 5], "........................................", 20*2); /*  2 */
            std::strncpy(_point_xpm[ 6], "........................................", 20*2); /*  3 */
            std::strncpy(_point_xpm[ 7], "........................................", 20*2); /*  4 */
            std::strncpy(_point_xpm[ 8], "...............#.#.#.#.#................", 20*2); /*  5 */
            std::strncpy(_point_xpm[ 9], "...........#.#.#.#.#.#.#.#.#............", 20*2); /*  6 */
            std::strncpy(_point_xpm[10], "...........#.#.#.#.#.#.#.#.#............", 20*2); /*  7 */
            std::strncpy(_point_xpm[11], ".........#.#.#.#.;.;.;.#.#.#.#..........", 20*2); /*  8 */
            std::strncpy(_point_xpm[12], ".........#.#.#.;.;.;.;.;.#.#.#..........", 20*2); /*  9 */
            std::strncpy(_point_xpm[13], ".........#.#.#.;.;.;.;.;.#.#.#..........", 20*2); /* 10 */
            std::strncpy(_point_xpm[14], ".........#.#.#.;.;.;.;.;.#.#.#..........", 20*2); /*  1 */
            std::strncpy(_point_xpm[15], ".........#.#.#.#.;.;.;.#.#.#.#..........", 20*2); /*  2 */
            std::strncpy(_point_xpm[16], "...........#.#.#.#.#.#.#.#.#............", 20*2); /*  3 */
            std::strncpy(_point_xpm[17], "...........#.#.#.#.#.#.#.#.#............", 20*2); /*  4 */
            std::strncpy(_point_xpm[18], "...............#.#.#.#.#................", 20*2); /*  5 */
            std::strncpy(_point_xpm[19], "........................................", 20*2); /*  6 */
            std::strncpy(_point_xpm[20], "........................................", 20*2); /*  7 */
            std::strncpy(_point_xpm[21], "........................................", 20*2); /*  8 */
            std::strncpy(_point_xpm[22], "........................................", 20*2); /*  9 */
            std::strncpy(_point_xpm[23], "........................................", 20*2); /* 20 */
            break;
        }
    }

    // Set _point_type
    _point_type = PS;

    // Return
    return (*this);
} // }}}

inline void WxCurve::UpdateSize(WxTransformData const & TD) // {{{
{
    for (int i=0; i<_size; ++i)
        WxReal2Canvas(TD, _x[i],_y[i], _points[i].x,_points[i].y);
} // }}}

inline void WxCurve::GetRange(REAL & MinX, REAL & MaxX,  REAL & MinY, REAL & MaxY) const // {{{
{
    MinX = _min_x;  MaxX = _max_x;
    MinY = _min_y;  MaxY = _max_y;
} // }}}

inline void WxCurve::DrawLine(wxDC & DC) // {{{ 
{
    if (!_enabled) return;
    DC.SetPen (_line_pen);
    if (_is_contour)
    {
        for (int i=0; i<_size-1; i+=2)
        {
            wxPoint * pts = new wxPoint [2];
            pts[0].x=_points[i  ].x;  pts[0].y=_points[i  ].y;
            pts[1].x=_points[i+1].x;  pts[1].y=_points[i+1].y;
            DC.DrawLines(2,pts);
            delete [] pts;
        }
    }
    else
        DC.DrawLines (_size, _points);
} // }}}

inline void WxCurve::DrawPoints(wxDC & DC) // {{{ 
{
    if (!_enabled) return;
    if (_point_type==WxCurve_PS_NONE) return;
    wxIcon icon(_point_xpm);
    for (int i=0; i<_size; ++i)
        DC.DrawIcon(icon, _points[i].x-9, _points[i].y-9); // -9 ~ half width and half height
} // }}}

inline void WxCurve::ResetData(REAL const * X, REAL const * Y, int Size) // {{{ 
{
    // Delete arrays of data
    if (_size>0)
    {
        delete [] _x;
        delete [] _y;
        delete [] _points;
    }
    else return;

    // Allocate arrays of data
      _size = Size;
         _x = new REAL    [_size];
         _y = new REAL    [_size];
    _points = new wxPoint [_size];
    for (int i=0; i<_size; ++i)
    {
             _x[i]   = X[i];
             _y[i]   = Y[i];
        _points[i].x = 0;
        _points[i].y = 0;
    }

    // Get bounding box
    _bounding_box();
} // }}}

inline void WxCurve::ResetData(Array<REAL> const & X, Array<REAL> const & Y) // {{{ 
{
    // Delete arrays of data
    if (_size>0)
    {
        delete [] _x;
        delete [] _y;
        delete [] _points;
    }
    else return;

    // Allocate arrays of data
      _size = X.size();
         _x = new REAL    [_size];
         _y = new REAL    [_size];
    _points = new wxPoint [_size];
    for (int i=0; i<_size; ++i)
    {
             _x[i]   = X[i];
             _y[i]   = Y[i];
        _points[i].x = 0;
        _points[i].y = 0;
    }

    // Get bounding box
    _bounding_box();
} // }}}

inline void WxCurve::ResetData(REAL x_min, REAL x_max, REAL y_min, REAL y_max, int nDiv, REAL DelPctX, REAL DelPctY) // {{{
{
    // Delete arrays of data
    if (_grid_size>0)
    {
        delete [] _grid_x;
        delete [] _grid_y;  for (int i=0; i<_grid_size; ++i)
        delete [] _grid_f[i];
        delete [] _grid_f;
    }
    else return;

    // New grid size
    _grid_size = nDiv;

    // Set limits
    _min_x=x_min; _max_x=x_max;
    _min_y=y_min; _max_y=y_max;
    _x_range = _max_x - _min_x;
    _y_range = _max_y - _min_y;

    // Allocate and generate grid
    REAL         dx = DelPctX*_x_range;
    REAL         dy = DelPctY*_y_range;
    REAL    start_x = _min_x-dx;
    REAL      end_x = _max_x+dx;
    REAL    start_y = _min_y-dy;
    REAL      end_y = _max_y+dy;
            _grid_x = new REAL [_grid_size];
            _grid_y = new REAL [_grid_size];
    REAL     step_x = (end_x-start_x)/(_grid_size-1.0);
    REAL     step_y = (end_y-start_y)/(_grid_size-1.0);
         _grid_x[0] = start_x;
         _grid_y[0] = start_y;
    for (int i=1; i<_grid_size; ++i)  _grid_x[i]=_grid_x[i-1]+step_x;
    for (int i=1; i<_grid_size; ++i)  _grid_y[i]=_grid_y[i-1]+step_y;

    // Allocate (void) function values
    _grid_f    = new REAL * [_grid_size];  for (int i=0; i<_grid_size; ++i)
    _grid_f[i] = new REAL   [_grid_size];

} // }}}

inline void WxCurve::SetContour(int nLevels, REAL const * Levels) // {{{ 
{
    // Contour
    Array<REAL> X;
    Array<REAL> Y;
    conrec(_grid_f, 0,_grid_size-1,0,_grid_size-1, _grid_x,_grid_y, nLevels,Levels, X,Y);

    // Delete previous arrays of data
    if (_size>0)
    {
        delete [] _x;
        delete [] _y;
        delete [] _points;
    }

    // Allocate arrays of data
      _size = X.size();
         _x = new REAL    [_size];
         _y = new REAL    [_size];
    _points = new wxPoint [_size];
    for (int i=0; i<_size; ++i)
    {
             _x[i]   = X[i];
             _y[i]   = Y[i];
        _points[i].x = 0;
        _points[i].y = 0;
    }

    // Get bounding box
    _bounding_box();

    // Enable
    _enabled = true;
} // }}}

inline void WxCurve::_init_pen_brush() // {{{
{
    _line_pen   .SetColour(_T("black"));
    _point_pen  .SetColour(_T("blue"));
    _point_brush.SetColour(_T("red"));
    _line_pen   .SetStyle (wxSOLID);
    _point_pen  .SetStyle (wxSOLID);
    _point_brush.SetStyle (wxSOLID);
    _line_pen   .SetWidth (1);
    _point_pen  .SetWidth (1);
} // }}}

inline void WxCurve::_bounding_box() // {{{
{
    int i_min_x=0; int i_max_x=0;
    int i_min_y=0; int i_max_y=0;
    for (int i=1; i<_size; ++i)
    {
        if (_x[i]<_x[i_min_x]) i_min_x=i;
        if (_x[i]>_x[i_max_x]) i_max_x=i;
        if (_y[i]<_y[i_min_y]) i_min_y=i;
        if (_y[i]>_y[i_max_y]) i_max_y=i;
    }
    _min_x=_x[i_min_x]; _max_x=_x[i_max_x];
    _min_y=_y[i_min_y]; _max_y=_y[i_max_y];
    _x_range = _max_x - _min_x;
    _y_range = _max_y - _min_y;
} // }}}

inline void WxCurve::_allocate_xpm() // {{{
{
    _point_xpm    = new char* [24]; // 1-setup, 3-colors, 20-pixels
    _point_xpm[0] = new char  [10]; // "20 20 3 2" width height num_colors chars_per_pixel
    _point_xpm[1] = new char  [10]; // ".. c None"     color - none
    _point_xpm[2] = new char  [13]; // ".# c #000000"  color - pen
    _point_xpm[3] = new char  [13]; // ".a c #ffffff"  color - brush
    std::strncpy(_point_xpm[0], "20 20 3 2"   , 9 );  _point_xpm[0][9]  = '\0';
    std::strncpy(_point_xpm[1], ".. c None"   , 9 );  _point_xpm[1][9]  = '\0';
    std::strncpy(_point_xpm[2], ".# c #000000", 12);  _point_xpm[2][12] = '\0';
    std::strncpy(_point_xpm[3], ".; c None   ", 12);  _point_xpm[3][12] = '\0';
    for (int i=0; i<20; ++i)
    {
        _point_xpm[4+i] = new char [20*2+1]; // 20(width)*2(chars_per_pixel) + '\0'
        std::strncpy(_point_xpm[4+i], "........................................", 20*2);  _point_xpm[4+i][20*2] = '\0';
    }
} // }}}

inline void WxCurve::_colour_to_hex(const wxColour & Col, char * HexBufferSizeEq8) // {{{
{
    int r = Col.Red  ();
    int g = Col.Green();
    int b = Col.Blue ();

    std::ostringstream oss; oss<<'#';
    oss<<std::hex<<std::setw(2)<<std::setfill('0')<<r;
    oss<<std::hex<<std::setw(2)<<std::setfill('0')<<g;
    oss<<std::hex<<std::setw(2)<<std::setfill('0')<<b;

    std::strncpy(HexBufferSizeEq8, oss.str().c_str(), 7);
    HexBufferSizeEq8[7]='\0';
} // }}}

#endif // MECHSYS_WXCURVE_H

// vim:fdm=marker

---