mathplot.h

Go to the documentation of this file.

// Name:            mathplot.cpp
// Purpose:         Framework for plotting in wxWindows
// Original Author: David Schalig
// Maintainer:      Davide Rondini
// Contributors:    Jose Luis Blanco, Val Greene, Maciej Suminski, Tomasz Wlostowski
// Created:         21/07/2003
// Last edit:       05/08/2016
// Copyright:       (c) David Schalig, Davide Rondini
// Licence:         wxWindows licence

#ifndef _MP_MATHPLOT_H_
#define _MP_MATHPLOT_H_

// this definition uses windows dll to export function.
// WXDLLIMPEXP_MATHPLOT definition definition changed to WXDLLIMPEXP_MATHPLOT
// mathplot_EXPORTS will be defined by cmake
#ifdef mathplot_EXPORTS
#define WXDLLIMPEXP_MATHPLOT WXEXPORT
#define WXDLLIMPEXP_DATA_MATHPLOT( type ) WXEXPORT type
#else    // not making DLL
#define WXDLLIMPEXP_MATHPLOT
#define WXDLLIMPEXP_DATA_MATHPLOT( type ) type
#endif

#include <vector>

#include <wx/defs.h>
#include <wx/menu.h>
#include <wx/scrolwin.h>
#include <wx/event.h>
#include <wx/dynarray.h>
#include <wx/pen.h>
#include <wx/dcmemory.h>
#include <wx/string.h>
#include <wx/print.h>
#include <wx/image.h>


#include <deque>

#include <algorithm>

// For memory leak debug
#ifdef _WINDOWS
#ifdef _DEBUG
#include <crtdbg.h>
#define DEBUG_NEW   new (_NORMAL_BLOCK, __FILE__, __LINE__)
#else
#define DEBUG_NEW   new
#endif      // _DEBUG
#endif      // _WINDOWS

// Separation for axes when set close to border
#define X_BORDER_SEPARATION 40
#define Y_BORDER_SEPARATION 60

// -----------------------------------------------------------------------------
// classes
// -----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpLayer;
class WXDLLIMPEXP_MATHPLOT mpFX;
class WXDLLIMPEXP_MATHPLOT mpFY;
class WXDLLIMPEXP_MATHPLOT mpFXY;
class WXDLLIMPEXP_MATHPLOT mpFXYVector;
class WXDLLIMPEXP_MATHPLOT mpScaleX;
class WXDLLIMPEXP_MATHPLOT mpScaleY;
class WXDLLIMPEXP_MATHPLOT mpWindow;
class WXDLLIMPEXP_MATHPLOT mpText;
class WXDLLIMPEXP_MATHPLOT mpPrintout;

enum
{
    mpID_FIT = 2000,    // !< Fit view to match bounding box of all layers
    mpID_ZOOM_IN,       // !< Zoom into view at clickposition / window center
    mpID_ZOOM_OUT,      // !< Zoom out
    mpID_CENTER,        // !< Center view on click position
    mpID_LOCKASPECT,    // !< Lock x/y scaling aspect
};

// -----------------------------------------------------------------------------
// mpLayer
// -----------------------------------------------------------------------------

typedef enum __mp_Layer_Type
{
    mpLAYER_UNDEF,      // !< Layer type undefined
    mpLAYER_AXIS,       // !< Axis type layer
    mpLAYER_PLOT,       // !< Plot type layer
    mpLAYER_INFO,       // !< Info box type layer
    mpLAYER_BITMAP      // !< Bitmap type layer
} mpLayerType;

class mpScaleBase;

class WXDLLIMPEXP_MATHPLOT mpLayer : public wxObject
{
public:
    mpLayer();

    virtual ~mpLayer() {};

    virtual bool HasBBox() const { return true; }

    virtual bool IsInfo() const { return false; };

    virtual double GetMinX() const { return -1.0; }

    virtual double GetMaxX() const { return 1.0; }

    virtual double GetMinY() const { return -1.0; }

    virtual double GetMaxY() const { return 1.0; }

    virtual void Plot( wxDC& dc, mpWindow& w ) = 0;

    const wxString& GetName() const { return m_name; }

    const wxFont& GetFont() const { return m_font; }

    const wxPen& GetPen() const { return m_pen; }

    void SetContinuity( bool continuity ) { m_continuous = continuity; }

    bool GetContinuity() const { return m_continuous; }

    void ShowName( bool show ) { m_showName = show; };

    void SetName( wxString name ) { m_name = name; }

    void SetFont( wxFont& font )  { m_font = font; }

    void SetPen( wxPen pen )     { m_pen = pen;  }

    void SetDrawOutsideMargins( bool drawModeOutside ) { m_drawOutsideMargins = drawModeOutside; };

    bool GetDrawOutsideMargins() { return m_drawOutsideMargins; };

    wxBitmap GetColourSquare( int side = 16 ) const;

    mpLayerType GetLayerType() const { return m_type; };

    bool IsVisible() const { return m_visible; };

    void SetVisible( bool show ) { m_visible = show; };

