mathplot.h

Go to the documentation of this file.

 
// Name:            mathplot.h
// Purpose:         Framework for plotting in wxWindows
// Original Author: David Schalig
// Maintainer:      Davide Rondini
// Contributors:    Jose Luis Blanco, Val Greene, Lionel Reynaud, Dave Nadler, MortenMacFly,
//                  Oskar Waldemarsson (for multi Y axis and corrections)
// Created:         21/07/2003
// Last edit:       11/07/2026
// Copyright:       (c) David Schalig, Davide Rondini
// Licence:         wxWindows licence
 
#ifndef MATHPLOT_H_INCLUDED
#define MATHPLOT_H_INCLUDED
 
// mathplot_EXPORTS definition uses windows dll to export function.
// 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
 
#if defined(__GNUG__) && !defined(__APPLE__) && !defined(__INTEL_CLANG_COMPILER)
  #pragma interface "mathplot.h"
#endif
 
#include <cassert>  // For assert debug message (assert is disabled if NDEBUG is defined)
#include <vector>
#include <map>
#include <unordered_map>
 
#include <optional>
typedef std::optional<unsigned int> mpOptional_uint;
typedef std::optional<int> mpOptional_int;
 
// #include <wx/wx.h>
#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 <wx/intl.h>
 
#include <cmath>
#include <deque>
#include <algorithm>
 
#if defined(MP_USER_INCLUDE)
  #define xstr(x) #x
  #define str(x) xstr(x)
  #define header MP_USER_INCLUDE.h
  #include str(header)
  #undef header
#endif
 
#if defined(MP_ENABLE_CONFIG) || defined(ENABLE_MP_CONFIG)
  #include "MathPlotConfig.h"
#endif // MP_ENABLE_CONFIG
 
