wxgraph.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_WXGRAPH_H
#define MECHSYS_WXGRAPH_H

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

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

#include "util/array.h"
#include "util/lineparser.h"

#include "gui/wxcurve.h"
#include "gui/wxruler.h"
#include "gui/wxgrid.h"

class WxGraph : public wxWindow
{
public:
    // Constructor
     WxGraph (wxFrame * Parent, wxSize Size=wxDefaultSize);
     WxGraph (wxFrame * Parent, String const & BgPenColor, String const & BgColor, wxSize Size=wxDefaultSize);
    ~WxGraph ();

    // Methods
    void RePaint();

    // Events
    void OnPaint           (wxPaintEvent & Event);
    void OnEraseBackground (wxEraseEvent & Event);
    void OnSize            (wxSizeEvent  & Event);

    // Config Methods
    WxGraph & EqualScales(bool Val=false) { _td.EqScales=Val; return (*this); }

    // Methods
    WxCurve & AddCurve    (Array<REAL> const & X, Array<REAL> const & Y);
    WxCurve & AddCurve    (REAL const * X, REAL const * Y, int Size);
    WxCurve & AddCurve    (REAL x_min, REAL x_max, REAL y_min, REAL y_max, int nDiv, REAL DelPctX=0.1, REAL DelPctY=0.1);
    WxCurve & ResetCurve  (int i, REAL const * X, REAL const * Y, int Size);
    WxCurve & ResetCurve  (int i, Array<REAL> const & X, Array<REAL> const & Y);
    WxCurve & ResetCurve  (int i, REAL x_min, REAL x_max, REAL y_min, REAL y_max, int nDiv, REAL DelPctX=0.1, REAL DelPctY=0.1);
    WxCurve & SetContour  (int i, int nLevels, REAL const * Levels);
    WxCurve & EnableCurve (int i, bool Enabled);
    WxRuler & XRuler      ()      { return _x_ruler;      }
    WxRuler & YRuler      ()      { return _y_ruler;      }
    WxRuler & X2Ruler     ()      { return _x2_ruler;     }
    WxRuler & Y2Ruler     ()      { return _y2_ruler;     }
    WxCurve & GetCurve    (int i) { return (*_curves[i]); }
    WxGrid  & Grid        ()      { return _grid;         }
    void      DelCurve    (size_t i) { if (i<_curves.size()) { delete _curves[i]; _curves.erase(_curves.begin()+i); } }

private:
    // Event table
    DECLARE_EVENT_TABLE()
    // Data
    WxTransformData _td;
    Array<WxCurve*> _curves;
    wxPen           _bg_pen;
    wxBrush         _bg_brush;
    // Scales
    WxRuler         _x_ruler;  // bottom
    WxRuler         _y_ruler;  // left
    WxRuler         _x2_ruler; // top
    WxRuler         _y2_ruler; // right
    // Grid
    WxGrid          _grid;

    // Methods
    void _bounding_box     ();
    void _paint_background (wxDC & DC);
    void _draw_graph       (wxDC & DC);
    void _calc_size        ();
}; // class SWindow




inline WxGraph::WxGraph(wxFrame * Parent, wxSize Size) // {{{
    : wxWindow (Parent, wxID_ANY, wxDefaultPosition, Size, wxFULL_REPAINT_ON_RESIZE),
      _bg_pen   (_T("blue"),/*width*/1,wxSOLID),
      _bg_brush (static_cast<wxColour>(GetBackgroundColour()), wxSOLID)
{
    // TransformData
    _td.EqScales = false;
    
    // Rulers
    _x_ruler .Position(WxRuler::POS_BOTTOM);
    _y_ruler .Position(WxRuler::POS_LEFT  );
    _x2_ruler.Position(WxRuler::POS_TOP   );
    _y2_ruler.Position(WxRuler::POS_RIGHT );
} // }}}