    const wxBrush& GetBrush() const { return m_brush; };

    void SetBrush( wxBrush brush ) { m_brush = brush; };

protected:

    wxFont m_font;                  // !< Layer's font
    wxPen m_pen;                    // !< Layer's pen
    wxBrush m_brush;                // !< Layer's brush
    wxString    m_name;             // !< Layer's name
    bool    m_continuous;           // !< Specify if the layer will be plotted as a continuous line or a set of points.
    bool    m_showName;             // !< States whether the name of the layer must be shown (default is true).
    bool    m_drawOutsideMargins;   // !< select if the layer should draw only inside margins or over all DC
    mpLayerType m_type;             // !< Define layer type, which is assigned by constructor
    bool m_visible;                 // !< Toggles layer visibility
    DECLARE_DYNAMIC_CLASS( mpLayer )
};


// -----------------------------------------------------------------------------
// mpInfoLayer
// -----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpInfoLayer : public mpLayer
{
public:
    mpInfoLayer();

    mpInfoLayer( wxRect rect, const wxBrush* brush = wxTRANSPARENT_BRUSH );

    virtual ~mpInfoLayer();

    virtual void UpdateInfo( mpWindow& w, wxEvent& event );

    virtual bool HasBBox() const override { return false; }

    virtual void Plot( wxDC& dc, mpWindow& w ) override;

    virtual bool IsInfo() const override { return true; }

    virtual bool Inside( wxPoint& point );

    virtual void Move( wxPoint delta );

    virtual void UpdateReference();

    wxPoint GetPosition() const;

    wxSize GetSize() const;

    const wxRect& GetRectangle() const { return m_dim; };

protected:
    wxRect m_dim;               // !< The bounding rectangle of the box. It may be resized dynamically by the Plot method.
    wxPoint m_reference;        // !< Holds the reference point for movements
    wxBrush m_brush;            // !< The brush to be used for the background
    int m_winX, m_winY;         // !< Holds the mpWindow size. Used to rescale position when window is resized.

    DECLARE_DYNAMIC_CLASS( mpInfoLayer )
};

class WXDLLIMPEXP_MATHPLOT mpInfoCoords : public mpInfoLayer
{
public:
    mpInfoCoords();
    mpInfoCoords( wxRect rect, const wxBrush* brush = wxTRANSPARENT_BRUSH );

    ~mpInfoCoords();

    virtual void UpdateInfo( mpWindow& w, wxEvent& event ) override;

    virtual void Plot( wxDC& dc, mpWindow& w ) override;

protected:
    wxString m_content;     // !< string holding the coordinates to be drawn.
};

class WXDLLIMPEXP_MATHPLOT mpInfoLegend : public mpInfoLayer
{
public:
    mpInfoLegend();

    mpInfoLegend( wxRect rect, const wxBrush* brush = wxTRANSPARENT_BRUSH );

    ~mpInfoLegend();

    virtual void UpdateInfo( mpWindow& w, wxEvent& event ) override;

    virtual void Plot( wxDC& dc, mpWindow& w ) override;

protected:
};


// -----------------------------------------------------------------------------
// mpLayer implementations - functions
// -----------------------------------------------------------------------------

#define mpALIGNMASK             0x03

#define mpALIGN_RIGHT           0x00

#define mpALIGN_CENTER          0x01

#define mpALIGN_LEFT            0x02

#define mpALIGN_TOP             mpALIGN_RIGHT

#define mpALIGN_BOTTOM          mpALIGN_LEFT

#define mpALIGN_BORDER_BOTTOM   0x04

#define mpALIGN_BORDER_TOP      0x05

#define mpX_NORMAL              0x00

#define mpX_TIME                0x01

#define mpX_HOURS               0x02

#define mpX_DATE                0x03

#define mpX_DATETIME            0x04

#define mpALIGN_BORDER_LEFT     mpALIGN_BORDER_BOTTOM

#define mpALIGN_BORDER_RIGHT    mpALIGN_BORDER_TOP

#define mpALIGN_NE              0x00

#define mpALIGN_NW              0x01

#define mpALIGN_SW              0x02

#define mpALIGN_SE              0x03

class WXDLLIMPEXP_MATHPLOT mpFX : public mpLayer
{
public:
    mpFX( const wxString& name = wxEmptyString, int flags = mpALIGN_RIGHT );

    virtual double GetY( double x ) const = 0;

    virtual void Plot( wxDC& dc, mpWindow& w ) override;

protected:
    int m_flags;     // !< Holds label alignment

    DECLARE_DYNAMIC_CLASS( mpFX )
};

class WXDLLIMPEXP_MATHPLOT mpFY : public mpLayer
{
public:
    mpFY( const wxString& name = wxEmptyString, int flags = mpALIGN_TOP );

    virtual double GetX( double y ) const = 0;

    virtual void Plot( wxDC& dc, mpWindow& w ) override;

protected:
    int m_flags;     // !< Holds label alignment

    DECLARE_DYNAMIC_CLASS( mpFY )
};

