MiniChart 0.91

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

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



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

  {

   C1=1,//One Chart

   C2=2,//Two Chart

   C3=3,//Three Chart

   C4=4//Four Chart

  };



extern Cout_Chart Chart=C3;



input  ENUM_LINE    Chart_1_TimeFrame=Line_SCALE_1000000;//First Chart TimeFrame

extern ENUM_LINE    Chart_2_TimeFrame= Line_SCALE_100000;//Second Chart TimeFrame

extern ENUM_LINE    Chart_3_TimeFrame=Line_SCALE_10000;//Third Chart TimeFrame

extern ENUM_LINE    Chart_4_TimeFrame= Line_SCALE_1000;//Fourth Chart TimeFrame







input bool Auto_Height_Mini_Charts=true;

extern int Fixed_Height_Mini_Charts=60;



extern int Width_Mini_Charts=250;

extern int Space_Between_Mini_Charts=10;

extern int Space_Up=10;

extern int Space_Left=10;



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 = clrRed;



input color Up_Gistogram_Color=clrYellowGreen;

input color Down_Gistogram_Color=clrLightPink;



input color MACD_Line_Color=clrCrimson;



/*

MACD_1

MACD_2

MACD_3

MACD_4

*/



//COLOR2RGB(clr)

/*color

color

color

color*/



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

double buffer[1500];



string canvas[10]={"canvas_I","canvas_II","canvas_III","canvas_IV","canvas_V","canvas_VI","canvas_VII","canvas_IIX","canvas_IX","canvas_X"};

CCanvas C[10];



long x_distance,x_distance_prev,y_distance_prev;

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

//|                                                                  |

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

int OnInit()

  {

   long y_distance;

   Max_Chart=Chart*2;



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



   if(Auto_Height_Mini_Charts)

      Height_Charts=(int)(y_distance-2*Space_Up-Space_Between_Mini_Charts*(Max_Chart-1))/Max_Chart;

   else

      Height_Charts=Fixed_Height_Mini_Charts;



   ChartSetInteger(0,CHART_FOREGROUND,true);

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

     {

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

     }

   x_distance_prev=x_distance;

   y_distance_prev= y_distance;

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

   return(INIT_SUCCEEDED);

  }

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

//|                                                                  |

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

bool CBL(int i)

  {



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

                                 Space_Up+i *(Height_Charts+Space_Between_Mini_Charts),

                                 Width_Mini_Charts,Height_Charts,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()

  {

   DrawSingleChar(0,Chart_1_TimeFrame,Max_Bars);

   DrawSingleGis(1,Chart_1_TimeFrame,Max_Bars);

   if(Max_Chart>1)

     {

      DrawSingleChar(2,Chart_2_TimeFrame,Max_Bars);

      DrawSingleGis(3,Chart_2_TimeFrame,Max_Bars);

     }

   if(Max_Chart>2)

     {

      DrawSingleChar(4,Chart_3_TimeFrame,Max_Bars);

      DrawSingleGis(5,Chart_3_TimeFrame,Max_Bars);

     }

   if(Max_Chart>3)

     {

      DrawSingleChar(6,Chart_4_TimeFrame,Max_Bars);

      DrawSingleGis(7,Chart_4_TimeFrame,Max_Bars);

     }

  }

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

//|                                                                  |

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

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

  {

   int i;

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

     {

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

     }

   int  w=Width_Bars,u=Space_Between_Bars;

   double Lo=buffer[ArrayMinimum(buffer,count)],k=Height_Charts/(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)(Height_Charts -(-Lo+doHigh)*k),(count-i)*(w+u)+w,(int)(Height_Charts -(-Lo+doLow)*k),COLOR2RGB(colors));

     }



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

     {

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

     }



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



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

     {

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

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

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

                 int(Height_Charts -(-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  w=Width_Bars,u=Space_Between_Bars;

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

   k=Height_Charts/(iHigh(Symbol(),tf,iHighest(Symbol(),tf,MODE_HIGH,count,0))-Lo);

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



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

     {



      double doOpen=iOpen(Symbol(),tf,i);

      double doClose=iClose(Symbol(),tf,i);

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

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

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

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

     }

   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,Symbol()+", "+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)

     {

      long y_distance;

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

         if(Auto_Height_Mini_Charts)

            Height_Charts=(int)(y_distance-2*Space_Up-Space_Between_Mini_Charts *(Max_Chart-1))/Max_Chart;

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

           {

            C[i].Destroy();

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

           }



        }

      y_distance_prev=y_distance;

      x_distance_prev=x_distance;

      Redraw();

     }

  }

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