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_