Corel

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

//| Open code                                                        |

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

#property strict

#property version     "1.0"

#property copyright   "Roman."

#property link        "https://www.mql5.com/ru/users/romankiverin"



#property description "You may support the development of the project"

#property description " "

#property description "Webmoney: Z330494414179, R222585888867"

#property description " "

#property description "Thank you very much."



#property indicator_chart_window

#include <Canvas\Canvas.mqh>

struct SCROLLINFO

  {

   int               cbSize, fMask, nMin, nMax, nPage, nPos, nTrackPos;

  };

  

#import "user32.dll"

int SetWindowLongA(int hWnd,int nIndex, int dwNewLong);

int GetWindowLongA(int hWnd,int nIndex);

int GetParent(int hWnd);

int GetTopWindow(int hWnd);

int GetWindow(int hWnd, int wCmd);

int SetScrollPos(int hWnd, int  nBar, int  nPos, bool bRedraw);

bool SetScrollRange(int hWnd, int  nBar, int  nMinPos, int  nMaxPos, bool bRedraw);

bool GetScrollInfo(int hWnd, int nBar, SCROLLINFO & lpsi);

bool MoveWindow(int hWnd, int x, int y, int nWidth, int nHeight, bool bRepaint);

bool GetWindowRect(int hWnd,int &Pos[4]);

bool RedrawWindow(int hWnd,int &Pos[4],int &iPos[4],int flag);

int  SetWindowPos(int hWnd,int hWndInsertAfter,int X,int Y,int cx,int cy,int uFlags);

int  SendMessageW(int hWnd,int Msg,int wParam,int lParam);

int  PostMessageA(int hWnd,int Msg,int wParam,int lParam);

#import



#define GWL_STYLE         -16

#define WS_VSCROLL        0x00200000

#define nWS_VSCROLL       0xFFDFFFFF

#define SB_VERT           0x00000001

#define RDW_FRAME         1024

#define RDW_UPDATENOW     256

#define RDW_ERASE         4



#define WS_CAPTION        0x00C00000

#define WS_BORDER         0x00800000

#define WS_SIZEBOX        0x00040000

#define WS_DLGFRAME       0x00400000

#define SWP_NOSIZE        0x0001

#define SWP_NOMOVE        0x0002

#define SWP_NOZORDER      0x0004

#define SWP_NOACTIVATE    0x0010

#define SWP_FRAMECHANGED  0x0020

#define GW_CHILD          0x0005

#define GW_HWNDNEXT       0x0002

#define WM_MDIRESTORE     0x0223



#property indicator_buffers 6



extern int DaysSearch = 300;     //History Days Search

extern int ki = 3;               //Depth Days Search

extern int u = 46;               //Value Forecast Candle



extern color CRate1 = clrTomato; //Color Rate 1

extern color CRate2 = clrGold;   //Color Rate 2

extern color CRate3 = clrGreen;  //Color Rate 3

extern color CRate4 = clrBlue;   //Color Rate 4

extern color CRate5 = clrMagenta;//Color Rate 5

extern color CAvRate = clrGray;  //Color Average



input string KeyShow="A";        //Key Show/Hide Statistics

input string KeyQuit="Q";        //Key Quit



long Charts[5];

double Rate1[], Rate2[], Rate3[], Rate4[], Rate5[], AvRate[],dSHi[], dSLo[], dEHi[], dELo[], doRateLo[], doRateHi[], doRateMult[], doHi[], doLo[];

bool ShowRate1,ShowRate2,ShowRate3,ShowRate4,ShowRate5,ShowAvRate,Draw;

int iDay[], Y, iMainWindowRect_[4];



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

//|                                                                  |

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

void OnTimer()

  {

   static int TimerCont = 1;



   static int ChartCont = 0;



   if(TimerCont>0)

     {

      TimerCont += 1;

      if(TimerCont>20)

        {

         TimerCont = -1;

         ChartCont = 1;

         Copy();

        }

     }



   if(ChartCont>0)

     {

      ChartCont += 1;

      if(ChartCont>20)

        {

         ChartCont = -1;

         DrawCharts();

        }

     }





   int _iMainWindowRect[4];



   GetWindowRect(GetParent(GetParent((int)ChartGetInteger(ChartID(),CHART_WINDOW_HANDLE))),_iMainWindowRect);

   if(iMainWindowRect_[0]!=_iMainWindowRect[0]||iMainWindowRect_[1]!=_iMainWindowRect[1]||

      iMainWindowRect_[2]!=_iMainWindowRect[2]||iMainWindowRect_[3]!=_iMainWindowRect[3])

     {

      OpenSixWindow();

      iMainWindowRect_[0]=_iMainWindowRect[0];

      iMainWindowRect_[1]=_iMainWindowRect[1];

      iMainWindowRect_[2]=_iMainWindowRect[2];

      iMainWindowRect_[3]=_iMainWindowRect[3];

     }

   SCROLLINFO Inf;

   Inf.cbSize = sizeof(SCROLLINFO);

   Inf.fMask = 23;

   int hWindow = GetParent((int)ChartGetInteger(ChartID(),CHART_WINDOW_HANDLE));



   if(hWindow>0)

     {

      GetScrollInfo(hWindow, SB_VERT, Inf);

      if(Inf.nPos!=Inf.nTrackPos)

        {

         int PrevRect[4],iMainWindowRect[4];

         GetWindowRect(GetParent(GetParent((int)ChartGetInteger(ChartID(),CHART_WINDOW_HANDLE))),PrevRect);



         long currChart=ChartFirst();

         while(true)

           {

            if(currChart!=ChartID())

              {

               int hWnd=GetParent((int)ChartGetInteger(currChart,CHART_WINDOW_HANDLE));

               GetWindowRect(hWnd,iMainWindowRect);

               int X=iMainWindowRect[2]-iMainWindowRect[0];

               Y=iMainWindowRect[3]-iMainWindowRect[1];

               MoveWindow(hWnd,

                          iMainWindowRect[0]-PrevRect[0]-2,

                          iMainWindowRect[1]-PrevRect[1]-2 - Inf.nTrackPos + Inf.nPos, X, Y,true);

               ChartRedraw(currChart);

              }

            if(ChartNext(currChart)<0)

               break;

            else

               currChart=ChartNext(currChart);

           }

         SetScrollPos(hWindow, SB_VERT, Inf.nTrackPos, true);

        }

     }

  }



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