class WXDLLIMPEXP_MATHPLOT mpFXY : public mpLayer
{
public:
    mpFXY( const wxString& name = wxEmptyString, int flags = mpALIGN_NE );

    virtual void Rewind() = 0;

    virtual bool GetNextXY( double& x, double& y ) = 0;

    virtual size_t GetCount() const = 0;

    virtual void Plot( wxDC& dc, mpWindow& w ) override;

    virtual void SetScale( mpScaleBase* scaleX, mpScaleBase* scaleY );

    void UpdateScales();

    double  s2x( double plotCoordX ) const;
    double  s2y( double plotCoordY ) const;

    double  x2s( double x ) const;
    double  y2s( double y ) const;

protected:
    int m_flags;     // !< Holds label alignment

    // Data to calculate label positioning
    wxCoord maxDrawX, minDrawX, maxDrawY, minDrawY;
    // int drawnPoints;
    mpScaleBase* m_scaleX, * m_scaleY;

    void UpdateViewBoundary( wxCoord xnew, wxCoord ynew );

    DECLARE_DYNAMIC_CLASS( mpFXY )
};

class WXDLLIMPEXP_MATHPLOT mpProfile : public mpLayer
{
public:
    mpProfile( const wxString& name = wxEmptyString, int flags = mpALIGN_TOP );

    virtual double GetY( double x ) const = 0;

    virtual void Plot( wxDC& dc, mpWindow& w ) override;

protected:
    int m_flags;     // !< Holds label alignment

    DECLARE_DYNAMIC_CLASS( mpProfile )
};

// -----------------------------------------------------------------------------
// mpLayer implementations - furniture (scales, ...)
// -----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpScaleBase : public mpLayer
{
public:
    mpScaleBase();
    virtual ~mpScaleBase() {};

    virtual bool IsHorizontal() const = 0;

    bool HasBBox() const override { return false; }

    void SetAlign( int align ) { m_flags = align; };

    void SetNameAlign( int align ) { m_nameFlags = align; }

    void SetTicks( bool enable ) { m_ticks = enable; };

    bool GetTicks() const { return m_ticks; };


    // virtual double X2p( mpWindow &w, double x ) = 0;
    // virtual double P2x( mpWindow &w, double x ) = 0;

    void SetDataRange( double minV, double maxV )
    {
        m_rangeSet = true;
        m_minV  = minV;
        m_maxV  = maxV;
    }

    void GetDataRange( double& minV, double& maxV ) const
    {
        minV = m_minV;
        maxV = m_maxV;
    }

    void ExtendDataRange( double minV, double maxV )
    {
        if( !m_rangeSet )
        {
            m_minV  = minV;
            m_maxV  = maxV;
            m_rangeSet = true;
        }
        else
        {
            m_minV  = std::min( minV, m_minV );
            m_maxV  = std::max( maxV, m_maxV );
        }

        if( m_minV == m_maxV )
        {
            m_minV = m_minV - 1.0;
            m_maxV = m_maxV + 1.0;
        }
    }

    void ResetDataRange()
    {
        m_rangeSet = 0;
    }

    double AbsMaxValue() const
    {
        return std::max( std::abs( m_maxV ), std::abs( m_minV ) );
    }

    double AbsVisibleMaxValue() const
    {
        return m_absVisibleMaxV;
    }

    virtual double TransformToPlot( double x ) const { return 0.0; };
    virtual double TransformFromPlot( double xplot ) const { return 0.0; };

    struct TickLabel
    {
        TickLabel( double pos_ = 0.0, const wxString& label_ = wxT("") ) :
            pos( pos_ ), label( label_ ), pixelPos( 0 ), visible( true )
        {}

        double pos;
        wxString label;
        int pixelPos;
        bool visible;
    };

    std::vector<TickLabel>& TickLabels() { return m_tickLabels; };

protected:

    void    updateTickLabels( wxDC& dc, mpWindow& w );
    void    computeLabelExtents( wxDC& dc, mpWindow& w );

    // virtual int getLabelDecimalDigits(int maxDigits) const;
    virtual void getVisibleDataRange( mpWindow& w, double& minV, double& maxV ) {};
    virtual void recalculateTicks( wxDC& dc, mpWindow& w ) {};

    int tickCount() const
    {
        return m_tickValues.size();
    }

    virtual int labelCount() const
    {
        return m_tickLabels.size();
    }

    virtual const wxString formatLabel( double value, int nDigits ) { return wxT( "" ); }
    virtual void formatLabels() {};

    virtual double getTickPos( int n ) const
    {
        return m_tickValues[n];
    }

    virtual double getLabelPos( int n ) const
    {
        return m_tickLabels[n].pos;
    }

    virtual wxString getLabel( int n ) const
    {
        return m_tickLabels[n].label;
    }

    std::vector<double> m_tickValues;
    std::vector<TickLabel> m_tickLabels;

    double m_offset, m_scale;
    double m_absVisibleMaxV;
    int m_flags;        // !< Flag for axis alignment
    int m_nameFlags;
    bool m_ticks;       // !< Flag to toggle between ticks or grid
    double m_minV, m_maxV;
    bool    m_rangeSet;
    int m_maxLabelHeight;
    int m_maxLabelWidth;
};