#if defined(MP_ENABLE_NAMESPACE) || defined(ENABLE_MP_NAMESPACE)
  namespace MathPlot {
#endif // MP_ENABLE_NAMESPACE
 
#ifdef MP_ENABLE_DEBUG
  // For memory leak debug
  #ifdef _WIN32
    #ifdef _DEBUG
      #include <crtdbg.h>
      #define DEBUG_NEW new(_NORMAL_BLOCK ,__FILE__, __LINE__)
    #else
      #define DEBUG_NEW new
    #endif // _DEBUG
  #endif // _WINDOWS
#endif // MP_ENABLE_DEBUG
 
#define MP_X_BORDER_SEPARATION 40
#define MP_Y_BORDER_SEPARATION 60
 
#define MP_X_LOCALTIME 0x10
#define MP_X_UTCTIME 0x20
#define MP_X_RAWTIME MP_X_UTCTIME
 
#define MP_EPSILON   1e-30
#define MP_ISNOTNULL(x) (std::fpclassify(x) != FP_ZERO)
 
#define MP_EXTRA_MARGIN  8
 
#define MP_ZOOM_AROUND_CENTER  -1
 
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
 
#define DECLARE_DYNAMIC_CLASS_MATHPLOT(mp_class)  wxDECLARE_DYNAMIC_CLASS(mp_class)
 
class WXDLLIMPEXP_MATHPLOT mpLayer;
class WXDLLIMPEXP_MATHPLOT mpFunction;
class WXDLLIMPEXP_MATHPLOT mpLine;
class WXDLLIMPEXP_MATHPLOT mpHorizontalLine;
class WXDLLIMPEXP_MATHPLOT mpVerticalLine;
class WXDLLIMPEXP_MATHPLOT mpFX;
class WXDLLIMPEXP_MATHPLOT mpFY;
class WXDLLIMPEXP_MATHPLOT mpFXY;
class WXDLLIMPEXP_MATHPLOT mpFXYVector;
class WXDLLIMPEXP_MATHPLOT mpFXGeneric;
class WXDLLIMPEXP_MATHPLOT mpGaussian;
class WXDLLIMPEXP_MATHPLOT mpNormal;
class WXDLLIMPEXP_MATHPLOT mpProfile;
class WXDLLIMPEXP_MATHPLOT mpChart;
class WXDLLIMPEXP_MATHPLOT mpBarChart;
class WXDLLIMPEXP_MATHPLOT mpScale;
class WXDLLIMPEXP_MATHPLOT mpScaleX;
class WXDLLIMPEXP_MATHPLOT mpScaleY;
class WXDLLIMPEXP_MATHPLOT mpInfoLayer;
class WXDLLIMPEXP_MATHPLOT mpInfoCoords;
class WXDLLIMPEXP_MATHPLOT mpInfoLegend;
class WXDLLIMPEXP_MATHPLOT mpWindow;
class WXDLLIMPEXP_MATHPLOT mpText;
class WXDLLIMPEXP_MATHPLOT mpTitle;
class WXDLLIMPEXP_MATHPLOT mpPrintout;
class WXDLLIMPEXP_MATHPLOT mpMovableObject;
class WXDLLIMPEXP_MATHPLOT mpCovarianceEllipse;
class WXDLLIMPEXP_MATHPLOT mpPolygon;
class WXDLLIMPEXP_MATHPLOT mpBitmapLayer;
 
#if defined(MP_ENABLE_CONFIG) || defined(ENABLE_MP_CONFIG)
class MathPlotConfigDialog;
#endif // MP_ENABLE_CONFIG
 
struct mpRect
{
    union {
        struct
        {
            wxCoord startPx;
            wxCoord startPy;
            wxCoord endPx;
            wxCoord endPy;
        };
        struct
        {
            wxCoord left;
            wxCoord top;
            wxCoord right;
            wxCoord bottom;
        };
        struct
        {
            wxCoord x1;
            wxCoord y1;
            wxCoord x2;
            wxCoord y2;
        };
        wxCoord tab[4];  
    };
    wxRect GetRect(void) const
    {
      return wxRect(startPx, startPy, endPx - startPx, endPy - startPy);
    }
};
static_assert(sizeof(mpRect) == 4 * sizeof(wxCoord));
 
template<typename T>
struct mpRange
{
    T min = 0;  
    T max = 0;  
 
    mpRange()
    {
      min = 0;
      max = 0;
    }
 
    mpRange(T value1, T value2)
    {
      if (value1 < value2)
      {
        min = value1;
        max = value2;
      }
      else
      {
        min = value2;
        max = value1;
      }
    }
 
    void Set(T value_)
    {
      min = value_;
      max = value_;
    }
 
    void Set(T min_, T max_)
    {
      min = min_;
      max = max_;
    }
 
    void SetMin(T min_)
    {
      min = min_;
      if (max < min)
        max = min;
    }
 
    void SetMax(T max_)
    {
      max = max_;
      if (min > max)
        min = max;
    }
 
    void Assign(T value1, T value2)
    {
      if (value1 < value2)
      {
        min = value1;
        max = value2;
      }
      else
      {
        min = value2;
        max = value1;
      }
    }
 
    bool IsSet() const
    {
      return ((min != 0) || (max != 0));
    }
 
    void Update(T value)
    {
      if (value < min)
        min = value;
      else if (value > max)
        max = value;
    }
 
    void Update(T min_, T max_)
    {
      if (min_ < min)
        min = min_;
      if (max_ > max)
        max = max_;
    }
 
    void Update(mpRange range)
    {
      if (range.min < min)
        min = range.min;
      if (range.max > max)
        max = range.max;
    }
 
    void Check(void)
    {
      if (min == max)
      {
        if (max > 0)
          min = 0;
        else
          max = 0;
      }
    }
 
    T Length(void) const
    {
      return max - min;
    }
 
    T GetCenter(void) const
    {
      return (min + max) / 2;
    }
 
    T GetMaxAbs(void) const
    {
      return std::max(fabs(min), fabs(max));
    }
 
    void ToLog(void)
    {
      min = (min > 0) ? log10(min) : 0;
      max = (max > 0) ? log10(max) : 0;
    }
 
    bool PointIsInside(T point) const
    {
      return ((point >= min) && (point <= max));
    }
 
    #if (defined(__cplusplus) && (__cplusplus > 201703L)) // C++20 or newer
      bool operator==(const mpRange&) const = default;
    #else
      bool operator==(const mpRange &other) const
      {
        return (min == other.min) && (max == other.max);
      }
      bool operator!=(const mpRange& other) const
      {
        return !(*this == other);
      }
    #endif
};
 
struct [[deprecated("Deprecated! No longer used as X and Y are now separated")]] mpFloatRect
{
  mpRange<double> x;               
  std::vector<mpRange<double>> y;  
 
  mpFloatRect(mpWindow& w);
 
  mpFloatRect() = delete;
 
  bool PointIsInside(const double px, const double py, const size_t yAxisID = 0) const {
    if (yAxisID < y.size())
    {
      if( (px < x.min || px > x.max) ||
          (py < y[yAxisID].min || py > y[yAxisID].max))
      {
        return false;
      }
    }
    else
    {
      return false;
    }
 
    return true;
  }
 
  void UpdateBoundingBoxToInclude(const double px, const double py, const size_t yAxisID = 0) {
    assert(yAxisID < y.size());
    if (yAxisID < y.size())
    {
      if      (px  < x.min ) x.min = px;
      else if (px  > x.max ) x.max = px;
      if      (py  < y[yAxisID].min ) y[yAxisID].min = py;
      else if (py  > y[yAxisID].max ) y[yAxisID].max = py;
    }
  }
 
  void InitializeBoundingBox(const double px, const double py, const size_t yAxisID = 0) {
    assert(yAxisID < y.size());
    if (yAxisID < y.size())
    {
      x.min = x.max = px;
      y[yAxisID].min = y[yAxisID].max = py;
    }
  }
  bool IsNotSet(mpWindow& w) const { const mpFloatRect def(w); return *this==def; }
#if (defined(__cplusplus) && (__cplusplus > 201703L)) // C++ > C++17 (MSVC requires <AdditionalOptions>/Zc:__cplusplus</AdditionalOptions>
  bool operator==(const mpFloatRect&) const = default;
#else
  // We compare with an epsilon precision
  // NOTE: should be unnecessary as we are looking for any changes; normally this will be an exact match or a real change...
  bool operator==(const mpFloatRect& rect) const
  {
    auto Same = [](const double a, const double b) {
      return std::fabs(a - b) < MP_EPSILON;
    };
 
    // Compare scalar members
    if (!Same(x.min, rect.x.min) || !Same(x.max, rect.x.max))
    {
      return false;
    }
 
    // Compare vector sizes
    if (y.size() != rect.y.size())
    {
      return false;
    }
 
    // Compare each Y boundary
    for (size_t i = 0; i < y.size(); ++i)
    {
      if (!Same(y[i].min, rect.y[i].min) ||
          !Same(y[i].max, rect.y[i].max)  )
      {
        return false;
      }
    }
 
    return true;
  }
#endif
};
 
struct mpFloatRectSimple
{
  mpRange<double> x;   
  mpRange<double> y;   
 
  mpFloatRectSimple(const mpRange<double> x_, const mpRange<double> y_) : x(x_), y(y_) { };
 
  bool PointIsInside(const double px, const double py) const {
    return x.PointIsInside(px) && y.PointIsInside(py);
  }
 
  void UpdateBoundingBoxToInclude(const double px, const double py)
  {
    x.Update(px);
    y.Update(py);
  }
 
  void InitializeBoundingBox(const double px, const double py)
  {
    x.Set(px, px);
    y.Set(py, py);
  }
};
 
struct mpPlotHit
{
  wxColour colour;      
  wxRealPoint coords;   
};
 
enum
{
  mpID_FIT = 2000,         
  mpID_ZOOM_IN,            
  mpID_ZOOM_OUT,           
  mpID_CENTER,             
  mpID_LOCKASPECT,         
  mpID_TOGGLE_GRID,        
  mpID_TOGGLE_COORD,       
  mpID_SCREENSHOT,         
#if defined(MP_ENABLE_CONFIG) || defined(ENABLE_MP_CONFIG)
  mpID_CONFIG,             
#endif // MP_ENABLE_CONFIG
  mpID_LOAD_FILE,          
  mpID_HELP_MOUSE,         
  mpID_FULLSCREEN          
};
 
typedef enum __mp_Location_Type
{
  mpMarginLeftCenter,    
  mpMarginTopLeft,       
  mpMarginTopCenter,     
  mpMarginTopRight,      
  mpMarginRightCenter,   
  mpMarginBottomLeft,    
  mpMarginBottomCenter,  
  mpMarginBottomRight,   
  mpMarginUser,          
  mpCursor               
} mpLocation;
 
typedef enum __XAxis_Align_Type
{
  mpALIGN_BORDER_BOTTOM = 10, 
  mpALIGN_BOTTOM,             
  mpALIGN_CENTERX,            
  mpALIGN_TOP,                
  mpALIGN_BORDER_TOP          
} mpXAxis_Align;
 
typedef enum __YAxis_Align_Type
{
  mpALIGN_BORDER_LEFT = 20, 
  mpALIGN_LEFT,             
  mpALIGN_CENTERY,          
  mpALIGN_RIGHT,            
  mpALIGN_BORDER_RIGHT      
} mpYAxis_Align;
 
typedef enum __Plot_Align_Name_Type
{
  mpALIGN_NW = 5,  
  mpALIGN_NE,      
  mpALIGN_SE,      
  mpALIGN_SW       
} mpPlot_Align;
 
typedef enum __mp_Style_Type
{
  mpLegendLine,    
  mpLegendSquare,  
  mpLegendSymbol   
} mpLegendStyle;
 
typedef enum __mp_Direction_Type
{
  mpVertical,      
  mpHorizontal     
} mpLegendDirection;
 
typedef enum __Symbol_Type
{
  mpsNone,         
  mpsCircle,       
  mpsSquare,       
  mpsUpTriangle,   
  mpsDownTriangle, 
  mpsCross,        
  mpsPlus          
} mpSymbol;
 
//-----------------------------------------------------------------------------
// mpLayer sub_type values
//-----------------------------------------------------------------------------
 
typedef enum __Info_Type
{
  mpiNone,     
  mpiInfo,     
  mpiCoords,   
  mpiLegend    
} mpInfoType;
 
typedef enum __Text_Type
{
  mptNone,     
  mptText,     
  mptTitle     
} mpTextType;
 
typedef enum __Function_Type
{
  mpfNone,       
  mpfFX,         
  mpfFY,         
  mpfFXY,        
  mpfFXYVector,  
  mpfMovable,    
  mpfLine,       
  mpfAllType     
} mpFunctionType;
 
typedef enum __Scale_Type
{
  mpsScaleNone,     
  mpsScaleX,        
  mpsScaleY,        
  mpsAllType        
} mpScaleType;
 
typedef enum __Chart_Type
{
  mpcChartNone,     
  mpcBarChart,      
  mpcPieChart,      
  mpcAllType        
} mpChartType;
 
enum mpMouseButtonAction
{
  mpMouseBoxZoom,     
  mpMouseDragZoom,    
};
 
enum mpLabelType
{
  mpLabel_AUTO,
  mpLabel_DECIMAL,
  mpLabel_SCIENTIFIC,
  mpLabel_TIME,
  mpLabel_HOURS,
  mpLabel_DATE,
  mpLabel_DATETIME,
  mpLabel_USER,
  mpLabel_NONE,
};
 
//-----------------------------------------------------------------------------
// mpLayer
//-----------------------------------------------------------------------------
 
typedef enum __mp_Layer_Type
{
  mpLAYER_UNDEF,   
  mpLAYER_AXIS,    
  mpLAYER_PLOT,    
  mpLAYER_INFO,    
  mpLAYER_TEXT,    
  mpLAYER_BITMAP,  
  mpLAYER_LINE,    
  mpLAYER_CHART,   
} mpLayerType;
 
typedef enum __mp_Layer_ZOrder
{
  mpZIndex_BACKGROUND,   
  mpZIndex_AXIS,         
  mpZIndex_LINE,         
  mpZIndex_PLOT,         
  mpZIndex_CHART,        
  mpZIndex_INFO,         
  mpZIndex_TEXT,         
  mpZIndex_END           
} mpLayerZOrder;
 
typedef enum __mp_Delete_Action
{
  mpNoDelete,     
  mpYesDelete,    
  mpForceDelete   
} mpDeleteAction;
 
class WXDLLIMPEXP_MATHPLOT mpLayer: public wxObject
{
  public:
    mpLayer(mpLayerType layerType);
 
    ~mpLayer() override
    {
      ;
    }
 
    void SetWindow(mpWindow &w)
    {
      m_win = &w;
    }
 
    virtual bool HasBBox()
    {
      return true;
    }
 
    mpLayerType GetLayerType() const
    {
      return m_type;
    }
 
    int GetLayerSubType() const
    {
      return m_subtype;
    }
 
    virtual bool IsLayerType(const mpLayerType typeOfInterest, int *subtype)
    {
      *subtype = m_subtype;
      return (m_type == typeOfInterest);
    }
 
    virtual double GetMinX()
    {
      return -1.0;
    }
 
    virtual double GetMaxX()
    {
      return 1.0;
    }
 
    virtual double GetMinY()
    {
      return -1.0;
    }
 
    virtual double GetMaxY()
    {
      return 1.0;
    }
 
    void Plot(wxDC &dc, mpWindow &w);
 
    void SetName(const wxString &name)
    {
      m_name = name;
    }
 
    const wxString& GetName() const
    {
      return m_name;
    }
 
    void SetFont(const wxFont &font)
    {
      m_font = font;
    }
 
    const wxFont& GetFont() const
    {
      return m_font;
    }
 
    void SetFontColour(const wxColour &colour)
    {
      m_fontcolour = colour;
    }
 
    const wxColour& GetFontColour() const
    {
      return m_fontcolour;
    }
 
    void SetPen(const wxPen &pen)
    {
      m_pen = pen;
    }
 
    const wxPen& GetPen() const
    {
      return m_pen;
    }
 
    void SetBrush(const wxBrush &brush)
    {
      if (brush == wxNullBrush)
        m_brush = *wxTRANSPARENT_BRUSH;
      else
        m_brush = brush;
    }
 
    void SetBrush(const wxColour &colour, enum wxBrushStyle style = wxBRUSHSTYLE_SOLID)
    {
      m_brush.SetColour(colour);
      m_brush.SetStyle(style);
    }
 
    const wxBrush& GetBrush() const
    {
      return m_brush;
    }
 
    void SetShowName(const bool show)
    {
      m_showName = show;
    }
 
    bool GetShowName() const
    {
      return m_showName;
    }
 
    void SetDrawOutsideMargins(const bool drawModeOutside)
    {
      m_drawOutsideMargins = drawModeOutside;
    }
 
    bool GetDrawOutsideMargins() const
    {
      return m_drawOutsideMargins;
    }
 
    wxBitmap GetColourSquare(int side = 16);
 
    bool IsVisible() const
    {
      return m_visible;
    }
 
    virtual void SetVisible(const bool show)
    {
      m_visible = show;
    }
 
    bool IsTractable() const
    {
      return m_tractable;
    }
 
    virtual void SetTractable(const bool track)
    {
      m_tractable = track;
    }
 
    void SetAlign(const int align)
    {
      m_flags = align;
    }
 
    int GetAlign() const
    {
      return m_flags;
    }
 
    void SetCanDelete(const bool canDelete)
    {
      m_CanDelete = canDelete;
    }
 
    bool GetCanDelete(void) const
    {
      return m_CanDelete;
    }
 
    mpLayerZOrder GetZIndex(void) const
    {
      return m_ZIndex;
    }
 
  protected:
    const mpLayerType m_type;   
    mpWindow* m_win;            
    int m_subtype;              
    wxFont m_font;              
    wxColour m_fontcolour;      
    wxPen m_pen;                
    wxBrush m_brush;            
    wxString m_name;            
    bool m_showName;            
    bool m_drawOutsideMargins;  
    bool m_visible;             
    bool m_tractable;           
    int m_flags;                
    mpRect m_plotBoundaries;    
    bool m_CanDelete;           
    mpLayerZOrder m_ZIndex;     
 
    void UpdateContext(wxDC &dc) const;
 
    virtual void DoPlot(wxDC &dc, mpWindow &w) = 0;
 
    virtual bool DoBeforePlot()
    {
      return true;
    }
 
    void CheckLog(double *x, double *y, int yAxisID);
 
  private:
    bool m_busy;          
    mpLayer() = delete;   // default ctor not implemented/permitted
 
  DECLARE_DYNAMIC_CLASS_MATHPLOT(mpLayer);
};
 
//-----------------------------------------------------------------------------
// mpInfoLayer
//-----------------------------------------------------------------------------
 
class WXDLLIMPEXP_MATHPLOT mpInfoLayer: public mpLayer
{
  public:
    mpInfoLayer();
 
    mpInfoLayer(wxPoint pos, const wxBrush &brush = *wxTRANSPARENT_BRUSH, mpLocation location = mpMarginUser);
 
    ~mpInfoLayer() override;
 
    void SetVisible(bool show) override;
 
    virtual void UpdateInfo(mpWindow &w, wxEvent &event);
 
    bool HasBBox() override
    {
      return false;
    }
 
    [[deprecated("Use Show() instead")]]
    virtual void ErasePlot(wxDC&, mpWindow&) {};
 
    virtual bool Inside(const wxPoint &point);
 
    virtual void Move(wxPoint delta, mpWindow &w);
 
    virtual void UpdateReference();
 
    wxPoint GetPosition() const
    {
      return m_dim.GetPosition();
    }
 
    void SetInitialPosition(const wxPoint pos)
    {
      m_relX = pos.x / 100.0;
      m_relY = pos.y / 100.0;
    }
 
    wxSize GetSize() const
    {
      return m_dim.GetSize();
    }
 
    const wxRect& GetRectangle() const
    {
      return m_dim;
    }
 
    void SetLocation(const mpLocation location)
    {
      m_location = location;
    }
 
    mpLocation GetLocation() const
    {
      return m_location;
    }
 
  protected:
    wxRect m_dim;           
    wxBitmap* m_info_bmp;   
    wxPoint m_reference;    
    double m_relX;          
    double m_relY;          
    mpLocation m_location;  
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
    void SetInfoRectangle(mpWindow &w, int width = 0, int height = 0);
 
  private:
 
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpInfoLayer);
};
 