//|                                                                  |

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

void OnDeinit(const int reason)

  {

   ObjectsDeleteAll(0,"Box");

   EventKillTimer();

   CDraw.Destroy();

  }

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

//|                                                                  |

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

void DrawCharts()

  {

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

     {

      ObjectsDeleteAll(Charts[i]);

      ChartShowAskLineSet(false,Charts[i]);

      ChartRedraw(Charts[i]);

     }



   ArrayFree(dEHi);

   ArrayFree(dELo);

   CopyHigh(_Symbol, _Period, 0, ki*1440/Period(), dEHi);

   CopyLow(_Symbol, _Period, 0, ki*1440/Period(), dELo);

   string name = "BoxStart";

   ObjectCreate(name,OBJ_RECTANGLE,0,0,0);

   ObjectSetInteger(0,name,OBJPROP_TIME1,Time[0]);

   ObjectSetInteger(0,name,OBJPROP_TIME2,Time[ki*1440/Period()]);

   ObjectSetDouble(0,name,OBJPROP_PRICE1,dEHi[ArrayMaximum(dEHi)]);

   ObjectSetDouble(0,name,OBJPROP_PRICE2,dELo[ArrayMinimum(dELo)]);

   ObjectSetInteger(0,name,OBJPROP_BACK,true);

   ObjectSetInteger(0,name,OBJPROP_COLOR,clrBlue);

   ObjectSetInteger(0,name,OBJPROP_BACK,false);

   OutText(name+"L","Start Element",Time[ki*1440/Period()],dEHi[ArrayMaximum(dEHi)]);

   ObjectCopy(name);

   ObjectCopy(name+"L");

   ObjectSetInteger(0,name,OBJPROP_COLOR,clrMagenta);

   int i;

   string guk;

   for(i = 0; i<ArraySize(iDay); i++)

     {

      if(i < 1)

         guk=guk + "\n Best 5 Element";

      if(i == 5)

         guk=guk + "\n\n Over 15 Element";

      guk = guk + "\n" + IntegerToString(i+1) + ". Shift " + IntegerToString(iDay[i]) + " Hi: " + DoubleToStr(doRateHi[i]) + " Lo: " + DoubleToStr(doRateLo[i]) + " Mult: " + DoubleToStr(doRateMult[i]);

      if(i > 18)

         break;

      ArrayFree(dEHi);

      ArrayFree(dELo);



      CopyHigh(_Symbol, _Period, iDay[i]*1440/Period(), ki*1440/Period(), dEHi);

      CopyLow(_Symbol, _Period, iDay[i]*1440/Period(), ki*1440/Period(), dELo);



      name = "Box" + IntegerToString(i);



      ObjectCreate(name,OBJ_RECTANGLE,0,0,0);



      ObjectSetInteger(0,name,OBJPROP_TIME1,Time[iDay[i]*1440/Period()]);

      ObjectSetInteger(0,name,OBJPROP_TIME2,Time[iDay[i]*1440/Period()+ki*1440/Period()]);

      ObjectSetDouble(0,name,OBJPROP_PRICE1,dEHi[ArrayMaximum(dEHi)]);

      ObjectSetDouble(0,name,OBJPROP_PRICE2,dELo[ArrayMinimum(dELo)]);

      ObjectSetInteger(0,name,OBJPROP_BACK,true);

      ObjectSetInteger(0,name,OBJPROP_COLOR,clrBlue);

      ObjectSetInteger(0,name,OBJPROP_BACK,false);

      OutText(name+"L","Sh " + IntegerToString(iDay[i]),Time[iDay[i]*1440/Period()+ki*1440/Period()],dEHi[ArrayMaximum(dEHi)]);

      ObjectCopy(name);

      ObjectCopy(name+"L");

      OutText(name+"R","Rate "+ IntegerToString(i+1),Time[iDay[i]*1440/Period()+ki*1440/Period()],dELo[ArrayMinimum(dELo)]);

      ObjectSetInteger(0,name+"R",OBJPROP_ANCHOR,ANCHOR_LEFT_UPPER);

      if(i<5)

        {

         ObjectSetInteger(0,name,OBJPROP_COLOR,clrTomato);

         ChartNavigate(Charts[i],CHART_END,-iDay[i]*1440/Period());

         ObjectSetInteger(Charts[i],name,OBJPROP_COLOR,clrTomato);

         ObjectSetInteger(Charts[i],name,OBJPROP_BACK,false);



         OutText(name+"R", "Rate "+ IntegerToString(i+1), Time[iDay[i]*1440/Period()+ki*1440/Period()], dELo[ArrayMinimum(dELo)],                       // :>>@48=0B0 ?> >A8 Y

                 i<1?CRate1:(i<2?CRate2:(i<3?CRate3:(i<4?CRate4:CRate5))),            // F25B

                 12,             // @07<5@ H@8DB0

                 CORNER_LEFT_UPPER, // C3>; 3@0D8:0 4;O ?@82O7:8

                 ANCHOR_LEFT_UPPER, // A?>A>1 ?@82O7:8

                 "Arial",             // H@8DB

                 0.0,                // =0:;>= B5:AB0

                 false,               // =0 704=5< ?;0=5

                 false,          // 2K45;8BL 4;O ?5@5<5I5=89

                 true,              // A:@KB 2 A?8A:5 >1J5:B>2

                 0, 0,             // =><5@ ?>4>:=0

                 Charts[i]               // ID 3@0D8:0

                );

         ChartRedraw(Charts[i]);

        }

     }



   for(int j = i; j<5; j++)

     {

      LabelCreate(Charts[j], "Label", 0, 30, 30, CORNER_RIGHT_LOWER, "Search Result is Void", "Arial", 30, ANCHOR_RIGHT_LOWER);

      ChartRedraw(Charts[j]);

     }



   LabelCreate(0, "Label1", 0, 30, 30*6, CORNER_RIGHT_LOWER, "Rate 1", "Arial", 15, ANCHOR_RIGHT_LOWER,CRate1);

   LabelCreate(0, "Label2", 0, 30, 30*5, CORNER_RIGHT_LOWER, "Rate 2", "Arial", 15, ANCHOR_RIGHT_LOWER,CRate2);

   LabelCreate(0, "Label3", 0, 30, 30*4, CORNER_RIGHT_LOWER, "Rate 3", "Arial", 15, ANCHOR_RIGHT_LOWER,CRate3);

   LabelCreate(0, "Label4", 0, 30, 30*3, CORNER_RIGHT_LOWER, "Rate 4", "Arial", 15, ANCHOR_RIGHT_LOWER,CRate4);

   LabelCreate(0, "Label5", 0, 30, 30*2, CORNER_RIGHT_LOWER, "Rate 5", "Arial", 15, ANCHOR_RIGHT_LOWER,CRate5);

   LabelCreate(0, "Label6", 0, 30, 30, CORNER_RIGHT_LOWER, "AvRate", "Arial", 15, ANCHOR_RIGHT_LOWER,CAvRate);

   LabelCreate(0, "Label7", 0, 30, 30, CORNER_LEFT_LOWER, "Click Rate to Show/Hide this Forecast", "Arial", 15, ANCHOR_LEFT_LOWER,clrBrown);

   LabelCreate(0, "Label8", 0, 30, 90, CORNER_LEFT_LOWER, "Key "+KeyQuit+" Exit","Arial", 15, ANCHOR_LEFT_LOWER,clrBrown);

   LabelCreate(0, "Label9", 0, 30, 60, CORNER_LEFT_LOWER, "Key "+KeyShow+" Show/Hide Statistic","Arial", 15, ANCHOR_LEFT_LOWER,clrBrown);



   ChartRedraw(0);



   Comment(guk);



   ChartSetInteger(0,CHART_SHIFT,true);

   ChartSetInteger(0,CHART_AUTOSCROLL,true);

   ChartSetDouble(0,CHART_SHIFT_SIZE,30.35);

   ChartNavigate(0,CHART_END,0);

   ChartSetInteger(0,CHART_AUTOSCROLL,false);

   ChartRedraw();

  }



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

