//+------------------------------------------------------------------+
//|                                                     CGraphic.mqh |
//|                             Copyright 2000-2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#include <Arrays\ArrayObj.mqh>
#include "Curve.mqh"
#include "Axis.mqh"
#include "ColorGenerator.mqh"
//--- tick position
enum ENUM_MARK_POSITION
  {
   MARK_EXTERNAL,
   MARK_INTERNAL,
   MARK_MIDDLE
  };
//+------------------------------------------------------------------+
//| Structure CBackground                                            |
//| Usage: background on a two-dimensional graphics                  |
//+------------------------------------------------------------------+
struct CBackground
  {
   uint              clr;
   uint              clr_main;
   uint              clr_sub;
   string            main;
   string            sub;
   int               size_main;
   int               size_sub;
  };
//+------------------------------------------------------------------+
//| Structure CCurveHistory                                          |
//| Usage: history of curves on a two-dimensional graphics           |
//+------------------------------------------------------------------+
struct CCurveHistory
  {
   int               name_width;
   int               name_size;
   int               symbol_size;
   int               count_total;
   int               count_points;
   int               count_lines;
   int               count_histogram;
   int               count_custom;
  };
//+------------------------------------------------------------------+
//| Structure CGrid                                                  |
//| Usage: grid on a two-dimensional graphics                        |
//+------------------------------------------------------------------+
struct CGrid
  {
   uint              clr_line;
   uint              clr_background;
   uint              clr_circle;
   uint              clr_axis_line;
   uint              clr_frame;
   int               r_circle;
   bool              has_circle;
  };