class WXDLLIMPEXP_MATHPLOT mpInfoCoords: public mpInfoLayer
{
  public:
    mpInfoCoords();
 
    mpInfoCoords(mpLocation location);
 
    mpInfoCoords(wxPoint pos, const wxBrush &brush = *wxTRANSPARENT_BRUSH, mpLocation location = mpMarginUser);
 
    ~mpInfoCoords() override
    {
      ;
    }
 
    enum infoCoordType
    {
      infoCoord_axis,             
      infoCoord_closestSeries,    
      infoCoord_allSeries         
    };
 
    void UpdateInfo(mpWindow &w, wxEvent &event) override;
 
    [[deprecated("Use Show() instead")]]
    void ErasePlot(wxDC&, mpWindow&) override {};
 
    void Show(const bool show)
    {
      m_show = show;
    }
 
    bool IsShown() const
    {
      return m_show;
    }
 
    bool ShouldBeShown(const wxRect plotArea, const wxPoint mousePos) const
    {
      return IsVisible() && (GetDrawOutsideMargins() || plotArea.Contains(mousePos));
    }
 
    void SetLabelMode(const mpLabelType mode, const unsigned int time_conv = MP_X_RAWTIME)
    {
      m_labelType = mode;
      m_timeConv = time_conv;
    }
 
    [[deprecated("Deprecated, use SetInfoCoordType instead")]]
    void SetSeriesCoord(const bool show)
    {
      m_infoCoordType = show ? infoCoord_closestSeries : infoCoord_axis;
    }
    
    void SetInfoCoordType(const infoCoordType type)
    {
      m_infoCoordType = type;
    }
    
    infoCoordType GetInfoCoordType() const
    {
      return m_infoCoordType;
    }
 
    virtual wxString GetInfoCoordsText(mpWindow &w, double xVal, std::unordered_map<int, double> yValList);
 
    void DrawContent(wxDC &dc, mpWindow &w);
 
  protected:
    bool m_show;                          
    wxString m_content;                   
    mpLabelType m_labelType;              
    unsigned int m_timeConv;              
    wxCoord m_mouseX;                     
    wxCoord m_mouseY;                     
    infoCoordType m_infoCoordType;        
    std::vector<wxColor> m_seriesColors;  
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
  private:
 
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpInfoCoords);
};
 
class WXDLLIMPEXP_MATHPLOT mpInfoLegend: public mpInfoLayer
{
  public:
    mpInfoLegend();
 
    mpInfoLegend(wxPoint pos, const wxBrush &brush = *wxWHITE_BRUSH, mpLocation location = mpMarginUser);
 
    ~mpInfoLegend() override {}
 
    void SetItemMode(const mpLegendStyle mode)
    {
      m_item_mode = mode;
      m_needs_update = true;
    }
 
    mpLegendStyle GetItemMode() const
    {
      return m_item_mode;
    }
 
    void SetItemDirection(const mpLegendDirection mode)
    {
      m_item_direction = mode;
      m_needs_update = true;
    }
 
    mpLegendDirection GetItemDirection() const
    {
      return m_item_direction;
    }
 
    void SetNeedUpdate()
    {
      m_needs_update = true;
    }
 
    void ShowDraggedSeries(const bool active)
    {
      m_showDraggedSeries = active;
    }
 
    bool IsDraggedSeriesShown() const
    {
      return m_showDraggedSeries;
    }
 
    void EnableSeriesValues(const bool enable)
    {
      m_enableSeriesValues = enable;
      m_maxSeriesValueWidth = 0;
    }
 
    bool IsSeriesValuesEnabled() const
    {
      return m_enableSeriesValues;
    }
 
    bool SeriesValuesShouldBeShown(const wxRect plotArea, const wxPoint mousePos) const
    {
      return m_enableSeriesValues && plotArea.Contains(mousePos);
    }
 
    void ShowSeriesValues(const bool show)
    {
      m_showSeriesValues = show;
    }
 
    bool IsSeriesValuesShown() const
    {
      return m_showSeriesValues && IsVisible();
    }
 
    void IndicateSeriesIntersection(const bool enable)
    {
      m_indicateSeriesIntersection = enable;
    }
 
    void SetVerticalCursorFollowMouse();
 
    void SetVerticalCursorFixed(double posX);
 
    enum VerticalCursorMode
    {
       CursorMode_mouse, 
       CursorMode_fixed  
    };
 
    VerticalCursorMode GetVerticalCursorMode() const
    {
      return m_verticalCursorMode;
    }
 
    wxCoord GetVerticalCursorX() const;
 
    int GetLegendHitRegion(wxPoint mousePos);
 
    void DrawDraggedSeries(wxDC& dc, mpWindow &w) const;
 
    void DrawContent(wxDC &dc, mpWindow &w);
 
    static void RestoreAxisHighlighting(mpWindow &w);
 
    enum HitCode : int
    {
      HitNone   = -1,
      HitHeader = -2
    };
 
    mpFunction* m_selectedSeries = nullptr;               
    mpOptional_int m_lastHoveredAxisID = std::nullopt;    
 
  protected:
    mpLegendStyle m_item_mode;          
    mpLegendDirection m_item_direction; 
    bool m_showDraggedSeries;           
    wxString m_headerString = wxString::FromUTF8("≡");  
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
  private:
    struct LegendDetail
    {
      unsigned int layerIdx; 
      wxCoord legendEnd;     
    };
    std::vector<LegendDetail> m_LegendDetailList; 
    wxCoord m_headerEnd;                          
    bool m_needs_update;                          
    int m_maxSeriesValueWidth;                    
    bool m_enableSeriesValues;                    
    bool m_showSeriesValues;                      
    bool m_indicateSeriesIntersection;            
    VerticalCursorMode m_verticalCursorMode;      
    double m_verticalCursorPosX;                  
 
    void UpdateBitmap(wxDC &dc, mpWindow &w);
 
    int GetMaxLabelWidth(wxDC &dc, mpWindow &w) const;
 
    int DrawSeriesValue(wxDC& dc, mpWindow& w, mpFunction& function, int posX, int posY, int labelHeight, int labelWidth, int maxLabelWidth);
 
    void DrawVerticalCursor(wxDC &dc, mpWindow &w);
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpInfoLegend);
};
 
//-----------------------------------------------------------------------------
// mpLayer implementations - functions
//-----------------------------------------------------------------------------
 
 
class WXDLLIMPEXP_MATHPLOT mpFunction: public mpLayer
{
  public:
    mpFunction(mpLayerType layerType = mpLAYER_PLOT, const wxString &name = wxEmptyString, unsigned int yAxisID = 0);
 
    void SetContinuity(const bool continuity)
    {
      m_continuous = continuity;
    }
 
    bool GetContinuity() const
    {
      return m_continuous;
    }
 
    void SetStep(const unsigned int step)
    {
      m_step = step;
    }
 
    unsigned int GetStep() const
    {
      return m_step;
    }
 
    void SetSymbol(const mpSymbol symbol)
    {
      m_symbol = symbol;
    }
 
    mpSymbol GetSymbol() const
    {
      return m_symbol;
    }
 
    void SetSymbolSize(const int size)
    {
      m_symbolSize = size;
    }
 
    int GetSymbolSize() const
    {
      return m_symbolSize;
    }
 
    virtual bool DrawSymbol(wxDC &dc, wxCoord x, wxCoord y);
 
    std::optional<double> GetSeriesValue(double xValue);
 
    int GetYAxisID() const
    {
      return m_yAxisID;
    }
 
    void SetYAxisID(const unsigned int yAxisID)
    {
      m_yAxisID = yAxisID;
    }
 
    void SetLegendIsAlwaysVisible(const bool alwaysVisible)
    {
      m_LegendIsAlwaysVisible = alwaysVisible;
    }
 
    bool GetLegendIsAlwaysVisible() const
    {
      return m_LegendIsAlwaysVisible;
    }
 
    void SetAutoStep(const bool enable)
    {
      m_autoStep = enable;
    }
 
    bool GetAutoStep() const
    {
      return m_autoStep;
    }
 
    void SetMaxNOfPoints(const size_t nOfPoints)
    {
      m_maxNOfPoints = nOfPoints;
    }
 
    size_t GetMaxNOfPoints() const
    {
      return m_maxNOfPoints;
    }
 
  protected:
    bool m_continuous;            
    mpSymbol m_symbol;            
    int m_symbolSize;             
    unsigned int m_step;          
    int m_yAxisID;                
    bool m_LegendIsAlwaysVisible; 
    bool m_autoStep;              
    size_t m_maxNOfPoints;        
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpFunction);
};
 
class WXDLLIMPEXP_MATHPLOT mpLine: public mpFunction
{
  public:
    mpLine(double value, const wxPen &pen = *wxGREEN_PEN);
 
    // We don't want to include line (horizontal or vertical) in BBox computation
    bool HasBBox() override
    {
      return false;
    }
 
    double GetValue() const
    {
      return m_value;
    }
 
    void SetValue(const double value)
    {
      m_value = value;
    }
 
    bool IsHorizontal(void) const
    {
      return m_IsHorizontal;
    }
 
  protected:
    double m_value;        
    bool m_IsHorizontal;   
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpLine);
};
 
class WXDLLIMPEXP_MATHPLOT mpHorizontalLine: public mpLine
{
  public:
    mpHorizontalLine(double yvalue, const wxPen &pen = *wxGREEN_PEN, unsigned int yAxisID = 0);
 
    void SetYValue(const double yvalue)
    {
      SetValue(yvalue);
    }
 
  protected:
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpHorizontalLine);
};
 
class WXDLLIMPEXP_MATHPLOT mpVerticalLine: public mpLine
{
  public:
    mpVerticalLine(double xvalue, const wxPen &pen = *wxGREEN_PEN);
 
    void SetXValue(const double xvalue)
    {
      SetValue(xvalue);
    }
 
  protected:
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
    bool DoBeforePlot() override
    {
      return true;
    }
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpVerticalLine);
};
 
class WXDLLIMPEXP_MATHPLOT mpFX: public mpFunction
{
  public:
    mpFX(const wxString &name = wxEmptyString, int flags = mpALIGN_RIGHT, unsigned int yAxisID = 0);
 
    virtual double GetY(double x) = 0;
 