//|                                                                  |

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

void Comments()

  {

   int i;

   string guk;

   for(i = 0; i<ArraySize(iDay); i++)

     {

      if(i < 1)

         guk=guk + "\n Best 5 Element";

      if(i == 5)

         guk=guk + "\n\n Over 15 Element";

      guk = guk + "\n" + IntegerToString(i+1) + ". Shift " + IntegerToString(iDay[i]) + " Hi: " + DoubleToStr(doRateHi[i]) + " Lo: " + DoubleToStr(doRateLo[i]) + " Mult: " + DoubleToStr(doRateMult[i]);

      if(i > 18)

         break;

     }

   Comment(guk);

  }

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

//| Custom indicator initialization function                         |

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

int OnInit()

  {

//--- indicator buffers mapping

   ChartSetInteger(0,CHART_EVENT_MOUSE_MOVE,1);



   ShowRate1=ShowRate2=ShowRate3=ShowRate4=ShowRate5=false;

   ShowAvRate=true;

   SetIndexBuffer(0,Rate1);

   SetIndexStyle(0,DRAW_LINE,STYLE_SOLID,2,CRate1);

   SetIndexShift(0,u);



   SetIndexBuffer(1,Rate2);

   SetIndexStyle(1,DRAW_LINE,STYLE_SOLID,2,CRate2);

   SetIndexShift(1,u);



   SetIndexBuffer(2,Rate3);

   SetIndexStyle(2,DRAW_LINE,STYLE_SOLID,2,CRate3);

   SetIndexShift(2,u);



   SetIndexBuffer(3,Rate4);

   SetIndexStyle(3,DRAW_LINE,STYLE_SOLID,2,CRate4);

   SetIndexShift(3,u);



   SetIndexBuffer(4,Rate5);

   SetIndexStyle(4,DRAW_LINE,STYLE_SOLID,2,CRate5);

   SetIndexShift(4,u);



   SetIndexBuffer(5,AvRate);

   SetIndexStyle(5,DRAW_LINE,STYLE_SOLID,5,CAvRate);

   SetIndexShift(5,u);



   Draw = false;



   OpenSixWindow();

//---

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

     }

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

     }

   CBL();



//>?8@C5< 2 1CD5@K B@8 4=O

   InsertValues();



//!>@B8@C5<

   SortValues();



   EventSetMillisecondTimer(25);

   return(INIT_SUCCEEDED);

  }



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

//|                                                                  |

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

void SortValues()

  {

   for(int i = 0; i<ArraySize(iDay)-1; i++)

     {

      int key = ArrayMaximum(doRateMult,WHOLE_ARRAY, i);

      int tmpDay = iDay[i];

      double tmpLo = doRateLo[i],tmpHi = doRateHi[i],tmpMult = doRateMult[i];



      iDay[i] = iDay[key];

      doRateLo[i] = doRateLo[key];

      doRateHi[i] = doRateHi[key];

      doRateMult[i] = doRateMult[key];



      iDay[key] = tmpDay;

      doRateLo[key] = tmpLo;

      doRateHi[key] = tmpHi;

      doRateMult[key] = tmpMult;

     }

  }



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

//|                                                                  |

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

void  InsertValues()

  {

   CopyHigh(_Symbol, _Period, 0, ki*1440/Period(), dSHi);

   CopyLow(_Symbol, _Period, 0, ki*1440/Period(), dSLo);



//!<5AB8BLAO =0 >48= 45=L

   for(int i = 1; i < DaysSearch*1440/Period(); i++)

     {

      //>43>B02;8205< 4;O A@02=5=8O

      ArrayFree(dEHi);

      ArrayFree(dELo);



      //>?8@C5< 40==K5

      CopyHigh(_Symbol, _Period, i*1440/Period(), ki*1440/Period(), dEHi);

      CopyLow(_Symbol, _Period, i*1440/Period(), ki*1440/Period(), dELo);



      //KAI8BK205< :>@5;OF8N

      double CorelLo = CorrelationV(dSLo,dELo);

      double CorelHi = CorrelationV(dSHi,dEHi);



      //!G8B05< 7=0G5=85

      double CorelMult = CorelLo>0?CorelLo*CorelHi:0;



#define InsetInArrayValue(Arr,Value) ArrayResize(Arr,ArraySize(Arr)+1); Arr[ArraySize(Arr)-1] = Value



      //=>A8< 7=0G5=8O

      InsetInArrayValue(iDay,i);

      InsetInArrayValue(doRateLo,CorelLo);

      InsetInArrayValue(doRateHi,CorelHi);

      InsetInArrayValue(doRateMult,CorelMult);

     }

  }

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