class WXDLLIMPEXP_MATHPLOT mpScaleXBase : public mpScaleBase
{
public:
    mpScaleXBase( const wxString& name = wxT("X"), int flags = mpALIGN_CENTER,
                  bool ticks = true, unsigned int type = mpX_NORMAL );
    virtual ~mpScaleXBase() {};

    virtual bool IsHorizontal() const override { return true; }
    virtual void Plot( wxDC& dc, mpWindow& w ) override;

    virtual void getVisibleDataRange( mpWindow& w, double& minV, double& maxV ) override;

    // unsigned int m_labelType; //!< Select labels mode: mpX_NORMAL for normal labels, mpX_TIME for time axis in hours, minutes, seconds
    // wxString m_labelFormat; //!< Format string used to print labels

    DECLARE_DYNAMIC_CLASS( mpScaleXBase )
};


class WXDLLIMPEXP_MATHPLOT mpScaleX : public mpScaleXBase
{
public:
    mpScaleX( const wxString& name = wxT("X"), int flags = mpALIGN_CENTER,
              bool ticks = true, unsigned int type = mpX_NORMAL );

    // virtual void Plot(wxDC & dc, mpWindow & w);

    // virtual double X2p( mpWindow &w, double x );
    // virtual double P2x( mpWindow &w, double x );
    virtual double TransformToPlot( double x ) const override;
    virtual double TransformFromPlot( double xplot ) const override;

protected:
    virtual void recalculateTicks( wxDC& dc, mpWindow& w ) override;


    DECLARE_DYNAMIC_CLASS( mpScaleX )
};


class WXDLLIMPEXP_MATHPLOT mpScaleXLog : public mpScaleXBase
{
public:
    mpScaleXLog( const wxString& name = wxT("log(X)"), int flags = mpALIGN_CENTER,
                 bool ticks = true, unsigned int type = mpX_NORMAL );

    virtual double TransformToPlot( double x ) const override;
    virtual double TransformFromPlot( double xplot ) const override;

    // virtual double X2p( mpWindow &w, double x );
    // virtual double P2x( mpWindow &w, double x );

protected:
    void recalculateTicks( wxDC& dc, mpWindow& w ) override;

    // int tickCount() const;
    // int labelCount() const;
    // const wxString getLabel( int n );
    // double getTickPos( int n );
    // double getLabelPos( int n );

    void computeLabelExtents( wxDC& dc, mpWindow& w );


    DECLARE_DYNAMIC_CLASS( mpScaleXLog )
};


class WXDLLIMPEXP_MATHPLOT mpScaleY : public mpScaleBase
{
public:
    mpScaleY( const wxString& name = wxT( "Y" ), int flags = mpALIGN_CENTER, bool ticks = true );

    virtual bool IsHorizontal() const override { return false; }

    virtual void Plot( wxDC& dc, mpWindow& w ) override;

    virtual bool HasBBox() const override { return false; }

    void SetAlign( int align ) { m_flags = align; };

    void SetTicks( bool ticks ) { m_ticks = ticks; };

    bool GetTicks() const { return m_ticks; };

    virtual double  TransformToPlot( double x ) const override;
    virtual double  TransformFromPlot( double xplot ) const override;


    void SetMasterScale( mpScaleY* masterScale )
    {
        m_masterScale = masterScale;
    }

protected:
    virtual void    getVisibleDataRange( mpWindow& w, double& minV, double& maxV ) override;
    virtual void    recalculateTicks( wxDC& dc, mpWindow& w ) override;

    // virtual int tickCount() const;
    // virtual int labelCount() const;
    // virtual const wxString getLabel( int n );
    // virtual double getTickPos( int n );
    // virtual double getLabelPos( int n );
    void    computeLabelExtents( wxDC& dc, mpWindow& w );
    void    computeSlaveTicks( mpWindow& w );

    mpScaleY* m_masterScale;

    // double m_minV, m_maxV;

    int m_flags;        // !< Flag for axis alignment
    bool m_ticks;       // !< Flag to toggle between ticks or grid
    // wxString m_labelFormat; //!< Format string used to print labels

    DECLARE_DYNAMIC_CLASS( mpScaleY )
};

// -----------------------------------------------------------------------------
// mpWindow
// -----------------------------------------------------------------------------

#define mpMOUSEMODE_DRAG    0

#define mpMOUSEMODE_ZOOMBOX 1

// WX_DECLARE_HASH_MAP( int, mpLayer*, wxIntegerHash, wxIntegerEqual, wxLayerList );
typedef std::deque<mpLayer*> wxLayerList;

class WXDLLIMPEXP_MATHPLOT mpWindow : public wxWindow
{
public:
    mpWindow();
    mpWindow( wxWindow* parent, wxWindowID id,
              const wxPoint& pos = wxDefaultPosition,
              const wxSize& size = wxDefaultSize,
              long flags = 0 );
    ~mpWindow();