    double DoGetY(double x);
 
    void DefineDoGetY(void);
 
  protected:
 
     double (mpFX::*pDoGetY)(double x);  
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
    double NormalDoGetY(double x);
 
    double LogDoGetY(double x);
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpFX);
};
 
class WXDLLIMPEXP_MATHPLOT mpFY: public mpFunction
{
  public:
    mpFY(const wxString &name = wxEmptyString, int flags = mpALIGN_TOP, unsigned int yAxisID = 0);
 
    virtual double GetX(double y) = 0;
 
    double DoGetX(double y);
 
    void DefineDoGetX(void);
 
  protected:
 
    double (mpFY::*pDoGetX)(double y);  
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
    double NormalDoGetX(double y);
 
    double LogDoGetX(double y);
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpFY);
};
 
class WXDLLIMPEXP_MATHPLOT mpFXY: public mpFunction
{
  public:
    mpFXY(const wxString &name = wxEmptyString, int flags = mpALIGN_SW, bool viewAsBar = false, unsigned int yAxisID = 0);
 
    virtual void Rewind() = 0;
 
    virtual void Clear()
    {
      ;
    }
 
    virtual size_t GetSize()
    {
      return 0;
    }
 
    virtual bool GetNextXY(double *x, double *y) = 0;
 
    bool DoGetNextXY(double *x, double *y);
 
    void SetViewMode(bool asBar);
 
    int GetBarWidth(void) const
    {
      return m_BarWidth;
    }
 
    bool ViewAsBar(void) const
    {
      return m_ViewAsBar;
    }
 
  protected:
 
    // Data to calculate label positioning
    mpRange<int> m_drawX;    
    mpRange<int> m_drawY;    
 
    // Min delta between 2 x coordinate (used for view as bar)
    double m_deltaX;    
    double m_deltaY;    
 
    int m_BarWidth;  
 
    bool m_ViewAsBar = false;  
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
    void UpdateViewBoundary(wxCoord xnew, wxCoord ynew);
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpFXY);
};
 
//-----------------------------------------------------------------------------
// mpFXYVector - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
 
class WXDLLIMPEXP_MATHPLOT mpFXYVector: public mpFXY
{
  public:
    mpFXYVector(const wxString &name = wxEmptyString, int flags = mpALIGN_SW, bool viewAsBar = false, unsigned int yAxisID = 0);
 
    ~mpFXYVector() override
    {
      Clear();
    }
 
    void SetData(const std::vector<double> &xs, const std::vector<double> &ys);
 
    void Clear() override;
 
    size_t GetSize() override
    {
      return m_xs.size();
    }
 
    const std::vector<double>& GetXData() const
    {
      return m_xs;
    }
 
    const std::vector<double>& GetYData() const
    {
      return m_ys;
    }
 
    bool AddData(double x, double y, bool updatePlot);
 
    void SetReserve(const int reserve)
    {
      m_reserveXY = reserve;
      m_xs.reserve(m_reserveXY);
      m_ys.reserve(m_reserveXY);
    }
 
    int GetReserve() const
    {
      return m_reserveXY;
    }
 
  protected:
    std::vector<double> m_xs;    
    std::vector<double> m_ys;    
    bool m_isMonotonicX;         
    int m_reserveXY;             
    size_t m_index;              
    size_t m_endIndex;           
    mpRange<double> m_rangeX;    
    double m_lastX;              
    mpRange<double> m_rangeY;    
    double m_lastY;              
 
    void Rewind() override;
 
    bool GetNextXY(double *x, double *y) override;
 
    void DrawAddedPoint(double x, double y);
 
    double GetMinX()override
    {
      if (m_ViewAsBar)
      {
        // Make extra space for outer bars
        return m_rangeX.min - (m_deltaX / 2);
      }
      else
      {
        return m_rangeX.min;
      }
    }
 
    double GetMinY() override
    {
      return m_rangeY.min;
    }
 
    double GetMaxX() override
    {
      if(m_ViewAsBar)
      {
        // Make extra space for outer bars
        return m_rangeX.max + (m_deltaX / 2);
      }
      else
      {
        return m_rangeX.max;
      }
    }
 
    double GetMaxY() override
    {
      return m_rangeY.max;
    }
 
  private:
    void First_Point(double x, double y);
 
    static void Check_Limit(double val, mpRange<double> *range, double *last, double *delta);
 
  DECLARE_DYNAMIC_CLASS_MATHPLOT(mpFXYVector);
};
 
class WXDLLIMPEXP_MATHPLOT mpProfile: public mpFunction
{
  public:
    mpProfile(const wxString &name = wxEmptyString, int flags = mpALIGN_TOP);
 
    virtual double GetY(double x) = 0;
 
  protected:
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpProfile);
};
 
class mpFXGeneric: public mpFX
{
  public:
    mpFXGeneric(const wxString &name = wxT("Generic FX function"), const int flags = mpALIGN_LEFT, const unsigned int yAxisID = 0) :
        mpFX(name, flags, yAxisID)
    {
      const wxPen FXpen(*wxBLUE, 1, wxPENSTYLE_SOLID);
      SetDrawOutsideMargins(false);
      SetContinuity(true);
      SetPen(FXpen);
      SetStep(8); // Draw one point over eight
    }
 
    double GetY(const double x) override
    {
      double y;
      try
      {
        y = ComputeY(x);
      }
      catch (...)
      {
        y = 0;
      }
      m_rangeY.Update(y);
      return y;
    }
 
    double GetMinY() override
    {
      return m_rangeY.min;
    }
 
    double GetMaxY() override
    {
      return m_rangeY.max;
    }
 
  protected:
    mpRange<double> m_rangeY; 
 
    virtual double ComputeY(double x) = 0;
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpFXGeneric);
};
 
class mpGaussian: public mpFXGeneric
{
  public:
    mpGaussian(const double mu, const double sigma) :
      mpFXGeneric(wxT("Gaussian"), mpALIGN_LEFT)
    {
      m_mu = mu;
      m_sigma = sigma;
      m_variance = sigma * sigma;
      m_const = 1.0 / sqrt(2.0 * M_PI * m_variance);
    }
 
  protected:
    double m_mu;        
    double m_sigma;     
    double m_variance;  
    double m_const;     
 
    double ComputeY(const double x) override
    {
      return m_const * exp(-(x - m_mu) * (x - m_mu) / (2.0 * m_variance));
    }
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpGaussian);
};
 
class mpNormal: public mpFXGeneric
{
  public:
    mpNormal(const double mu, const double sigma) :
      mpFXGeneric(wxT("Normal"), mpALIGN_LEFT)
    {
      m_mu = mu;
      m_sigma = sigma;
      m_variance = sigma * sigma;
      m_const = 1.0 / (m_variance * sqrt(2.0 * M_PI));
    }
 
  protected:
    double m_mu;        
    double m_sigma;     
    double m_variance;  
    double m_const;     
 
    double ComputeY(const double x) override
    {
      if (x < 0)
        return 0.0;
      else
      {
        const double tmp = log(x) - m_mu;
        return m_const * exp(-tmp * tmp / (2.0 * m_variance)) / x;
      }
    }
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpNormal);
};
 
//-----------------------------------------------------------------------------
// mpChart
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpChart: public mpFunction
{
  public:
    mpChart(const wxString &name = wxEmptyString);
 
    ~mpChart() override
    {
      Clear();
    }
 
    void SetChartValues(const std::vector<double> &data);
 
    void SetChartLabels(const std::vector<std::string> &labelArray);
 
    void AddData(const double &data, const std::string &label);
 
    virtual void Clear();
 
    bool HasBBox() override
    {
      return (values.size() > 0);
    }
 
  protected:
    std::vector<double> values;       
    std::vector<std::string> labels;  
 
    double m_max_value;               
    double m_total_value;             
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpChart);
};
 
//-----------------------------------------------------------------------------
// mpBarChart  - provided by Jose Davide Rondini
//-----------------------------------------------------------------------------
/* Defines for bar charts label positioning. */
#define mpBAR_NONE      0       
#define mpBAR_AXIS_H    1       
#define mpBAR_AXIS_V    2       
#define mpBAR_INSIDE    3       
#define mpBAR_TOP       4       
 
class WXDLLIMPEXP_MATHPLOT mpBarChart: public mpChart
{
  public:
    mpBarChart(const wxString &name = wxEmptyString, double width = 0.5);
 
    ~mpBarChart() override
    {
      Clear();
    }
 
    void SetBarColour(const wxColour &colour);
 
    void SetColumnWidth(const double colWidth)
    {
      m_width = colWidth;
    }
 
    void SetBarLabelPosition(int position);
 
    double GetMinX() override;
 
    double GetMaxX() override;
 
    double GetMinY() override;
 
    double GetMaxY() override;
 
  protected:
 
    double m_width;        
    wxColour m_barColour;  
    int m_labelPos;        
    double m_labelAngle;   
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpBarChart);
};
 
class WXDLLIMPEXP_MATHPLOT mpPieChart: public mpChart
{
  public:
    mpPieChart(const wxString &name = wxEmptyString, double radius = 20);
 
    ~mpPieChart() override
    {
      Clear();
      colours.clear();
    }
 
    void SetCenter(const wxPoint center)
    {
      m_center = center;
    }
 
    wxPoint GetCenter(void) const
    {
      return m_center;
    }
 
    void SetPieColours(const std::vector<wxColour> &colourArray);
 
    double GetMinX() override
    {
      return m_center.x - m_radius;
    }
 
    double GetMaxX() override
    {
      return m_center.x + m_radius;
    }
 
    double GetMinY() override
    {
      return m_center.y - m_radius;
    }
 
    double GetMaxY() override
    {
      return m_center.y + m_radius;
    }
 
  protected:
 
    double m_radius;                
    wxPoint m_center;               
    std::vector<wxColour> colours;  
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
    const wxColour& GetColour(unsigned int id);
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpBarChart);
};
 