//|                                                                  |

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

double CorrelationV(double &arr1[], double &arr2[])

  {

   int period=ArraySize(arr1);



   if(period!=ArraySize(arr2))

      return(0);





   int i;

   double D1, D2, S1=0, S2=0, S3=0, M1=0, M2=0;



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

     {

      M1+=arr1[i];

      M2+=arr2[i];

     };



   M1/=period;

   M2/=period;



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

     {

      D1=arr1[i]-M1;

      D2=arr2[i]-M2;

      S1+=D1*D2;

      S2+=D1*D1;

      S3+=D2*D2;

     }

   if(S2*S3!=0)

      return(S1/(MathSqrt(S2*S3)));

   return(0);

  }

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

//| 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[])

  {

//---

//--- return value of prev_calculated for next call

   int limit=rates_total-prev_calculated;

   if(limit>1)

      Redraw();

   return(rates_total);

  }

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

//|                                                                  |

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



int prevPoint = 0;

long x_distance, y_distance, y_distance_prev, x_distance_prev;





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

//|                                                                  |

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

void Redraw()

  {

   for(int j=0; j < u; j++)

     {

#define Drift(price)  (High[0]+Low[0]-High[price*1440/Period()] - Low[price*1440/Period()])/2

#define Shift(price,j) (High[j - u + price*1440/Period()] + Low[j - u + price*1440/Period()])/2

#define Rate(price,j) Drift(price) + Shift(price,j)



      Rate1[j] = Rate(iDay[0],j);

      Rate2[j] = Rate(iDay[1],j);

      Rate3[j] = Rate(iDay[2],j);

      Rate4[j] = Rate(iDay[3],j);

      Rate5[j] = Rate(iDay[4],j);



      AvRate[j] = ShowAvRate?0.2 * (Rate1[j]+Rate2[j]+Rate3[j]+Rate4[j]+Rate5[j]):EMPTY_VALUE;



#define FRate(price,j) price?j:EMPTY_VALUE



      Rate1[j] = FRate(ShowRate1,Rate1[j]);

      Rate2[j] = FRate(ShowRate2,Rate2[j]);

      Rate3[j] = FRate(ShowRate3,Rate3[j]);

      Rate4[j] = FRate(ShowRate4,Rate4[j]);

      Rate5[j] = FRate(ShowRate5,Rate5[j]);

     }

  }

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

//|                                                                  |

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

void OnChartEvent(const int id,

                  const long &lparam,

                  const double &dparam,

                  const string &sparam)

  {

   if(id==CHARTEVENT_OBJECT_CLICK)

     {

      if("Label1"==sparam)

        {

         ShowRate1=!ShowRate1;

         Redraw();

        }

      if("Label2"==sparam)

        {

         ShowRate2=!ShowRate2;

         Redraw();

        }

      if("Label3"==sparam)

        {

         ShowRate3=!ShowRate3;

         Redraw();

        }

      if("Label4"==sparam)

        {

         ShowRate4=!ShowRate4;

         Redraw();

        }

      if("Label5"==sparam)

        {

         ShowRate5=!ShowRate5;

         Redraw();

        }

      if("Label6"==sparam)

        {

         ShowAvRate=!ShowAvRate;

         Redraw();

        }

     }



   if(id==CHARTEVENT_KEYDOWN)

     {



      if((int)lparam==StringGetChar(KeyQuit,0))

        {

         ChartClose(Charts[0]);

         ChartClose(Charts[1]);

         ChartClose(Charts[2]);

         ChartClose(Charts[3]);

         ChartClose(Charts[4]);

         ChartClose();

        }



      if((int)lparam==StringGetChar(KeyShow,0))

        {

         Draw = !Draw;

         if(Draw)

            Comment(" ");

         else

            Comments();

         CBL();

        }

     }



   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(y_distance_prev!=y_distance||x_distance_prev!=x_distance)

         CBL();

      y_distance_prev=y_distance;

      x_distance_prev=x_distance;

     }

  }



CCanvas CDraw;



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

//|                                                                  |

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