//+------------------------------------------------------------------+
//| Class CGraphic                                                   |
//| Usage: class for drawing two-dimensional graphics                |
//+------------------------------------------------------------------+
class CGraphic
  {
protected:
   CArrayObj         m_arr_curves;
   CCanvas           m_canvas;
   //--- parameters background 
   int               m_height;
   int               m_width;
   //--- parameters work space
   int               m_left;
   int               m_right;
   int               m_up;
   int               m_down;
   //--- default parameters work space
   int               m_left0;
   int               m_right0;
   int               m_up0;
   int               m_down0;
   //--- size of dash on the axes
   int               m_mark_size;
   //--- scaling parameters
   double            m_dx;
   double            m_dy;
   //--- element of graphic
   CAxis             m_x;                    // x axis
   CAxis             m_y;                    // y axis   
   CGrid             m_grid;                 // grid   
   CBackground       m_background;           // background
   CCurveHistory     m_history;              // history
   //--- generates color curves
   CColorGenerator   m_generator;
   //--- distance between the elements
   int               m_gap;
   //--- coordinates and values for axes
   int               m_xc[];
   int               m_yc[];
   string            m_xvalues[];
   string            m_yvalues[];
   int               m_xsize;
   int               m_ysize;
   bool              m_xupdate;
   bool              m_yupdate;

public:
                     CGraphic(void);
                    ~CGraphic(void);
   //--- gets width and height
   int               Width(void)  const { return(m_width);  }
   int               Height(void) const { return(m_height); }
   //--- gets or sets indents
   int               IndentUp(void)               const { return(m_up0);     }
   void              IndentUp(const int up)             { m_up0=up;          }
   int               IndentDown(void)             const { return(m_down0);   }
   void              IndentDown(const int down)         { m_down0=down;      }
   int               IndentLeft(void)             const { return(m_left0);   }
   void              IndentLeft(const int left)         { m_left0=left;      }
   int               IndentRight(void)            const { return(m_right0);  }
   void              IndentRight(const int right)       { m_right0=right;    }
   //--- gets or sets gap 
   int               GapSize(void)           const { return(m_gap); }
   void              GapSize(const int size)       { m_gap=size;    }
   //--- gets or sets major mark size
   int               MajorMarkSize(void)           const { return(m_mark_size); }
   void              MajorMarkSize(const int size)       { m_mark_size=size;    }
   //--- axis properties
   CAxis            *XAxis(void) { return GetPointer(m_x); }
   CAxis            *YAxis(void) { return GetPointer(m_y); }
   //--- gets the curve history properties
   int               HistoryNameWidth(void)            const { return(m_history.name_width);  }
   int               HistoryNameSize(void)             const { return(m_history.name_size);   }
   int               HistorySymbolSize(void)           const { return(m_history.symbol_size); }
   //--- sets the curve history properties
   void              HistoryNameWidth(const int width) { m_history.name_width=width; }
   void              HistoryNameSize(const int size)   { m_history.name_size=size;   }
   void              HistorySymbolSize(const int size) { m_history.symbol_size=size; }
   //--- gets the grid properties
   uint              GridLineColor(void)        const { return(m_grid.clr_line);       }
   uint              GridAxisLineColor(void)    const { return(m_grid.clr_axis_line);  }
   uint              GridBackgroundColor(void)  const { return(m_grid.clr_background); }
   int               GridCircleRadius(void)     const { return(m_grid.r_circle);       }
   uint              GridCircleColor(void)      const { return(m_grid.clr_circle);     }
   bool              GridHasCircle(void)        const { return(m_grid.has_circle);     }
   //--- sets the grid properties
   void              GridLineColor(const uint clr)        { m_grid.clr_line=clr;       }
   void              GridAxisLineColor(const uint clr)    { m_grid.clr_axis_line=clr;  }
   void              GridBackgroundColor(const uint clr)  { m_grid.clr_background=clr; }
   void              GridCircleRadius(const int r)        { m_grid.r_circle=r;         }
   void              GridCircleColor(const uint clr)      { m_grid.clr_circle=clr;     }
   void              GridHasCircle(const bool has)        { m_grid.has_circle=has;     }
   //--- gets the background properties
   uint              BackgroundColor(void)       const { return(m_background.clr);       }
   uint              BackgroundMainColor(void)   const { return(m_background.clr_main);  }
   uint              BackgroundSubColor(void)    const { return(m_background.clr_sub);   }
   string            BackgroundMain(void)        const { return(m_background.main);      }
   string            BackgroundSub(void)         const { return(m_background.sub);       }
   int               BackgroundMainSize(void)    const { return(m_background.size_main); }
   int               BackgroundSubSize(void)     const { return(m_background.size_sub);  }
   //--- sets the background properties
   void              BackgroundColor(const uint clr)      { m_background.clr=clr;        }
   void              BackgroundMainColor(const uint clr)  { m_background.clr_main=clr;   }
   void              BackgroundSubColor(const uint clr)   { m_background.clr_sub=clr;    }
   void              BackgroundMain(const string main)    { m_background.main=main;      }
   void              BackgroundSub(const string sub)      { m_background.sub=sub;        }
   void              BackgroundMainSize(const int size)   { m_background.size_main=size; }
   void              BackgroundSubSize(const int size)    { m_background.size_sub=size;  }
   //--- create/attach/destroy
   bool              Create(const long chart,const string name,const int subwin,const int x1,const int y1,const int x2,const int y2);
   bool              Attach(const long chart_id,const string objname);
   bool              Attach(const long chart_id,const string objname,const int width,const int height);
   void              Destroy(void);
   //--- main properties
   string            ChartObjectName(void) const { return(m_canvas.ChartObjectName()); }
   string            ResourceName(void)    const { return(m_canvas.ResourceName());    }
   //--- redraw all object on screen
   bool              Redraw(const bool rescale=false);
   //--- update object on screen
   void              Update(const bool redraw=true);
   //--- methods for add new curve 
   CCurve           *CurveAdd(const double &y[],ENUM_CURVE_TYPE type,const string name=NULL);
   CCurve           *CurveAdd(const double &x[],const double &y[],ENUM_CURVE_TYPE type,const string name=NULL);
   CCurve           *CurveAdd(const CPoint2D &points[],ENUM_CURVE_TYPE type,const string name=NULL);
   CCurve           *CurveAdd(CurveFunction function,const double from,const double to,const double step,ENUM_CURVE_TYPE type,const string name=NULL);
   CCurve           *CurveAdd(const double &x[],const double &y[],const uint clr,ENUM_CURVE_TYPE type,const string name=NULL);
   CCurve           *CurveAdd(const double &y[],const uint clr,ENUM_CURVE_TYPE type,const string name=NULL);
   CCurve           *CurveAdd(const CPoint2D &points[],const uint clr,ENUM_CURVE_TYPE type,const string name=NULL);
   CCurve           *CurveAdd(CurveFunction function,const double from,const double to,const double step,const uint clr,ENUM_CURVE_TYPE type,const string name=NULL);
   //--- methods for draw curve
   bool              CurvePlotAll(void);
   bool              CurvePlot(const int index);
   //--- methods for work with curves
   int               CurvesTotal(void);
   CCurve           *CurveGetByIndex(const int index);
   CCurve           *CurveGetByName(const string name);
   bool              CurveRemoveByIndex(const int index);
   bool              CurveRemoveByName(const string name);
   //--- methods for add new elements   
   bool              MarksToAxisAdd(const double &marks[],const int mark_size,ENUM_MARK_POSITION position,const int dimension=0);
   void              TextAdd(const int x,const int y,const string text,const uint clr,const uint alignment=0);
   void              TextAdd(const CPoint &point,const string text,const uint clr,const uint alignment=0);
   void              LineAdd(const int x1,const int y1,const int x2,const int y2,const uint clr,const uint style);
   void              LineAdd(const CPoint &point1,const CPoint &point2,const uint clr,const uint style);
   //--- methods for settings text parameters
   bool              FontSet(const string name,const int size,const uint flags=0,const uint angle=0) { return(m_canvas.FontSet(name,size,flags,angle)); }
   void              FontGet(string &name,int &size,uint &flags,uint &angle)                         { m_canvas.FontGet(name,size,flags,angle);         }
   //--- methods for convert real coordinates to pixel coordinates
   virtual int       ScaleX(double x);
   virtual int       ScaleY(double y);
   //--- methods for settings internal parameters
   void              SetDefaultParameters(void);
   void              ResetParameters(void);
   //--- method for calculate max and min values
   void              CalculateMaxMinValues(void);

protected:
   //--- methods for plot curve
   virtual void      CustomPlot(CCurve *curve);
   virtual void      PointsPlot(CCurve *curve);
   virtual void      LinesPlot(CCurve *curve);
   virtual void      PointsAndLinesPlot(CCurve *curve);
   virtual void      StepsPlot(CCurve *curve);
   virtual void      HistogramPlot(CCurve *curve);
   virtual void      TrendLinePlot(CCurve *curve);
   //--- methods for create graphic elements 
   virtual void      CreateWorkspace(void);
   virtual void      CreateGrid(void);
   virtual void      CreateBackground(void);
   virtual void      CreateXName(void);
   virtual void      CreateYName(void);
   virtual void      CreateAxes(void);
   virtual void      CreateHistory(void);
   //--- methods for calculation internal parameters
   virtual void      CalculateBoundaries(void);
   virtual void      CalculateXAxis(void);
   virtual void      CalculateYAxis(void);
   //--- services functions   
   static double     AxisFactorPrecision(const double min,const double max,const double step);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CGraphic::CGraphic(void) : m_height(0.0),m_width(0.0)
  {
   SetDefaultParameters();
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CGraphic::~CGraphic(void)
  {
  }
//+------------------------------------------------------------------+
//| Crete workspace on graphic                                       |
//+------------------------------------------------------------------+
void CGraphic::CreateWorkspace(void)
  {
//--- coordinates
   int x1 = m_left;
   int y1 = m_up;
   int x2 = m_width-m_right;
   int y2 = m_height-m_down;
//--- draw background of workspace
   m_canvas.FillRectangle(x1+1,y1+1,x2-1,y2-1,m_grid.clr_background);
  }
//+------------------------------------------------------------------+
//| Create grid on graphic                                           |
//+------------------------------------------------------------------+
void CGraphic::CreateGrid(void)
  {
   int xc0=-1.0;
   int yc0=-1.0;
   for(int i=1; i<m_ysize-1; i++)
     {
      if(StringToDouble(m_yvalues[i])==0.0)
         yc0=m_yc[i];
      else
         m_canvas.LineHorizontal(m_left+1,m_width-m_right,m_yc[i],m_grid.clr_line);
      for(int j=1; j<m_xsize-1; j++)
        {
         if(i==1)
           {
            if(StringToDouble(m_xvalues[j])==0.0)
               xc0=m_xc[j];
            else
               m_canvas.LineVertical(m_xc[j],m_height-m_down-1,m_up+1,m_grid.clr_line);
           }
         //-- draw circle
         if(m_grid.has_circle)
           {
            m_canvas.FillCircle(m_xc[j],m_yc[i],m_grid.r_circle,m_grid.clr_circle);
            m_canvas.CircleWu(m_xc[j],m_yc[i],m_grid.r_circle,m_grid.clr_circle);
           }
        }
     }
//---
   if(yc0>0)
      m_canvas.LineHorizontal(m_left+1,m_width-m_right,yc0,m_grid.clr_axis_line);
   if(xc0>0)
      m_canvas.LineVertical(xc0,m_height-m_down-1,m_up+1,m_grid.clr_axis_line);
//---
  }
//+------------------------------------------------------------------+
//| Create background, main and sub title                            |
//+------------------------------------------------------------------+
void CGraphic::CreateBackground(void)
  {
//--- coordinates
   int x1 = 0;
   int y1 = 0;
   int x2 = m_width;
   int y2 = m_height;
//--- create background
   m_canvas.FillRectangle(0,0,m_width,m_up-1,m_background.clr);
   m_canvas.FillRectangle(0,m_height-m_down+1,m_width,m_height,m_background.clr);
   m_canvas.FillRectangle(0,m_up,m_left-1,m_height-m_down,m_background.clr);
   m_canvas.FillRectangle(m_width-m_right+1,m_up,m_width,m_height-m_down,m_background.clr);
//--- set main title
   if(m_background.main!=NULL && m_background.size_main!=0)
     {
      m_canvas.FontSet("Arial",m_background.size_main,FW_HEAVY);
      int xc=int((x2+x1-m_canvas.TextWidth(m_background.main))/2.0);
      int yc=m_up-m_background.size_main-m_gap;
      m_canvas.TextOut(xc,yc,m_background.main,m_background.clr_main);
      m_canvas.FontFlagsSet(0);
     }
//--- set sub title
   if(m_background.sub!=NULL && m_background.size_sub!=0)
     {
      m_canvas.FontSet("Arial",m_background.size_sub,FW_MEDIUM);
      int xc=int((x2+x1-m_canvas.TextWidth(m_background.sub))/2.0);
      int yc=m_height-m_down+m_mark_size+m_y.ValuesSize()+m_y.NameSize()+m_gap*3;
      m_canvas.TextOut(xc,yc,m_background.sub,m_background.clr_sub);
      m_canvas.FontFlagsSet(0);
     }
  }
//+------------------------------------------------------------------+
//| Create x axis name on graphic                                    |
//+------------------------------------------------------------------+
void CGraphic::CreateXName(void)
  {
   if(m_x.NameSize()!=0 && m_x.Name()!=NULL)
     {
      m_canvas.FontSizeSet(m_x.NameSize());
      int yc=m_height-m_down+m_mark_size+m_x.ValuesSize()+m_gap*2;
      m_canvas.TextOut((int)((m_width-m_canvas.TextWidth(m_x.Name()))/2.0),yc,m_x.Name(),m_x.Color());
     }
  }
//+------------------------------------------------------------------+
//| Create y axis name on graphic                                    |
//+------------------------------------------------------------------+
void CGraphic::CreateYName(void)
  {
   if(m_y.NameSize()!=0 && m_y.Name()!=NULL)
     {
      m_canvas.FontSizeSet(m_y.NameSize());
      m_canvas.FontAngleSet(900);
      int xc=m_left-m_y.NameSize()-m_mark_size-m_y.ValuesWidth()-m_gap*2;
      m_canvas.TextOut(xc,(int)((m_height+m_canvas.TextWidth(m_y.Name()))/2.0),m_y.Name(),m_y.Color());
      m_canvas.FontAngleSet(0);
     }
  }
//+------------------------------------------------------------------+
//| Create axes on graphic                                           |
//+------------------------------------------------------------------+
void CGraphic::CreateAxes(void)
  {
//---  
   int x1=m_left;
   int x2=m_left-m_mark_size;
   int y1=m_height-m_down;
   int y2=m_height-m_down+m_mark_size;
//--- create frame
   m_canvas.Rectangle(m_left,m_up,m_width-m_right,m_height-m_down,m_grid.clr_frame);
//--- set font y
   m_canvas.FontSet(m_y.ValuesFontName(),m_y.ValuesSize(),m_y.ValuesFontFlags(),m_y.ValuesFontAngle());
//--- create y axis
   for(int i=0; i<m_ysize; i++)
     {
      string yvalue=m_yvalues[i];
      int yh=m_canvas.TextHeight(yvalue);
      if(m_canvas.TextWidth(yvalue)>m_y.ValuesWidth())
        {
         if(m_canvas.TextWidth("...")>m_y.ValuesWidth())
           {
            yvalue=NULL;
           }
         else
           {
            while(m_canvas.TextWidth(yvalue+"...")>m_y.ValuesWidth())
              {
               yvalue=StringSubstr(yvalue,0,StringLen(yvalue)-1);
              }
            yvalue+="...";
           }
        }
      //--- draw mark and set y value
      int yi_width=m_canvas.TextWidth(yvalue);
      m_canvas.TextOut(m_left-yi_width-m_mark_size-m_gap,m_yc[i]-yh/2,yvalue,ColorToARGB(clrBlack),TA_LEFT);
      if(m_mark_size>0.0)
         m_canvas.LineHorizontal(x1,x2,m_yc[i],ColorToARGB(clrBlack));
     }
//--- set font x
   m_canvas.FontSet(m_x.ValuesFontName(),m_x.ValuesSize(),m_x.ValuesFontFlags(),m_x.ValuesFontAngle());
//--- create x axis   
   for(int i=0; i<m_xsize; i++)
     {
      string xvalue=m_xvalues[i];
      int xw=m_canvas.TextWidth(xvalue);
      //--- draw mark and set y value
      m_canvas.TextOut(m_xc[i]-xw/2,y2+m_gap,xvalue,ColorToARGB(clrBlack));
      if(m_mark_size>0.0)
         m_canvas.LineVertical(m_xc[i],y1,y2,ColorToARGB(clrBlack));
     }
//---        
  }
//+------------------------------------------------------------------+
//| Create graphic                                                   |
//+------------------------------------------------------------------+
bool CGraphic::Create(const long chart,const string name,const int subwin,const int x1,const int y1,const int x2,const int y2)
  {
//--- check object name  
   if(ObjectFind(chart,name)>=0)
      return(false);
//--- preliminary calculation
   int width=x2-x1;
   int height=y2-y1;
   if(width>0 && height>0)
     {
      m_width=width;
      m_height=height;
      //--- create object
      if(!ObjectCreate(chart,name,OBJ_BITMAP_LABEL,subwin,0,0))
         return(false);
      //--- customize object
      if(!ObjectSetInteger(chart,name,OBJPROP_XDISTANCE,x1) || 
         !ObjectSetInteger(chart,name,OBJPROP_YDISTANCE,y1))
        {
         ObjectDelete(chart,name);
         return(false);
        }
      //--- attach object
      if(!m_canvas.Attach(chart,name,width,height))
        {
         ObjectDelete(chart,name);
         return(false);
        }
     }
//--- success
   return(true);
  }
//+------------------------------------------------------------------+
//| Attach new object with bitmap resource                           |
//+------------------------------------------------------------------+
bool CGraphic::Attach(const long chart_id,const string objname)
  {
   if(m_canvas.Attach(chart_id,objname))
     {
      m_width=m_canvas.Width();
      m_height=m_canvas.Height();
      //--- success
      return(true);
     }
//--- failed
   return(false);
  }
//+------------------------------------------------------------------+
//| Attach new object without bitmap resource                        |
//+------------------------------------------------------------------+
bool CGraphic::Attach(const long chart_id,const string objname,const int width,const int height)
  {
   if(m_canvas.Attach(chart_id,objname,width,height))
     {
      m_width=m_canvas.Width();
      m_height=m_canvas.Height();
      //--- success
      return(true);
     }
//--- failed
   return(false);
  }
//+------------------------------------------------------------------+
//| Remove graphic from chart                                        |
//+------------------------------------------------------------------+
void CGraphic::Destroy(void)
  {
   SetDefaultParameters();
   m_generator.Reset();
   m_canvas.Destroy();
  }
//+------------------------------------------------------------------+
//| Add new curve on graphic                                         |
//+------------------------------------------------------------------+
CCurve *CGraphic::CurveAdd(const double &y[],ENUM_CURVE_TYPE type,const string name=NULL)
  {
   return CurveAdd(y,m_generator.Next(),type,name);
  }
//+------------------------------------------------------------------+
//| Add new curve on graphic                                         |
//+------------------------------------------------------------------+
CCurve *CGraphic::CurveAdd(const double &x[],const double &y[],ENUM_CURVE_TYPE type,const string name=NULL)
  {
   return CurveAdd(x,y,m_generator.Next(),type,name);
  }
//+------------------------------------------------------------------+
//| Add new curve on graphic                                         |
//+------------------------------------------------------------------+
CCurve *CGraphic::CurveAdd(const CPoint2D &points[],ENUM_CURVE_TYPE type,const string name=NULL)
  {
   return CurveAdd(points,m_generator.Next(),type,name);
  }
//+------------------------------------------------------------------+
//| Add new curve on graphic                                         |
//+------------------------------------------------------------------+
CCurve *CGraphic::CurveAdd(CurveFunction function,const double from,const double to,const double step,ENUM_CURVE_TYPE type,const string name=NULL)
  {
   return CurveAdd(function,from,to,step,m_generator.Next(),type,name);
  }
//+------------------------------------------------------------------+
//| Add new curve on graphic                                         |
//+------------------------------------------------------------------+
CCurve *CGraphic::CurveAdd(const double &y[],const uint clr,ENUM_CURVE_TYPE type,const string name=NULL)
  {
//--- create new curve
   CCurve *curve=new CCurve(y,clr,type,name);
//--- set max and min values
   if(m_arr_curves.Total()==0)
     {
      if(m_x.AutoScale())
        {
         m_x.Max(curve.XMax());
         m_x.Min(curve.XMin());
        }
      if(m_y.AutoScale())
        {
         m_y.Max(curve.YMax());
         m_y.Min(curve.YMin());
        }
      m_xupdate = true;
      m_yupdate = true;
     }
   else
     {
      //--- find max of x
      if(m_x.Max()<curve.XMax() && m_x.AutoScale())
        {
         m_x.Max(curve.XMax());
         m_xupdate=true;
        }
      //--- find min of x
      if(m_x.Min()>curve.XMin() && m_x.AutoScale())
        {
         m_x.Min(curve.XMin());
         m_xupdate=true;
        }
      //--- find max of y
      if(m_y.Max()<curve.YMax() && m_y.AutoScale())
        {
         m_y.Max(curve.YMax());
         m_yupdate=true;
        }
      //--- find min of y
      if(m_y.Min()>curve.YMin() && m_y.AutoScale())
        {
         m_y.Min(curve.YMin());
         m_yupdate=true;
        }
     }
//--- add curve
   m_arr_curves.Add(curve);
   return(curve);
  }
//+------------------------------------------------------------------+
//| Add new curve on graphic                                         |
//+------------------------------------------------------------------+
CCurve *CGraphic::CurveAdd(const double &x[],const double &y[],const uint clr,ENUM_CURVE_TYPE type,const string name=NULL)
  {
   int xSize = ArraySize(x);
   int ySize = ArraySize(y);
//--- check
   if(xSize!=ySize)
      return(NULL);
//--- create new curve
   CCurve *curve=new CCurve(x,y,clr,type,name);
//--- set max and min values
   if(m_arr_curves.Total()==0)
     {
      if(m_x.AutoScale())
        {
         m_x.Max(curve.XMax());
         m_x.Min(curve.XMin());
        }
      if(m_y.AutoScale())
        {
         m_y.Max(curve.YMax());
         m_y.Min(curve.YMin());
        }
      m_xupdate = true;
      m_yupdate = true;
     }
   else
     {
      //--- find max of x
      if(m_x.Max()<curve.XMax() && m_x.AutoScale())
        {
         m_x.Max(curve.XMax());
         m_xupdate=true;
        }
      //--- find min of x
      if(m_x.Min()>curve.XMin() && m_x.AutoScale())
        {
         m_x.Min(curve.XMin());
         m_xupdate=true;
        }
      //--- find max of y
      if(m_y.Max()<curve.YMax() && m_y.AutoScale())
        {
         m_y.Max(curve.YMax());
         m_yupdate=true;
        }
      //--- find min of y
      if(m_y.Min()>curve.YMin() && m_y.AutoScale())
        {
         m_y.Min(curve.YMin());
         m_yupdate=true;
        }
     }
//--- add curve
   m_arr_curves.Add(curve);
   return(curve);
  }
//+------------------------------------------------------------------+
//| Add new curve on graphic                                         |
//+------------------------------------------------------------------+
CCurve *CGraphic::CurveAdd(const CPoint2D &points[],const uint clr,ENUM_CURVE_TYPE type,const string name=NULL)
  {
//--- create new curve 
   CCurve *curve=new CCurve(points,clr,type,name);
//--- set max and min values
   if(m_arr_curves.Total()==0)
     {
      if(m_x.AutoScale())
        {
         m_x.Max(curve.XMax());
         m_x.Min(curve.XMin());
        }
      if(m_y.AutoScale())
        {
         m_y.Max(curve.YMax());
         m_y.Min(curve.YMin());
        }
      m_xupdate = true;
      m_yupdate = true;
     }
   else
     {
      //--- find max of x
      if(m_x.Max()<curve.XMax() && m_x.AutoScale())
        {
         m_x.Max(curve.XMax());
         m_xupdate=true;
        }
      //--- find min of x
      if(m_x.Min()>curve.XMin() && m_x.AutoScale())
        {
         m_x.Min(curve.XMin());
         m_xupdate=true;
        }
      //--- find max of y
      if(m_y.Max()<curve.YMax() && m_y.AutoScale())
        {
         m_y.Max(curve.YMax());
         m_yupdate=true;
        }
      //--- find min of y
      if(m_y.Min()>curve.YMin() && m_y.AutoScale())
        {
         m_y.Min(curve.YMin());
         m_yupdate=true;
        }
     }
//--- add curve
   m_arr_curves.Add(curve);
   return(curve);
  }
//+------------------------------------------------------------------+
//| Add new curve on graphic                                         |
//+------------------------------------------------------------------+
CCurve *CGraphic::CurveAdd(CurveFunction function,const double from,const double to,const double step,const uint clr,ENUM_CURVE_TYPE type,const string name=NULL)
  {
//--- check
   if(from>=to || step<=0 || step>=MathAbs(to-from))
      return(NULL);
//--- create new curve 
   CCurve *curve=new CCurve(function,from,to,step,clr,type,name);
//--- set max and min values
   if(m_arr_curves.Total()==0)
     {
      if(m_x.AutoScale())
        {
         m_x.Max(curve.XMax());
         m_x.Min(curve.XMin());
        }
      if(m_y.AutoScale())
        {
         m_y.Max(curve.YMax());
         m_y.Min(curve.YMin());
        }
      m_xupdate = true;
      m_yupdate = true;
     }
   else
     {
      //--- find max of x
      if(m_x.Max()<curve.XMax() && m_x.AutoScale())
        {
         m_x.Max(curve.XMax());
         m_xupdate=true;
        }
      //--- find min of x
      if(m_x.Min()>curve.XMin() && m_x.AutoScale())
        {
         m_x.Min(curve.XMin());
         m_xupdate=true;
        }
      //--- find max of y
      if(m_y.Max()<curve.YMax() && m_y.AutoScale())
        {
         m_y.Max(curve.YMax());
         m_yupdate=true;
        }
      //--- find min of y
      if(m_y.Min()>curve.YMin() && m_y.AutoScale())
        {
         m_y.Min(curve.YMin());
         m_yupdate=true;
        }
     }
//--- add curve
   m_arr_curves.Add(curve);
   return(curve);
  }
//+------------------------------------------------------------------+
//| Add ticks to current graphic                                     |
//+------------------------------------------------------------------+
bool CGraphic::MarksToAxisAdd(const double &marks[],const int mark_size,ENUM_MARK_POSITION position,const int dimension=0)
  {
   int originalX=m_left;
   int originalY=m_height-m_down;
//--- check dimension
   if(dimension==0)
     {
      int y1=m_height-m_down;
      int y2=m_height-m_down;
      //--- calculate y coordinates for marks
      switch(position)
        {
         case MARK_INTERNAL:
            y1-=mark_size;
            break;
         case MARK_EXTERNAL:
            y2+=mark_size;
            break;
         case MARK_MIDDLE:
            y1-=mark_size/2;
            y2+=mark_size/2;
            break;
        }
      //--- draw marks to x axis
      for(int i=0; i<ArraySize(marks); i++)
        {
         int x=originalX+(int)((marks[i]-m_x.Min())*m_dx);
         m_canvas.LineVertical(x,y1,y2,ColorToARGB(clrBlack));
        }
     }
   else
   if(dimension==1)
     {
      int x1=m_left;
      int x2=m_left;
      //--- calculate x coordinates for marks
      switch(position)
        {
         case MARK_INTERNAL:
            x2+=mark_size;
            break;
         case MARK_EXTERNAL:
            x1-=mark_size;
            break;
         case MARK_MIDDLE:
            x2+=mark_size/2;
            x1-=mark_size/2;
            break;
        }
      //--- draw marks to y axis
      for(int i=0; i<ArraySize(marks); i++)
        {
         int y=originalY -(int)((marks[i]-m_y.Min())*m_dy);
         m_canvas.LineHorizontal(x1,x2,y,ColorToARGB(clrBlack));
        }
     }
   else
      return(false);
//--- success
   return(true);
  }
//+------------------------------------------------------------------+
//| Add text to graphic                                              |
//+------------------------------------------------------------------+
void CGraphic::TextAdd(const int x,const int y,const string text,const uint clr,const uint alignment=0)
  {
//--- check
   if(StringLen(text)<1)
      return;
//--- set text
   m_canvas.TextOut(x,y,text,clr,alignment);
  }
//+------------------------------------------------------------------+
//| Add text to graphic                                              |
//+------------------------------------------------------------------+
void CGraphic::TextAdd(const CPoint &point,const string text,const uint clr,const uint alignment=0)
  {
//--- check
   if(StringLen(text)<1)
      return;
//--- set text
   m_canvas.TextOut(point.x,point.y,text,clr,alignment);
  }
//+------------------------------------------------------------------+
//| Add line to graphic                                              |
//+------------------------------------------------------------------+
void CGraphic::LineAdd(const int x1,const int y1,const int x2,const int y2,const uint clr,const uint style)
  {
   m_canvas.LineWu(x1,y1,x2,y2,clr,style);
  }
//+------------------------------------------------------------------+
//| Add line to graphic                                              |
//+------------------------------------------------------------------+
void CGraphic::LineAdd(const CPoint &point1,const CPoint &point2,const uint clr,const uint style)
  {
   m_canvas.LineWu(point1.x,point1.y,point2.x,point2.y,clr,style);
  }
//+------------------------------------------------------------------+
//| Draws all curves                                                 |
//+------------------------------------------------------------------+
bool CGraphic::CurvePlotAll(void)
  {
   ResetParameters();
   CalculateBoundaries();
//--- updare axes
   if(m_xupdate)
      CalculateXAxis();
   if(m_yupdate)
      CalculateYAxis();
//--- create workspace and grid
   CreateWorkspace();
   CreateGrid();
//--- draw all curves
   for(int i=0; i<m_arr_curves.Total(); i++)
     {
      //--- gets the curve
      CCurve *curve=m_arr_curves.At(i);

      if(!CheckPointer(curve))
         return(false);
      curve.Visible(true);

      //--- draws depending on the type of curve
      switch(curve.Type())
        {
         case CURVE_CUSTOM:
            CustomPlot(curve);
            break;
         case CURVE_POINTS:
            PointsPlot(curve);
            break;
         case CURVE_LINES:
            LinesPlot(curve);
            break;
         case CURVE_POINTS_AND_LINES:
            PointsAndLinesPlot(curve);
            break;
         case CURVE_STEPS:
            StepsPlot(curve);
            break;
         case CURVE_HISTOGRAM:
            HistogramPlot(curve);
            break;
         case CURVE_NONE:
            break;
        }
      //--- draw trend line
      if(curve.TrendLineVisible())
         TrendLinePlot(curve);
     }
//--- create background
   CreateBackground();
//--- create names for axes
   CreateXName();
   CreateYName();
//--- create axes
   CreateAxes();
//--- create history  
   CreateHistory();
//--- success
   return(true);
  }
//+------------------------------------------------------------------+
//| Draws a curve by index                                           |
//+------------------------------------------------------------------+
bool CGraphic::CurvePlot(const int index)
  {
   CCurve *curve=dynamic_cast<CCurve*>(m_arr_curves.At(index));
   if(CheckPointer(curve)==POINTER_DYNAMIC)
      curve.Visible(true);
   else
      return(false);
//--- 
   ResetParameters();
   CalculateBoundaries();
//--- update axes
   if(m_xupdate)
      CalculateXAxis();
   if(m_yupdate)
      CalculateYAxis();
//--- create workspace and grid
   CreateWorkspace();
   CreateGrid();
//--- draw all curves
   for(int i=0; i<m_arr_curves.Total(); i++)
     {
      //--- gets the curve
      curve=dynamic_cast<CCurve*>(m_arr_curves.At(i));

      if(CheckPointer(curve)!=POINTER_DYNAMIC)
         return(false);
      if(!curve.Visible())
         continue;

      //--- draws depending on the type of curve
      switch(curve.Type())
        {
         case CURVE_CUSTOM:
            CustomPlot(curve);
            break;
         case CURVE_POINTS:
            PointsPlot(curve);
            break;
         case CURVE_LINES:
            LinesPlot(curve);
            break;
         case CURVE_POINTS_AND_LINES:
            PointsAndLinesPlot(curve);
            break;
         case CURVE_STEPS:
            StepsPlot(curve);
            break;
         case CURVE_HISTOGRAM:
            HistogramPlot(curve);
            break;
         case CURVE_NONE:
            break;
        }
      //--- draw trend line
      if(curve.TrendLineVisible())
         TrendLinePlot(curve);
     }
//--- create background
   CreateBackground();
//--- create names for axes
   CreateXName();
   CreateYName();
//--- create axes
   CreateAxes();
//--- create history
   CreateHistory();
//--- success
   return(true);
  }
//+------------------------------------------------------------------+
//| Redraw grahic                                                    |
//+------------------------------------------------------------------+
bool CGraphic::Redraw(const bool rescale=false)
  {
   ResetParameters();
   CalculateBoundaries();
   if(rescale)
     {
      CalculateMaxMinValues();
     }
//--- update axes
   if(m_xupdate)
      CalculateXAxis();
   if(m_yupdate)
      CalculateYAxis();
//--- create workspace and grid
   CreateWorkspace();
   CreateGrid();
//--- draw all curves
   for(int i=0; i<m_arr_curves.Total(); i++)
     {
      //--- gets the curve
      CCurve *curve=dynamic_cast<CCurve*>(m_arr_curves.At(i));

      if(CheckPointer(curve)!=POINTER_DYNAMIC)
         return(false);
      if(!curve.Visible())
         continue;

      //--- draws depending on the type of curve
      switch(curve.Type())
        {
         case CURVE_CUSTOM:
            CustomPlot(curve);
            break;
         case CURVE_POINTS:
            PointsPlot(curve);
            break;
         case CURVE_LINES:
            LinesPlot(curve);
            break;
         case CURVE_POINTS_AND_LINES:
            PointsAndLinesPlot(curve);
            break;
         case CURVE_STEPS:
            StepsPlot(curve);
            break;
         case CURVE_HISTOGRAM:
            HistogramPlot(curve);
            break;
         case CURVE_NONE:
            break;
        }
      //--- draw trend line
      if(curve.TrendLineVisible())
         TrendLinePlot(curve);
     }
//--- create background
   CreateBackground();
//--- create names for axes
   CreateXName();
   CreateYName();
//--- create axes
   CreateAxes();
//--- create hictory  
   CreateHistory();
//--- success
   return(true);
  }
//+------------------------------------------------------------------+
//| Update graphic on screen (redraw)                                |
//+------------------------------------------------------------------+  
void CGraphic::Update(const bool redraw=true)
  {
   m_canvas.Update(redraw);
  }
//+------------------------------------------------------------------+
//| Gets the number of curves on the graphic                         |
//+------------------------------------------------------------------+
int CGraphic::CurvesTotal(void)
  {
   return(m_arr_curves.Total());
  }
//+------------------------------------------------------------------+
//| Gets the curve in the specified index                            |
//+------------------------------------------------------------------+
CCurve *CGraphic::CurveGetByIndex(const int index)
  {
   return(m_arr_curves.At(index));
  }
//+------------------------------------------------------------------+
//| Gets the curve by name                                           |
//+------------------------------------------------------------------+
CCurve *CGraphic::CurveGetByName(const string name)
  {
//--- try to find curve by name
   for(int i=0; i<m_arr_curves.Total(); i++)
     {
      CCurve *curve=dynamic_cast<CCurve*>(m_arr_curves.At(i));
      if(curve.Name()==name)
         return(curve);
     }
//--- failed
   return(NULL);
  }
//+------------------------------------------------------------------+
//| Remove the curve in the specified index                          |
//+------------------------------------------------------------------+
bool CGraphic::CurveRemoveByIndex(const int index)
  {
   CCurve *curve=dynamic_cast<CCurve*>(m_arr_curves.Detach(index));
   if(CheckPointer(curve)==POINTER_DYNAMIC)
     {
      delete curve;
      return(true);
     }
   else
     {
      return(false);
     }
  }
//+------------------------------------------------------------------+
//| Remove the curve by name                                         |
//+------------------------------------------------------------------+
bool CGraphic::CurveRemoveByName(const string name)
  {
   for(int i=0; i<m_arr_curves.Total(); i++)
     {
      CCurve *curve=m_arr_curves.At(i);
      if(curve.Name()==name)
        {
         if(CheckPointer(curve)==POINTER_DYNAMIC)
           {
            delete m_arr_curves.Detach(i);
            return(true);
           }
         else
           {
            return(false);
           }
        }
     }
   return(false);
  }
//+------------------------------------------------------------------+
//| Calculate x coordinate in pixels                                 |
//+------------------------------------------------------------------+
int CGraphic::ScaleX(const double x)
  {
   int xc=m_left+(int)((x-m_x.Min())*m_dx);
//--- return x coordinate
   return(xc);
  }
//+------------------------------------------------------------------+
//| Calculate y coordinate in pixels                                 |
//+------------------------------------------------------------------+
int CGraphic::ScaleY(const double y)
  {
   int yc=m_height-m_down-(int)((y-m_y.Min())*m_dy);
//--- return y coordinate
   return(yc);
  }
//+------------------------------------------------------------------+
//| Draws a curve custom                                             |
//+------------------------------------------------------------------+
void CGraphic::CustomPlot(CCurve *curve)
  {
   int size=curve.Size();
   double x[],y[];
//--- gets the coordinates of the curve
   curve.GetX(x);
   curve.GetY(y);
//--- check
   if(ArraySize(x)==0 || ArraySize(y)==0)
      return;
//--- get and check custom fucntion
   PlotFucntion plot=curve.CustomPlotFunction();
   if(plot==NULL)
      return;

   CGraphic *graphic=GetPointer(this);
   CCanvas *canvas=GetPointer(m_canvas);
   void *cbdata=curve.CustomPlotCBData();
//--- draw   
   plot(x,y,size,graphic,canvas,cbdata);
  }
//+------------------------------------------------------------------+
//| Draws a curve points                                             |
//+------------------------------------------------------------------+
void CGraphic::PointsPlot(CCurve *curve)
  {
   int size=curve.Size();
   double x[],y[];
//--- gets the coordinates of the curve
   curve.GetX(x);
   curve.GetY(y);
//--- check
   if(ArraySize(x)==0 || ArraySize(y)==0)
      return;
//--- check points size
   if(curve.PointsSize()==0)
      return;
//--- gets the colors
   uint clr0 = curve.Color();
   uint clr1 = curve.PointsColor();
//--- draw 
   for(int i=0; i<size; i++)
     {
      //--- check coordinates
      if(!MathIsValidNumber(x[i]) || !MathIsValidNumber(y[i]))
         continue;
      int xc=ScaleX(x[i]);
      int yc=ScaleY(y[i]);
      int r=curve.PointsSize()/2;
      if(r>0)
        {
         switch(curve.PointsType())
           {
            case POINT_CIRCLE:
              {
               //--- draw fill circle
               if(curve.PointsFill())
                  m_canvas.FillCircle(xc,yc,r,clr1);
               //--- draw circle
               m_canvas.CircleWu(xc,yc,r,clr0);
               break;
              }
            case POINT_SQUARE:
              {
               //--- draw square
               m_canvas.Rectangle(xc-r,yc-r,xc+r,yc+r,clr0);
               //--- draw fill square
               if(curve.PointsFill())
                  m_canvas.FillRectangle(xc-r+1,yc-r+1,xc+r-1,yc+r-1,clr1);
               break;
              }
            case POINT_DIAMOND:
              {
               int xc1=xc+1-r;
               int yc1=yc;
               int xc2=xc;
               int yc2=yc+1-r;
               //--- draw diamond
               m_canvas.Line(xc-r,yc,xc,yc-r,clr0);
               m_canvas.Line(xc,yc-r,xc+r,yc,clr0);
               m_canvas.Line(xc+r,yc,xc,yc+r,clr0);
               m_canvas.Line(xc,yc+r,xc-r,yc,clr0);
               //--- draw fill diamond
               if(curve.PointsFill())
                 {
                  int count=(curve.PointsSize()%2==0) ? curve.PointsSize()-1 : curve.PointsSize()-2;
                  for(int j=0; j<count; j++)
                    {
                     m_canvas.Line(xc1,yc1,xc2,yc2,clr1);
                     if(j%2==0)
                       {
                        yc2++;
                        xc1++;
                       }
                     else
                       {
                        xc2++;
                        yc1++;
                       }
                    }
                 }
               break;
              }
            case POINT_TRIANGLE:
              {
               //--- draw triangle
               m_canvas.TriangleWu(xc,yc-r,xc-r,yc+r,xc+r,yc+r,clr0);
               //--- draw fill triangle
               if(curve.PointsFill())
                 {
                  int dy=-r;
                  int dx=0;
                  int count=(curve.PointsSize()%2==0) ? curve.PointsSize()-1 : curve.PointsSize()-2;
                  for(int j=0; j<count; j++, dy++)
                    {
                     m_canvas.LineHorizontal(xc-dx+1,xc+dx,yc+1+dy,clr1);
                     if(j%2==0)
                        dx++;
                    }
                 }
               break;
              }
            case POINT_TRIANGLE_DOWN:
              {
               //--- draw down triangle
               m_canvas.TriangleWu(xc,yc+r,xc-r,yc-r,xc+r,yc-r,clr0);
               //--- draw fill triangle
               if(curve.PointsFill())
                 {
                  int dy=r;
                  int dx=0;
                  int count=(curve.PointsSize()%2==0) ? curve.PointsSize()-1 : curve.PointsSize()-2;
                  for(int j=0; j<count; j++, dy--)
                    {
                     m_canvas.LineHorizontal(xc-dx+1,xc+dx,yc-1+dy,clr1);
                     if(j%2==0)
                        dx++;
                    }
                 }
               break;
              }
            case POINT_X_CROSS:
              {
               //--- draw x cross
               m_canvas.Line(xc+r,yc+r,xc-r,yc-r,clr0);
               m_canvas.Line(xc-r,yc+r,xc+r,yc-r,clr0);
               break;
              }
            case POINT_PLUS:
              {
               //--- draw plus
               m_canvas.LineHorizontal(xc+r+1,xc-r,yc,clr0);
               m_canvas.LineVertical(xc,yc+r,yc-r,clr0);
               break;
              }
            case POINT_STAR:
              {
               //--- draw plus
               m_canvas.LineHorizontal(xc+r+1,xc-r,yc,clr0);
               m_canvas.LineVertical(xc,yc+r,yc-r,clr0);
               //--- draw x cross
               m_canvas.Line(xc+r,yc+r,xc-r,yc-r,clr0);
               m_canvas.Line(xc-r,yc+r,xc+r,yc-r,clr0);
               break;
              }
            case POINT_HORIZONTAL_DASH:
              {
               //--- draw horizontal line
               m_canvas.LineHorizontal(xc+r+1,xc-r,yc,clr0);
               break;
              }
            case POINT_VERTICAL_DASH:
              {
               //--- draw vertical line
               m_canvas.LineVertical(xc,yc+r,yc-r,clr0);
               break;
              }
           }
        }
      else
        {
         m_canvas.PixelSet(xc,yc,clr0);
        }
     }
//---
  }
//+------------------------------------------------------------------+
//| Draws a curve lines                                              |
//+------------------------------------------------------------------+
void CGraphic::LinesPlot(CCurve *curve)
  {
   int size;
   double x[],y[];
//--- gets the coordinates of the curve
   size=curve.Size();
   curve.GetX(x);
   curve.GetY(y);
//--- check
   if(ArraySize(x)==0 || ArraySize(y)==0)
      return;
//--- coordinates
   int  xc[];
   int  yc[];
   int discontinuity[];
//--- find gaps of curve   
   for(int i=0; i<size; i++)
     {
      if(!MathIsValidNumber(x[i]) || !MathIsValidNumber(y[i]))
        {
         ArrayResize(discontinuity,ArraySize(discontinuity)+1,size);
         discontinuity[ArraySize(discontinuity)-1]=i;
        }
     }
//--- get the tension for spline
   double tension=curve.LinesSmoothTension();
//--- check whether the curve breaks 
   if(ArraySize(discontinuity)==0)
     {
      //--- calculate coordinates of curve
      ArrayResize(xc,size);
      ArrayResize(yc,size);
      for(int i=0; i<size; i++)
        {
         xc[i]=ScaleX(x[i]);
         yc[i]=ScaleY(y[i]);
        }
      //--- draw curve
      if(curve.LinesSmooth() && size>2 && tension>0.0 && tension<=1.0)
         m_canvas.PolylineSmooth(xc,yc,curve.Color(),curve.LinesWidth(),curve.LinesStyle(),curve.LinesEndStyle(),tension,curve.LinesSmoothStep());
      else
      if(size>1)
         m_canvas.PolylineThick(xc,yc,curve.Color(),curve.LinesWidth(),curve.LinesStyle(),curve.LinesEndStyle());
      else
      if(size==1)
         m_canvas.PixelSet(xc[0],yc[0],curve.Color());
     }
   else
     {
      int index=0;
      for(int j=0; j<=ArraySize(discontinuity); j++)
        {
         double xj[];
         double yj[];
         int sizej=0;
         if(j==0)
           {
            sizej=discontinuity[0];
            ArrayCopy(xj,x,0,0,sizej);
            ArrayCopy(yj,y,0,0,sizej);
           }
         else
         if(j==ArraySize(discontinuity))
           {
            sizej=size-discontinuity[j-1]-1;
            ArrayCopy(xj,x,0,discontinuity[j-1]+1,sizej);
            ArrayCopy(yj,y,0,discontinuity[j-1]+1,sizej);
           }
         else
           {
            sizej=discontinuity[j]-discontinuity[j-1]-1;
            ArrayCopy(xj,x,0,discontinuity[j-1]+1,sizej);
            ArrayCopy(yj,y,0,discontinuity[j-1]+1,sizej);
           }
         //--- calculate coordinates path of curve
         ArrayResize(xc,sizej,size);
         ArrayResize(yc,sizej,size);
         for(int i=0; i<sizej; i++)
           {
            xc[i]=ScaleX(xj[i]);
            yc[i]=ScaleY(yj[i]);
            index++;
           }
         //--- draw path of curve
         if(curve.LinesSmooth() && size>2 && tension>0.0 && tension<=1.0)
            m_canvas.PolylineSmooth(xc,yc,curve.Color(),curve.LinesWidth(),curve.LinesStyle(),curve.LinesEndStyle(),tension,curve.LinesSmoothStep());
         else
         if(sizej>1)
            m_canvas.PolylineThick(xc,yc,curve.Color(),curve.LinesWidth(),curve.LinesStyle(),curve.LinesEndStyle());
         else
         if(sizej==1)
            m_canvas.PixelSet(xc[0],yc[0],curve.Color());
        }
     }
  }
//+------------------------------------------------------------------+
//| Draws a curve points over lines                                  |
//+------------------------------------------------------------------+
void CGraphic::PointsAndLinesPlot(CCurve *curve)
  {
   LinesPlot(curve);
   PointsPlot(curve);
  }
//+------------------------------------------------------------------+
//| Draws a curve steps                                              |
//+------------------------------------------------------------------+
void CGraphic::StepsPlot(CCurve *curve)
  {
   int size=curve.Size();
   double x[],y[];
//--- gets the coordinates of the curve
   curve.GetX(x);
   curve.GetY(y);
//--- coordinates
   int xc[],yc[];
   size=(size*2)-1;
   ArrayResize(xc,size);
   ArrayResize(yc,size);
   int index=0;
   if(curve.StepsDimension()==0)
     {
      //--- x dimension
      for(int i=0; i<size-1; i+=2,index++)
        {
         xc[i]=ScaleX(x[index]);
         xc[i+1]=ScaleX(x[index+1]);
         yc[i]=ScaleY(y[index]);
         yc[i+1]=yc[i];
        }
     }
   else
   if(curve.StepsDimension()==1)
     {
      //--- y dimension
      for(int i=0; i<size-1; i+=2,index++)
        {
         xc[i]=ScaleX(x[index]);
         xc[i+1]=xc[i];
         yc[i]=ScaleY(y[index]);
         yc[i+1]=ScaleY(y[index+1]);
        }
     }
   else
     {
      //--- unknown dimension
      return;
     }
//--- general path for x and y dimension   
   xc[size-1]=ScaleX(x[index]);
   yc[size-1]=ScaleY(y[index]);
   m_canvas.PolylineWu(xc,yc,curve.Color(),curve.LinesStyle());
  }
//+------------------------------------------------------------------+
//| Draws a curve histogram                                          |
//+------------------------------------------------------------------+
void CGraphic::HistogramPlot(CCurve *curve)
  {
   int size=curve.Size();
   double x[],y[];
//--- historgram parametrs
   int histogram_width=curve.HistogramWidth();
//--- check historgram 
   if(histogram_width<=0)
      return;
//--- gets the coordinates of the curve
   curve.GetX(x);
   curve.GetY(y);
//--- check
   if(ArraySize(x)==0 || ArraySize(y)==0)
      return;
//--- calculate original of y
   int originalY=m_height-m_down;
   int yc0=ScaleY(0.0);
//--- gets curve color
   uint clr=curve.Color();
//--- draw 
   for(int i=0; i<size; i++)
     {
      //--- check coordinates
      if(!MathIsValidNumber(x[i]) || !MathIsValidNumber(y[i]))
         continue;
      int xc=ScaleX(x[i]);
      int yc=ScaleY(y[i]);
      int xc1 = xc - histogram_width/2;
      int xc2 = xc + histogram_width/2;
      int yc1 = yc;
      int yc2 = (originalY>yc0 && yc0>0) ? yc0 : originalY;
      //---
      if(yc1>yc2)
         yc2++;
      else
         yc2--;
      //---
      m_canvas.FillRectangle(xc1,yc1,xc2,yc2,clr);
     }
//---
  }
//+------------------------------------------------------------------+
//| Draws a trend line for curve                                     |
//+------------------------------------------------------------------+
void CGraphic::TrendLinePlot(CCurve *curve)
  {
//--- simple linear regression 
   double coeff[];
   curve.TrendLineCoefficients(coeff);
//--- calculate coordinates   
   double x0=curve.XMin();
   double x1=curve.XMax();
   double y0=coeff[0]*x0+coeff[1];
   double y1=coeff[0]*x1+coeff[1];
//--- coordinates in pixels
   int xc0=ScaleX(x0);
   int xc1=ScaleX(x1);
   int yc0=ScaleY(y0);
   int yc1=ScaleY(y1);
   uint clr=curve.Color();
//--- draw line 
   m_canvas.LineWu(xc0,yc0,xc1,yc1,curve.TrendLineColor());
  }
//+------------------------------------------------------------------+
//| Create history of curves in the right side of the graphic        |
//+------------------------------------------------------------------+
void CGraphic::CreateHistory(void)
  {
   for(int i=0; i<m_arr_curves.Total(); i++)
     {
      CCurve *curve=dynamic_cast<CCurve*>(m_arr_curves.At(i));
      //--- check
      if(CheckPointer(curve)!=POINTER_DYNAMIC)
         return;
      if(!curve.Visible())
         continue;
      //--- calculate y coordinate
      int yc=m_up+m_history.name_size/2+m_history.name_size*m_history.count_total;
      //--- gets the curve name
      string name=curve.Name();
      //--- draw symbol
      switch(curve.Type())
        {
         case CURVE_STEPS:
         case CURVE_POINTS_AND_LINES:
         case CURVE_LINES:
           {
            //--- coordinates 
            int xc1=m_width-m_right+m_gap;
            int xc2=m_width-m_right+m_gap+m_history.symbol_size;
            if(m_history.symbol_size>0)
               m_canvas.LineWu(xc1,yc,xc2,yc,curve.Color(),curve.LinesStyle());
            if(curve.Type()==CURVE_LINES)
              {
               if(name==NULL)
                 {
                  name="Lines "+IntegerToString(m_history.count_lines++);
                  curve.Name(name);
                 }
               break;
              }
            else
            if(curve.Type()==CURVE_STEPS)
              {
               if(name==NULL)
                 {
                  name="Steps "+IntegerToString(m_history.count_lines++);
                  curve.Name(name);
                 }
               break;
              }
           }
         case CURVE_POINTS :
           {
            //--- coordinates 
            int xc=m_width-m_right+m_gap+m_history.symbol_size/2;
            int r=(m_history.symbol_size)/3;
            if(r>0)
              {
               switch(curve.PointsType())
                 {
                  case POINT_CIRCLE:
                    {
                     //--- draw fill circle
                     if(curve.PointsFill())
                        m_canvas.FillCircle(xc,yc,r,curve.PointsColor());
                     //--- draw circle
                     m_canvas.CircleWu(xc,yc,r,curve.Color());
                     break;
                    }
                  case POINT_SQUARE:
                    {
                     //--- draw square
                     m_canvas.Rectangle(xc-r,yc-r,xc+r,yc+r,curve.Color());
                     //--- draw fill square
                     if(curve.PointsFill())
                        m_canvas.FillRectangle(xc-r+1,yc-r+1,xc+r-1,yc+r-1,curve.PointsColor());
                     break;
                    }
                  case POINT_DIAMOND:
                    {
                     int xc1=xc+1-r;
                     int yc1=yc;
                     int xc2=xc;
                     int yc2=yc+1-r;
                     //--- draw diamond
                     m_canvas.Line(xc-r,yc,xc,yc-r,curve.Color());
                     m_canvas.Line(xc,yc-r,xc+r,yc,curve.Color());
                     m_canvas.Line(xc+r,yc,xc,yc+r,curve.Color());
                     m_canvas.Line(xc,yc+r,xc-r,yc,curve.Color());
                     //--- draw fill diamond
                     if(curve.PointsFill())
                       {
                        int count=((r*2)%2==0) ? (r*2)-1 : (r*2)-2;
                        for(int j=0; j<count; j++)
                          {
                           m_canvas.Line(xc1,yc1,xc2,yc2,curve.PointsColor());
                           if(j%2==0)
                             {
                              yc2++;
                              xc1++;
                             }
                           else
                             {
                              xc2++;
                              yc1++;
                             }
                          }
                       }
                     break;
                    }
                  case POINT_TRIANGLE:
                    {
                     //--- draw triangle
                     m_canvas.TriangleWu(xc,yc-r,xc-r,yc+r,xc+r,yc+r,curve.Color());
                     //--- draw fill triangle
                     if(curve.PointsFill())
                       {
                        int dy=-r;
                        int dx=0;
                        int count=((r*2)%2==0) ? (r*2)-1 : (r*2)-2;
                        for(int j=0; j<count; j++, dy++)
                          {
                           m_canvas.LineHorizontal(xc-dx+1,xc+dx,yc+1+dy,curve.PointsColor());
                           if(j%2==0)
                              dx++;
                          }
                       }
                     break;
                    }
                  case POINT_TRIANGLE_DOWN:
                    {
                     //--- draw down triangle
                     m_canvas.TriangleWu(xc,yc+r,xc-r,yc-r,xc+r,yc-r,curve.Color());
                     //--- draw fill triangle
                     if(curve.PointsFill())
                       {
                        int dy=r;
                        int dx=0;
                        int count=((r*2)%2==0) ? (r*2)-1 : (r*2)-2;
                        for(int j=0; j<count; j++, dy--)
                          {
                           m_canvas.LineHorizontal(xc-dx+1,xc+dx,yc-1+dy,curve.PointsColor());
                           if(j%2==0)
                              dx++;
                          }
                       }
                     break;
                    }
                  case POINT_X_CROSS:
                    {
                     //--- draw x cross
                     m_canvas.Line(xc+r,yc+r,xc-r,yc-r,curve.Color());
                     m_canvas.Line(xc-r,yc+r,xc+r,yc-r,curve.Color());
                     break;
                    }
                  case POINT_PLUS:
                    {
                     //--- draw plus
                     m_canvas.LineHorizontal(xc+r+1,xc-r,yc,curve.Color());
                     m_canvas.LineVertical(xc,yc+r,yc-r,curve.Color());
                     break;
                    }
                  case POINT_STAR:
                    {
                     //--- draw plus
                     m_canvas.LineHorizontal(xc+r+1,xc-r,yc,curve.Color());
                     m_canvas.LineVertical(xc,yc+r,yc-r,curve.Color());
                     //--- draw x cross
                     m_canvas.Line(xc+r,yc+r,xc-r,yc-r,curve.Color());
                     m_canvas.Line(xc-r,yc+r,xc+r,yc-r,curve.Color());
                     break;
                    }
                  case POINT_HORIZONTAL_DASH:
                    {
                     //--- draw horizontal line
                     m_canvas.LineHorizontal(xc+r+1,xc-r,yc,curve.Color());
                     break;
                    }
                  case POINT_VERTICAL_DASH:
                    {
                     //--- draw vertical line
                     m_canvas.LineVertical(xc,yc+r,yc-r,curve.Color());
                     break;
                    }
                 }
              }
            else
              {
               if(curve.PointsSize()>0)
                  m_canvas.PixelSet(xc,yc,curve.Color());
              }
            if(curve.Type()==CURVE_POINTS)
              {
               if(name==NULL)
                 {
                  name="Points "+IntegerToString(m_history.count_points++);
                  curve.Name(name);
                 }
              }
            else
            if(curve.Type()==CURVE_POINTS_AND_LINES)
              {
               if(name==NULL)
                 {
                  name="Points and Lines "+IntegerToString(m_history.count_points++);
                  curve.Name(name);
                 }
              }
            break;
           }
         case CURVE_HISTOGRAM:
           {
            //--- coordinates 
            int xc1=m_width-m_right+m_gap+m_history.symbol_size/6;
            int yc1=yc-m_history.symbol_size*1/3;
            int xc2=m_width-m_right+m_gap+(m_history.symbol_size*5)/6;
            int yc2=yc+m_history.symbol_size*1/3;
            if(m_history.symbol_size>0)
               m_canvas.FillRectangle(xc1,yc1,xc2,yc2,curve.Color());
            if(name==NULL)
              {
               name="Histogram "+IntegerToString(m_history.count_histogram++);
               curve.Name(name);
              }
            break;
           }
         case CURVE_CUSTOM:
           {
            if(name==NULL)
              {
               name="Custom "+IntegerToString(m_history.count_custom++);
               curve.Name(name);
              }
            break;
           }
        };
      //--- trim the name
      m_canvas.FontSet("arial",m_history.name_size);
      if(m_canvas.TextWidth(name)>m_history.name_width)
        {
         if(m_canvas.TextWidth("...")>m_history.name_width)
           {
            name=NULL;
           }
         else
           {
            while(m_canvas.TextWidth(name+"...")>m_history.name_width)
               name=StringSubstr(name,0,StringLen(name)-1);
            name+="...";
           }
        }
      //--- coordinates 
      int xct=m_width-m_right+2*m_gap+m_history.symbol_size;
      int yct=yc-m_history.name_size/2;
      //--- draw text
      m_canvas.TextOut(xct,yct,name,ColorToARGB(clrBlack));
      m_history.count_total++;
     }
  }
//+------------------------------------------------------------------+
//| Reset current parameters on graphic                              |
//+------------------------------------------------------------------+
void CGraphic::SetDefaultParameters(void)
  {
//--- sets the general default values
   m_xupdate=false;
   m_yupdate=false;
   m_xsize=0;
   m_ysize=0;
//--- sets the default values for boundaries
   m_left0=0;
   m_right0=5;
   m_up0=5;
   m_down0=0;
//--- sets the default values for graphic  
   m_mark_size=3;
   m_gap=4;
//--- sets the default values for history
   m_history.name_width=60;
   m_history.symbol_size=12;
   m_history.name_size=12;
   m_history.count_points=0;
   m_history.count_lines=0;
   m_history.count_histogram=0;
   m_history.count_custom=0;
//--- sets the default values for x and y axis
   m_x.Name(NULL);
   m_y.Name(NULL);
//--- sets the default values for grid
   m_grid.clr_line=clrWhiteSmoke;
   m_grid.clr_axis_line=clrSilver;
   m_grid.clr_frame=clrBlack;
   m_grid.clr_background=clrWhite;
   m_grid.r_circle=0;
   m_grid.clr_circle=clrWhite;
   m_grid.has_circle=false;
//--- sets the default values for background
   m_background.clr=clrWhite;
   m_background.clr_main= clrBlack;
   m_background.clr_sub = clrBlack;
   m_background.main= NULL;
   m_background.sub = NULL;
   m_background.size_main= 0;
   m_background.size_sub = 0;
  }
//+------------------------------------------------------------------+
//| Reset parametres                                                 |
//+------------------------------------------------------------------+
void CGraphic::ResetParameters(void)
  {
//--- reset boundaries 
   m_left=m_left0;
   m_right=m_right0;
   m_up=m_up0;
   m_down=m_down0;
//--- reset curve of history
   m_history.count_total=0;
  }
//+------------------------------------------------------------------+
//| Calculate boundaries for workspace                               |
//+------------------------------------------------------------------+
void  CGraphic::CalculateBoundaries(void)
  {
   if(m_width>0 && m_height>0)
     {
      m_right+=m_history.symbol_size+m_history.name_width+3*m_gap;
      m_up+=m_background.size_main+2*m_gap;
      m_down+=m_background.size_sub+m_x.ValuesSize()+m_x.NameSize()+4*m_gap;
      m_left+=m_y.NameSize()+m_mark_size+m_y.ValuesWidth()+4*m_gap;
     }
   else
     {
      ZeroMemory(m_right);
      ZeroMemory(m_up);
      ZeroMemory(m_down);
      ZeroMemory(m_left);
     }
  }
//+------------------------------------------------------------------+
//| Calculate the min and max values for both axes on all curves     |
//+------------------------------------------------------------------+
void CGraphic::CalculateMaxMinValues(void)
  {
   int size=m_arr_curves.Total();
   double xmax=0.0;
   double xmin=0.0;
   double ymax=0.0;
   double ymin=0.0;
   if(size>0)
     {
      bool valid=false;
      for(int i=0; i<size; i++)
        {
         CCurve *curve=dynamic_cast<CCurve*>(m_arr_curves.At(i));
         if(CheckPointer(curve)==POINTER_DYNAMIC)
           {
            if(!valid)
              {
               xmax = curve.XMax();
               xmin = curve.XMin();
               ymax = curve.YMax();
               ymin = curve.YMin();
               valid=true;
              }
            else
              {
               //--- find max of x
               if(xmax<curve.XMax())
                  xmax=curve.XMax();
               //--- find min of x
               if(xmin>curve.XMin())
                  xmin=curve.XMin();
               //--- find max of y
               if(ymax<curve.YMax())
                  ymax=curve.YMax();
               //--- find min of y
               if(ymin>curve.YMin())
                  ymin=curve.YMin();
              }
           }
        }
     }
   if(m_x.AutoScale())
     {
      m_x.Max(xmax);
      m_x.Min(xmin);
     }
   if(m_y.AutoScale())
     {
      m_y.Max(ymax);
      m_y.Min(ymin);
     }
   m_xupdate=true;
   m_yupdate=true;
  }
//+------------------------------------------------------------------+
//| Calculate coordinates and values for x axis                      |
//+------------------------------------------------------------------+
void CGraphic::CalculateXAxis(void)
  {
//---
   m_x.SelectAxisScale();
//--- gets the axis proprties
   double max = m_x.Max();
   double min = m_x.Min();
   double step= m_x.Step();
   ENUM_AXIS_TYPE xtype=m_x.Type();
   string xformat=m_x.ValuesFormat()==NULL ? "%.7g" : m_x.ValuesFormat();
   int xmode=m_x.ValuesDateTimeMode();
   DoubleToStringFunction xfunc=m_x.ValuesFunctionFormat();
   void *xcbdata=m_x.ValuesFunctionFormatCBData();
//--- calculate scaling parameters
   double xf1=m_left;
   double xf2=m_width-m_right;
//---
   double x_size=max-min;
   double xf_size=xf2-xf1;
//--- keep scaling parameters  
   m_dx=xf_size/x_size;
//--- calclulate size
   m_xsize=(int)MathRound((max-min)/step)+1;
   ArrayResize(m_xc,m_xsize);
   ArrayResize(m_xvalues,m_xsize);
//--- gets the factor precision
   double factor=AxisFactorPrecision(min,max,step);
   for(int i=0; i<m_xsize; i++)
     {
      double x=min+(i*step);
      //--- rounding off the calculation error     
      if(factor!=1.0)
         x=MathRound(x/factor)*factor;
      if(x>max)
         x=max;
      //--- calculate real coordinate
      if(i==0)
         m_xc[i]=m_left;
      else
      if(i==m_xsize-1)
         m_xc[i]=m_width-m_right;
      else
         m_xc[i]=m_left+(int)((x-min)*m_dx);
      //--- create values names
      switch(xtype)
        {
         case AXIS_TYPE_DOUBLE:
           {
            m_xvalues[i]=StringFormat(xformat,x);
            break;
           }
         case AXIS_TYPE_DATETIME:
           {
            m_xvalues[i]=TimeToString((datetime)x,xmode);
            break;
           }
         case AXIS_TYPE_CUSTOM:
           {
            m_xvalues[i]=(xfunc==NULL) ? NULL : xfunc(x,xcbdata);
            break;
           }
        };
     }
//---
   m_xupdate=false;
  }
//+------------------------------------------------------------------+
//| Calculate coordinates and values for y axis                      |
//+------------------------------------------------------------------+
void CGraphic::CalculateYAxis(void)
  {
//---
   m_y.SelectAxisScale();
//--- gets the axis proprties
   double max = m_y.Max();
   double min = m_y.Min();
   double step= m_y.Step();
   ENUM_AXIS_TYPE ytype=m_y.Type();
   string yformat=m_y.ValuesFormat()==NULL ? "%.7g" : m_y.ValuesFormat();
   int ymode=m_y.ValuesDateTimeMode();
   DoubleToStringFunction yfunc=m_y.ValuesFunctionFormat();
   void *ycbdata=m_y.ValuesFunctionFormatCBData();
//--- calculate scaling parameters
   double yf1=m_up;
   double yf2=m_height-m_down;
//---
   double y_size=max-min;
   double yf_size=yf2-yf1;
//--- keep scaling parameters  
   m_dy=yf_size/y_size;
//--- calclulate size
   m_ysize=(int)MathRound((max-min)/step)+1;
   ArrayResize(m_yc,m_ysize);
   ArrayResize(m_yvalues,m_ysize);
//--- gets the factor precision
   double factor=AxisFactorPrecision(min,max,step);
   for(int i=0; i<m_ysize; i++)
     {
      double y=min+(i*step);
      //--- rounding off the calculation error
      if(factor!=1.0)
         y=MathRound(y/factor)*factor;
      if(y>max)
         y=max;
      //--- calculate real coordinate
      if(i==0)
         m_yc[i]=m_height-m_down;
      else
      if(i==m_ysize-1)
         m_yc[i]=m_up;
      else
         m_yc[i]=m_height-m_down-(int)((y-min)*m_dy);
      //--- create values names
      switch(ytype)
        {
         case AXIS_TYPE_DOUBLE:
           {
            m_yvalues[i]=StringFormat(yformat,y);
            StringTrimLeft(m_yvalues[i]);
            StringTrimRight(m_yvalues[i]);
            break;
           }
         case AXIS_TYPE_DATETIME:
           {
            m_yvalues[i]=TimeToString((datetime)y,ymode);
            break;
           }
         case AXIS_TYPE_CUSTOM:
           {
            m_yvalues[i]=(yfunc==NULL) ? NULL : yfunc(y,ycbdata);
            break;
           }
        };
     }
//---
   m_yupdate=false;
  }
//+------------------------------------------------------------------+
//| Gets the factor precision for calculation error of control values|
//| on axis                                                          |
//+------------------------------------------------------------------+
double CGraphic::AxisFactorPrecision(const double min,const double max,const double step)
  {
   static const double big_value=4097.0;
//--- create some big values based on control values
   double big_min=big_value*min;
   double big_max=big_value*max;
   double big_step=big_value*step;
//--- gets the difference between big values and their control values
   double delta_min=big_min-min;
   double delta_max=big_max-max;
   double delta_step=big_step-step;
//--- gets the calculating error of control values
   double error_min=MathAbs(min-(big_min-delta_min));
   double error_max=MathAbs(max-(big_max-delta_max));
   double error_step=MathAbs(step-(big_step-delta_step));
//--- get max error
   double error=MathMax(MathMax(error_min,error_max),error_step);
//--- calculate factor
   double factor=1.0;
   if(error!=0)
     {
      double log10_val=MathLog10(MathAbs(error));
      log10_val=(log10_val>0) ? MathCeil(log10_val) : MathFloor(log10_val);
      if(log10_val<=-308)
         factor=1e-308;
      else
      if(log10_val>=308)
         factor=1e308;
      else
         factor=MathPow(10,log10_val);
     }
   return(factor);
  }
//+------------------------------------------------------------------+
//| Create graphic of one curve and return resource name             |
//+------------------------------------------------------------------+
string GraphPlot(const double &y[],ENUM_CURVE_TYPE type=CURVE_POINTS,string objname=NULL)
  {
   CGraphic graphic;
   ulong    width = ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   ulong    height= ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- create graphic
   bool res=false;
   objname = (objname==NULL) ? "Graphic" : objname;
   if(ObjectFind(0,objname)>=0)
      res=graphic.Attach(0,objname);
   else
      res=graphic.Create(0,objname,0,65,45,(int)(0.6*width),(int)(0.65*height));
   if(!res)
      return(NULL);
//--- add curves
   graphic.CurveAdd(y,type);
//--- plot curves
   graphic.CurvePlotAll();
   graphic.Update();
//--- return resource name
   return graphic.ChartObjectName();
  }
//+------------------------------------------------------------------+
//| Create graphic of one curve and return resource name             |
//+------------------------------------------------------------------+
string GraphPlot(const double &x[],const double &y[],ENUM_CURVE_TYPE type=CURVE_POINTS,string objname=NULL)
  {
   CGraphic graphic;
   ulong    width = ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   ulong    height= ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- create graphic
   bool res=false;
   objname = (objname==NULL) ? "Graphic" : objname;
   if(ObjectFind(0,objname)>=0)
      res=graphic.Attach(0,objname);
   else
      res=graphic.Create(0,objname,0,65,45,(int)(0.6*width),(int)(0.65*height));
   if(!res)
      return(NULL);
//--- add curves
   graphic.CurveAdd(x,y,type);
//--- plot curves
   graphic.CurvePlotAll();
   graphic.Update();
//--- return resource name
   return graphic.ChartObjectName();
  }
//+------------------------------------------------------------------+
//| Create graphic of two curve and return resource name             |
//+------------------------------------------------------------------+  
string GraphPlot(const double &x1[],const double &y1[],const double &x2[],const double &y2[],ENUM_CURVE_TYPE type=CURVE_POINTS,string objname=NULL)
  {
   CGraphic graphic;
   ulong    width = ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   ulong    height= ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- create graphic
   bool res=false;
   objname = (objname==NULL) ? "Graphic" : objname;
   if(ObjectFind(0,objname)>=0)
      res=graphic.Attach(0,objname);
   else
      res=graphic.Create(0,objname,0,65,45,(int)(0.6*width),(int)(0.65*height));
   if(!res)
      return(NULL);
//--- add curves
   graphic.CurveAdd(x1,y1,type);
   graphic.CurveAdd(x2,y2,type);
//--- plot curves
   graphic.CurvePlotAll();
   graphic.Update();
//--- return resource name
   return graphic.ChartObjectName();
  }
//+------------------------------------------------------------------+
//| Create graphic of three curve and return resource name           |
//+------------------------------------------------------------------+  
string GraphPlot(const double &x1[],const double &y1[],const double &x2[],const double &y2[],const double &x3[],const double &y3[],ENUM_CURVE_TYPE type=CURVE_POINTS,string objname=NULL)
  {
   CGraphic graphic;
   ulong    width = ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   ulong    height= ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- create graphic
   bool res=false;
   objname = (objname==NULL) ? "Graphic" : objname;
   if(ObjectFind(0,objname)>=0)
      res=graphic.Attach(0,objname);
   else
      res=graphic.Create(0,objname,0,65,45,(int)(0.6*width),(int)(0.65*height));
   if(!res)
      return(NULL);
//--- add curves
   graphic.CurveAdd(x1,y1,type);
   graphic.CurveAdd(x2,y2,type);
   graphic.CurveAdd(x3,y3,type);
//--- plot curves
   graphic.CurvePlotAll();
   graphic.Update();
//--- return resource name
   return graphic.ChartObjectName();
  }
//+------------------------------------------------------------------+
//| Create graphic of one curve and return resource name             |
//+------------------------------------------------------------------+
string GraphPlot(const CPoint2D &points[],ENUM_CURVE_TYPE type=CURVE_POINTS,string objname=NULL)
  {
   CGraphic graphic;
   ulong    width = ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   ulong    height= ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- create graphic
   bool res=false;
   objname = (objname==NULL) ? "Graphic" : objname;
   if(ObjectFind(0,objname)>=0)
      res=graphic.Attach(0,objname);
   else
      res=graphic.Create(0,objname,0,65,45,(int)(0.6*width),(int)(0.65*height));
   if(!res)
      return(NULL);
//--- add curves
   graphic.CurveAdd(points,type);
//--- plot curves
   graphic.CurvePlotAll();
   graphic.Update();
//--- return resource name
   return graphic.ChartObjectName();
  }
//+------------------------------------------------------------------+
//| Create graphic of two curve and return resource name             |
//+------------------------------------------------------------------+  
string GraphPlot(const CPoint2D &points1[],const CPoint2D &points2[],ENUM_CURVE_TYPE type=CURVE_POINTS,string objname=NULL)
  {
   CGraphic graphic;
   ulong    width = ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   ulong    height= ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- create graphic
   bool res=false;
   objname = (objname==NULL) ? "Graphic" : objname;
   if(ObjectFind(0,objname)>=0)
      res=graphic.Attach(0,objname);
   else
      res=graphic.Create(0,objname,0,65,45,(int)(0.6*width),(int)(0.65*height));
   if(!res)
      return(NULL);
//--- add curves
   graphic.CurveAdd(points1,type);
   graphic.CurveAdd(points2,type);
//--- plot curves
   graphic.CurvePlotAll();
   graphic.Update();
//--- return resource name
   return graphic.ChartObjectName();
  }
//+------------------------------------------------------------------+
//| Create graphic of three curve and return resource name           |
//+------------------------------------------------------------------+  
string GraphPlot(const CPoint2D &points1[],const CPoint2D &points2[],const CPoint2D &points3[],ENUM_CURVE_TYPE type=CURVE_POINTS,string objname=NULL)
  {
   CGraphic graphic;
   ulong    width = ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   ulong    height= ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- create graphic
   bool res=false;
   objname = (objname==NULL) ? "Graphic" : objname;
   if(ObjectFind(0,objname)>=0)
      res=graphic.Attach(0,objname);
   else
      res=graphic.Create(0,objname,0,65,45,(int)(0.6*width),(int)(0.65*height));
   if(!res)
      return(NULL);
//--- add curves
   graphic.CurveAdd(points1,type);
   graphic.CurveAdd(points2,type);
   graphic.CurveAdd(points3,type);
//--- plot curves
   graphic.CurvePlotAll();
   graphic.Update();
//--- return resource name
   return graphic.ChartObjectName();
  }
//+------------------------------------------------------------------+
//| Create graphic of one curve and return resource name             |
//+------------------------------------------------------------------+
string GraphPlot(CurveFunction function,const double from,const double to,const double step,ENUM_CURVE_TYPE type=CURVE_POINTS,string objname=NULL)
  {
   CGraphic graphic;
   ulong    width = ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   ulong    height= ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- create graphic
   bool res=false;
   objname = (objname==NULL) ? "Graphic" : objname;
   if(ObjectFind(0,objname)>=0)
      res=graphic.Attach(0,objname);
   else
      res=graphic.Create(0,objname,0,65,45,(int)(0.6*width),(int)(0.65*height));
   if(!res)
      return(NULL);
//--- add curves
   graphic.CurveAdd(function,from,to,step,type);
//--- plot curves
   graphic.CurvePlotAll();
   graphic.Update();
//--- return resource name
   return graphic.ChartObjectName();
  }
//+------------------------------------------------------------------+
//| Create graphic of two curve and return resource name             |
//+------------------------------------------------------------------+  
string GraphPlot(CurveFunction function1,CurveFunction function2,const double from,const double to,const double step,ENUM_CURVE_TYPE type=CURVE_POINTS,string objname=NULL)
  {
   CGraphic graphic;
   ulong    width = ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   ulong    height= ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- create graphic
   bool res=false;
   objname = (objname==NULL) ? "Graphic" : objname;
   if(ObjectFind(0,objname)>=0)
      res=graphic.Attach(0,objname);
   else
      res=graphic.Create(0,objname,0,65,45,(int)(0.6*width),(int)(0.65*height));
   if(!res)
      return(NULL);
//--- add curves
   graphic.CurveAdd(function1,from,to,step,type);
   graphic.CurveAdd(function2,from,to,step,type);
//--- plot curves
   graphic.CurvePlotAll();
   graphic.Update();
//--- return resource name
   return graphic.ChartObjectName();
  }
//+------------------------------------------------------------------+
//| Create graphic of three curve and return resource name           |
//+------------------------------------------------------------------+  
string GraphPlot(CurveFunction function1,CurveFunction function2,CurveFunction function3,const double from,const double to,const double step,ENUM_CURVE_TYPE type=CURVE_POINTS,string objname=NULL)
  {
   CGraphic graphic;
   ulong    width = ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   ulong    height= ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- create graphic
   bool res=false;
   objname = (objname==NULL) ? "Graphic" : objname;
   if(ObjectFind(0,objname)>=0)
      res=graphic.Attach(0,objname);
   else
      res=graphic.Create(0,objname,0,65,45,(int)(0.6*width),(int)(0.65*height));
   if(!res)
      return(NULL);
//--- add curves
   graphic.CurveAdd(function1,from,to,step,type);
   graphic.CurveAdd(function2,from,to,step,type);
   graphic.CurveAdd(function3,from,to,step,type);
//--- plot curves 
   graphic.CurvePlotAll();
   graphic.Update();
//--- return resource name
   return graphic.ChartObjectName();
  }
//+------------------------------------------------------------------+