//-----------------------------------------------------------------------------
// mpLayer implementations - furniture (scales, ...)
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpScale: public mpLayer
{
  public:
    struct mpScaleConstraints
    {
      double step = 0.0;          
      double maxAxisValue = 0.0;  
      bool UseScientific = false; 
      int SignificantDigits = 0;  
      int DecimalDigits = 0;      
      double EpsilonScale = 0.0;  
    };
 
    mpScale(const wxString &name, int flags, bool grids, mpLabelType labelType = mpLabel_AUTO, mpOptional_uint axisID = std::nullopt);
 
    bool HasBBox() override
    {
      return false;
    }
 
    int GetAxisID(void) const
    {
      return m_axisID;
    }
 
    void SetAxisID(const unsigned int yAxisID)
    {
      m_axisID = yAxisID;
    }
 
    void ShowTicks(const bool ticks)
    {
      m_ticks = ticks;
    }
 
    bool GetShowTicks() const
    {
      return m_ticks;
    }
 
    void ShowGrids(const bool grids)
    {
      m_grids = grids;
    }
 
    bool GetShowGrids() const
    {
      return m_grids;
    }
 
    void SetLabelFormat(const wxString &format, const bool updateLabelMode = false)
    {
      m_labelFormat = format;
      if (updateLabelMode)
        m_labelType = mpLabel_USER;
    }
 
    mpLabelType GetLabelMode() const
    {
      return m_labelType;
    }
 
    void SetLabelMode(const mpLabelType mode, const unsigned int time_conv = MP_X_RAWTIME)
    {
      m_labelType = mode;
      m_timeConv = time_conv;
    }
 
    const wxString& GetLabelFormat() const
    {
      return m_labelFormat;
    }
 
    void SetGridPen(const wxPen &pen)
    {
      m_gridpen = pen;
    }
 
    const wxPen& GetGridPen() const
    {
      return m_gridpen;
    }
 
    void SetAuto(const bool automaticScalingIsEnabled)
    {
      m_auto = automaticScalingIsEnabled;
    }
 
    bool GetAuto() const
    {
      return m_auto;
    }
 
    void SetMinScale(const double min)
    {
      m_axisRange.SetMin(min);
    }
 
    double GetMinScale() const
    {
      return m_axisRange.min;
    }
 
    void SetMaxScale(const double max)
    {
      m_axisRange.SetMax(max);
    }
 
    double GetMaxScale() const
    {
      return m_axisRange.max;
    }
 
    void SetScale(const double min, const double max)
    {
      m_axisRange.Set(min, max);
    }
 
    void GetScale(double *min, double *max) const
    {
      *min = m_axisRange.min;
      *max = m_axisRange.max;
    }
 
    void SetScale(const mpRange<double> range)
    {
      m_axisRange = range;
    }
 
    mpRange<double> GetScale() const
    {
      return mpRange<double>(m_axisRange);
    }
 
    void SetHovering(const bool hover)
    {
      m_hover = hover;
    }
 
    virtual bool IsLogAxis()
    {
      return m_isLog;
    }
 
    virtual void SetLogAxis(const bool log)
    {
      m_isLog = log;
    }
 
    void SetCoordIsAlwaysVisible(const bool alwaysVisible)
    {
      m_CoordIsAlwaysVisible = alwaysVisible;
    }
 
    bool GetCoordIsAlwaysVisible() const
    {
      return m_CoordIsAlwaysVisible;
    }
 
    static mpScaleConstraints ComputeScaleConstraints(double step, double maxAxisValue);
 
    wxString FormatLabelValue(double value, const mpScaleConstraints &constraints);
 
  protected:
    static constexpr wxCoord kTickSize = 4;        
    static constexpr wxCoord kYAxisExtraSpace = 6; 
    static constexpr wxCoord kYAxisTitleSpace = 2; 
    static constexpr wxCoord kYAxisLabelSpace = 2; 
    static constexpr wxCoord kXAxisTitleSpace = 3; 
 
    int m_axisID;                
    wxPen m_gridpen;             
    bool m_ticks;                
    bool m_grids;                
    bool m_auto;                 
    mpRange<double> m_axisRange; 
    mpLabelType m_labelType;     
    unsigned int m_timeConv;     
    wxString m_labelFormat;      
    bool m_isLog;                
    bool m_hover = false;        
    bool m_CoordIsAlwaysVisible; 
 
    virtual int GetOrigin(mpWindow &w) = 0;
 
    static double GetStep(double scale, int minLabelSpacing);
 
    virtual void DrawScaleName(wxDC &dc, mpWindow &w, int origin, int labelSize) = 0;
 
    static wxString FormatLogValue(double n);
 
    int GetLabelWidth(double value, wxDC &dc, const mpScaleConstraints &constraints);
 
    static bool UseScientific(double maxAxisValue);
 
    static int GetSignificantDigits(double step, double maxAxisValue);
 
    static int GetDecimalDigits(double step);
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpScale);
};
 
 
class WXDLLIMPEXP_MATHPLOT mpScaleX: public mpScale
{
  public:
    mpScaleX(const wxString &name = _T("X"), const int flags = mpALIGN_CENTERX, const bool grids = false, const mpLabelType type = mpLabel_AUTO) :
        mpScale(name, flags, grids, type)
    {
      m_subtype = mpsScaleX;
    }
 
    bool IsTopAxis() const
    {
      return ((GetAlign() == mpALIGN_BORDER_TOP) || (GetAlign() == mpALIGN_TOP));
    }
 
    bool IsBottomAxis() const
    {
      return ((GetAlign() == mpALIGN_BORDER_BOTTOM) || (GetAlign() == mpALIGN_BOTTOM));
    }
 
  protected:
    static int m_orgy;
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
    int GetOrigin(mpWindow &w) override;
    void DrawScaleName(wxDC &dc, mpWindow &w, int origin, int labelSize) override;
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpScaleX);
 
    friend mpScaleY;
};
 
class WXDLLIMPEXP_MATHPLOT mpScaleY: public mpScale
{
  public:
    mpScaleY(const wxString &name = _T("Y"), const int flags = mpALIGN_CENTERY, const bool grids = false, const mpOptional_uint yAxisID = std::nullopt, const mpLabelType labelType = mpLabel_AUTO) :
        mpScale(name, flags, grids, labelType, yAxisID)
    {
      m_subtype = mpsScaleY;
      m_axisWidth = MP_Y_BORDER_SEPARATION;
      m_xPos = 0;
      m_autoHideAxis = false;
    }
 
    void UpdateAxisWidth(mpWindow &w);
 
    int GetAxisWidth() const
    {
      return m_axisWidth;
    }
 
    void SetAutoHideAxis(const bool autoHide)
    {
      m_autoHideAxis = autoHide;
    }
 
    bool GetAutoHideAxis() const
    {
      return m_autoHideAxis;
    }
 
    bool IsLeftAxis() const
    {
      return ((GetAlign() == mpALIGN_BORDER_LEFT) || (GetAlign() == mpALIGN_LEFT));
    }
 
    bool IsRightAxis() const
    {
      return ((GetAlign() == mpALIGN_BORDER_RIGHT) || (GetAlign() == mpALIGN_RIGHT));
    }
 
    bool IsInside(const wxCoord xPixel) const
    {
      if ( (IsLeftAxis() || IsRightAxis()) && (xPixel >= m_xPos) && (xPixel <= (m_xPos + m_axisWidth)) )
      {
        return true;
      }
      return false;
    }
 
  protected:
    int m_axisWidth;      
    int m_xPos;           
    bool m_autoHideAxis;  
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
    int GetOrigin(mpWindow &w) override;
    void DrawScaleName(wxDC &dc, mpWindow &w, int origin, int maxLabelWidth) override;
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpScaleY);
};
 
//-----------------------------------------------------------------------------
// mpWindow
//-----------------------------------------------------------------------------
 
#define mpMOUSEMODE_DRAG    0
#define mpMOUSEMODE_ZOOMBOX 1
 
//WX_DECLARE_HASH_MAP( int, mpLayer*, wxIntegerHash, wxIntegerEqual, mpLayerList );
typedef std::deque<mpLayer*> mpLayerList;
 
struct mpAxisData
{
    mpScale* axis = nullptr;  
    double scale = 1.0;       
    double pos = 0;           
    mpRange<double> bound;            
    mpRange<double> desired;          
    mpRange<double> lastDesired;      
 
    // Note: we don't use the default operator since we don't want to compare axis pointers
    bool operator==(const mpAxisData& other) const
    {
      return /*(axis == other.axis) && */ (scale == other.scale) && (pos == other.pos) &&
          (bound == other.bound) && (desired == other.desired);
    }
};
 
typedef std::map<int, mpAxisData> mpAxisList;
 
typedef enum {
  uXAxis = 1,
  uYAxis = 2,
  uXYAxis = 3
} mpAxisUpdate;
 
typedef std::function<void(void *Sender, const wxString &classname, bool &cancel)> mpOnDeleteLayer;
 
typedef std::function<void(void *Sender, wxMouseEvent &event, bool &cancel)> mpOnUserMouseAction;
 
class mpMagnet
{
  public:
    mpMagnet()
    {
      m_enable = false;
      m_show = false;
    }
    ~mpMagnet()
    {
      ;
    }
 
    void UpdateBox(const wxRect &plotArea)
    {
      m_domain = plotArea;
    }
 
    void Enable(const bool enable)
    {
      m_enable = enable;
    }
 
    bool IsEnabled() const
    {
      return m_enable;
    }
 
    void DrawCross(wxDC &dc, mpWindow &w);
 
    bool ShouldBeShown(const wxPoint mousePos) const
    {
      return m_enable && m_domain.Contains(mousePos);
    }
 
    void Show(const bool show)
    {
      m_show = show;
    }
 
    bool IsShown() const
    {
      return m_show;
    }
 
  private:
    bool m_enable;             
    bool m_show;               
    wxRect m_domain;           
};
 
class WXDLLIMPEXP_MATHPLOT mpWindow: public wxWindow
{
  public:
    mpWindow()
    {
      InitParameters();
    }
 
    mpWindow(wxWindow *parent, wxWindowID id = wxID_ANY, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
        long flags = 0);
 
    ~mpWindow() override;
 
    wxMenu* GetPopupMenu()
    {
      return &m_popmenu;
    }
 
    bool AddLayer(mpLayer *layer, bool fit = true, bool refreshConfig = true);
 
    bool DelLayer(mpLayer *layer, mpDeleteAction alsoDeleteObject, bool refreshDisplay = true, bool refreshConfig = true);
 
    void DelAllLayers(mpDeleteAction alsoDeleteObject, bool refreshDisplay = true);
 
    void DelAllPlot(mpDeleteAction alsoDeleteObject, mpFunctionType func = mpfAllType, bool refreshDisplay = true, bool refreshConfig = true);
 
    void DelAllYAxisAfterID(mpDeleteAction alsoDeleteObject, int yAxisID = 0, bool refreshDisplay = true);
 
    mpLayer* GetLayer(int position);
 
    int GetLayerPosition(mpLayer* layer);
 
    mpLayer* GetLayersType(int position, mpLayerType type);
 
    mpLayer* GetLayerPlot(int position, mpFunctionType func = mpfAllType);
 
    mpScale* GetLayerAxis(int position, mpScaleType scale = mpsAllType);
 
    mpFXYVector* GetXYSeries(unsigned int n, const wxString &name = _T("Serie "), bool create = true);
 
    std::optional<mpPlotHit> GetClosestPlot(wxCoord ix, wxCoord iy);
 
    mpLayer* GetLayerByName(const wxString &name);
 
    mpLayer* GetLayerByClassName(const wxString &name);
 
    void RefreshLegend(void);
 
    bool IsYAxisUsedByFunction(int yAxisID);
 
    bool ShouldDrawYAxis(const mpScaleY &yAxis);
 
 
    mpScaleX* GetLayerXAxis() const;
 