    wxMenu* GetPopupMenu() { return &m_popmenu; }

    bool AddLayer( mpLayer* layer, bool refreshDisplay = true );

    bool DelLayer( mpLayer* layer, bool alsoDeleteObject = false, bool refreshDisplay = true );

    void DelAllLayers( bool alsoDeleteObject, bool refreshDisplay = true );


    mpLayer* GetLayer( int position ) const;

    const mpLayer* GetLayerByName( const wxString& name ) const;
    mpLayer* GetLayerByName( const wxString& name )
    {
        return const_cast<mpLayer*>( static_cast<const mpWindow*>( this )->GetLayerByName( name ) );
    }

    double GetXscl() const { return m_scaleX; }
    double GetScaleX( void ) const { return m_scaleX; };  // Schaling's method: maybe another method exists with the same name

    double GetYscl() const { return m_scaleY; }
    double GetScaleY( void ) const { return m_scaleY; }   // Schaling's method: maybe another method exists with the same name

    double GetXpos() const { return m_posX; }
    double GetPosX( void ) const { return m_posX; }

    double GetYpos() const { return m_posY; }
    double GetPosY( void ) const { return m_posY; }

    int GetScrX( void ) const { return m_scrX; }
    int GetXScreen( void ) const { return m_scrX; }

    int GetScrY( void ) const { return m_scrY; }
    int GetYScreen( void ) const { return m_scrY; }

    void SetScaleX( double scaleX );

    void SetScaleY( double scaleY )
    {
        if( scaleY != 0 )
            m_scaleY = scaleY;

        UpdateAll();
    }

    void SetPosX( double posX ) { m_posX = posX; UpdateAll(); }

    void SetPosY( double posY ) { m_posY = posY; UpdateAll(); }

    void SetPos( double posX, double posY ) { m_posX = posX; m_posY = posY; UpdateAll(); }

    void SetScr( int scrX, int scrY ) { m_scrX = scrX; m_scrY = scrY; }

    // double p2x(wxCoord pixelCoordX, bool drawOutside = true ); // { return m_posX + pixelCoordX/m_scaleX; }
    inline double p2x( wxCoord pixelCoordX ) { return m_posX + pixelCoordX / m_scaleX; }

    // double p2y(wxCoord pixelCoordY, bool drawOutside = true ); //{ return m_posY - pixelCoordY/m_scaleY; }
    inline double p2y( wxCoord pixelCoordY ) { return m_posY - pixelCoordY / m_scaleY; }

    // wxCoord x2p(double x, bool drawOutside = true); // { return (wxCoord) ( (x-m_posX) * m_scaleX); }
    inline wxCoord x2p( double x ) { return (wxCoord) ( (x - m_posX) * m_scaleX ); }

    // wxCoord y2p(double y, bool drawOutside = true); // { return (wxCoord) ( (m_posY-y) * m_scaleY); }
    inline wxCoord y2p( double y ) { return (wxCoord) ( (m_posY - y) * m_scaleY ); }


    void EnableDoubleBuffer( bool enabled ) { m_enableDoubleBuffer = enabled; }

    void EnableMousePanZoom( bool enabled ) { m_enableMouseNavigation = enabled; }

    void EnableMouseWheelPan( bool enabled ) { m_enableMouseWheelPan = enabled; }

    void LockAspect( bool enable = true );

    inline bool IsAspectLocked() const { return m_lockaspect; }

    void Fit() override;

    void Fit( double xMin, double xMax, double yMin, double yMax,
              wxCoord* printSizeX = NULL, wxCoord* printSizeY = NULL );

    void ZoomIn( const wxPoint& centerPoint = wxDefaultPosition );
    void ZoomIn( const wxPoint& centerPoint, double zoomFactor );

    void ZoomOut( const wxPoint& centerPoint = wxDefaultPosition );
    void ZoomOut( const wxPoint& centerPoint, double zoomFactor );

    void ZoomInX();

    void ZoomOutX();

    void ZoomInY();

    void ZoomOutY();

    void ZoomRect( wxPoint p0, wxPoint p1 );

    void UpdateAll();

    // Added methods by Davide Rondini

    unsigned int CountLayers() const;

    unsigned int CountAllLayers() const { return m_layers.size(); };

#if 0

    void PrintGraph(mpPrintout *print);
#endif

    double GetDesiredXmin() const { return m_desiredXmin; }

    double GetDesiredXmax() const { return m_desiredXmax; }

    double GetDesiredYmin() const { return m_desiredYmin; }

    double GetDesiredYmax() const { return m_desiredYmax; }

    void GetBoundingBox( double* bbox ) const;

    void SetMPScrollbars( bool status );

    bool GetMPScrollbars() const { return m_enableScrollBars; };

    bool SaveScreenshot( const wxString& filename, wxBitmapType type = wxBITMAP_TYPE_BMP,
                         wxSize imageSize = wxDefaultSize, bool fit = false );

    static double zoomIncrementalFactor;

