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);

  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;
    }

    void UpdateAxisWidth(mpWindow &w);

    int GetAxisWidth() const
    {
      return m_axisWidth;
    }

    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;       

    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 refreshDisplay = 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 IsYAxisUsed(int yAxisID);

    bool IsYAxisUsedByFunction(int yAxisID, int *position);

    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;
    }

    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.Set(m_AxisDataX.pos + (m_margin.left / m_AxisDataX.scale),
            m_AxisDataX.pos + ((m_margin.left + m_plotWidth) / m_AxisDataX.scale));
      }

      // Change on Y axis
      if (update & uYAxis)
      {
        for (auto& [yID, yData] : m_AxisDataYList)
        {
          yData.desired.Set(yData.pos - ((m_margin.top + m_plotHeight) / yData.scale),
              yData.pos - (m_margin.top / yData.scale));
        }
      }
    }

    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 GetBoundingBox(mpRange<double> *boundX, mpRange<double> *boundY, const int yAxisID)
    {
      if (m_AxisDataYList.count(yAxisID) == 0)
        return false;
      *boundX = m_AxisDataX.bound;
      *boundY = m_AxisDataYList[yAxisID].bound;
      return true;
    }

    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, int param = 0);

    void OpenConfigWindow(mpLayerType layerType = mpLAYER_UNDEF, int param = 0);

    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 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