    mpScaleY* GetLayerYAxis(int yAxisID);
 
    void SetScaleX(const double scaleX)
    {
      if (MP_ISNOTNULL(scaleX))
      {
        m_AxisDataX.scale = scaleX;
        UpdateDesiredBoundingBox(uXAxis);
      }
      UpdateAll();
    }
 
    double GetScaleX(void) const
    {
      return m_AxisDataX.scale;
    }
 
    void SetScaleY(const double scaleY, const int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      if (MP_ISNOTNULL(scaleY))
      {
        m_AxisDataYList[yAxisID].scale = scaleY;
        UpdateDesiredBoundingBox(uYAxis);
      }
      UpdateAll();
    }
 
    double GetScaleY(const int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      return m_AxisDataYList[yAxisID].scale;
    } // Schaling's method: maybe another method exists with the same name
 
    [[deprecated("Incomplete, use UpdateBBox instead")]]
    void SetBound();
 
    mpRange<double> GetBoundX(void) const
    {
      return m_AxisDataX.bound;
    }
 
    mpRange<double> GetDesiredBoundX(void) const
    {
      return m_AxisDataX.desired;
    }
 
    mpRange<double> GetBoundY(const int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      return m_AxisDataYList[yAxisID].bound;
    }
 
    mpRange<double> GetDesiredBoundY(const int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      return m_AxisDataYList[yAxisID].desired;
    }
 
    mpRange<double> GetVisibleRangeX()
    {
      return mpRange<double>(m_AxisDataX.pos + (m_margin.left / m_AxisDataX.scale), m_AxisDataX.pos + ((m_margin.left + m_plotWidth) / m_AxisDataX.scale));
    }
 
    mpRange<double> GetVisibleRangeY(const unsigned int yAxisID = 0)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      mpAxisData& yData = m_AxisDataYList[yAxisID];
      return mpRange<double>(yData.pos - ((m_margin.top + m_plotHeight) / yData.scale), yData.pos - (m_margin.top / yData.scale));
    }
 
    std::unordered_map<int, mpRange<double>> GetAllBoundY()
    {
      std::unordered_map<int, mpRange<double>> yRange;
      for (const auto& [m_yID, m_yData] : m_AxisDataYList)
      {
        yRange[m_yID] = m_yData.bound;
      }
      return yRange;
    }
 
    std::unordered_map<int, mpRange<double>> GetAllDesiredY()
    {
      std::unordered_map<int, mpRange<double>> yRange;
      for (const auto& [m_yID, m_yData] : m_AxisDataYList)
      {
        yRange[m_yID] = m_yData.desired;
      }
      return yRange;
    }
 
    void SetPosX(const double posX)
    {
      m_AxisDataX.pos = posX;
      UpdateDesiredBoundingBox(uXAxis);
      UpdateAll();
    }
 
    double GetPosX(void) const
    {
      return m_AxisDataX.pos;
    }
 
    void SetPosY(std::unordered_map<int, double>& posYList)
    {
      for (auto& [m_yID, m_yData] : m_AxisDataYList)
      {
        m_yData.pos = posYList[m_yID];
      }
      UpdateDesiredBoundingBox(uYAxis);
      UpdateAll();
    }
 
    double GetPosY(const int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      return m_AxisDataYList[yAxisID].pos;
    }
 
    int GetNOfYAxis(void) const
    {
      return (int)m_AxisDataYList.size();
    }
 
    mpAxisList GetAxisDataYList(void) const
    {
      return m_AxisDataYList;
    }
 
    void SetScreen(const int scrX, const int scrY)
    {
      m_scrX = scrX;
      m_scrY = scrY;
      m_plotWidth = m_scrX - (m_margin.left + m_margin.right);
      m_plotHeight = m_scrY - (m_margin.top + m_margin.bottom);
 
      m_plotBoundaries.endPx = m_scrX;
      m_plotBoundariesMargin.endPx = m_scrX - m_margin.right;
      m_plotBoundaries.endPy = m_scrY;
      m_plotBoundariesMargin.endPy = m_scrY - m_margin.bottom;
 
      m_PlotArea = wxRect(m_margin.left - m_extraMargin, m_margin.top - m_extraMargin,
          m_plotWidth + 2*m_extraMargin, m_plotHeight + 2*m_extraMargin);
 
      m_magnet.UpdateBox(m_PlotArea);
    }
 
    int GetScreenX(void) const
    {
      return m_scrX;
    }
 
    int GetScreenY(void) const
    {
      return m_scrY;
    }
 
    void SetPos(const double posX, std::unordered_map<int, double>& posYList)
    {
      m_AxisDataX.pos = posX;
      SetPosY(posYList);
    }
 
    double p2x(const wxCoord pixelCoordX) const
    {
      return m_AxisDataX.pos + (pixelCoordX / m_AxisDataX.scale);
    }
 
    double p2y(const wxCoord pixelCoordY, const int yAxisID = 0)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      if (m_AxisDataYList.count(yAxisID) == 0)
        return 0.0;
      return m_AxisDataYList[yAxisID].pos - (pixelCoordY / m_AxisDataYList[yAxisID].scale);
    }
 
    wxCoord x2p(const double x) const
    {
      return (wxCoord)((x - m_AxisDataX.pos) * m_AxisDataX.scale);
    }
 
    wxCoord y2p(const double y, const int yAxisID = 0)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      if (m_AxisDataYList.count(yAxisID) == 0)
        return 0;
      return (wxCoord)((m_AxisDataYList[yAxisID].pos - y) * m_AxisDataYList[yAxisID].scale);
    }
 
    [[deprecated("Deprecated - use EnableBufferedPaintDC??")]]
    void EnableDoubleBuffer(const bool enabled)
    {
      EnableBufferedPaintDC(enabled);
    }
 
    void EnableBufferedPaintDC(const bool enabled)
    {
      m_enableBufferedPaintDC = enabled;
    }
 
    void EnableMousePanZoom(const bool enabled)
    {
      m_enableMouseNavigation = enabled;
    }
 
    void LockAspect(bool enable = true);
 
    bool IsAspectLocked() const
    {
      return m_lockaspect;
    }
 
    void Fit() override;
 
    void Fit(const mpRange<double> &rangeX, std::unordered_map<int, mpRange<double>> rangeY, bool updateDesired = true, wxCoord *printSizeX = NULL, wxCoord *printSizeY = NULL);
 
    void FitX(void);
 
    void FitY(int yAxisID);
 
    void ZoomIn(const wxPoint &centerPoint = wxDefaultPosition);
 
    void ZoomOut(const wxPoint &centerPoint = wxDefaultPosition);
 
    void ZoomInX();
 
    void ZoomOutX();
 
    void ZoomInY(mpOptional_int yAxisID = std::nullopt);
 
    void ZoomOutY(mpOptional_int yAxisID = std::nullopt);
 
    void ZoomRect(wxPoint p0, wxPoint p1);
 
    void UpdateAll();
 
    // Added methods by Davide Rondini
 
    unsigned int CountLayers();
 
    unsigned int CountAllLayers() const
    {
      return (unsigned int)m_layers.size();
    }
 
    unsigned int CountLayersType(mpLayerType type);
 
    unsigned int CountLayersFXYPlot();
 
    void UpdateDesiredBoundingBox(const mpAxisUpdate update)
    {
      // Change on X axis
      if (update & uXAxis)
      {
        m_AxisDataX.desired = GetVisibleRangeX();
      }
 
      // Change on Y axis
      if (update & uYAxis)
      {
        for (auto& [yID, yData] : m_AxisDataYList)
        {
          yData.desired = GetVisibleRangeY(yID);
        }
      }
    }
 
    mpFloatRectSimple GetBoundingBox(const bool desired, const unsigned int yAxisID = 0)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      if (desired)
        return mpFloatRectSimple(m_AxisDataX.desired, m_AxisDataYList[yAxisID].desired);
      else
        return mpFloatRectSimple(m_AxisDataX.bound, m_AxisDataYList[yAxisID].bound);
    }
 
    bool PointIsInsideBound(const double px, const double py, const int yAxisID)
    {
      if (m_AxisDataYList.count(yAxisID) == 0)
        return false;
 
      return m_AxisDataX.bound.PointIsInside(px) && GetBoundY(yAxisID).PointIsInside(py);
    }
 
    void UpdateBoundingBoxToInclude(const double px, const double py, const int yAxisID)
    {
      if (m_AxisDataYList.count(yAxisID) == 0)
        return ;
 
      m_AxisDataX.bound.Update(px);
      m_AxisDataYList[yAxisID].bound.Update(py);
    }
 
    /* Initialize bounding box with an initial point
     * @param px point on x-axis
     * @param py point on y-axis
     * @param yAxisID the y-axis ID
     */
    void InitializeBoundingBox(const double px, const double py, const int yAxisID)
    {
      if (m_AxisDataYList.count(yAxisID) == 0)
        return ;
 
      m_AxisDataX.bound.Set(px, px);
      m_AxisDataYList[yAxisID].bound.Set(py, py);
    }
 
    void SetMPScrollbars(bool status);
 
    bool GetMPScrollbars() const
    {
      return m_enableScrollBars;
    }
 
    bool SaveScreenshot(const wxString &filename, int type = wxBITMAP_TYPE_BMP, wxSize imageSize = wxDefaultSize, bool fit = false);
 
    wxBitmap* BitmapScreenshot(wxSize imageSize = wxDefaultSize, bool fit = false);
 
    void ClipboardScreenshot(wxSize imageSize = wxDefaultSize, bool fit = false);
 
    void SetWildcard(const wxString &wildcard)
    {
      m_wildcard = wildcard;
    }
 
    const wxString& GetWildcard(void) const
    {
      return m_wildcard;
    }
 
    bool LoadFile(const wxString &filename = wxEmptyString);
 
    void SetDefaultDir(const wxString &dirname)
    {
      m_DefaultDir = dirname;
    }
 
    static double m_zoomIncrementalFactor;
 
    static bool m_DefaultLegendIsAlwaysVisible;
 
    static void SetDefaultLegendIsAlwaysVisible(const bool visible)
    {
      m_DefaultLegendIsAlwaysVisible = visible;
    }
 
    static bool m_DefaultCoordIsAlwaysVisible;
 
 
    void SetAutoFit(const bool autoFit)
    {
      m_autoFit = autoFit;
    }
 
    void SetMargins(int top, int right, int bottom, int left);
 
    void UpdateMargins()
    {
      SetMargins(m_marginOuter.top, m_marginOuter.right, m_marginOuter.bottom, m_marginOuter.left);
    }
 
    void SetMarginTop(const int top)
    {
      SetMargins(top, m_marginOuter.right, m_marginOuter.bottom, m_marginOuter.left);
    }
 
    int GetMarginTop(const bool minusExtra = false) const
    {
      if (minusExtra)
        return m_margin.top - m_extraMargin;
      else
        return m_margin.top;
    }
 
    void SetMarginRight(const int right)
    {
      SetMargins(m_marginOuter.top, right, m_marginOuter.bottom, m_marginOuter.left);
    }
 
    int GetMarginRight(const bool minusExtra = false) const
    {
      if (minusExtra)
        return m_margin.right - m_extraMargin;
      else
        return m_margin.right;
    }
 
    int GetMarginRightOuter() const
    {
      return m_marginOuter.right;
    }
 
    void SetMarginBottom(const int bottom)
    {
      SetMargins(m_marginOuter.top, m_marginOuter.right, bottom, m_marginOuter.left);
    }
 
    int GetMarginBottom(const bool minusExtra = false) const
    {
      if (minusExtra)
        return m_margin.bottom - m_extraMargin;
      else
        return m_margin.bottom;
    }
 
    void SetMarginLeft(const int left)
    {
      SetMargins(m_marginOuter.top, m_marginOuter.right, m_marginOuter.bottom, left);
    }
 
    int GetMarginLeft(const bool minusExtra = false) const
    {
      if (minusExtra)
        return m_margin.left - m_extraMargin;
      else
        return m_margin.left;
    }
 
    void SetExtraMargin(const int extra)
    {
      m_extraMargin = extra;
      SetMargins(m_marginOuter.top, m_marginOuter.right, m_marginOuter.bottom, m_marginOuter.left);
    }
 
    int GetExtraMargin() const
    {
      return m_extraMargin;
    }
 
    int GetMarginLeftOuter() const
    {
      return m_marginOuter.left;
    }
 
    int GetPlotWidth() const
    {
      return m_plotWidth;
    }
 
    int GetPlotHeight() const
    {
      return m_plotHeight;
    }
 
    mpRect GetPlotBoundaries(const bool with_margin) const
    {
      mpRect bond;
      if (with_margin)
        bond = m_plotBoundariesMargin;
      else
        bond = m_plotBoundaries;
      bond.startPx -= m_extraMargin;
      bond.endPx += m_extraMargin;
      bond.startPy -= m_extraMargin;
      bond.endPy += m_extraMargin;
      return bond;
    }
 
    int GetLeftYAxesWidth(mpOptional_int yAxisID = std::nullopt);
 
    int GetRightYAxesWidth(mpOptional_int yAxisID = std::nullopt);
 
    void SetDrawBox(const bool drawbox)
    {
      m_drawBox = drawbox;
    }
 
    bool GetDrawBox() const
    {
      return m_drawBox;
    }
 
    mpOptional_int IsInsideYAxis(const wxPoint &point);
 
    mpInfoLayer* IsInsideInfoLayer(const wxPoint &point);
 
    void SetLayerVisible(const wxString &name, bool viewable);
 
    bool IsLayerVisible(const wxString &name);
 
    bool IsLayerVisible(const unsigned int position);
 
    void SetLayerVisible(const unsigned int position, bool viewable);
 
    void SetColourTheme(const wxColour &bgColour, const wxColour &drawColour, const wxColour &axesColour);
 
    const wxColour& GetAxesColour() const
    {
      return m_axColour;
    }
 
    const wxColour& GetbgColour() const
    {
      return m_bgColour;
    }
 
    void SetbgColour(const wxColour &colour)
    {
      m_bgColour = colour;
    }
 
    void SetOnDeleteLayer(const mpOnDeleteLayer &event)
    {
      m_OnDeleteLayer = event;
    }
 
    void UnSetOnDeleteLayer()
    {
      m_OnDeleteLayer = NULL;
    }
 
    void SetOnUserMouseAction(const mpOnUserMouseAction &userMouseEventHandler)
    {
      m_OnUserMouseAction = userMouseEventHandler;
    }
 
    void UnSetOnUserMouseAction()
    {
      m_OnUserMouseAction = NULL;
    }
 
    bool IsLogXaxis() const
    {
      if (m_AxisDataX.axis)
        return ((mpScaleX *)m_AxisDataX.axis)->IsLogAxis();
      else
        return false;
    }
 
    bool IsLogYaxis(const int yAxisID)
    {
      assert(m_AxisDataYList.count(yAxisID) != 0);
      mpScaleY* yAxis = GetLayerYAxis(yAxisID);
      if (yAxis)
        return yAxis->IsLogAxis();
      else
        return false;
    }
 
    void SetLogXaxis(const bool log)
    {
      if (m_AxisDataX.axis)
        ((mpScaleX *)m_AxisDataX.axis)->SetLogAxis(log);
    }
 
    void SetLogYaxis(const int yAxisID, const bool log)
    {
      mpScaleY* yAxis = GetLayerYAxis(yAxisID);
      if (yAxis)
        yAxis->SetLogAxis(log);
    }
 
    bool GetMagnetize() const
    {
      return m_magnet.IsEnabled();
    }
 
    void SetMagnetize(const bool mag)
    {
      m_magnet.Enable(mag);
    }
 
    void SetMouseLeftDownAction(const mpMouseButtonAction action)
    {
      m_mouseLeftDownAction = action;
    }
 
    mpMouseButtonAction GetMouseLeftDownAction() const
    {
      return m_mouseLeftDownAction;
    }
 
    wxPoint GetMousePosition() const
    {
      return m_mousePos;
    }
 
    mpInfoLayer* GetMovingInfoLayer() const
    {
      return m_movingInfoLayer;
    }
 