    void SetMargins( int top, int right, int bottom, int left );

    void SetMarginTop( int top ) { m_marginTop = top; };
    void SetMarginRight( int right ) { m_marginRight = right; };
    void SetMarginBottom( int bottom ) { m_marginBottom = bottom; };
    void SetMarginLeft( int left ) { m_marginLeft = left; };

    int GetMarginTop() const { return m_marginTop; };
    int GetMarginRight() const { return m_marginRight; };
    int GetMarginBottom() const { return m_marginBottom; };
    int GetMarginLeft() const { return m_marginLeft; };

#if 0

    // void EnableCoordTooltip(bool value = true);

    // bool GetCoordTooltip() { return m_coordTooltip; };
#endif

    mpInfoLayer* IsInsideInfoLayer( wxPoint& point );

    void SetLayerVisible( const wxString& name, bool viewable );

    bool IsLayerVisible( const wxString& name ) const;

    void SetLayerVisible( const unsigned int position, bool viewable );

    bool IsLayerVisible( unsigned int position ) const;

    void SetColourTheme( const wxColour& bgColour,
                         const wxColour& drawColour,
                         const wxColour& axesColour );

    const wxColour& GetAxesColour() { return m_axColour; };

    void LimitView( bool aEnable )
    {
        m_enableLimitedView = aEnable;
    }

protected:
    void    OnPaint( wxPaintEvent& event );             // !< Paint handler, will plot all attached layers
    void    OnSize( wxSizeEvent& event );               // !< Size handler, will update scroll bar sizes

    // void OnScroll2       (wxScrollWinEvent &event); //!< Scroll handler, will move canvas
    void    OnShowPopupMenu( wxMouseEvent& event );     // !< Mouse handler, will show context menu
    void    OnMouseMiddleDown( wxMouseEvent& event );   // !< Mouse handler, for detecting when the user

    // !< drags with the middle button or just "clicks" for the menu
    void    OnCenter( wxCommandEvent& event );              // !< Context menu handler
    void    OnFit( wxCommandEvent& event );                 // !< Context menu handler
    void    OnZoomIn( wxCommandEvent& event );              // !< Context menu handler
    void    OnZoomOut( wxCommandEvent& event );             // !< Context menu handler
    void    OnLockAspect( wxCommandEvent& event );          // !< Context menu handler
    void    OnMouseWheel( wxMouseEvent& event );            // !< Mouse handler for the wheel
    void    OnMagnify( wxMouseEvent& event );               // !< Pinch zoom handler
    void    OnMouseMove( wxMouseEvent& event );             // !< Mouse handler for mouse motion (for pan)
    void    OnMouseLeftDown( wxMouseEvent& event );         // !< Mouse left click (for rect zoom)
    void    OnMouseLeftRelease( wxMouseEvent& event );      // !< Mouse left click (for rect zoom)
    void    OnScrollThumbTrack( wxScrollWinEvent& event );  // !< Scroll thumb on scroll bar moving
    void    OnScrollPageUp( wxScrollWinEvent& event );      // !< Scroll page up
    void    OnScrollPageDown( wxScrollWinEvent& event );    // !< Scroll page down
    void    OnScrollLineUp( wxScrollWinEvent& event );      // !< Scroll line up
    void    OnScrollLineDown( wxScrollWinEvent& event );    // !< Scroll line down
    void    OnScrollTop( wxScrollWinEvent& event );         // !< Scroll to top
    void    OnScrollBottom( wxScrollWinEvent& event );      // !< Scroll to bottom

    void DoScrollCalc( const int position, const int orientation );

    void    DoZoomInXCalc( const int staticXpixel );
    void    DoZoomInYCalc( const int staticYpixel );
    void    DoZoomOutXCalc( const int staticXpixel );
    void    DoZoomOutYCalc( const int staticYpixel );

    bool CheckXLimits( double& desiredMax, double& desiredMin ) const
    {
        return !( m_enableLimitedView
                  && (desiredMax > m_maxX - m_marginRight / m_scaleX
                      || desiredMin < m_minX - m_marginLeft / m_scaleX) );
    }

    bool CheckYLimits( double& desiredMax, double& desiredMin ) const
    {
        return !( m_enableLimitedView
                  && (desiredMax > m_maxY + m_marginBottom / m_scaleY
                      || desiredMin < m_minY + m_marginTop / m_scaleY) );
    }

    void AdjustLimitedView();

    virtual bool UpdateBBox();

    virtual bool SetXView( double pos, double desiredMax, double desiredMin );

    virtual bool SetYView( double pos, double desiredMax, double desiredMin );

    // wxList m_layers;    //!< List of attached plot layers
    wxLayerList m_layers;   // !< List of attached plot layers
    wxMenu m_popmenu;       // !< Canvas' context menu
    bool m_lockaspect;      // !< Scale aspect is locked or not
    // bool   m_coordTooltip; //!< Selects whether to show coordinate tooltip
    wxColour m_bgColour;    // !< Background Colour
    wxColour m_fgColour;    // !< Foreground Colour
    wxColour m_axColour;    // !< Axes Colour

