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
// Copyright        (c) 2021-2024 KiCad Developers, see AUTHORS.txt for contributors.
// 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 <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 <vector>
#include <deque>
#include <stack>
#include <array>
#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 mpPrintout;
 
enum
{
    mpID_FIT = 2000,    // !< Fit view to match bounding box of all layers
    mpID_ZOOM_UNDO,
    mpID_ZOOM_REDO,
    mpID_ZOOM_IN,       // !< Zoom into view at clickposition / window center
    mpID_ZOOM_OUT,      // !< Zoom out
    mpID_CENTER,        // !< Center view on click position
};
 
// -----------------------------------------------------------------------------
// 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 wxString& GetDisplayName() const
    {
        return m_displayName.IsEmpty() ? m_name : m_displayName;
    }
 
    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; };
 
    virtual void SetName( const wxString& name ) { m_name = name; }
 
    void SetFont( const wxFont& font )  { m_font = font; }
 
    void SetPen( const wxPen& pen )     { m_pen = pen;  }
 
    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( const 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
    wxString    m_displayName;
    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).
    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 bool HasBBox() const override { return false; }
 
    virtual void Plot( wxDC& dc, mpWindow& w ) override;
 
    virtual bool IsInfo() const override { return true; }
 
    virtual bool Inside( const wxPoint& point ) const;
 
    virtual void Move( wxPoint delta );
 
    virtual void UpdateReference();
 
    wxPoint GetPosition() const;
 
    wxSize GetSize() const;
 
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;         // !< Holds the mpWindow size. Used to rescale position when window is
    int     m_winY;         //    resized.
 
    DECLARE_DYNAMIC_CLASS( mpInfoLayer )
};
 
class WXDLLIMPEXP_MATHPLOT mpInfoLegend : public mpInfoLayer
{
public:
    mpInfoLegend();
 
    mpInfoLegend( wxRect rect, const wxBrush* brush = wxTRANSPARENT_BRUSH );
 
    ~mpInfoLegend();
 
    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 mpALIGN_FAR_RIGHT       0x06
#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 void SetSweepWindow( int aSweepIdx ) { Rewind(); }
 
    virtual bool GetNextXY( double& x, double& y ) = 0;
 
    virtual size_t GetCount() const = 0;
    virtual int GetSweepCount() const { return 1; }
 
    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 )
};
 
// -----------------------------------------------------------------------------
// 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; };
 
    void GetDataRange( double& minV, double& maxV ) const
    {
        minV = m_minV;
        maxV = m_maxV;
    }
 
    virtual 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;
        }
    }
 
    virtual void ResetDataRange()
    {
        m_rangeSet = false;
    }
 
    double AbsMaxValue() const
    {
        return std::max( std::abs( m_maxV ), std::abs( m_minV ) );
    }
 
    double AbsVisibleMaxValue() const
    {
        return m_absVisibleMaxV;
    }
 
    void SetAxisMinMax( bool lock, double minV, double maxV )
    {
        m_axisLocked = lock;
        m_axisMin = minV;
        m_axisMax = maxV;
    }
 
    bool GetAxisMinMax( double* minV, double* maxV )
    {
        if( m_axisLocked )
        {
            *minV = m_axisMin;
            *maxV = m_axisMax;
        }
        else if( !m_tickValues.empty() )
        {
            *minV = m_tickValues.front();
            *maxV = m_tickValues.back();
        }
 
        return m_axisLocked;
    }
 
    virtual double TransformToPlot( double x ) const { return 0.0; };
    virtual double TransformFromPlot( double xplot ) const { return 0.0; };
 
    struct TICK_LABEL
    {
        TICK_LABEL( double pos_ = 0.0, const wxString& label_ = wxT( "" ) ) :
                pos( pos_ ),
                label( label_ ),
                visible( true )
        {}
 
        double   pos;
        wxString label;
        bool     visible;
    };
 
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 ) {};
 
    virtual void formatLabels() {};
 
protected:
    std::vector<double>     m_tickValues;
    std::vector<TICK_LABEL> 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;
    bool                    m_axisLocked;
    double                  m_axisMin;
    double                  m_axisMax;
    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;
 
    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 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;
 