inline WxGraph::WxGraph(wxFrame * Parent, String const & BgPenColor, String const & BgColor, wxSize Size) // {{{
    : wxWindow (Parent, wxID_ANY, wxDefaultPosition, Size, wxFULL_REPAINT_ON_RESIZE),
      _bg_pen   (BgPenColor,/*width*/1,wxSOLID),
      _bg_brush (BgColor,wxSOLID)
{
    // TransformData
    _td.EqScales = false;

    // Rulers
    _x_ruler .Position(WxRuler::POS_BOTTOM);
    _y_ruler .Position(WxRuler::POS_LEFT  );
    _x2_ruler.Position(WxRuler::POS_TOP   );
    _y2_ruler.Position(WxRuler::POS_RIGHT );
} // }}}

inline WxGraph::~WxGraph() // {{{
{
    for (size_t i=0; i<_curves.size(); ++i)
        delete _curves[i];
} // }}}

inline void WxGraph::RePaint() // {{{
{
    _calc_size();
    this->Refresh();
    this->Update();
} // }}}

inline void WxGraph::OnPaint(wxPaintEvent & Event) // {{{
{
    // Device context
    wxBufferedPaintDC dc(this);
    PrepareDC(dc);

    // Background
    _paint_background(dc);

    // Paint
    _draw_graph(dc);
} // }}}

inline void WxGraph::OnEraseBackground(wxEraseEvent & Event) // {{{
{
    // Empty implementation to prevent flicker
} // }}}

inline void WxGraph::OnSize(wxSizeEvent & Event) // {{{
{
    _calc_size();
} // }}}

inline WxCurve & WxGraph::AddCurve(Array<REAL> const & X, Array<REAL> const & Y) // {{{
{
    WxCurve * C = new WxCurve (X,Y);
    _curves.push_back(C);
    _bounding_box();
    return (*C);
} // }}}

inline WxCurve & WxGraph::AddCurve(REAL const * X, REAL const * Y, int Size) // {{{
{
    WxCurve * C = new WxCurve (X,Y,Size);
    _curves.push_back(C);
    _bounding_box();
    return (*C);
} // }}}

inline WxCurve & WxGraph::AddCurve(REAL x_min, REAL x_max, REAL y_min, REAL y_max, int nDiv, REAL DelPctX, REAL DelPctY) // {{{
{
    WxCurve * C = new WxCurve (x_min,x_max, y_min,y_max, nDiv, DelPctX, DelPctY);
    _curves.push_back(C);
    _bounding_box();
    return (*C);
} // }}}

inline WxCurve & WxGraph::ResetCurve(int i, REAL const * X, REAL const * Y, int Size) // {{{
{
    // TODO: check range
    _curves[i]->ResetData(X, Y, Size);
    _bounding_box();

    // Send event to (re)paint the graph
    RePaint();

    // Return
    return (*_curves[i]);
} // }}}

inline WxCurve & WxGraph::ResetCurve(int i, Array<REAL> const & X, Array<REAL> const & Y) // {{{
{
    // TODO: check range
    _curves[i]->ResetData(X, Y);
    _bounding_box();

    // Send event to (re)paint the graph
    RePaint();

    // Return
    return (*_curves[i]);
} // }}}

inline WxCurve & WxGraph::ResetCurve(int i, REAL x_min, REAL x_max, REAL y_min, REAL y_max, int nDiv, REAL DelPctX, REAL DelPctY) // {{{
{
    // TODO: check range
    _curves[i]->ResetData(x_min, x_max, y_min, y_max, nDiv, DelPctX, DelPctY);
    _bounding_box();

    // Send event to (re)paint the graph
    RePaint();

    // Return
    return (*_curves[i]);
} // }}}

inline WxCurve & WxGraph::SetContour(int i, int nLevels, REAL const * Levels) // {{{
{
    _curves[i]->SetContour(nLevels, Levels);
    _bounding_box();

    // Send event to (re)paint the graph
    RePaint();

    // Return
    return (*_curves[i]);
} // }}}