#if defined(MP_ENABLE_CONFIG) || defined(ENABLE_MP_CONFIG)
    MathPlotConfigDialog* GetConfigWindow(bool Create = false);
#endif // MP_ENABLE_CONFIG
 
    void RefreshConfigWindow(mpLayerType layerType = mpLAYER_UNDEF, int param = -1);
 
    void OpenConfigWindow(mpLayerType layerType = mpLAYER_UNDEF, int param = -1);
 
    void DeleteConfigWindow(void);
 
    void Paint(wxDC& dc);
 
    void RenderOverlays(wxDC& dc);
 
    wxMemoryDC *GetMemoryDC(void)
    {
      m_buff_dc.SelectObject(m_buff_bmp);
      return &m_buff_dc;
    }
 
  protected:
    virtual void BindEvents(void);                                
    virtual void OnPaint(wxPaintEvent &event);                    
    virtual void OnSize(wxSizeEvent &event);                      
    virtual void OnShowPopupMenu(wxMouseEvent &event);            
    virtual void OnCenter(wxCommandEvent &event);                 
    virtual void OnFit(wxCommandEvent &event);                    
    virtual void OnToggleGrids(wxCommandEvent &event);            
    virtual void OnToggleCoords(wxCommandEvent &event);           
    virtual void OnScreenShot(wxCommandEvent &event);             
    virtual void OnFullScreen(wxCommandEvent &event);             
#if defined(MP_ENABLE_CONFIG) || defined(ENABLE_MP_CONFIG)
    virtual void OnConfiguration(wxCommandEvent &event);          
#endif // MP_ENABLE_CONFIG
    virtual void OnLoadFile(wxCommandEvent &event);               
    virtual void OnZoomIn(wxCommandEvent &event);                 
    virtual void OnZoomOut(wxCommandEvent &event);                
    virtual void OnLockAspect(wxCommandEvent &event);             
    virtual void OnMouseHelp(wxCommandEvent &event);              
    virtual void OnMouseLeftDown(wxMouseEvent &event);            
    virtual void OnMouseLeftDoubleClick(wxMouseEvent &event);     
    virtual void OnMouseRightDown(wxMouseEvent &event);           
    virtual void OnMouseMove(wxMouseEvent &event);                
    virtual void OnMouseLeftRelease(wxMouseEvent &event);         
    virtual void OnMouseWheel(wxMouseEvent &event);               
    virtual void OnMouseLeave(wxMouseEvent &event);               
    bool CheckUserMouseAction(wxMouseEvent &event);               
    virtual void OnScrollThumbTrack(wxScrollWinEvent &event);     
    virtual void OnScrollPageUp(wxScrollWinEvent &event);         
    virtual void OnScrollPageDown(wxScrollWinEvent &event);       
    virtual void OnScrollLineUp(wxScrollWinEvent &event);         
    virtual void OnScrollLineDown(wxScrollWinEvent &event);       
    virtual void OnScrollTop(wxScrollWinEvent &event);            
    virtual void OnScrollBottom(wxScrollWinEvent &event);         
 
    void DoScrollCalc(const int position, const int orientation);
 
    void DoZoomXCalc(bool zoomIn, wxCoord staticXpixel = MP_ZOOM_AROUND_CENTER);
 
    void DoZoomYCalc(bool zoomIn, wxCoord staticYpixel = MP_ZOOM_AROUND_CENTER, mpOptional_int yAxisID = std::nullopt);
 
    void SetScaleXAndCenter(double scaleX);
 
    void SetScaleYAndCenter(double scaleY, int yAxisID);
 
    void Zoom(bool zoomIn, const wxPoint &centerPoint);
 
    virtual bool UpdateBBox();
 
    void DrawBoxZoom(wxDC& dc);
 
    void InitParameters();
 
    wxTopLevelWindow* m_parent;  
    bool m_fullscreen;           
 
    mpLayerList m_layers;        
    mpAxisData m_AxisDataX;      
    mpAxisList m_AxisDataYList;  
 
    wxMenu m_popmenu;       
    bool m_lockaspect;      
    wxColour m_bgColour;    
    wxColour m_fgColour;    
    wxColour m_axColour;    
    bool m_drawBox;         
 
    int m_scrX;             
    int m_scrY;             
    int m_clickedX;         
    int m_clickedY;         
 
    mpRect m_margin;                    
    mpRect m_marginOuter;               
    int m_extraMargin;                  
    wxCoord m_plotWidth;                
    wxCoord m_plotHeight;               
 
    mpRect m_plotBoundaries;            
    mpRect m_plotBoundariesMargin;      
    wxRect m_PlotArea;                  
 
    int m_last_lx;                      
    int m_last_ly;                      
    wxBitmap m_buff_bmp;                
    wxMemoryDC m_buff_dc;               
    bool m_cacheDirty;                  
    bool m_enableBufferedPaintDC;       
    bool m_enableMouseNavigation;       
    mpMouseButtonAction m_mouseLeftDownAction;  
    bool m_mouseMovedAfterRightClick;   
    wxPoint m_mousePos;                 
    wxPoint m_mouseRClick;              
    wxPoint m_mouseLClick;              
    double m_mouseScaleX;               
    std::unordered_map<int, double> m_mouseScaleYList;  
    mpOptional_int m_mouseYAxisID;      
    bool m_enableScrollBars;            
    bool m_autoFit;                     
    mpInfoLayer* m_movingInfoLayer;     
    mpInfoCoords* m_InfoCoords;         
    mpInfoLegend* m_InfoLegend;         
 
    bool m_boxZoomActive;               
 
    mpMagnet m_magnet;                  
 
    wxBitmap* m_Screenshot_bmp;         
 
    wxString m_wildcard;                
    wxString m_DefaultDir;              
 
