MiniChart 0.9202

ÿþ//+------------------------------------------------------------------+

//| Open code                                                        |

//+------------------------------------------------------------------+

#property strict

#property version     "1.05"

#property copyright   "Roman."

#property link        "qwer1234_4@bk.ru"



#property description "Indicator Description." 

#property description "Press Mouse Left Button On First Mini Chart"

#property description "and Move Mouse to Scale Mini Charts." 

#property description " " 

#property description "If you like the indicator, you can thank the author"

#property description "Webmoney: Z330494414179, R222585888867" 

#property description " " 

#property description "Thank you very much."

#property indicator_chart_window

#define CSym(a) ( CSymbol[a] != "" ? CSymbol[a] : Symbol() )



#include <Canvas\Canvas.mqh>

//+------------------------------------------------------------------+

//| Custom indicator initialization function                         |

//+------------------------------------------------------------------+



// Osma, Stochastic, 



enum ENUM_LINE

  {

   Line_SCALE_ = 0,               // Current Time Frame

   Line_SCALE_0 = PERIOD_M1,      // Time Frame 1

   Line_SCALE_1 = PERIOD_M5,      // Time Frame 5

   Line_SCALE_10 = PERIOD_M15,    // Time Frame 15

   Line_SCALE_100 = PERIOD_M30,   // Time Frame 30

   Line_SCALE_1000 = PERIOD_H1,   // Time Frame 1

   Line_SCALE_10000 = PERIOD_H4,  // Time Frame 4

   Line_SCALE_100000 = PERIOD_D1, // Time Frame D

   Line_SCALE_1000000 = PERIOD_W1 // Time Frame W

  };

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

enum Chart_Style

  {

   CG1 = 1,//Line

   CG2 = 2,//Bar

   CG3 = 3,//Empty Candle

   CG4 = 4 //Fill Candle

  };

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

enum Cout_Chart

  {

   C1=1,//One Chart

   C2=2,//Two Chart

   C3=3,//Three Chart

   C4=4//Four Chart

  };

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

enum Sub_Window

  {

   SW1 = 0,//No Sub Window

   SW2 = 1,//MACD

   SW3=2//OsMA



/*   SW4 = 3 //OsMA + 2 Line MACD*/

  };

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

enum Chart_Percent

  {

   CP1 = 20,//20 Percent

   CP2 = 25,//25 Percent

   CP3 = 30,//30 Percent

   CP4 = 35,//35 Percent

   CP5 = 40,//40 Percent

   CP6 = 50,//50 Percent

   CP7 = 60 //60 Percent

  };



extern Cout_Chart   Chart=C3;

extern string Id="MnCharFirst";//Identifier Mini Charts



input  string Chart_1_Symbol="";//First Chart Symbol

input  ENUM_LINE    Chart_1_TimeFrame=Line_SCALE_1000000;//First Chart TimeFrame

input  Chart_Style Chart_1_Style=CG2;//First Chart Style

input  Sub_Window Chart_1_First_Sub_Window=SW2;//First Chart First Sub Window

input  Sub_Window Chart_1_Second_Sub_Window=SW1;//First Chart Second Sub Window



input  string Chart_2_Symbol="";//Second Chart Symbol                                                

extern ENUM_LINE    Chart_2_TimeFrame=Line_SCALE_100000;//Second Chart TimeFrame

input  Chart_Style Chart_2_Style=CG2;//Second Chart Style

input  Sub_Window Chart_2_First_Sub_Window=SW2;//Second Chart First Sub Window 

input  Sub_Window Chart_2_Second_Sub_Window=SW1;//Second Chart Chart Second Sub Window 



input  string Chart_3_Symbol="";//Third Chart Symbol  

extern ENUM_LINE    Chart_3_TimeFrame=Line_SCALE_10000;//Third Chart TimeFrame

input  Chart_Style Chart_3_Style=CG2;//Third Chart Style