bool CBL()

  {

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



     }

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



     }

   y_distance_prev=y_distance;

   x_distance_prev=x_distance;



   bool RetVal =

      CDraw.CreateBitmapLabel(0,0,"Strings", (int)10,(int)10,(int)x_distance-20,(int)y_distance-20,COLOR_FORMAT_XRGB_NOALPHA);



   if(!Draw)

      ObjectSetInteger(0,"Strings",OBJPROP_TIMEFRAMES,EMPTY);

   else

     {

      ObjectSetInteger(0,"Strings",OBJPROP_TIMEFRAMES,OBJ_ALL_PERIODS);

      CDraw.FillRectangle(0,0,CDraw.Width()-1,CDraw.Height()-1,COLOR2RGB(ChartGetInteger(ChartID(),CHART_COLOR_BACKGROUND)));

      CDraw.Rectangle(0,0,CDraw.Width()-1,CDraw.Height()-1,COLOR2RGB(clrLightPink));

      CDraw.TextOut(10,10,"Statistics",COLOR2RGB(clrTomato));



#define _ShiftX_ 50



      int CountPoint = MathMin(ArraySize(iDay)-1,19);

      double StepArr = ((double)(CDraw.Width()-_ShiftX_))/((double)(CountPoint-1));



      double DoRateLo[], DoRateHi[], DoRateMult[];



      ArrayResize(DoRateLo,CountPoint);

      ArrayResize(DoRateHi,CountPoint);

      ArrayResize(DoRateMult,CountPoint);



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

        {

         DoRateLo[i] = doRateLo[i];

         DoRateHi[i] = doRateHi[i];

         DoRateMult[i] = doRateMult[i];

        }



      double AbsMax = DoRateLo[ArrayMaximum(DoRateLo)], AbsMin = DoRateLo[ArrayMinimum(DoRateLo)];

      AbsMin = MathMin(AbsMin,DoRateHi[ArrayMinimum(DoRateHi)]);

      AbsMax = MathMax(AbsMax,DoRateHi[ArrayMaximum(DoRateHi)]);

      AbsMin = MathMin(AbsMin,DoRateMult[ArrayMinimum(DoRateMult)]);

      AbsMax = MathMax(AbsMax,DoRateMult[ArrayMaximum(DoRateMult)]);



#define ShiftX_ _ShiftX_/2

#define _ShiftY_ 60

#define ShiftY_ _ShiftY_/2



      double StepY = (CDraw.Height()-_ShiftY_)/(AbsMax-AbsMin);

      for(int i = 0; i<CountPoint-1; i++)

        {

         CDraw.Line(CDraw.Width()-ShiftX_-(int)(i*StepArr),

                    ShiftY_+(int)

                    ((-DoRateLo[i]+AbsMax)*StepY),

                    CDraw.Width()-ShiftX_-(int)((i+1)*StepArr),

                    ShiftY_+(int)

                    ((-DoRateLo[i+1]+AbsMax)*StepY), COLOR2RGB(clrRed));



         if(((int)i/3)*3==i)

           {

            CDraw.TextOut(CDraw.Width()-ShiftX_-(int)((i)*StepArr),

                          ShiftY_+(int)

                          ((-DoRateLo[i]+AbsMax)*StepY), DoubleToStr(DoRateLo[i],3), COLOR2RGB(clrRed), TA_CENTER | TA_BOTTOM);



           }

         CDraw.Line(CDraw.Width()-ShiftX_-(int)(i*StepArr),

                    ShiftY_+(int)

                    ((-DoRateHi[i]+AbsMax)*StepY),

                    CDraw.Width()-ShiftX_-(int)((i+1)*StepArr),

                    ShiftY_+(int)

                    ((-DoRateHi[i+1]+AbsMax)*StepY), COLOR2RGB(clrBlueViolet));



         if(((int)i/3)*3==i)

           {

            CDraw.TextOut(CDraw.Width()-ShiftX_-(int)((i)*StepArr),

                          ShiftY_+(int)

                          ((-DoRateHi[i]+AbsMax)*StepY), DoubleToStr(DoRateHi[i],3), COLOR2RGB(clrBlueViolet), TA_CENTER | TA_TOP);



           }



         CDraw.Line(CDraw.Width()-ShiftX_-(int)(i*StepArr),

                    ShiftY_+(int)

                    ((-DoRateMult[i]+AbsMax)*StepY),

                    CDraw.Width()-ShiftX_-(int)((i+1)*StepArr),

                    ShiftY_+(int)

                    ((-DoRateMult[i+1]+AbsMax)*StepY), COLOR2RGB(clrGreen));



         CDraw.Line(CDraw.Width()-ShiftX_-(int)(i*StepArr),

                    ShiftY_+(int)

                    ((-DoRateMult[i]+AbsMax)*StepY)-2,

                    CDraw.Width()-ShiftX_-(int)((i)*StepArr),

                    ShiftY_+(int)

                    ((-DoRateMult[i]+AbsMax)*StepY)+2, COLOR2RGB(clrGreen));



         if(((int)i/2)*2==i)

           {

            CDraw.TextOut(CDraw.Width()-ShiftX_-(int)((i)*StepArr),

                          ShiftY_+(int)

                          ((-DoRateMult[i]+AbsMax)*StepY), DoubleToStr(DoRateMult[i],3), COLOR2RGB(clrGreen), TA_CENTER | TA_BOTTOM);



           }



         CDraw.TextOut(CDraw.Width()-ShiftX_-(int)((i)*StepArr),

                       CDraw.Height()-10, IntegerToString(i+1), COLOR2RGB(clrGreen), TA_CENTER | TA_BOTTOM);

        }

      CDraw.TextOut(10,10,"Statistics",COLOR2RGB(clrTomato));



      CDraw.TextOut(CDraw.Width()-10,CDraw.Height()-10-30-25,"Color Hi",COLOR2RGB(clrBlueViolet),TA_RIGHT | TA_BOTTOM);

      CDraw.TextOut(CDraw.Width()-10,CDraw.Height()-10-15-25,"Color Lo",COLOR2RGB(clrRed),TA_RIGHT | TA_BOTTOM);

      CDraw.TextOut(CDraw.Width()-10,CDraw.Height()-10-25,"Color Mult = Hi * Lo",COLOR2RGB(clrGreen),TA_RIGHT | TA_BOTTOM);

      //  CDraw.TextOut(CDraw.Width()-10,CDraw.Height()-10,"Color Mult = Hi * Lo",COLOR2RGB(clrGreen),TA_RIGHT | TA_BOTTOM);



      CDraw.Update();

     }



   ObjectSetInteger(0,"Strings",OBJPROP_BACK,false);

   return RetVal;

  }

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

//|                                                                  |

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



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

long voUpDateChart(int iUpChart)

  {

   int iPrevCount=1;

   long Chart[300],loMainID=ChartID(),currChart=ChartFirst();

   Chart[0]=currChart;

   while(true)

     {

      if(ChartNext(currChart)<0)

         break;

      else

        {

         currChart=ChartNext(currChart);

         Chart[iPrevCount]=currChart;

         iPrevCount=iPrevCount+1;

        }

     }

   if(iPrevCount<iUpChart)

      for(int j=0; j<iUpChart-iPrevCount; j++)

         ChartOpen(Symbol(),_Period);

   if(iPrevCount>iUpChart)

      for(int k_=iPrevCount-1; k_>=0; k_--)

        {

         if(Chart[k_]==loMainID)

            continue;

         ChartClose(Chart[k_]);

         iPrevCount=iPrevCount-1;

         if(iPrevCount<=iUpChart)

            break;

        }

   ChartSetInteger(loMainID,CHART_BRING_TO_TOP,true);

   ChartRedraw(loMainID);

   return loMainID;

  }

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

//|                                                                  |

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

void ManageBorderByWindowHandle(int hWindow,bool state)

  {

   int iNewStyle;

   if(state)

      iNewStyle=(int)(GetWindowLongA(hWindow,GWL_STYLE) &(~(WS_BORDER|WS_DLGFRAME|WS_SIZEBOX)));

   else

      iNewStyle=(int)(GetWindowLongA(hWindow,GWL_STYLE)|((WS_BORDER|WS_DLGFRAME|WS_SIZEBOX)));

   if(hWindow>0 && iNewStyle>0)

     {

      SetWindowLongA(hWindow,GWL_STYLE,iNewStyle);

      SetWindowPos(hWindow,0,0,0,0,0,SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|SWP_FRAMECHANGED);

     }

  }

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

//|                                                                  |

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