    double m_minX;          // !< Global layer bounding box, left border incl.
    double m_maxX;          // !< Global layer bounding box, right border incl.
    double m_minY;          // !< Global layer bounding box, bottom border incl.
    double m_maxY;          // !< Global layer bounding box, top border incl.
    double m_scaleX;        // !< Current view's X scale
    double m_scaleY;        // !< Current view's Y scale
    double m_posX;          // !< Current view's X position
    double m_posY;          // !< Current view's Y position
    int m_scrX;             // !< Current view's X dimension
    int m_scrY;             // !< Current view's Y dimension
    int m_clickedX;         // !< Last mouse click X position, for centering and zooming the view
    int m_clickedY;         // !< Last mouse click Y position, for centering and zooming the view

    double m_desiredXmin, m_desiredXmax, m_desiredYmin, m_desiredYmax;

    int m_marginTop, m_marginRight, m_marginBottom, m_marginLeft;

    int m_last_lx, m_last_ly;               // !< For double buffering
    wxMemoryDC m_buff_dc;                   // !< For double buffering
    wxBitmap*   m_buff_bmp;                 // !< For double buffering
    bool    m_enableDoubleBuffer;           // !< For double buffering
    bool    m_enableMouseNavigation;        // !< For pan/zoom with the mouse.
    bool    m_enableMouseWheelPan;          // !< Trackpad pan/zoom
    bool    m_enableLimitedView;
    wxPoint m_mouseMClick;                  // !< For the middle button "drag" feature
    wxPoint m_mouseLClick;                  // !< Starting coords for rectangular zoom selection
    bool    m_enableScrollBars;
    wxPoint m_scroll;
    mpInfoLayer* m_movingInfoLayer;          // !< For moving info layers over the window area
    bool m_zooming;
    wxRect m_zoomRect;
    DECLARE_DYNAMIC_CLASS( mpWindow )
    DECLARE_EVENT_TABLE()
};

// -----------------------------------------------------------------------------
// mpFXYVector - provided by Jose Luis Blanco
// -----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpFXYVector : public mpFXY
{
public:
    mpFXYVector( const wxString& name = wxEmptyString, int flags = mpALIGN_NE );

    virtual ~mpFXYVector() {}

    virtual void SetData( const std::vector<double>& xs, const std::vector<double>& ys );

    void Clear();

protected:
    std::vector<double> m_xs, m_ys;

    size_t m_index;

    double m_minX, m_maxX, m_minY, m_maxY;

    void Rewind() override;

    bool GetNextXY( double& x, double& y ) override;

    size_t GetCount() const override;

public:
    double GetMinX() const override { return m_minX; }

    double GetMinY() const override { return m_minY; }

    double GetMaxX() const override { return m_maxX; }

    double GetMaxY() const override { return m_maxY; }

protected:

    DECLARE_DYNAMIC_CLASS( mpFXYVector )
};


#if 0

class WXDLLIMPEXP_MATHPLOT mpFSemiLogXVector : public mpFXYVector
{
public:
    mpFSemiLogXVector( wxString name = wxEmptyString, int flags = mpALIGN_NE );

    virtual ~mpFSemiLogXVector() {}

    DECLARE_DYNAMIC_CLASS( mpFSemiLogXVector )
};
#endif

// -----------------------------------------------------------------------------
// mpText - provided by Val Greene
// -----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpText : public mpLayer
{
public:
    mpText( const wxString& name = wxT("Title"), int offsetx = 5, int offsety = 50 );

    virtual void Plot( wxDC& dc, mpWindow& w ) override;

    virtual bool HasBBox() const override { return false; }

protected:
    int m_offsetx;      // !< Holds offset for X in percentage
    int m_offsety;      // !< Holds offset for Y in percentage

    DECLARE_DYNAMIC_CLASS( mpText )
};


// -----------------------------------------------------------------------------
// mpPrintout - provided by Davide Rondini
// -----------------------------------------------------------------------------

class WXDLLIMPEXP_MATHPLOT mpPrintout : public wxPrintout
{
public:
    mpPrintout( mpWindow* drawWindow, const wxChar* title = _T("wxMathPlot print output") );
    virtual ~mpPrintout() {};

    void SetDrawState( bool drawState ) { drawn = drawState; };
    bool    OnPrintPage( int page ) override;
    bool    HasPage( int page ) override;

private:
    bool drawn;
    mpWindow* plotWindow;
};