inline WxCurve & WxGraph::EnableCurve(int i, bool Enabled) // {{{
{
    // TODO: check range
    _curves[i]->Enable(Enabled);

    // Return
    return (*_curves[i]);
} // }}}

inline void WxGraph::_bounding_box() // {{{
{
    if (_curves.size()==0) return;

    _curves[0]->GetRange(_td.xMin, _td.xMax,  _td.yMin, _td.yMax);

    for (size_t i=1; i<_curves.size(); ++i)
    {
        REAL min_x;  REAL max_x;
        REAL min_y;  REAL max_y;
        _curves[i]->GetRange(min_x, max_x,  min_y, max_y);
        if (min_x<_td.xMin) _td.xMin=min_x;
        if (max_x>_td.xMax) _td.xMax=max_x;
        if (min_y<_td.yMin) _td.yMin=min_y;
        if (max_y>_td.yMax) _td.yMax=max_y;
    }

    _td.xRange = _td.xMax - _td.xMin;
    _td.yRange = _td.yMax - _td.yMin;
} // }}}

inline void WxGraph::_paint_background(wxDC & DC) // {{{
{
    DC.SetBrush(_bg_brush);
    DC.SetPen  (_bg_pen);
    wxRect win_rect(wxPoint(0,0), GetClientSize());
    DC.DrawRectangle(win_rect);
} // }}}

inline void WxGraph::_draw_graph(wxDC & DC) // {{{
{
    if (_curves.size()>0)
    {
        // Grid
        _grid.Draw(DC);

        // Rulers
        _x_ruler .Draw(DC);
        _y_ruler .Draw(DC);
        _x2_ruler.Draw(DC);
        _y2_ruler.Draw(DC);

        // Curves
        for (size_t i=0; i<_curves.size(); ++i)
        {
            _curves[i]->DrawLine  (DC);
            _curves[i]->DrawPoints(DC);
        }
    }
} // }}}

inline void WxGraph::_calc_size() // {{{
{
    // Client (canvas) area
    _td.CanvasRect.x = 0;
    _td.CanvasRect.y = 0;
    GetClientSize(&_td.CanvasRect.width, &_td.CanvasRect.height);

    // Area - rulers
    if (_x_ruler .IsActive()) _td.CanvasRect.height -= _x_ruler .Thick();                                                // bottom ruler
    if (_y_ruler .IsActive()) { _td.CanvasRect.x     = _y_ruler .Thick();  _td.CanvasRect.width  -= _y_ruler .Thick(); } // left ruler
    if (_x2_ruler.IsActive()) { _td.CanvasRect.y     = _x2_ruler.Thick();  _td.CanvasRect.height -= _x2_ruler.Thick(); } // top ruler
    if (_y2_ruler.IsActive()) _td.CanvasRect.width  -= _y2_ruler.Thick();                                                // right ruler

    // Calculate scale factors
    WxCalcScaleFactor(_td);

    // Set rulers
    _x_ruler .UpdateSize(_td);
    _y_ruler .UpdateSize(_td);
    _x2_ruler.UpdateSize(_td);
    _y2_ruler.UpdateSize(_td);
    
    // Set curves
    for (size_t i=0; i<_curves.size(); ++i)
        _curves[i]->UpdateSize(_td);

    // Grid
    _grid.UpdateSize(_td);
    
} // }}}

BEGIN_EVENT_TABLE(WxGraph, wxWindow) // {{{
    EVT_PAINT            ( WxGraph::OnPaint           )
    EVT_ERASE_BACKGROUND ( WxGraph::OnEraseBackground )
    EVT_SIZE             ( WxGraph::OnSize            )
END_EVENT_TABLE() // }}}

#endif // MECHSYS_WXGRAPH_H

// vim:fdm=marker

---