input  Sub_Window Chart_3_First_Sub_Window=SW2;//Third Chart First Sub Window

input  Sub_Window Chart_3_Second_Sub_Window=SW1;//Third Chart Chart Second Sub Window



input  string Chart_4_Symbol="";//Fourth Chart Symbol  

extern ENUM_LINE    Chart_4_TimeFrame=Line_SCALE_1000;//Fourth Chart TimeFrame

input  Chart_Style Chart_4_Style=CG2;//Fourth Chart Style

input  Sub_Window Chart_4_First_Sub_Window=SW2;//Fourth Chart First Sub Window

input  Sub_Window Chart_4_Second_Sub_Window=SW1;//Fourth Chart Chart Second Sub Window



input Chart_Percent Graph_Height_Percent=CP4;//Sub Graphics Height Percent

input bool Auto_Height_Mini_Charts=true;//Auto Height Mini Charts

extern int Fixed_Height_Mini_Charts=60;//Fixed Height Mini Charts



extern int Width_Mini_Charts=250;//Width Mini Charts

extern int Space_Between_Mini_Charts=10;//Space Between Mini Charts

extern int Space_Up=10;  //Space Between Up Main Window and Mini Charts

extern int Space_Left=10;//Space Between Left Main Window and Mini Charts



input color Charts_Color=clrSlateGray;

input color Charts_Comment_Color=clrGold;



input color Up_Bar_Color=clrChartreuse;

input color Doji_Bar_Color = clrYellow;

input color Down_Bar_Color = clrOrangeRed;

input color Up_Fill_Candle=clrYellowGreen;

input color Down_Fill_Candle=clrDarkOrange;



input color Up_Gistogram_Color=clrYellowGreen;

input color Down_Gistogram_Color=clrLightPink;



input color MACD_Line_Color=clrCrimson;



int Width_Bars=4,Space_Between_Bars=1,Max_Chart,Max_Bars;

double buffer[1500];



string Ecanvas[20]=

  {

   "canvas_I","canvas_II","canvas_III","canvas_IV","canvas_V","canvas_VI","canvas_VII","canvas_IIX","canvas_IX","canvas_X",

   "canvas_XI","canvas_XII","canvas_XIII","canvas_XIV","canvas_XV","canvas_XVI","canvas_XVII","canvas_XIIX","canvas_XIX","canvas_XX"

  };

int chartH[20],RealHi[20];

string canvas[20],CSymbol[20];

CCanvas C[20];



int Height_SCharts[20];



long x_distance,y_distance,x_distance_prev,y_distance_prev;

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

int BigChart=1,SubChar=0;

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