protected:
    void recalculateTicks( wxDC& dc, mpWindow& w ) override;
 
    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; }
 
    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;
 
    void    computeSlaveTicks( mpWindow& w );
 
    mpScaleY* m_masterScale;
    int       m_flags;        // !< Flag for axis alignment
    bool      m_ticks;       // !< Flag to toggle between ticks or grid
 
    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:
    enum class MouseWheelAction
    {
        NONE,
        PAN_LEFT_RIGHT,
        PAN_RIGHT_LEFT,
        PAN_UP_DOWN,
        ZOOM,
        ZOOM_HORIZONTALLY,
        ZOOM_VERTICALLY,
        COUNT // Internal use only
    };
 
    struct MouseWheelActionSet
    {
        /* If this bundled wxMathPlot implementation is to remain single-header and not dependent
         * on any part of KiCad, then the SIM_MOUSE_WHEEL_ACTION_SET struct must be duplicated
         * here. SIM_PLOT_TAB::convertMouseWheelActions is used to convert from
         * SIM_MOUSE_WHEEL_ACTION_SET to mpWindow::MouseWheelActionSet. */
 
        MouseWheelAction verticalUnmodified;
        MouseWheelAction verticalWithCtrl;
        MouseWheelAction verticalWithShift;
        MouseWheelAction verticalWithAlt;
        MouseWheelAction horizontal;
    };
 
    mpWindow();
    mpWindow( wxWindow* parent, wxWindowID id );
    ~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 GetScaleX() const { return m_scaleX; };
 
    double GetScaleY() const { return m_scaleY; }
 
    double GetPosX() const { return m_posX; }
 
    double GetPosY() const { return m_posY; }
 
    int GetScrX() const { return m_scrX; }
    int GetXScreen() const { return m_scrX; }
 
    int GetScrY() const { return m_scrY; }
    int GetYScreen() 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; }
 
    inline double p2x( wxCoord pixelCoordX ) { return m_posX + pixelCoordX / m_scaleX; }
 
    inline double p2y( wxCoord pixelCoordY ) { return m_posY - pixelCoordY / m_scaleY; }
 
    inline wxCoord x2p( double x ) { return (wxCoord) ( (x - m_posX) * m_scaleX ); }
 
    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 SetMouseWheelActions( const MouseWheelActionSet& s ) { m_mouseWheelActions = s; }
 
    void Fit() override;
 
    void Fit( double xMin, double xMax, double yMin, double yMax,
              const wxCoord* printSizeX = nullptr, const wxCoord* printSizeY = nullptr,
              wxOrientation directions = wxBOTH );
 
    void ZoomIn( const wxPoint& centerPoint = wxDefaultPosition );
    void ZoomIn( const wxPoint& centerPoint, double zoomFactor, wxOrientation directions = wxBOTH );
 
    void ZoomOut( const wxPoint& centerPoint = wxDefaultPosition );
    void ZoomOut( const wxPoint& centerPoint, double zoomFactor,
                  wxOrientation directions = wxBOTH );
 
    void ZoomRect( wxPoint p0, wxPoint p1 );
 
    void UpdateAll();
 
    // Added methods by Davide Rondini
 
    unsigned int CountAllLayers() const { return m_layers.size(); };
 
    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;
 
    bool SaveScreenshot( wxImage& aImage,
                         wxSize aImageSize = wxDefaultSize, bool aFit = 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; };
 
    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;
    }
 
    void LockY( bool aLock ) { m_yLocked = aLock; }
    bool GetYLocked() const { return m_yLocked; }
 
    void ZoomUndo();
    void ZoomRedo();
    int UndoZoomStackSize() const { return m_undoZoomStack.size(); }
    int RedoZoomStackSize() const { return m_redoZoomStack.size(); }
 
    void AdjustLimitedView( wxOrientation directions = wxBOTH );
 
    void OnFit( wxCommandEvent& event );
    void OnCenter( wxCommandEvent& event );
 
protected:
    static MouseWheelActionSet defaultMouseWheelActions();
 
    void pushZoomUndo( const std::array<double, 4>& aZoom );
 
    void OnPaint( wxPaintEvent& event );             // !< Paint handler, will plot all attached layers
    void OnSize( wxSizeEvent& event );               // !< Size handler, will update scroll bar sizes
 
    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 onZoomIn( wxCommandEvent& event );          // !< Context menu handler
    void onZoomOut( wxCommandEvent& event );         // !< Context menu handler
    void onZoomUndo( wxCommandEvent& event );        // !< Context menu handler
    void onZoomRedo( 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 DoZoom( const wxPoint& centerPoint, double zoomFactor, wxOrientation directions );
    void RecomputeDesiredX( double& min, double& max );
    void RecomputeDesiredY( double& min, double& max );
    wxOrientation ViewNeedsRefitting( wxOrientation directions ) const;
 
    void PerformMouseWheelAction( wxMouseEvent& event, MouseWheelAction action );
 
    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
    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
 
    bool m_yLocked;
 
    double m_desiredXmin, m_desiredXmax, m_desiredYmin, m_desiredYmax;
 
    // These are gaps between the curve extrema and the edges of the plot area, expressed as
    // a factor of global layer bounding box width/height.
    double m_topBottomPlotGapFactor;
    double m_leftRightPlotGapFactor;
 
    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_enableLimitedView;
    MouseWheelActionSet m_mouseWheelActions;
    wxPoint m_mouseMClick;                  // !< For the middle button "drag" feature
    wxPoint m_mouseLClick;                  // !< Starting coords for rectangular zoom selection
    mpInfoLayer* m_movingInfoLayer;         // !< For moving info layers over the window area
    bool m_zooming;
    wxRect m_zoomRect;
    std::stack<std::array<double, 4>> m_undoZoomStack;
    std::stack<std::array<double, 4>> m_redoZoomStack;
 
    DECLARE_DYNAMIC_CLASS( mpWindow )
    DECLARE_EVENT_TABLE()
 
private:
    struct DelegatingContructorTag {};
 
    template <typename... Ts>
    mpWindow( DelegatingContructorTag, Ts&&... windowArgs );
 
    void initializeGraphicsContext();
};
 
// -----------------------------------------------------------------------------
// 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 SetSweepCount( int aSweepCount ) { m_sweepCount = aSweepCount; }
    void SetSweepSize( size_t aSweepSize ) { m_sweepSize = aSweepSize; }
 
    void Clear();
 
protected:
    std::vector<double> m_xs, m_ys;
 
    size_t m_index;           // internal counter for the "GetNextXY" interface
    size_t m_sweepWindow;     // last m_index of the current sweep
 
    double m_minX, m_maxX, m_minY, m_maxY;
    int    m_sweepCount = 1;                                   // sweeps to split data into
    size_t m_sweepSize = std::numeric_limits<size_t>::max();   // data-points in each sweep
 
    void Rewind() override;
    void SetSweepWindow( int aSweepIdx ) override;
 
    bool GetNextXY( double& x, double& y ) override;
 
    size_t GetCount() const override { return m_xs.size(); }
    int GetSweepCount() const override { return m_sweepCount; }
 
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 )
};
 
 
#endif    // _MP_MATHPLOT_H_