amirghadiri1987
526 lines
16 KiB
Plaintext
526 lines
16 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| Plot.mqh |
|
|
//| Copyright (c) 2019, Marketeer |
|
|
//| https://www.mql5.com/en/users/marketeer |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright (c) 2019, Marketeer"
|
|
#property link "https://www.mql5.com/en/users/marketeer"
|
|
#property version "1.0"
|
|
|
|
#include <Controls\WndClient.mqh>
|
|
#include <Graphics\Graphic.mqh>
|
|
#include <OLAP/PairArray.mqh>
|
|
|
|
class CurveSubtitles
|
|
{
|
|
public:
|
|
CCurve *curve;
|
|
PairArray *data;
|
|
|
|
void assign(const CCurve *c, const PairArray *d)
|
|
{
|
|
curve = (CCurve *)c;
|
|
data = (PairArray *)d;
|
|
}
|
|
};
|
|
|
|
class CGraphicInPlot: public CGraphic
|
|
{
|
|
protected:
|
|
long m_chart_id; // chart ID
|
|
CurveSubtitles curvecache[];
|
|
|
|
void CGraphicInPlot::Customize(CCurve *c, const int points);
|
|
CCurve *CGraphicInPlot::CacheIt(const CCurve *c, const PairArray *data = NULL);
|
|
|
|
public:
|
|
CGraphicInPlot();
|
|
~CGraphicInPlot();
|
|
|
|
virtual bool Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2);
|
|
|
|
CCurve *CurveAdd(const PairArray *data, ENUM_CURVE_TYPE type, const string name = NULL); // overload
|
|
CCurve *CurveAdd(const double &x[], const double &y[], ENUM_CURVE_TYPE type, const string name = NULL); // overload
|
|
|
|
void CurvesRemoveAll(void);
|
|
|
|
virtual bool Shift(const int dx, const int dy);
|
|
|
|
virtual bool Show(void);
|
|
virtual bool Hide(void);
|
|
|
|
void Destroy(void);
|
|
void ResetColors(void);
|
|
CCurve *CurveDetach(const int index);
|
|
bool CurveAttach(CCurve *curve);
|
|
|
|
int getIndexInCache(CCurve *c);
|
|
void replaceInCache(const int index, CCurve *c);
|
|
|
|
int cacheSize() const
|
|
{
|
|
return ArraySize(curvecache);
|
|
}
|
|
|
|
const CurveSubtitles *cacheItem(const int index) const
|
|
{
|
|
return &curvecache[index];
|
|
}
|
|
|
|
void InitXAxis(const bool custom);
|
|
void InitYAxis(const bool custom);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
|
|
string CustomDoubleToStringFunction(double value, void *ptr)
|
|
{
|
|
CGraphicInPlot *self = dynamic_cast<CGraphicInPlot *>(ptr);
|
|
if(self != NULL)
|
|
{
|
|
if(self.cacheSize() > 0)
|
|
{
|
|
const int index = (int)value;
|
|
if(MathAbs(((double)index) - value) <= DBL_EPSILON)
|
|
{
|
|
const CurveSubtitles *s = self.cacheItem(0);
|
|
if(index < 0 || index >= ArraySize(s.data.array)) return NULL; // (string)(float)value; // debug
|
|
return s.data.array[index].title;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
CGraphicInPlot::CGraphicInPlot()
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
CGraphicInPlot::~CGraphicInPlot()
|
|
{
|
|
CurvesRemoveAll();
|
|
}
|
|
|
|
void CGraphicInPlot::Destroy(void)
|
|
{
|
|
m_generator.Reset();
|
|
m_canvas.Destroy();
|
|
}
|
|
|
|
void CGraphicInPlot::ResetColors(void)
|
|
{
|
|
m_generator.Reset();
|
|
}
|
|
|
|
/* TODO: enable this to support Y marks customization
|
|
class AxisCustomizer
|
|
{
|
|
public:
|
|
const bool Y; // true for Y, false for X (default)
|
|
const CGraphicInPlot *parent;
|
|
AxisCustomizer(const bool axisY, CGraphicInPlot *p): Y(axisY), parent(p) {}
|
|
};
|
|
*/
|
|
|
|
void CGraphicInPlot::InitXAxis(const bool custom)
|
|
{
|
|
if(custom)
|
|
{
|
|
m_x.Type(AXIS_TYPE_CUSTOM);
|
|
m_x.ValuesFunctionFormat(CustomDoubleToStringFunction);
|
|
m_x.ValuesFunctionFormatCBData(&this);
|
|
}
|
|
else
|
|
{
|
|
m_x.Type(AXIS_TYPE_DOUBLE);
|
|
}
|
|
}
|
|
|
|
void CGraphicInPlot::InitYAxis(const bool custom)
|
|
{
|
|
if(custom)
|
|
{
|
|
m_y.Type(AXIS_TYPE_CUSTOM);
|
|
m_y.ValuesFunctionFormat(CustomDoubleToStringFunction);
|
|
m_y.ValuesFunctionFormatCBData(&this);
|
|
}
|
|
else
|
|
{
|
|
m_y.Type(AXIS_TYPE_DOUBLE);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CGraphicInPlot::Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2)
|
|
{
|
|
if(!CGraphic::Create(chart, name, subwin, x1, y1, x2, y2)) return false;
|
|
m_chart_id = chart;
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CGraphicInPlot::Show(void)
|
|
{
|
|
string obj_name = ChartObjectName();
|
|
if(obj_name == NULL || ObjectFind(m_chart_id, obj_name) < 0) return false;
|
|
if(!ObjectSetInteger(m_chart_id, obj_name, OBJPROP_TIMEFRAMES, OBJ_ALL_PERIODS)) return false;
|
|
Update(false);
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CGraphicInPlot::Hide(void)
|
|
{
|
|
string obj_name = ChartObjectName();
|
|
if(obj_name == NULL || ObjectFind(m_chart_id, obj_name) < 0) return false;
|
|
return ObjectSetInteger(m_chart_id, obj_name, OBJPROP_TIMEFRAMES, OBJ_NO_PERIODS);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CGraphicInPlot::Shift(const int dx, const int dy)
|
|
{
|
|
string obj_name = ChartObjectName();
|
|
if(obj_name == NULL || ObjectFind(m_chart_id, obj_name) < 0) return false;
|
|
|
|
int x = (int)ObjectGetInteger(m_chart_id, obj_name, OBJPROP_XDISTANCE) + dx;
|
|
int y = (int)ObjectGetInteger(m_chart_id, obj_name, OBJPROP_YDISTANCE) + dy;
|
|
if(!ObjectSetInteger(m_chart_id, obj_name, OBJPROP_XDISTANCE, x)) return false;
|
|
if(!ObjectSetInteger(m_chart_id, obj_name, OBJPROP_YDISTANCE, y)) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
CCurve *CGraphicInPlot::CurveDetach(const int index)
|
|
{
|
|
return m_arr_curves.Detach(index);
|
|
}
|
|
|
|
bool CGraphicInPlot::CurveAttach(CCurve *curve)
|
|
{
|
|
return m_arr_curves.Add(curve);
|
|
}
|
|
|
|
void CGraphicInPlot::Customize(CCurve *c, const int points)
|
|
{
|
|
int w = MathMax(Width() / points / 4, 1);
|
|
c.HistogramWidth(w);
|
|
c.LinesWidth(3);
|
|
c.PointsFill(true);
|
|
}
|
|
|
|
CCurve *CGraphicInPlot::CacheIt(const CCurve *c, const PairArray *data = NULL)
|
|
{
|
|
int n = ArraySize(curvecache);
|
|
ArrayResize(curvecache, n + 1);
|
|
curvecache[n].assign(c, data);
|
|
return (CCurve *)c;
|
|
}
|
|
|
|
CCurve *CGraphicInPlot::CurveAdd(const PairArray *data, ENUM_CURVE_TYPE type, const string name = NULL)
|
|
{
|
|
double y[];
|
|
string s[];
|
|
data.convert(y, s);
|
|
CCurve *c = CGraphic::CurveAdd(y, type, name);
|
|
Customize(c, ArraySize(y));
|
|
|
|
return CacheIt(c, data);
|
|
}
|
|
|
|
CCurve *CGraphicInPlot::CurveAdd(const double &x[], const double &y[], ENUM_CURVE_TYPE type, const string name = NULL)
|
|
{
|
|
CCurve *c = CGraphic::CurveAdd(x, y, type, name);
|
|
Customize(c, ArraySize(x));
|
|
|
|
return CacheIt(c);
|
|
}
|
|
|
|
int CGraphicInPlot::getIndexInCache(CCurve *c)
|
|
{
|
|
int n = ArraySize(curvecache);
|
|
for(int i = 0; i < n; i++)
|
|
{
|
|
if(curvecache[i].curve == c) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void CGraphicInPlot::replaceInCache(const int index, CCurve *c)
|
|
{
|
|
curvecache[index].curve = c;
|
|
}
|
|
|
|
void CGraphicInPlot::CurvesRemoveAll(void)
|
|
{
|
|
int n = m_arr_curves.Total();
|
|
for(int i = n - 1; i >= 0; i--)
|
|
{
|
|
CurveRemoveByIndex(i);
|
|
}
|
|
n = ArraySize(curvecache);
|
|
for(int i = n - 1; i >= 0; i--)
|
|
{
|
|
if(CheckPointer(curvecache[i].data) == POINTER_DYNAMIC) delete curvecache[i].data;
|
|
}
|
|
ArrayResize(curvecache, 0);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
class CPlot: public CWndClient
|
|
{
|
|
private:
|
|
CGraphicInPlot *m_graphic;
|
|
ENUM_CURVE_TYPE type;
|
|
uint i_text_color;
|
|
CCurve *temp[];
|
|
|
|
public:
|
|
CPlot();
|
|
~CPlot();
|
|
|
|
bool Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2, const ENUM_CURVE_TYPE t = CURVE_HISTOGRAM);
|
|
virtual void Destroy(const int reason = 0) override;
|
|
bool Refresh(const bool enforce = false);
|
|
bool SetTextColor(color value);
|
|
|
|
virtual bool Shift(const int dx, const int dy) override;
|
|
|
|
virtual bool Show(void);
|
|
virtual bool Hide(void);
|
|
|
|
bool Resize(const int x1, const int y1, const int x2, const int y2);
|
|
|
|
CCurve *CurveAdd(const PairArray *data, const string name = NULL);
|
|
CCurve *CurveAdd(const double &x[], const double &y[], const string name = NULL);
|
|
|
|
void CurvesRemoveAll(void);
|
|
|
|
void SetDefaultCurveType(ENUM_CURVE_TYPE t)
|
|
{
|
|
type = t;
|
|
}
|
|
|
|
void InitXAxis(const bool custom)
|
|
{
|
|
if(CheckPointer(m_graphic) != POINTER_INVALID)
|
|
{
|
|
m_graphic.InitXAxis(custom);
|
|
}
|
|
}
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
CPlot::CPlot():
|
|
type(CURVE_HISTOGRAM), i_text_color(ColorToARGB(clrBlack, 255))
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
CPlot::~CPlot()
|
|
{
|
|
if(CheckPointer(m_graphic) != POINTER_INVALID)
|
|
{
|
|
m_graphic.Destroy();
|
|
delete m_graphic;
|
|
}
|
|
}
|
|
|
|
void CPlot::Destroy(const int reason = 0)
|
|
{
|
|
if(CheckPointer(m_graphic) != POINTER_INVALID)
|
|
{
|
|
m_graphic.Destroy();
|
|
delete m_graphic;
|
|
m_graphic = NULL;
|
|
}
|
|
CWndClient::Destroy(reason);
|
|
}
|
|
|
|
CCurve *CPlot::CurveAdd(const PairArray *data, const string name = NULL)
|
|
{
|
|
if(CheckPointer(m_graphic) == POINTER_INVALID) return NULL;
|
|
return m_graphic.CurveAdd(data, type, name);
|
|
}
|
|
|
|
CCurve *CPlot::CurveAdd(const double &x[], const double &y[], const string name = NULL)
|
|
{
|
|
if(CheckPointer(m_graphic) == POINTER_INVALID) return NULL;
|
|
return m_graphic.CurveAdd(x, y, type, name);
|
|
}
|
|
|
|
void CPlot::CurvesRemoveAll(void)
|
|
{
|
|
m_graphic.CurvesRemoveAll();
|
|
m_graphic.ResetColors();
|
|
}
|
|
|
|
bool CPlot::Resize(const int x1, const int y1, const int x2, const int y2)
|
|
{
|
|
if(CheckPointer(m_graphic) == POINTER_INVALID) return false;
|
|
|
|
int width = Width();
|
|
int height = Height();
|
|
Size(x2 - x1, y2 - y1);
|
|
|
|
string obj_name = m_name + "_0_0";
|
|
int obj_x1 = m_rect.left;
|
|
int obj_x2 = obj_x1 + width;
|
|
int obj_y1 = m_rect.top;
|
|
int obj_y2 = obj_y1 + height;
|
|
|
|
m_graphic.Destroy();
|
|
if(!m_graphic.Create(m_chart_id, obj_name, m_subwin, obj_x1, obj_y1, obj_x2, obj_y2))
|
|
{
|
|
Print(GetLastError());
|
|
return false;
|
|
}
|
|
|
|
for(int i = 0; i < ArraySize(temp); ++i)
|
|
{
|
|
if(CheckPointer(temp[i]) == POINTER_DYNAMIC) delete temp[i];
|
|
}
|
|
|
|
ArrayResize(temp, m_graphic.CurvesTotal());
|
|
|
|
// Graphic library does not provide a method to update curve without array copying
|
|
for(int i = m_graphic.CurvesTotal() - 1; i >= 0; --i)
|
|
{
|
|
temp[i] = m_graphic.CurveDetach(i);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CPlot::Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2, const ENUM_CURVE_TYPE t = CURVE_HISTOGRAM)
|
|
{
|
|
if(!CWndClient::Create(chart, name, subwin, x1, y1, x2, y2)) return false;
|
|
type = t;
|
|
|
|
int width = Width();
|
|
int height = Height();
|
|
|
|
string obj_name = m_name + "_0_0";
|
|
int obj_x1 = m_rect.left;
|
|
int obj_x2 = obj_x1 + width;
|
|
int obj_y1 = m_rect.top;
|
|
int obj_y2 = obj_y1 + height;
|
|
|
|
m_graphic = new CGraphicInPlot();
|
|
if(CheckPointer(m_graphic) == POINTER_INVALID) return false;
|
|
if(!m_graphic.Create(m_chart_id, obj_name, m_subwin, obj_x1, obj_y1, obj_x2, obj_y2)) return false;
|
|
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CPlot::Hide(void)
|
|
{
|
|
if(CheckPointer(m_graphic) == POINTER_INVALID) return false;
|
|
if(!m_graphic.Hide()) return false;
|
|
|
|
return CWndClient::Hide();
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CPlot::Show(void)
|
|
{
|
|
if(!CWndClient::Show()) return false;
|
|
|
|
if(CheckPointer(m_graphic) == POINTER_INVALID) return false;
|
|
if(m_graphic.Show()) return false;
|
|
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
|
|
bool CPlot::Shift(const int dx, const int dy)
|
|
{
|
|
if(CheckPointer(m_graphic) == POINTER_INVALID) return false;
|
|
if(!m_graphic.Shift(dx, dy)) return false;
|
|
|
|
return CWndClient::Shift(dx, dy);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool CPlot::Refresh(const bool enforce = false)
|
|
{
|
|
if(CheckPointer(m_graphic) == POINTER_INVALID) return false;
|
|
|
|
if(ArraySize(temp) == 0 && enforce)
|
|
{
|
|
m_graphic.ResetColors();
|
|
ArrayResize(temp, m_graphic.CurvesTotal());
|
|
for(int i = m_graphic.CurvesTotal() - 1; i >= 0; --i)
|
|
{
|
|
temp[i] = m_graphic.CurveDetach(i);
|
|
}
|
|
}
|
|
|
|
for(int i = 0; i < ArraySize(temp); ++i)
|
|
{
|
|
if(CheckPointer(temp[i]) == POINTER_DYNAMIC)
|
|
{
|
|
double x[], y[];
|
|
temp[i].GetX(x);
|
|
temp[i].GetY(y);
|
|
string name = temp[i].Name();
|
|
|
|
int index = m_graphic.getIndexInCache(temp[i]);
|
|
|
|
delete temp[i];
|
|
CCurve *curve = NULL;
|
|
if(ArraySize(x) > 0)
|
|
{
|
|
if(ArraySize(y) > 0)
|
|
{
|
|
curve = m_graphic.CurveAdd(x, y, type, name);
|
|
}
|
|
else
|
|
{
|
|
curve = m_graphic.CurveAdd(x, type, name);
|
|
}
|
|
}
|
|
|
|
m_graphic.replaceInCache(index, curve);
|
|
|
|
// axis does not yet calculated, it's done only during CurvePlotAll
|
|
// so we can't automatically adjust histogram width
|
|
// double range = (m_graphic.XAxis().Max() - m_graphic.XAxis().Min());
|
|
// double data = (x[ArrayMaximum(x)] - x[ArrayMinimum(x)]);
|
|
// int downsize = (int)(range / data);
|
|
curve.HistogramWidth(Width() / ArraySize(x) / 4);
|
|
curve.LinesWidth(3);
|
|
}
|
|
}
|
|
ArrayResize(temp, 0);
|
|
|
|
if(!m_graphic.CurvePlotAll()) return false;
|
|
|
|
m_graphic.Update(false);
|
|
|
|
ChartRedraw(m_chart_id);
|
|
return true;
|
|
}
|