void OpenSixWindow()

  {

   long ID=voUpDateChart(6),currChart=ChartFirst();

   GetWindowRect(GetParent(GetParent((int)ChartGetInteger(ChartID(),CHART_WINDOW_HANDLE))),iMainWindowRect_);

   int i=4,X=iMainWindowRect_[2]-iMainWindowRect_[0],rect[4];

   Y=iMainWindowRect_[3]-iMainWindowRect_[1];

   while(true)

     {

      int hWnd=GetParent((int)ChartGetInteger(currChart,CHART_WINDOW_HANDLE));

      WindowRestore(hWnd);

      ChartAutoscrollSet(false,currChart);

      if(currChart!=ID)

        {

         MoveWindow(hWnd,3*X/5,Y/3*(int)(i),2*X/5+2,Y/3+2,true);

         Charts[i]=currChart;

         i--;

         ManageBorderByWindowHandle(hWnd,true);

         ChartSetSymbolPeriod(currChart,_Symbol,_Period);

         //CopyPar(currChart,ID);

        }

      else

        {

         ManageBorderByWindowHandle(hWnd,true);

         ChartNavigate(ChartID(),CHART_END,0);

         int hWindow =

            GetParent((int)ChartGetInteger(ChartID(),CHART_WINDOW_HANDLE));



         int iNewStyle = GetWindowLongA(hWindow, GWL_STYLE) | (WS_VSCROLL);



         if(hWindow>0 && iNewStyle>0)

           {

            SetWindowLongA(hWindow, GWL_STYLE, iNewStyle);

            SetScrollRange(hWindow, SB_VERT, 0,  2*Y/3, true);

            SetScrollPos(hWindow, SB_VERT, 0, true);

           }

         MoveWindow(hWnd,0,0,3*X/5+2,Y+2,true);

        }

      ChartRedraw(currChart);

      if(ChartNext(currChart)<0)

         break;

      else

         currChart=ChartNext(currChart);

     }

  }

void ObjectCopy(string objName)

  {

   long objChartID=ChartID();

   int objType=(int)ObjectGetInteger(objChartID,objName,OBJPROP_TYPE),

       objColor = (int)ObjectGetInteger(objChartID, objName, OBJPROP_COLOR),

       objStyle = (int)ObjectGetInteger(objChartID, objName, OBJPROP_STYLE),

       objWidth = (int)ObjectGetInteger(objChartID, objName, OBJPROP_WIDTH);

   bool objBack=ObjectGetInteger(objChartID,objName,OBJPROP_BACK),

        objRayRight=ObjectGetInteger(objChartID,objName,OBJPROP_RAY_RIGHT);

   int objFontSize=0,objAnchor=0;

   string objText,objFont;

   double objAngle=0.0;



   datetime time[]= {0,0};

   double pce[]= {0,0};

   for(int j=0; j<2; j++)

     {

      time[j]=(datetime)ObjectGetInteger(objChartID,objName,OBJPROP_TIME,j);

      pce[j] = ObjectGetDouble(objChartID,objName,OBJPROP_PRICE,j);

     }

   if(objType==OBJ_TEXT)

     {

      objAngle=ObjectGetDouble(objChartID,objName,OBJPROP_ANGLE);

      objFont = ObjectGetString(objChartID, objName, OBJPROP_FONT);

      objText = ObjectGetString(objChartID, objName, OBJPROP_TEXT);

      objFontSize=(int)ObjectGetInteger(objChartID,objName,OBJPROP_FONTSIZE);

      objAnchor=(int)ObjectGetInteger(objChartID,objName,OBJPROP_ANCHOR);

     }

   long currChart=ChartFirst();

   while(true)

     {

      if(ChartSymbol(currChart)==_Symbol && currChart!=ChartID())

        {

         if(ObjectFind(currChart,objName)<0)

            if(objType!=OBJ_TEXT)

               ObjectCreate(currChart,objName,objType,0,time[0],pce[0],time[1],pce[1]);

            else

              {

               int window=0;

               datetime time_=0;

               double price=0;



               ObjectCreate(currChart,objName,OBJ_TEXT,0,time[0],pce[0]);

              }

         else

            for(int j=0; j<2; j++)

              {

               ObjectSetInteger(currChart,objName,OBJPROP_TIME,j,time[j]);

               ObjectSetDouble(currChart,objName,OBJPROP_PRICE,j,pce[j]);

              }

         if(objType==OBJ_TEXT)

           {

            ObjectSetDouble(currChart,objName,OBJPROP_ANGLE,objAngle);

            ObjectSetString(currChart,objName,OBJPROP_FONT,objFont);

            ObjectSetString(currChart,objName,OBJPROP_TEXT,objText);

            ObjectSetInteger(currChart,objName,OBJPROP_FONTSIZE,objFontSize);

            ObjectSetInteger(currChart,objName,OBJPROP_ANCHOR,objAnchor);

           }



         ObjectSetInteger(currChart,objName,OBJPROP_COLOR,objColor);

         ObjectSetInteger(currChart,objName,OBJPROP_STYLE,objStyle);

         ObjectSetInteger(currChart,objName,OBJPROP_BACK,objBack);

         ObjectSetInteger(currChart,objName,OBJPROP_RAY_RIGHT,objRayRight);

         ObjectSetInteger(currChart,objName,OBJPROP_WIDTH,objWidth);



         ChartRedraw(currChart);

        }

      if(ChartNext(currChart)<0)

         break;

      else

         currChart=ChartNext(currChart);

     }

  }

void Copy()

  {

   long ID=ChartID();



   CopyPar(Charts[0],ID);

//         ChartRedraw(currChart);

   CopyPar(Charts[1],ID);

   CopyPar(Charts[2],ID);

   CopyPar(Charts[3],ID);

   CopyPar(Charts[4],ID);

  }



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

//|                                                                  |

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

bool ChartAutoscrollSet(const bool value,const long chart_ID=0)

  {

//--- A1@>A8< 7=0G5=85 >H81:8

   ResetLastError();

//--- CAB0=>28< 7=0G5=85 A2>9AB20

   if(!ChartSetInteger(chart_ID,CHART_AUTOSCROLL,0,value))

     {

      //--- 2K2545< A>>1I5=85 >1 >H81:5 2 6C@=0; "-:A?5@BK"

      Print(__FUNCTION__+", Error Code = ",GetLastError());

      return(false);

     }

//--- CA?5H=>5 2K?>;=5=85

   return(true);

  }