int OnInit()

  {



   chartH[0] = 1;

   Max_Chart = 1;

   CSymbol[0]= Chart_1_Symbol;

   if(Chart_1_First_Sub_Window!=SW1)

     {

      chartH[Max_Chart]=-1;

      CSymbol[Max_Chart]=Chart_1_Symbol;

      Max_Chart=Max_Chart+1;

      SubChar=1;



     }



   if(Chart_1_Second_Sub_Window!=SW1)

     {

      chartH[Max_Chart]=-1;

      CSymbol[Max_Chart]=Chart_1_Symbol;

      Max_Chart=Max_Chart+1;

      SubChar=SubChar+1;

     }



   if(Chart>1)

     {

      BigChart=2;

      chartH[Max_Chart]=1;

      CSymbol[Max_Chart]=Chart_2_Symbol;

      Max_Chart=Max_Chart+1;

      if(Chart_2_First_Sub_Window!=SW1)

        {

         chartH[Max_Chart]=-1;

         CSymbol[Max_Chart]=Chart_2_Symbol;

         Max_Chart=Max_Chart+1;

         SubChar=SubChar+1;

        }



      if(Chart_2_Second_Sub_Window!=SW1)

        {

         chartH[Max_Chart]=-1;

         CSymbol[Max_Chart]=Chart_2_Symbol;

         SubChar=SubChar+1;

         Max_Chart=Max_Chart+1;

        }

     }



   if(Chart>2)

     {

      BigChart=3;

      chartH[Max_Chart]=1;

      CSymbol[Max_Chart]=Chart_3_Symbol;

      Max_Chart=Max_Chart+1;

      if(Chart_3_First_Sub_Window!=SW1)

        {

         chartH[Max_Chart]=-1;

         CSymbol[Max_Chart]=Chart_3_Symbol;

         Max_Chart=Max_Chart+1;

         SubChar=SubChar+1;

        }



      if(Chart_3_Second_Sub_Window!=SW1)

        {

         chartH[Max_Chart]=-1;

         CSymbol[Max_Chart]=Chart_3_Symbol;

         Max_Chart=Max_Chart+1;

         SubChar=SubChar+1;

        }

     }



   if(Chart>3)

     {

      BigChart=4;

      chartH[Max_Chart]=1;

      CSymbol[Max_Chart]=Chart_4_Symbol;

      Max_Chart=Max_Chart+1;

      if(Chart_4_First_Sub_Window!=SW1)

        {

         chartH[Max_Chart]=-1;

         CSymbol[Max_Chart]=Chart_4_Symbol;

         Max_Chart=Max_Chart+1;

         SubChar=SubChar+1;

        }



      if(Chart_4_Second_Sub_Window!=SW1)

        {

         chartH[Max_Chart]=-1;

         CSymbol[Max_Chart]=Chart_4_Symbol;

         Max_Chart=Max_Chart+1;

         SubChar=SubChar+1;

        }

     }



   ChartSetInteger(0,CHART_EVENT_MOUSE_MOVE,1);

   if(!ChartGetInteger(0,CHART_WIDTH_IN_PIXELS,0,x_distance))

     {

      Print("5 C40;>AL ?>;CG8BL H8@8=C 3@0D8:0! >4 >H81:8 = ",GetLastError());

      return 0;

     }



   if(!ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS,0,y_distance))

     {

      Print("5 C40;>AL ?>;CG8BL H8@8=C 3@0D8:0! >4 >H81:8 = ",GetLastError());

      return 0;

     }

   long handle=ChartID();

   ChartSetInteger(handle,CHART_AUTOSCROLL,true);

