wxruler.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_WXRULER_H
#define MECHSYS_WXRULER_H

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

#include "util/array.h"

#include "gui/wxtransform.h"

class WxRuler
{
public:
    // RulerPosition
    enum RulerPosition
    { // {{{
        POS_BOTTOM ,
        POS_LEFT   ,
        POS_TOP    ,
        POS_RIGHT
    }; // enum RulerPosition // }}}

    // Constructor & Destructor
     WxRuler ();
    ~WxRuler ();

    // Config Methods
    WxRuler & Active       (bool          Val) { _active=Val; return (*this); }
    WxRuler & Position     (RulerPosition Pos);
    WxRuler & Thickness    (int           Wid);
    WxRuler & nMajorTicks  (int           Num);
    WxRuler & MajorTickLen (int           Len);

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

private:
    bool           _active;
    RulerPosition  _position;
    int            _thickness; // should be "width", however we use this to avoid confusion with vertical and horizontal "width's"
    int            _n_major_ticks;
    int            _major_tick_len;
    Array<wxPoint> _major_start_points;
    Array<wxPoint> _major_end_points;
    wxPoint        _base_line_start;
    wxPoint        _base_line_end;
}; // class WxScale




inline WxRuler::WxRuler() // {{{
    : _active         (true)      ,
      _position       (POS_BOTTOM),
      _thickness      (15)        ,
      _major_tick_len (10)        
{
    nMajorTicks(10);
} // }}}

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

inline WxRuler & WxRuler::Position(WxRuler::RulerPosition Pos) // {{{
{
    _position = Pos;
    return (*this);
} // }}}

inline WxRuler & WxRuler::Thickness(int Wid) // {{{
{
    _thickness = Wid;
    return (*this);
} // }}}

inline WxRuler & WxRuler::nMajorTicks(int Num) // {{{
{
    _n_major_ticks = Num;
    _major_start_points.resize(_n_major_ticks+1);
    _major_end_points.  resize(_n_major_ticks+1);
    return (*this);
} // }}}

inline WxRuler & WxRuler::MajorTickLen(int Len) // {{{
{
    _major_tick_len = Len;
    return (*this);
} // }}}

inline void WxRuler::UpdateSize(WxTransformData const & TD) // {{{
{
    // Base line
    switch (_position)
    {
    case POS_BOTTOM:
        {
            // Base line
            _base_line_start.x = TD.CanvasRect.x;
            _base_line_start.y = TD.CanvasRect.y + TD.CanvasRect.height;
              _base_line_end.x = _base_line_start.x + TD.CanvasRect.width;
              _base_line_end.y = _base_line_start.y;

            // Major ticks
            int major_step = TD.CanvasRect.width/_n_major_ticks;
            _major_start_points[0].x = _base_line_start.x;
            _major_start_points[0].y = _base_line_start.y;
              _major_end_points[0].x = _major_start_points[0].x;
              _major_end_points[0].y = _major_start_points[0].y + _major_tick_len;
            for (int i=1; i<_n_major_ticks+1; ++i)
            {
                _major_start_points[i].x = _major_start_points[i-1].x + major_step;
                _major_start_points[i].y = _base_line_start.y;
                  _major_end_points[i].x = _major_start_points[i].x;
                  _major_end_points[i].y = _major_start_points[i].y + _major_tick_len;
            }

            break;
        }
    case POS_LEFT:
        {
            // Base line
            _base_line_start.x = TD.CanvasRect.x;
            _base_line_start.y = TD.CanvasRect.y;
              _base_line_end.x = _base_line_start.x;
              _base_line_end.y = _base_line_start.y + TD.CanvasRect.height;

            // Major ticks
            int major_step = TD.CanvasRect.height/_n_major_ticks;
            _major_start_points[0].x = _base_line_start.x - _major_tick_len;
            _major_start_points[0].y = _base_line_start.y;
              _major_end_points[0].x = _base_line_start.x;
              _major_end_points[0].y = _major_start_points[0].y;
            for (int i=1; i<_n_major_ticks+1; ++i)
            {
                _major_start_points[i].x = _base_line_start.x - _major_tick_len;
                _major_start_points[i].y = _major_start_points[i-1].y + major_step;
                  _major_end_points[i].x = _base_line_start.x;
                  _major_end_points[i].y = _major_start_points[i].y;
            }

            break;
        }
    case POS_TOP:
        {
            // Base line
            _base_line_start.x = TD.CanvasRect.x;
            _base_line_start.y = TD.CanvasRect.y;
              _base_line_end.x = _base_line_start.x + TD.CanvasRect.width;
              _base_line_end.y = _base_line_start.y;

            // Major ticks
            int major_step = TD.CanvasRect.width/_n_major_ticks;
            _major_start_points[0].x = _base_line_start.x;
            _major_start_points[0].y = _base_line_start.y;
              _major_end_points[0].x = _major_start_points[0].x;
              _major_end_points[0].y = _major_start_points[0].y - _major_tick_len;
            for (int i=1; i<_n_major_ticks+1; ++i)
            {
                _major_start_points[i].x = _major_start_points[i-1].x + major_step;
                _major_start_points[i].y = _base_line_start.y;
                  _major_end_points[i].x = _major_start_points[i].x;
                  _major_end_points[i].y = _major_start_points[i].y - _major_tick_len;
            }

            break;
        }
    case POS_RIGHT:
        {
            // Base line
            _base_line_start.x = TD.CanvasRect.x + TD.CanvasRect.width;
            _base_line_start.y = TD.CanvasRect.y;
              _base_line_end.x = _base_line_start.x;
              _base_line_end.y = _base_line_start.y + TD.CanvasRect.height;

            // Major ticks
            int major_step = TD.CanvasRect.height/_n_major_ticks;
            _major_start_points[0].x = _base_line_start.x;
            _major_start_points[0].y = _base_line_start.y;
              _major_end_points[0].x = _major_start_points[0].x + _major_tick_len;
              _major_end_points[0].y = _major_start_points[0].y;
            for (int i=1; i<_n_major_ticks+1; ++i)
            {
                _major_start_points[i].x = _base_line_start.x;
                _major_start_points[i].y = _major_start_points[i-1].y + major_step;
                  _major_end_points[i].x = _major_start_points[i].x + _major_tick_len;
                  _major_end_points[i].y = _major_start_points[i].y;
            }

            break;
        }
    }
} // }}}

inline void WxRuler::Draw(wxDC & DC) // {{{
{
    if (_active)
    {
        // Major ticks
        DC.SetPen(wxPen(_T("black")));
        for (int i=0; i<_n_major_ticks+1; ++i)
            DC.DrawLine(_major_start_points[i], _major_end_points[i]);

        // Baseline
        DC.DrawLine(_base_line_start, _base_line_end);
    }
} // }}}

#endif // MECHSYS_WXRULER_H

// vim:fdm=marker

---