int WindowRestore(long hWnd)

  {

   int Parent=GetParent((int)hWnd);

   return SendMessageW(GetParent(Parent), 0x0223, Parent, 0);

  }

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



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

//|                                                                  |

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

void CopyPar(long Id,long Curr)

  {

   ChartScaleSet(0,Id);

   ChartSetInteger(Id,CHART_SHIFT,true);

   ChartSetDouble(Id,CHART_SHIFT_SIZE,0.35);

   ChartSetInteger(Id,CHART_MODE,ChartGetInteger(Curr,CHART_MODE));

   ChartSetInteger(Id,CHART_AUTOSCROLL,false);

   ChartSetInteger(Id,CHART_SHOW_OHLC,false);

   ChartSetInteger(Id,CHART_SHOW_BID_LINE,clrNONE);

   ChartSetInteger(Id,CHART_SHOW_ASK_LINE,clrNONE);

   ChartSetInteger(Id,CHART_COLOR_BACKGROUND,ChartGetInteger(Curr,CHART_COLOR_BACKGROUND));

   ChartSetInteger(Id,CHART_COLOR_FOREGROUND,ChartGetInteger(Curr,CHART_COLOR_FOREGROUND));

   ChartSetInteger(Id,CHART_COLOR_GRID,ChartGetInteger(Curr,CHART_COLOR_GRID));

   ChartSetInteger(Id,CHART_COLOR_VOLUME,ChartGetInteger(Curr,CHART_COLOR_VOLUME));

   ChartSetInteger(Id,CHART_COLOR_CHART_UP,ChartGetInteger(Curr,CHART_COLOR_CHART_UP));

   ChartSetInteger(Id,CHART_COLOR_CHART_DOWN,ChartGetInteger(Curr,CHART_COLOR_CHART_DOWN));

   ChartSetInteger(Id,CHART_COLOR_CHART_LINE,ChartGetInteger(Curr,CHART_COLOR_CHART_LINE));

   ChartSetInteger(Id,CHART_COLOR_CANDLE_BULL,ChartGetInteger(Curr,CHART_COLOR_CANDLE_BULL));

   ChartSetInteger(Id,CHART_COLOR_CANDLE_BEAR,ChartGetInteger(Curr,CHART_COLOR_CANDLE_BEAR));

   ChartSetInteger(Id,CHART_COLOR_BID,ChartGetInteger(Curr,CHART_COLOR_BID));

   ChartSetInteger(Id,CHART_COLOR_ASK,ChartGetInteger(Curr,CHART_COLOR_ASK));

   ChartSetInteger(Id,CHART_COLOR_LAST,ChartGetInteger(Curr,CHART_COLOR_LAST));

   ChartSetInteger(Id,CHART_COLOR_STOP_LEVEL,clrNONE);

   ChartSetInteger(Id,CHART_SHOW_TRADE_LEVELS,ChartGetInteger(Curr,CHART_SHOW_TRADE_LEVELS));

   ChartSetInteger(Id,CHART_DRAG_TRADE_LEVELS,ChartGetInteger(Curr,CHART_DRAG_TRADE_LEVELS));

   ChartNavigate(Id,CHART_END,0);

   ChartRedraw(Id);

  }

bool OutText(const string            name="Label",             // 8<O <5B:8

             const string            text="Label",             // B5:AB

             const datetime          x=0,                      // :>>@48=0B0 ?> >A8 X

             const double            y=0,                      // :>>@48=0B0 ?> >A8 Y

             const color             clr=clrYellow,            // F25B

             const int               font_size=12,             // @07<5@ H@8DB0

             const ENUM_BASE_CORNER  corner=CORNER_LEFT_UPPER, // C3>; 3@0D8:0 4;O ?@82O7:8

             const ENUM_ANCHOR_POINT anchor=ANCHOR_LEFT_LOWER, // A?>A>1 ?@82O7:8

             const string            font="Arial",             // H@8DB

             const double            angle=0.0,                // =0:;>= B5:AB0

             const bool              back=false,               // =0 704=5< ?;0=5

             const bool              selection=false,          // 2K45;8BL 4;O ?5@5<5I5=89

             const bool              hidden=true,              // A:@KB 2 A?8A:5 >1J5:B>2

             const long              z_order=0,

             const int               sub_window=0,             // =><5@ ?>4>:=0

             const long              chart_ID=0                // ID 3@0D8:0

            )                // ?@8>@8B5B =0 =060B85 <KHLN

  {

//--- A1@>A8< 7=0G5=85 >H81:8

   ResetLastError();

//--- A>74048< B5:AB>2CN <5B:C

   if(ObjectFind(chart_ID,name)==-1)

     {

      if(!ObjectCreate(chart_ID,name,OBJ_TEXT,sub_window,x,y))

        {

         Print(__FUNCTION__, ": =5 C40;>AL A>740BL B5:AB>2CN <5B:C! >4 >H81:8 = ",GetLastError());

         //       return(false);

        }

     }

   else

     {

      ObjectSetInteger(chart_ID,name,OBJPROP_TIME,x);

      ObjectSetDouble(chart_ID,name,OBJPROP_PRICE,y);

     }

//--- CAB0=>28< C3>; 3@0D8:0, >B=>A8B5;L=> :>B>@>3> 1C4CB >?@545;OBLAO :>>@48=0BK B>G:8

   ObjectSetInteger(chart_ID,name,OBJPROP_CORNER,corner);

//--- CAB0=>28< B5:AB

   ObjectSetString(chart_ID,name,OBJPROP_TEXT,text);

//--- CAB0=>28< H@8DB B5:AB0

   ObjectSetString(chart_ID,name,OBJPROP_FONT,font);

//--- CAB0=>28< @07<5@ H@8DB0

   ObjectSetInteger(chart_ID,name,OBJPROP_FONTSIZE,font_size);

//--- CAB0=>28< C3>; =0:;>=0 B5:AB0

   ObjectSetDouble(chart_ID,name,OBJPROP_ANGLE,angle);

//--- CAB0=>28< A?>A>1 ?@82O7:8

   ObjectSetInteger(chart_ID,name,OBJPROP_ANCHOR,anchor);

//--- CAB0=>28< F25B

   ObjectSetInteger(chart_ID,name,OBJPROP_COLOR,clr);

//--- >B>1@078< =0 ?5@54=5< (false) 8;8 704=5< (true) ?;0=5

   ObjectSetInteger(chart_ID,name,OBJPROP_BACK,back);

//--- 2:;NG8< (true) 8;8 >B:;NG8< (false) @568< ?5@5<5I5=8O <5B:8 <KHLN

   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTABLE,selection);

   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTED,selection);