#if defined(MP_ENABLE_CONFIG) || defined(ENABLE_MP_CONFIG)
    MathPlotConfigDialog* m_configWindow = NULL;  
#endif // MP_ENABLE_CONFIG
    bool m_openConfigWindowPending = false;  
    int m_infoLegendSelectedSeries;          
 
    mpOnDeleteLayer m_OnDeleteLayer = NULL;          
    mpOnUserMouseAction m_OnUserMouseAction = NULL;  
 
    virtual void DesiredBoundsHaveChanged() {};
 
  private:
    void CheckAndReportDesiredBoundsChanges();
 
    unsigned int GetNewAxisDataID(void)
    {
      int newID = 0;
      for (const auto& [m_yID, m_yData] : m_AxisDataYList)
      {
        if(m_yData.axis)
        {
          // This ID is used by an axis. Make sure the new ID is larger
          newID = std::max(newID, m_yID + 1);
        }
      }
      return newID;
    }
 
  DECLARE_DYNAMIC_CLASS_MATHPLOT(mpWindow);
 
    // To have direct access to m_Screenshot_dc
    friend mpPrintout;
};
 
//-----------------------------------------------------------------------------
// mpText - provided by Val Greene
//-----------------------------------------------------------------------------
 
class WXDLLIMPEXP_MATHPLOT mpText: public mpLayer
{
  public:
    mpText(const wxString &name = wxEmptyString) : mpLayer(mpLAYER_TEXT)
    {
      m_subtype = mptText;
      SetName(name);
      m_offsetx = 5;
      m_offsety = 50;
      m_location = mpMarginUser;
      m_ZIndex = mpZIndex_TEXT;
    }
 
    mpText(const wxString &name, int offsetx, int offsety);
 
    mpText(const wxString &name, mpLocation marginLocation);
 
    bool HasBBox() override
    {
      return false;
    }
 
    void SetLocation(const mpLocation location)
    {
      m_location = location;
    }
 
    mpLocation GetLocation() const
    {
      return m_location;
    }
 
    void SetOffset(const int offX, const int offY)
    {
      m_offsetx = offX;
      m_offsety = offY;
    }
 
    void GetOffset(int *offX, int *offY) const
    {
      *offX = m_offsetx;
      *offY = m_offsety;
    }
 
  protected:
    int m_offsetx;  
    int m_offsety;  
    mpLocation m_location;  
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpText);
};
 
class WXDLLIMPEXP_MATHPLOT mpTitle: public mpText
{
  public:
    mpTitle();
 
    mpTitle(const wxString &name) :
        mpText(name, mpMarginTopCenter)
    {
      m_subtype = mptTitle;
      SetPen(*wxWHITE_PEN);
      SetBrush(*wxWHITE_BRUSH);
    }
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpTitle);
};
 
//-----------------------------------------------------------------------------
// mpPrintout - provided by Davide Rondini
//-----------------------------------------------------------------------------
 
class WXDLLIMPEXP_MATHPLOT mpPrintout: public wxPrintout
{
  public:
    mpPrintout()
    {
      plotWindow = NULL;
      drawn = false;
      stretch_factor = 2;
    }
 
    mpPrintout(mpWindow *drawWindow, const wxString &title = _T("wxMathPlot print output"), int factor = 2);
    ~mpPrintout() override
    {
      ;
    }
 
    void SetDrawState(const bool drawState)
    {
      drawn = drawState;
    }
 
    bool OnPrintPage(int page) override;
    bool HasPage(int page) override;
 
    void SetFactor(const int factor)
    {
      stretch_factor = factor;
    }
 
  private:
    bool drawn;
    mpWindow* plotWindow;
    int stretch_factor;  // To reduce the size of plot
 
  DECLARE_DYNAMIC_CLASS_MATHPLOT(mpPrintout);
};
 
//-----------------------------------------------------------------------------
// mpMovableObject  - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpMovableObject: public mpFunction
{
  public:
    mpMovableObject() :
        m_reference_x(0), m_reference_y(0), m_reference_phi(0), m_shape_xs(0), m_shape_ys(0)
    {
      assert(m_type == mpLAYER_PLOT); // m_type is already set to mpLAYER_PLOT in default-arg mpFunction ctor: m_type = mpLAYER_PLOT;
      m_subtype = mpfMovable;
    }
 
    ~mpMovableObject() override {}
 
    void GetCoordinateBase(double &x, double &y, double &phi) const
    {
      x = m_reference_x;
      y = m_reference_y;
      phi = m_reference_phi;
    }
 
    void SetCoordinateBase(const double x, const double y, const double phi = 0)
    {
      m_reference_x = x;
      m_reference_y = y;
      m_reference_phi = phi;
      m_flags = mpALIGN_SW;
      ShapeUpdated();
    }
 
    bool HasBBox() override
    {
      return m_trans_shape_xs.size() != 0;
    }
 
    double GetMinX() override
    {
      return m_bbox_x.min;
    }
 
    double GetMaxX() override
    {
      return m_bbox_x.max;
    }
 
    double GetMinY() override
    {
      return m_bbox_y.min;
    }
 
    double GetMaxY() override
    {
      return m_bbox_y.max;
    }
 
  protected:
 
    double m_reference_x;    
    double m_reference_y;    
    double m_reference_phi;  
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
    void TranslatePoint(double x, double y, double &out_x, double &out_y) const;
 
    // the object points, in local coordinates (to be transformed by the current transformation).
    std::vector<double> m_shape_xs;  
    std::vector<double> m_shape_ys;  
 
    // The buffer for the translated & rotated points (to avoid recomputing them with each mpWindow refresh).
    std::vector<double> m_trans_shape_xs;  
    std::vector<double> m_trans_shape_ys;  
 
    mpRange<double> m_bbox_x;   
    mpRange<double> m_bbox_y;   
 
    void ShapeUpdated();
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpMovableObject);
};
 
//-----------------------------------------------------------------------------
// mpCovarianceEllipse  - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpCovarianceEllipse: public mpMovableObject
{
  public:
    mpCovarianceEllipse(const double cov_00 = 1, const double cov_11 = 1, const double cov_01 = 0, const double quantiles = 2, const int segments = 32,
        const wxString &layerName = _T("")) : mpMovableObject(),
        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();
    }
 
    ~mpCovarianceEllipse() override
    {
      ;
    }
 
    double GetQuantiles() const
    {
      return m_quantiles;
    }
 
    void SetQuantiles(const double q)
    {
      m_quantiles = q;
      RecalculateShape();
    }
 
    void SetSegments(const 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(const double cov_00, const double cov_01, const double cov_11)
    {
      m_cov_00 = cov_00;
      m_cov_01 = cov_01;
      m_cov_11 = cov_11;
      RecalculateShape();
    }
 
  protected:
    double m_cov_00;  
    double m_cov_11;  
    double m_cov_01;  
    double m_quantiles;  
 
    int m_segments;
 
    void RecalculateShape();
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpCovarianceEllipse);
};
 
//-----------------------------------------------------------------------------
// mpPolygon - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpPolygon: public mpMovableObject
{
  public:
    mpPolygon(const wxString &layerName = _T("")) : mpMovableObject()
    {
      m_continuous = true;
      m_name = layerName;
    }
 
    ~mpPolygon() override
    {
      ;
    }
 
    void setPoints(const std::vector<double> &points_xs, const std::vector<double> &points_ys, bool closedShape = true);
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpPolygon);
};
 
//-----------------------------------------------------------------------------
// mpBitmapLayer - provided by Jose Luis Blanco
//-----------------------------------------------------------------------------
class WXDLLIMPEXP_MATHPLOT mpBitmapLayer: public mpLayer
{
  public:
    mpBitmapLayer() : mpLayer(mpLAYER_BITMAP)
    {
      m_validImg = false;
      m_bitmapChanged = false;
      m_scaledBitmap_offset_x = m_scaledBitmap_offset_y = 0;
    }
 
    ~mpBitmapLayer() override
    {
      ;
    }
 
    void GetBitmapCopy(wxImage &outBmp) const;
 
    void SetBitmap(const wxImage &inBmp, double x, double y, double lx, double ly);
 
    double GetMinX() override
    {
      return m_bitmapX.min;
    }
 
    double GetMaxX() override
    {
      return m_bitmapX.max;
    }
 
    double GetMinY() override
    {
      return m_bitmapY.min;
    }
 
    double GetMaxY() override
    {
      return m_bitmapY.max;
    }
 
  protected:
 
    wxImage m_bitmap;
    wxBitmap m_scaledBitmap;  
    wxCoord m_scaledBitmap_offset_x;  
    wxCoord m_scaledBitmap_offset_y;  
    bool m_validImg;       
    bool m_bitmapChanged;  
 
    mpRange<double> m_bitmapX;  
    mpRange<double> m_bitmapY;  
 
    void DoPlot(wxDC &dc, mpWindow &w) override;
 
  private:
    DECLARE_DYNAMIC_CLASS_MATHPLOT(mpBitmapLayer);
};
 
// utility class
 
typedef enum __mp_Colour
{
  mpBlue,
  mpRed,
  mpGreen,
  mpPurple,
  mpYellow,
  mpFuchsia,
  mpLime,
  mpAqua,
  mpOlive
} mpColour;
 
class WXDLLIMPEXP_MATHPLOT wxIndexColour: public wxColour
{
  public:
    wxIndexColour(const unsigned int id)
    {
#ifdef _WIN32
      auto GetRandomColor = []() {
        return (rand() * 255) / RAND_MAX;
      };
#else
      auto GetRandomColor = []() {
        return (random() * 255) / RAND_MAX;
      };
#endif
      switch (id)
      {
        case 0:
          this->Set(0, 0, 255);
          break;  // Blue
        case 1:
          this->Set(255, 0, 0);
          break;  // Red
        case 2:
          this->Set(0, 128, 0);
          break;  // Green
        case 3:
          this->Set(128, 0, 128);
          break;  // Purple
        case 4:
          this->Set(255, 255, 0);
          break;  // Yellow
        case 5:
          this->Set(255, 0, 255);
          break;  // Fuchsia
        case 6:
          this->Set(0, 255, 0);
          break;  // Lime
        case 7:
          this->Set(0, 255, 255);
          break;  // Aqua/Cyan
        case 8:
          this->Set(128, 128, 0);
          break;  // Olive
        default:
          this->Set((ChannelType) (GetRandomColor()), (ChannelType) (GetRandomColor()), (ChannelType) (GetRandomColor()));
      }
    }
};
 
// ---------------------------------------------------------------------
#if defined(MP_ENABLE_NAMESPACE) || defined(ENABLE_MP_NAMESPACE)
  }// namespace MathPlot
#endif // MP_ENABLE_NAMESPACE
 
#endif // MATHPLOT_H_INCLUDED