//--- CAB0=>28< >BABC? ?@02>3> :@0O 3@0D8:0

   ChartSetInteger(handle,CHART_SHIFT,true);



   ChartSetDouble(0,CHART_SHIFT_SIZE,(double(Width_Mini_Charts+Space_Left)/x_distance)*100+1);

   ChartNavigate(handle,CHART_END,0);



   ChartSetInteger(0,CHART_FOREGROUND,true);

   CalcMaxH();

   x_distance_prev=x_distance;

   y_distance_prev= y_distance;

   Max_Bars=Width_Mini_Charts/(Width_Bars+Space_Between_Bars)-1;

   return(INIT_SUCCEEDED);

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void CalcMaxH()

  {

   if(Auto_Height_Mini_Charts)

     {

      double Max_H=(double)(y_distance-2*Space_Up-Space_Between_Mini_Charts*(Max_Chart-1));

      Max_H=Max_H/(BigChart+0.01*(Graph_Height_Percent *SubChar));

      for(int i=0; i<Max_Chart; i++)

        {

         if(chartH[i]>0)

            RealHi[i]=(int)Max_H;

         else RealHi[i]=(int)(Max_H*Graph_Height_Percent)/100;

        }

     }

   else

     {

      for(int i=0; i<Max_Chart; i++)

        {

         if(chartH[i]>0)

            RealHi[i]=Fixed_Height_Mini_Charts;

         else RealHi[i]=(int)(Fixed_Height_Mini_Charts*Graph_Height_Percent)/100;

        }

     }



   int PrevH= 0;

   for(int i=0; i<Max_Chart; i++)

     {

      canvas[i]=Ecanvas[i]+Id;

      if(!CBL(i,PrevH)) Print("Error creating canvas: ",GetLastError());

      PrevH=PrevH+RealHi[i];

     }

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

bool CBL(int i,int Hi)

  {

   return C[i].CreateBitmapLabel(0,0,canvas[i], (int)x_distance - Width_Mini_Charts - Space_Left,

                                 Space_Up+i *(Space_Between_Mini_Charts)+Hi,

                                 Width_Mini_Charts,RealHi[i],COLOR_FORMAT_XRGB_NOALPHA);

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void deinit()

  {

   for(int i=0; i<Max_Chart; i++) C[i].Destroy();

  }

//+------------------------------------------------------------------+

//| Custom indicator iteration function                              |

//+------------------------------------------------------------------+

int OnCalculate(const int rates_total,

                const int prev_calculated,

                const datetime &time[],

                const double &open[],

                const double &high[],

                const double &low[],

                const double &close[],

                const long &tick_volume[],

                const long &volume[],

                const int &spread[])

  {

//---

   Redraw();



   return(rates_total);

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void Redraw()

  {

   int Ci=0;

   DrawSingleChar(0,Chart_1_TimeFrame,Max_Bars,Chart_1_Style);

   switch(Chart_1_First_Sub_Window)

     {

      case SW2:

         Ci=Ci+1;

         DrawSingleGis(Ci,Chart_1_TimeFrame,Max_Bars);

         break;

      case SW3:

         Ci=Ci+1;

         DrawSingleGisOsm(Ci,Chart_1_TimeFrame,Max_Bars);

         break;

     }



   switch(Chart_1_Second_Sub_Window)

     {

      case SW2:

         Ci=Ci+1;

         DrawSingleGis(Ci,Chart_1_TimeFrame,Max_Bars);

         break;

      case SW3:

         Ci=Ci+1;

         DrawSingleGisOsm(Ci,Chart_1_TimeFrame,Max_Bars);

         break;

     }



   if(Max_Chart>1)

     {

      Ci=Ci+1;

      DrawSingleChar(Ci,Chart_2_TimeFrame,Max_Bars,Chart_2_Style);

      switch(Chart_2_First_Sub_Window)

        {

         case SW2:

            Ci=Ci+1;

            DrawSingleGis(Ci,Chart_2_TimeFrame,Max_Bars);

            break;

         case SW3:

            Ci=Ci+1;

            DrawSingleGisOsm(Ci,Chart_2_TimeFrame,Max_Bars);

            break;

        }



      switch(Chart_2_Second_Sub_Window)

        {

         case SW2:

            Ci=Ci+1;

            DrawSingleGis(Ci,Chart_2_TimeFrame,Max_Bars);

            break;

         case SW3:

            Ci=Ci+1;

            DrawSingleGisOsm(Ci,Chart_2_TimeFrame,Max_Bars);

            break;

        }

     }



   if(Max_Chart>2)

     {

      Ci=Ci+1;

      DrawSingleChar(Ci,Chart_3_TimeFrame,Max_Bars,Chart_3_Style);

      switch(Chart_3_First_Sub_Window)

        {

         case SW2:

            Ci=Ci+1;

            DrawSingleGis(Ci,Chart_3_TimeFrame,Max_Bars);

            break;

         case SW3:

            Ci=Ci+1;

            DrawSingleGisOsm(Ci,Chart_3_TimeFrame,Max_Bars);

            break;

        }



      switch(Chart_3_Second_Sub_Window)

        {

         case SW2:

            Ci=Ci+1;

            DrawSingleGis(Ci,Chart_3_TimeFrame,Max_Bars);

            break;

         case SW3:

            Ci=Ci+1;

            DrawSingleGisOsm(Ci,Chart_3_TimeFrame,Max_Bars);

            break;

        }

     }



   if(Max_Chart>3)

     {

      Ci=Ci+1;

      DrawSingleChar(Ci,Chart_4_TimeFrame,Max_Bars,Chart_4_Style);

      switch(Chart_4_First_Sub_Window)

        {

         case SW2:

            Ci=Ci+1;

            DrawSingleGis(Ci,Chart_4_TimeFrame,Max_Bars);

            break;

         case SW3:

            Ci=Ci+1;

            DrawSingleGisOsm(Ci,Chart_4_TimeFrame,Max_Bars);

            break;

        }



      switch(Chart_4_Second_Sub_Window)

        {

         case SW2:

            Ci=Ci+1;

            DrawSingleGis(Ci,Chart_4_TimeFrame,Max_Bars);

            break;

         case SW3:

            Ci=Ci+1;

            DrawSingleGisOsm(Ci,Chart_4_TimeFrame,Max_Bars);

            break;

        }

     }

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void DrawSingleGisOsm(int kl,int tf,int count)

  {

   int i;

   for(i=0; i<=count; i++)

     {

      buffer[i]=iOsMA(CSym(kl),tf,12,26,9,PRICE_CLOSE,i);

     }

   int  w=Width_Bars,u=Space_Between_Bars;

   double Lo=buffer[ArrayMinimum(buffer,count)],k=RealHi[kl]/(buffer[ArrayMaximum(buffer,count)]-Lo);

   C[kl].Erase(COLOR2RGB(Charts_Color));



   for(i=0; i<=count; i++)

     {

      double doHigh= 0,doLow = 0;

      color colors = Down_Gistogram_Color;

      if(buffer[i] < 0){ doLow = buffer[i]; doHigh = 0;}

      if(buffer[i] > 0){ doLow = 0; doHigh = buffer[i];}

      if(i!=count) if(buffer[i]>buffer[i+1]) colors=Up_Gistogram_Color;



      C[kl].FillRectangle((count-i)*(w+u),(int)(RealHi[kl]-(-Lo+doHigh)*k),(count-i)*(w+u)+w,(int)(RealHi[kl]-(-Lo+doLow)*k),COLOR2RGB(colors));

     }



   C[kl].FontSizeSet(12);

   C[kl].TextOut(0,0,"OsMA(12,26,9)", COLOR2RGB(Charts_Comment_Color));

   C[kl].Update();

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void DrawSingleGis(int kl,int tf,int count)

  {

   int i;

   for(i=0; i<=count; i++)

     {

      buffer[i]=iMACD(CSym(kl),tf,12,26,9,PRICE_CLOSE,MODE_MAIN,i);

     }

   int  w=Width_Bars,u=Space_Between_Bars;

   double Lo=buffer[ArrayMinimum(buffer,count)],k=RealHi[kl]/(buffer[ArrayMaximum(buffer,count)]-Lo);

   C[kl].Erase(COLOR2RGB(Charts_Color));



   for(i=0; i<=count; i++)

     {

      double doHigh= 0,doLow = 0;

      color colors = Down_Gistogram_Color;

      if(buffer[i] < 0){ doLow = buffer[i]; doHigh = 0;}

      if(buffer[i] > 0){ doLow = 0; doHigh = buffer[i];}

      if(i!=count) if(buffer[i]>buffer[i+1]) colors=Up_Gistogram_Color;



      C[kl].FillRectangle((count-i)*(w+u),(int)(RealHi[kl]-(-Lo+doHigh)*k),(count-i)*(w+u)+w,(int)(RealHi[kl]-(-Lo+doLow)*k),COLOR2RGB(colors));

     }



   for(i=0; i<=count; i++)

     {

      buffer[i]=iMACD(CSym(kl),tf,12,26,9,PRICE_CLOSE,MODE_SIGNAL,i);

     }



   Lo=buffer[ArrayMinimum(buffer,count)]; k=RealHi[kl]/(buffer[ArrayMaximum(buffer,count)]-Lo);



   for(i=0; i<count; i++)

     {

      C[kl].Line((count-i) *(w+u),

                 int(RealHi[kl]-(-Lo+buffer[i+1])*k),

                 (count-i+1) *(w+u),

                 int(RealHi[kl]-(-Lo+buffer[i])*k),COLOR2RGB(MACD_Line_Color));

     }

   C[kl].FontSizeSet(12);

   C[kl].TextOut(0,0,"MACD(12,26,9)", COLOR2RGB(Charts_Comment_Color));

   C[kl].Update();

  }

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void DrawSingleChar(int Name,int tf,int count,int Style)

  {

   int  w=Width_Bars,u=Space_Between_Bars;

   double  Lo=iLow(CSym(Name),tf,iLowest(CSym(Name),tf,MODE_LOW,count,0)),

   k=RealHi[Name]/(iHigh(CSym(Name),tf,iHighest(CSym(Name),tf,MODE_HIGH,count,0))-Lo);

   C[Name].Erase(COLOR2RGB(Charts_Color));



   for(int i=0; i<=count; i++)

     {



      double doOpen=iOpen(CSym(Name),tf,i);

      double doClose=iClose(CSym(Name),tf,i);

      double doPrevClose=iClose(CSym(Name),tf,i+1);

      color colors=doOpen>doClose ? Down_Bar_Color:doOpen<doClose ? Up_Bar_Color: Doji_Bar_Color;

      color FillColors=doOpen>doClose ? Down_Fill_Candle:doOpen<doClose ? Up_Fill_Candle: Doji_Bar_Color;

      switch(Style)

        {

         case 1:

            C[Name].Line((count-i-1)*(w+u),int(RealHi[Name]-(doPrevClose-Lo)*k),(count-i)*(w+u),int(RealHi[Name]-(doClose-Lo)*k),COLOR2RGB(colors));

            break;

         case 2:

            C[Name].LineVertical((count-i)*(w+u),int(RealHi[Name]-(iHigh(CSym(Name),tf,i)-Lo)*k),int(RealHi[Name]-(iLow(CSym(Name),tf,i)-Lo)*k),COLOR2RGB(colors));

            C[Name].LineHorizontal((count-i)*(w+u),(count-i)*(w+u)-(w+1)/2+1,int(RealHi[Name]-(doOpen-Lo)  * k),COLOR2RGB(colors));

            C[Name].LineHorizontal((count-i)*(w+u),(count-i)*(w+u)+(w+1)/2,int(RealHi[Name]-(doClose-Lo) * k),COLOR2RGB(colors));

            break;

         case 3:



         if(doOpen<doClose){doPrevClose=doClose;doClose=doOpen; doOpen=doPrevClose;}

         C[Name].LineVertical((count-i)*(w+u),int(RealHi[Name]-(iHigh(CSym(Name),tf,i)-Lo)*k),int(RealHi[Name]-(doOpen-Lo)*k),COLOR2RGB(colors));



         C[Name].LineVertical((count-i)*(w+u),int(RealHi[Name]-(doClose-Lo)*k),int(RealHi[Name]-(iLow(CSym(Name),tf,i)-Lo)*k),COLOR2RGB(colors));



         C[Name].Rectangle((count-i)*(w+u)-(w+1)/2+1,int(RealHi[Name]-(doOpen-Lo)*k),

                           (count-i)*(w+u)+(w+1)/2,int(RealHi[Name]-(doClose-Lo)*k),COLOR2RGB(colors));



         break;

         case 4:



         if(doOpen<doClose){doPrevClose=doClose;doClose=doOpen; doOpen=doPrevClose;}

         C[Name].LineVertical((count-i)*(w+u),int(RealHi[Name]-(iHigh(CSym(Name),tf,i)-Lo)*k),int(RealHi[Name]-(doOpen-Lo)*k),COLOR2RGB(colors));



         C[Name].LineVertical((count-i)*(w+u),int(RealHi[Name]-(doClose-Lo)*k),int(RealHi[Name]-(iLow(CSym(Name),tf,i)-Lo)*k),COLOR2RGB(colors));



         C[Name].FillRectangle((count-i)*(w+u)-(w+1)/2+1,int(RealHi[Name]-(doOpen-Lo)*k),

                               (count-i)*(w+u)+(w+1)/2,int(RealHi[Name]-(doClose-Lo)*k),COLOR2RGB(FillColors));

         C[Name].Rectangle((count-i)*(w+u)-(w+1)/2+1,int(RealHi[Name]-(doOpen-Lo)*k),

                           (count-i)*(w+u)+(w+1)/2,int(RealHi[Name]-(doClose-Lo)*k),COLOR2RGB(colors));



         break;

        }

     }

   C[Name].FontSizeSet(12);

   string NameT=tf>0? tf>1? tf>5? tf>15? tf>30? tf>60? tf>240? tf>1440? "Weekly": "Daily": "H4": "H1": "M30": "M15": "M5": "M1": "Current";

   C[Name].TextOut(0,0,CSym(Name)+", "+NameT,COLOR2RGB(Charts_Comment_Color));

   C[Name].Update();

  }



//+------------------------------------------------------------------+

uint Prev_x,PrevSParam;

//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

void OnChartEvent(const int id,const long &lparam,const double &dparam,const string &sparam)

  {

   if(id==CHARTEVENT_MOUSE_MOVE)

     {

      if(((uint)sparam  &1)==1)

        {

         if(PrevSParam!=(uint)sparam)PrevSParam=(uint)sparam; else

           {

            if((x_distance-Width_Mini_Charts-Space_Left)<(int)lparam)

               if((x_distance-Space_Left)>(int)lparam)

                  if((Width_Mini_Charts+Space_Up)>(int)dparam)

                     if((Space_Up)<(int)dparam)

                       {

                        if((int)Prev_x>(int)lparam)

                          {

                           if(Space_Between_Bars!=0)

                              Width_Bars=Width_Bars+1;else Space_Between_Bars=1;

                           if(Width_Bars>10)Width_Bars=10;   Max_Bars=Width_Mini_Charts/(Width_Bars+Space_Between_Bars)-1;Redraw();

                          }

                        if((int)Prev_x<(int)lparam)

                          {

                           Width_Bars=Width_Bars-1; if(Width_Bars<1){Space_Between_Bars=0;Width_Bars=1;}

                           Max_Bars=Width_Mini_Charts/(Width_Bars+Space_Between_Bars)-1;Redraw();

                          }

                       }

           }

         Prev_x=(int)lparam;

        }

     }



   if(id==CHARTEVENT_CHART_CHANGE)

     {

      if(!ChartGetInteger(0,CHART_WIDTH_IN_PIXELS,0,x_distance))

        {

         Print("5 C40;>AL ?>;CG8BL H8@8=C 3@0D8:0! >4 >H81:8 = ",GetLastError());

         return;

        }

      if(!ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS,0,y_distance))

        {

         Print("5 C40;>AL ?>;CG8BL H8@8=C 3@0D8:0! >4 >H81:8 = ",GetLastError());

         return;

        }

      if((x_distance_prev!=x_distance) || (y_distance_prev!=y_distance))

        {

         long handle=ChartID();

         ChartSetDouble(0,CHART_SHIFT_SIZE,(double(Width_Mini_Charts+Space_Left)/x_distance)*100+1);

         ChartNavigate(handle,CHART_END,0);

         CalcMaxH();

        }

      y_distance_prev=y_distance;

      x_distance_prev=x_distance;

      Redraw();

     }

  }

//+------------------------------------------------------------------+