wxgrid.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_WXGRID_H
#define MECHSYS_WXGRID_H

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

#include "gui/wxtransform.h"

class WxGrid
{
public:
    // Constructor & Destructor
     WxGrid ();
    ~WxGrid ();

    // Config Methods
    WxGrid & Active  (bool Val) { _active=Val; return (*this); }
    WxGrid & nHLines (int  Num);
    WxGrid & nVLines (int  Num);

    // Methods
    void UpdateSize (WxTransformData const & TD);
    void Draw       (wxDC & DC);
    bool IsActive   () const { return _active; }

private:
    // Grid
    bool           _active;
    int            _n_h_lines;      // number of horizontal lines
    int            _n_v_lines;      // number of vertical lines
    Array<wxPoint> _h_start_points; // horizontal lines
    Array<wxPoint> _h_end_points;   // horizontal lines
    Array<wxPoint> _v_start_points; // vertical lines
    Array<wxPoint> _v_end_points;   // vertical lines
    // Origin (cross)
    wxPoint        _ori_h_line_start; // horizontal passing by origin
    wxPoint        _ori_h_line_end;   
    wxPoint        _ori_v_line_start; // vertical passing by origin
    wxPoint        _ori_v_line_end;   

}; // class WxGrid



inline WxGrid::WxGrid() // {{{
    : _active(true)
{
    nHLines(10);
    nVLines(10);
} // }}}

inline WxGrid::~WxGrid() // {{{
{
} // }}}

inline WxGrid & WxGrid::nHLines(int Num) // {{{
{
    _n_h_lines = Num;
    _h_start_points.resize(_n_h_lines);
    _h_end_points  .resize(_n_h_lines);
    return (*this);
} // }}}

inline WxGrid & WxGrid::nVLines(int Num) // {{{
{
    _n_v_lines = Num;
    _v_start_points.resize(_n_v_lines);
    _v_end_points  .resize(_n_v_lines);
    return (*this);
} // }}}

inline void WxGrid::UpdateSize(WxTransformData const & TD) // {{{
{
    // Horizontal lines
    int h_step = TD.CanvasRect.height/_n_h_lines;
    _h_start_points[0].x = TD.CanvasRect.x;
    _h_start_points[0].y = TD.CanvasRect.y;
    _h_end_points  [0].x = _h_start_points[0].x + TD.CanvasRect.width;
    _h_end_points  [0].y = _h_start_points[0].y;
    for (int i=1; i<_n_h_lines; ++i)
    {
        _h_start_points[i].x = TD.CanvasRect.x;
        _h_start_points[i].y = _h_start_points[i-1].y + h_step;
        _h_end_points  [i].x = _h_start_points[i].x + TD.CanvasRect.width;
        _h_end_points  [i].y = _h_start_points[i].y;
    }

    // Vertical lines
    int v_step = TD.CanvasRect.width /_n_v_lines;
    _v_start_points[0].x = TD.CanvasRect.x;
    _v_start_points[0].y = TD.CanvasRect.y;
    _v_end_points  [0].x = _v_start_points[0].x;
    _v_end_points  [0].y = _v_start_points[0].y + TD.CanvasRect.height;
    for (int i=1; i<_n_v_lines; ++i)
    {
        _v_start_points[i].x = _v_start_points[i-1].x + v_step;
        _v_start_points[i].y = TD.CanvasRect.y;
        _v_end_points  [i].x = _v_start_points[i].x;
        _v_end_points  [i].y = _v_start_points[i].y + TD.CanvasRect.height;
    }

    // Horizontal line passing by origin (cross)
    WxReal2Canvas(TD, TD.xMin,0.0, _ori_h_line_start.x, _ori_h_line_start.y);
    WxReal2Canvas(TD, TD.xMax,0.0, _ori_h_line_end  .x, _ori_h_line_end  .y);

    // Vertical line passing by origin (cross)
    WxReal2Canvas(TD, 0.0,TD.yMin, _ori_v_line_start.x, _ori_v_line_start.y);
    WxReal2Canvas(TD, 0.0,TD.yMax, _ori_v_line_end  .x, _ori_v_line_end  .y);
} // }}}

inline void WxGrid::Draw(wxDC & DC) // {{{
{
    if (_active)
    {
        // Grid lines
        DC.SetPen(wxPen(_T("gray"), 1, wxDOT));
        for (int i=0; i<_n_h_lines; ++i) DC.DrawLine(_h_start_points[i], _h_end_points[i]); // Horizontal lines
        for (int i=0; i<_n_v_lines; ++i) DC.DrawLine(_v_start_points[i], _v_end_points[i]); // Vertical lines

        // Cross lines
        DC.SetPen(wxPen(_T("black")));
        DC.DrawLine(_ori_h_line_start, _ori_h_line_end);
        DC.DrawLine(_ori_v_line_start, _ori_v_line_end);
    }
} // }}}

#endif // MECHSYS_WXGRID_H

// vim:fdm=marker

---