//--- A:@>5< (true) 8;8 >B>1@078< (false) 8<O 3@0D8G5A:>3> >1J5:B0 2 A?8A:5 >1J5:B>2

   ObjectSetInteger(chart_ID,name,OBJPROP_HIDDEN,hidden);

//--- CAB0=>28< ?@8>@8B5B =0 ?>;CG5=85 A>1KB8O =060B8O <KH8 =0 3@0D8:5

   ObjectSetInteger(chart_ID,name,OBJPROP_ZORDER,z_order);

//--- CA?5H=>5 2K?>;=5=85

   return(true);

  }



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

//|                                                                  |

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

bool ChartScaleSet(const long value,const long chart_ID=0)

  {

//--- A1@>A8< 7=0G5=85 >H81:8

   ResetLastError();

//--- CAB0=>28< 7=0G5=85 A2>9AB20

   if(!ChartSetInteger(chart_ID,CHART_SCALE,0,value))

     {

      //--- 2K2545< A>>1I5=85 >1 >H81:5 2 6C@=0; "-:A?5@BK"

      Print(__FUNCTION__+", Error Code = ",GetLastError());

      return(false);

     }

//--- CA?5H=>5 2K?>;=5=85

   return(true);

  }

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

bool ChartShowAskLineSet(const bool value,const long chart_ID=0)

  {

//--- A1@>A8< 7=0G5=85 >H81:8

   ResetLastError();

//--- CAB0=>28< 7=0G5=85 A2>9AB20

   if(!ChartSetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))

     {

      //--- 2K2545< A>>1I5=85 >1 >H81:5 2 6C@=0; "-:A?5@BK"

      Print(__FUNCTION__+", Error Code = ",GetLastError());

      return(false);

     }

   if(!ChartSetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))

     {

      //--- 2K2545< A>>1I5=85 >1 >H81:5 2 6C@=0; "-:A?5@BK"

      Print(__FUNCTION__+", Error Code = ",GetLastError());

      return(false);

     }

//--- CA?5H=>5 2K?>;=5=85

   return(true);

  }

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

bool LabelCreate(const long              chart_ID=0,               // ID 3@0D8:0

                 const string            name="Label",             // 8<O <5B:8

                 const int               sub_window=0,             // =><5@ ?>4>:=0

                 const int               x=0,                      // :>>@48=0B0 ?> >A8 X

                 const int               y=0,                      // :>>@48=0B0 ?> >A8 Y

                 const ENUM_BASE_CORNER  corner=CORNER_LEFT_UPPER, // C3>; 3@0D8:0 4;O ?@82O7:8

                 const string            text="Label",             // B5:AB

                 const string            font="Arial",             // H@8DB

                 const int               font_size=10,             // @07<5@ H@8DB0

                 const ENUM_ANCHOR_POINT anchor=ANCHOR_LEFT_UPPER, // A?>A>1 ?@82O7:8

                 const color             clr=clrRed,               // F25B

                 const double            angle=0.0,                // =0:;>= B5:AB0

                 const bool              back=false,               // =0 704=5< ?;0=5

                 const bool              selection=false,          // 2K45;8BL 4;O ?5@5<5I5=89

                 const bool              hidden=true,              // A:@KB 2 A?8A:5 >1J5:B>2

                 const long              z_order=0)                // ?@8>@8B5B =0 =060B85 <KHLN

  {

//--- A1@>A8< 7=0G5=85 >H81:8

   ResetLastError();

//--- A>74048< B5:AB>2CN <5B:C

   if(!ObjectCreate(chart_ID,name,OBJ_LABEL,sub_window,0,0))

     {

      Print(__FUNCTION__,

            ": =5 C40;>AL A>740BL B5:AB>2CN <5B:C! >4 >H81:8 = ",GetLastError());

      return(false);

     }

//--- CAB0=>28< :>>@48=0BK <5B:8

   ObjectSetInteger(chart_ID,name,OBJPROP_XDISTANCE,x);

   ObjectSetInteger(chart_ID,name,OBJPROP_YDISTANCE,y);

//--- CAB0=>28< C3>; 3@0D8:0, >B=>A8B5;L=> :>B>@>3> 1C4CB >?@545;OBLAO :>>@48=0BK B>G:8

   ObjectSetInteger(chart_ID,name,OBJPROP_CORNER,corner);

//--- CAB0=>28< B5:AB

   ObjectSetString(chart_ID,name,OBJPROP_TEXT,text);

//--- CAB0=>28< H@8DB B5:AB0

   ObjectSetString(chart_ID,name,OBJPROP_FONT,font);

//--- CAB0=>28< @07<5@ H@8DB0

   ObjectSetInteger(chart_ID,name,OBJPROP_FONTSIZE,font_size);

//--- CAB0=>28< C3>; =0:;>=0 B5:AB0

   ObjectSetDouble(chart_ID,name,OBJPROP_ANGLE,angle);

//--- CAB0=>28< A?>A>1 ?@82O7:8

   ObjectSetInteger(chart_ID,name,OBJPROP_ANCHOR,anchor);

//--- CAB0=>28< F25B

   ObjectSetInteger(chart_ID,name,OBJPROP_COLOR,clr);

//--- >B>1@078< =0 ?5@54=5< (false) 8;8 704=5< (true) ?;0=5

   ObjectSetInteger(chart_ID,name,OBJPROP_BACK,back);

//--- 2:;NG8< (true) 8;8 >B:;NG8< (false) @568< ?5@5<5I5=8O <5B:8 <KHLN

   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTABLE,selection);

   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTED,selection);

//--- A:@>5< (true) 8;8 >B>1@078< (false) 8<O 3@0D8G5A:>3> >1J5:B0 2 A?8A:5 >1J5:B>2

   ObjectSetInteger(chart_ID,name,OBJPROP_HIDDEN,hidden);

//--- CAB0=>28< ?@8>@8B5B =0 ?>;CG5=85 A>1KB8O =060B8O <KH8 =0 3@0D8:5

   ObjectSetInteger(chart_ID,name,OBJPROP_ZORDER,z_order);

//--- CA?5H=>5 2K?>;=5=85

   return(true);

  }



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