| //+------------------------------------------------------------------+
|
| //| Axis.mqh |
|
| //| Copyright 2000-2025, MetaQuotes Ltd. |
|
| //| https://www.mql5.com |
|
| //+------------------------------------------------------------------+
|
| typedef string(*DoubleToStringFunction)(double,void*);
|
| //--- Various axis types
|
| enum ENUM_AXIS_TYPE
|
| {
|
| AXIS_TYPE_DOUBLE,
|
| AXIS_TYPE_DATETIME,
|
| AXIS_TYPE_CUSTOM,
|
| };
|
| //+------------------------------------------------------------------+
|
| //| Class CAxis |
|
| //| Usage: class for create axes on a two-dimensional graphics |
|
| //+------------------------------------------------------------------+
|
| class CAxis
|
| {
|
| private:
|
| double m_min;
|
| double m_max;
|
| double m_step;
|
| uint m_clr;
|
| string m_name;
|
| int m_name_size;
|
| int m_values_size;
|
| int m_values_width;
|
| string m_values_format;
|
| string m_values_fontname;
|
| uint m_values_fontflags;
|
| uint m_values_fontangle;
|
| bool m_auto_scale;
|
| double m_zero_lever; // this number is used to determine when an axis scale range should be extended to include the zero value.
|
| double m_default_step; // length of the default step
|
| double m_max_labels; // the maximum number of marks
|
| double m_min_grace; // "grace" value applied to the minimum data range
|
| double m_max_grace; // "grace" value applied to the maximum data range
|
| int m_values_dt_mode;
|
| DoubleToStringFunction m_values_func;
|
| void *m_values_cbdata;
|
| ENUM_AXIS_TYPE m_type;
|
|
|
| public:
|
| CAxis(void);
|
| ~CAxis(void);
|
| //--- properties
|
| double Step(void) const { return(m_step); }
|
| double Min(void) const { return(m_min); }
|
| void Min(const double min) { m_min=min; }
|
| double Max(void) const { return(m_max); }
|
| void Max(const double max) { m_max=max; }
|
| string Name(void) const { return(m_name); }
|
| void Name(const string name) { m_name=name; }
|
| ENUM_AXIS_TYPE Type(void) const { return(m_type); }
|
| void Type(ENUM_AXIS_TYPE type) { m_type=type; }
|
| //--- default properties
|
| uint Color(void) const { return(m_clr); }
|
| void Color(const uint clr) { m_clr=clr; }
|
| bool AutoScale(void) const { return(m_auto_scale); }
|
| void AutoScale(const bool auto) { m_auto_scale=auto; }
|
| int ValuesSize(void) const { return(m_values_size); }
|
| void ValuesSize(const int size) { m_values_size=size; }
|
| int ValuesWidth(void) const { return(m_values_width); }
|
| void ValuesWidth(const int width) { m_values_width=width; }
|
| string ValuesFormat(void) const { return(m_values_format); }
|
| void ValuesFormat(const string format) { m_values_format=format; }
|
| int ValuesDateTimeMode(void) const { return(m_values_dt_mode); }
|
| void ValuesDateTimeMode(const int mode) { m_values_dt_mode=mode; }
|
| DoubleToStringFunction ValuesFunctionFormat(void) const { return(m_values_func); }
|
| void ValuesFunctionFormat(DoubleToStringFunction func) { m_values_func=func; }
|
| void *ValuesFunctionFormatCBData(void) const { return(m_values_cbdata); }
|
| void ValuesFunctionFormatCBData(void *cbdata) { m_values_cbdata=cbdata; }
|
| string ValuesFontName(void) const { return(m_values_fontname); }
|
| void ValuesFontName(const string fontname) { m_values_fontname=fontname; }
|
| uint ValuesFontAngle(void) const { return(m_values_fontangle); }
|
| void ValuesFontAngle(const uint fontangle) { m_values_fontangle=fontangle; }
|
| uint ValuesFontFlags(void) const { return(m_values_fontflags); }
|
| void ValuesFontFlags(const uint fontflags) { m_values_fontflags=fontflags; }
|
| int NameSize(void) const { return(m_name_size); }
|
| void NameSize(const int size) { m_name_size=size; }
|
| double ZeroLever(void) const { return(m_zero_lever); }
|
| void ZeroLever(const double value) { m_zero_lever=value; }
|
| double DefaultStep(void) const { return(m_default_step); }
|
| void DefaultStep(const double value) { m_default_step=value; }
|
| double MaxLabels(void) const { return(m_max_labels); }
|
| void MaxLabels(const double value) { m_max_labels=value; }
|
| double MinGrace(void) const { return(m_min_grace); }
|
| void MinGrace(const double value) { m_min_grace=value; }
|
| double MaxGrace(void) const { return(m_max_grace); }
|
| void MaxGrace(const double value) { m_max_grace=value; }
|
| //--- method for auto scaling
|
| void SelectAxisScale(void);
|
|
|
| private:
|
| //--- additional methods for axis autoscaling
|
| void ExtensionBoundaries(void);
|
| double CalcStepSize(const double range,const double steps);
|
| double Mod(const double x,const double y);
|
| double CalcBoundedStepSize(const double range,const double max_steps);
|
| };
|
| //+------------------------------------------------------------------+
|
| //| Constructor |
|
| //+------------------------------------------------------------------+
|
| CAxis::CAxis(void) : m_auto_scale(true),
|
| m_zero_lever(0.25),
|
| m_default_step(25.0),
|
| m_max_labels(15),
|
| m_min_grace(0.01),
|
| m_max_grace(0.01),
|
| m_clr(clrBlack),
|
| m_name_size(0),
|
| m_values_size(12),
|
| m_values_fontname("arial"),
|
| m_values_fontflags(0),
|
| m_values_fontangle(0),
|
| m_values_func(NULL),
|
| m_values_cbdata(NULL),
|
| m_values_dt_mode(TIME_MINUTES),
|
| m_type(AXIS_TYPE_DOUBLE),
|
| m_values_width(30)
|
| {
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Destructor |
|
| //+------------------------------------------------------------------+
|
| CAxis::~CAxis(void)
|
| {
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Rounds a maximum, minimum values and defines step size. |
|
| //+------------------------------------------------------------------+
|
| void CAxis::SelectAxisScale(void)
|
| {
|
| if(m_min>m_max)
|
| m_max=m_min;
|
| if(!m_auto_scale)
|
| {
|
| if(m_max<=m_min)
|
| ExtensionBoundaries();
|
| m_step=((m_max-m_min)>m_default_step && m_default_step>0) ? m_default_step : m_max-m_min;
|
| return;
|
| }
|
| ExtensionBoundaries();
|
| //--- test for trivial condition of range = 0 and pick a suitable default
|
| if(m_max-m_min<1.0e-30)
|
| {
|
| m_max=m_max+0.2 *(m_max==0 ? 1.0 : MathAbs(m_max));
|
| m_min=m_min-0.2 *(m_min==0 ? 1.0 : MathAbs(m_min));
|
| }
|
| //--- this is the zero-lever test. If m_min is within the zero lever fraction of the data range,then use zero.
|
| if(m_min>0 && m_min/(m_max-m_min)<m_zero_lever)
|
| m_min=0;
|
| //--- repeat the zero-lever test for cases where the m_max is less than zero
|
| if(m_max<0 && MathAbs(m_max/(m_max-m_min))<m_zero_lever)
|
| m_max=0;
|
| //--- calculate the new m_step size
|
| double target_step=(m_default_step!=0) ? m_default_step : m_max-m_min;
|
| //--- Calculate the m_step size based on target steps
|
| m_step=CalcStepSize(m_max-m_min,target_step);
|
| double labels=MathCeil((m_max-m_min)/m_step);
|
| if(m_max_labels<labels && m_max_labels>0)
|
| m_step=CalcBoundedStepSize(m_max-m_min,m_max_labels);
|
| else
|
| m_step=CalcBoundedStepSize(m_max-m_min,labels);
|
| //--- calculate the scale minimum
|
| m_min=m_min-Mod(m_min,m_step);
|
| //--- calculate the scale maximum
|
| m_max=Mod(m_max,m_step)==0.0 ? m_max : m_max+m_step-Mod(m_max,m_step);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Expands the boundaries to the left and right. |
|
| //+------------------------------------------------------------------+
|
| void CAxis::ExtensionBoundaries(void)
|
| {
|
| double range=m_max-m_min;
|
| //--- do not let the grace value extend the axis below zero when all the values were positive
|
| if(m_min<0 || m_min-m_min_grace*range>=0.0)
|
| m_min=m_min-m_min_grace*range;
|
| //--- do not let the grace value extend the axis above zero when all the values were negative
|
| if(m_max>0 || m_max+m_max_grace*range<=0.0)
|
| m_max=m_max+m_max_grace*range;
|
| //--- calculate new min and max values if they equal
|
| if(m_max==m_min)
|
| {
|
| if(MathAbs(m_max)>1e-100)
|
| {
|
| m_max *= (m_min < 0 ? 0.95 : 1.05 );
|
| m_min *= (m_min < 0 ? 1.05 : 0.95 );
|
| }
|
| else
|
| {
|
| m_max = 1.0;
|
| m_min = -1.0;
|
| }
|
| }
|
| //---
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Calculate a m_step size based on a data range. |
|
| //+------------------------------------------------------------------+
|
| double CAxis::CalcStepSize(const double range,const double steps)
|
| {
|
| //--- calculate an initial guess at m_step size
|
| double temp=range/steps;
|
| //--- get the magnitude of the m_step size
|
| double mag=MathFloor(MathLog10(temp));
|
| double magPow=MathPow(10.0,mag);
|
| //--- calculate most significant digit of the new m_step size
|
| double magMsd=NormalizeDouble(temp/magPow+.5,0);
|
| //--- promote the MSD to either 1, 2, or 5
|
| if(magMsd>5.0)
|
| magMsd=10.0;
|
| else
|
| if(magMsd>2.0)
|
| magMsd=5.0;
|
| else
|
| if(magMsd>1.0)
|
| magMsd=2.0;
|
| //--- return step
|
| return(magMsd * magPow);
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Calculate the modulus (remainder) in a safe manner so that divide|
|
| //| by zero errors are avoided |
|
| //+------------------------------------------------------------------+
|
| double CAxis::Mod(const double x,const double y)
|
| {
|
| //--- check
|
| if(y==0)
|
| return(0);
|
| //--- calculate modulus
|
| return (x>0)? MathMod(x,y): MathMod(x,y)+y;
|
| }
|
| //+------------------------------------------------------------------+
|
| //| Calculate a m_step size based on a data range, limited to a max |
|
| //| number of steps. |
|
| //+------------------------------------------------------------------+
|
| double CAxis::CalcBoundedStepSize(const double range,const double max_steps)
|
| {
|
| //--- calculate an initial guess at m_step size
|
| double temp=range/max_steps;
|
| //--- get the magnitude of the m_step size
|
| double mag=MathFloor(MathLog10(temp));
|
| double magPow=MathPow((double) 10.0,mag);
|
| //--- calculate most significant digit of the new m_step size
|
| double magMsd=MathCeil(temp/magPow);
|
| //--- promote the MSD to either 1, 2, or 5
|
| if(magMsd>5.0)
|
| magMsd=10.0;
|
| else
|
| if(magMsd>2.0)
|
| magMsd=5.0;
|
| else
|
| if(magMsd>1.0)
|
| magMsd=2.0;
|
| //--- return step
|
| return(magMsd * magPow);
|
| }
|
| //+------------------------------------------------------------------+
|