// -----------------------------------------------------------------------------
// mpMovableObject  - provided by Jose Luis Blanco
// -----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpMovableObject : public mpLayer
{
public:
    mpMovableObject() :
        m_flags( 0 ),
        m_reference_x( 0 ),
        m_reference_y( 0 ),
        m_reference_phi( 0 ),
        m_shape_xs( 0 ),
        m_shape_ys( 0 ),
        m_bbox_min_x( 0 ),
        m_bbox_max_x( 0 ),
        m_bbox_min_y( 0 ),
        m_bbox_max_y( 0 )
    {
        m_type = mpLAYER_PLOT;
    }

    virtual ~mpMovableObject() {};

    void GetCoordinateBase( double& x, double& y, double& phi ) const
    {
        x = m_reference_x;
        y = m_reference_y;
        phi = m_reference_phi;
    }

    void SetCoordinateBase( double x, double y, double phi = 0 )
    {
        m_reference_x = x;
        m_reference_y = y;
        m_reference_phi = phi;
        m_flags = mpALIGN_NE;
        ShapeUpdated();
    }

    virtual bool HasBBox() const override { return m_trans_shape_xs.size()!=0; }

    virtual double GetMinX() const override { return m_bbox_min_x; }

    virtual double GetMaxX() const override { return m_bbox_max_x; }

    virtual double GetMinY() const override { return m_bbox_min_y; }

    virtual double GetMaxY() const override { return m_bbox_max_y; }

    virtual void Plot( wxDC& dc, mpWindow& w ) override;

    void SetAlign( int align ) { m_flags = align; };

protected:
    int m_flags;     // !< Holds label alignment

    double m_reference_x, m_reference_y, m_reference_phi;

    void TranslatePoint( double x, double y, double& out_x, double& out_y );

    std::vector<double> m_shape_xs, m_shape_ys;

    std::vector<double> m_trans_shape_xs, m_trans_shape_ys;

    double m_bbox_min_x, m_bbox_max_x, m_bbox_min_y, m_bbox_max_y;

    void ShapeUpdated();
};

// -----------------------------------------------------------------------------
// mpCovarianceEllipse  - provided by Jose Luis Blanco
// -----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpCovarianceEllipse : public mpMovableObject
{
public:
    mpCovarianceEllipse( double cov_00 = 1,
            double cov_11 = 1,
            double cov_01 = 0,
            double quantiles = 2,
            int segments = 32,
            const wxString& layerName = wxT("") ) :
        m_cov_00( cov_00 ),
        m_cov_11( cov_11 ),
        m_cov_01( cov_01 ),
        m_quantiles( quantiles ),
        m_segments( segments )
    {
        m_continuous = true;
        m_name = layerName;
        RecalculateShape();
        m_type = mpLAYER_PLOT;
    }

    virtual ~mpCovarianceEllipse() {}

    double GetQuantiles() const { return m_quantiles; }

    void SetQuantiles( double q )
    {
        m_quantiles = q;
        RecalculateShape();
    }

    void SetSegments( int segments ) { m_segments = segments; }
    int GetSegments() const { return m_segments; }

    void GetCovarianceMatrix( double& cov_00, double& cov_01, double& cov_11 ) const
    {
        cov_00  = m_cov_00;
        cov_01  = m_cov_01;
        cov_11  = m_cov_11;
    }

    void SetCovarianceMatrix( double cov_00, double cov_01, double cov_11 )
    {
        m_cov_00 = cov_00;
        m_cov_01 = cov_01;
        m_cov_11 = cov_11;
        RecalculateShape();
    }

protected:
    double m_cov_00, m_cov_11, m_cov_01;
    double m_quantiles;

    int m_segments;

    void RecalculateShape();
};

// -----------------------------------------------------------------------------
// mpPolygon - provided by Jose Luis Blanco
// -----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpPolygon : public mpMovableObject
{
public:
    mpPolygon( const wxString& layerName = wxT("") )
    {
        m_continuous = true;
        m_name = layerName;
    }

    virtual ~mpPolygon() {}

    void setPoints( const std::vector<double>& points_xs,
            const std::vector<double>& points_ys,
            bool closedShape = true );
};

// -----------------------------------------------------------------------------
// mpMovableObject  - provided by Jose Luis Blanco
// -----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpBitmapLayer : public mpLayer
{
public:
    mpBitmapLayer()
    {
        m_min_x = m_max_x =
                      m_min_y = m_max_y = 0;
        m_scaledBitmap_offset_x = 0;
        m_scaledBitmap_offset_y = 0;
        m_validImg = false;
        m_type = mpLAYER_BITMAP;
    }

    virtual ~mpBitmapLayer() {};

    void GetBitmapCopy( wxImage& outBmp ) const;

    void SetBitmap( const wxImage& inBmp, double x, double y, double lx, double ly );

    virtual bool HasBBox() const override { return true; }

    virtual double GetMinX() const override { return m_min_x; }

    virtual double GetMaxX() const override { return m_max_x; }

    virtual double GetMinY() const override { return m_min_y; }

    virtual double GetMaxY() const override { return m_max_y; }

    virtual void Plot( wxDC& dc, mpWindow& w ) override;

    void SetAlign( int align ) { m_flags = align; };

protected:
    int m_flags;     // !< Holds label alignment

    wxImage m_bitmap;
    wxBitmap m_scaledBitmap;
    wxCoord m_scaledBitmap_offset_x, m_scaledBitmap_offset_y;

    bool m_validImg;

    double m_min_x, m_max_x, m_min_y, m_max_y;
};

#endif    // _MP_MATHPLOT_H_