Navigation:Home > Content >

MZZMatricaDigitization_V2.mq4

Time: 2012-09-22 | Download file:MZZMatricaDigitization_V2.mq4

//+------------------------------------------------------------------+
//| MZZMatricaDigitization V2.mq4   10 мая 2010                      |
//+------------------------------------------------------------------+
#property copyright "nen"

#property indicator_chart_window
#property indicator_buffers 8

#define phi 1.61803399

//---- input parameters
extern string TimeFrame    = "1,5,15,30,60,240,1440,10080,43200";              // Таймфреймы, на которых рассчитываются зигзаги
extern string ExtMaxBar    = "5000,1000,1000,1000,1000,1000,1000,800,600,250"; // Количество обсчитываемых баров (0-все)
extern string zzVisible    = "0,1,1,0,1,1,1,1,1";                              // 0 - зигзаг не рассчитывается, 1 - зигзаг рассчитывается
extern string VisibleDigitization = "1,1,1,1,1,1,1,0,1";  // Задаем загзаги, которые будут оцифровываться
extern string zzColor      = "DarkSeaGreen,DarkGoldenrod,Aqua,SaddleBrown,Red,Yellow,Magenta,Purple,MediumSpringGreen";
extern string zzStyle      = "1,1,1,1,1,1,1,1,1";  // Стиль линий зигзага
extern string zzWidth      = "1,1,1,1,1,1,1,1,1";  // Толщина линий зигзага
extern int    SizeText     = 10;    // Размер шрифта для оцифровки
extern int    externalBar  = 0;     // 1 - на внешнем баре продолжается тренд предыдущего бара. 0 - луч от предыдущего бара идет к ближайшему экстремуму внешнего бара
extern bool   CurrentTF    = false; // рассчитывать или не рассчитывать зигзаг на текущем таймфрейме false - не рассчитывать
extern int    ExtComplekt  = 0;     // номер комплекта

//---- buffers
double zzh_1[], zzh_2[], zzh_3[], zzh_4[];
double zzl_1[], zzl_2[], zzl_3[], zzl_4[];

double level_1[5][2], level_2[5][3], level_3[5][4], level_4[5][5]; // сюда пишем цену и время экстремумов, а также оцифровку мениших таймфреймов.
bool first=true; // = true - необходимо провести оцифровку с самого начала. = false - оцифровываем условно последний бар
int firstbar=0;  // - номер бара, с которого на текущем таймфрейме необходимо начинать рассчет оцифровки
int firstbarsave=0;

int GrossPeriod_[]={0,0,0,0,0,0,0,0,0}, zzVisible_[]={0,0,0,0,0,0,0,0,0}, ExtMaxBar_[]={0,0,0,0,0,0,0,0,0};
int zzColor_[]={0,0,0,0,0,0,0,0,0}, zzStyle_[]={0,0,0,0,0,0,0,0,0}, zzWidth_[]={0,0,0,0,0,0,0,0,0}, VisibleDigitization_[]={0,0,0,0,0,0,0,0,0};

double lBar[]={0,0,0,0,0,0,0,0,0}, hBar[]={0,0,0,0,0,0,0,0,0};
datetime tiZZ[]={0,0,0,0,0,0,0,0,0};

double lLast[]={0,0,0,0,0,0,0,0,0}, hLast[]={0,0,0,0,0,0,0,0,0};
datetime tLast[]={0,0,0,0,0,0,0,0,0};

int saveBars, limit, m0, m1, m2, m3; 
int hi[]={0,0,0,0,0,0,0,0,0}, li[]={0,0,0,0,0,0,0,0,0}, hl[]={0,0,0,0,0,0,0,0,0}, saveBarsTF[9], hl_first[]={0,0,0,0,0,0,0,0,0};
static int up=1, dn=-1;
/*
tLast - время бара таймфрейма, с которого берутся данные для построения зигзага, на котором (баре) найден последний(ие) экстремум(ы)
*/
// переменные для расчета в "прямом эфире"
double save_lLast[]={0,0,0,0,0,0,0,0,0}, save_hLast[]={0,0,0,0,0,0,0,0,0};
datetime save_tLast[]={0,0,0,0,0,0,0,0,0}, save_tbar1[]={0,0,0,0,0,0,0,0,0}, t_hi[]={0,0,0,0,0,0,0,0,0}, t_li[]={0,0,0,0,0,0,0,0,0};
int save_hl[]={0,0,0,0,0,0,0,0,0};
int calculateTF[4];
bool TheExternalBar[9];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   int i, j, k, m;
//----
   _stringtointarray   (TimeFrame, GrossPeriod_, 9);
   _stringtointarray   (zzVisible, zzVisible_,   9);
   _stringtointarray   (ExtMaxBar, ExtMaxBar_,   9);
   _stringtocolorarray (zzColor,   zzColor_,     9);
   _stringtointarray   (zzStyle,   zzStyle_,     9);
   _stringtointarray   (zzWidth,   zzWidth_,     9);
   _stringtointarray   (VisibleDigitization, VisibleDigitization_, 9);
//---- indicators
   SetIndexBuffer(0,zzh_1);
   SetIndexEmptyValue(0,0.0);
   SetIndexBuffer(1,zzl_1);
   SetIndexEmptyValue(1,0.0);

   SetIndexBuffer(2,zzh_2);
   SetIndexEmptyValue(2,0.0);
   SetIndexBuffer(3,zzl_2);
   SetIndexEmptyValue(3,0.0);

   SetIndexBuffer(4,zzh_3);
   SetIndexEmptyValue(4,0.0);
   SetIndexBuffer(5,zzl_3);
   SetIndexEmptyValue(5,0.0);

   SetIndexBuffer(6,zzh_4);
   SetIndexEmptyValue(6,0.0);
   SetIndexBuffer(7,zzl_4);
   SetIndexEmptyValue(7,0.0);

   ArrayInitialize(calculateTF,-1);
   k=0; if (CurrentTF) j=0; else j=1;
   for (i=_tf(Period(), true)+j;i<9 && k<4;i++)
     {
      if (zzVisible_[i]==1)
        {
         calculateTF[k]=i;
         SetIndexStyle(k*2,   DRAW_ZIGZAG, zzStyle_[i], zzWidth_[i], zzColor_[i]);
         SetIndexStyle(k*2+1, DRAW_ZIGZAG, zzStyle_[i], zzWidth_[i], zzColor_[i]);
         k++;
        }
     }
//----
   if (externalBar<0) externalBar=0;
   if (externalBar>1) externalBar=1;


   for (k=0;k<4;k++)
     {
      if (calculateTF[k]<0) continue;
      i=calculateTF[k];
      m=iBarShift(NULL, 0, iTime(NULL,GrossPeriod_[i],ExtMaxBar_[i]), false);
      if (firstbariBars(NULL, GrossPeriod_[i])) ExtMaxBar_[i]=iBars(NULL, GrossPeriod_[i])-1;
     }

   firstbarsave=firstbar;
   m0=calculateTF[0]*VisibleDigitization_[calculateTF[0]]; 
   m1=calculateTF[1]*VisibleDigitization_[calculateTF[1]]; 
   m2=calculateTF[2]*VisibleDigitization_[calculateTF[2]]; 
   m3=calculateTF[3]*VisibleDigitization_[calculateTF[3]];

   if (firstbar>Bars-1) firstbar=Bars;
   saveBars=0;

   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   delete_objects();
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   bool calculate, calculatedigit=false;
   int i, j, k, n;
   double tfirst;
   string nameObj;

   for (k=0;k<4;k++)
     {
      if (Bars-saveBars>1) for (i=0;i<4;i++) {if (calculateTF[k]<0) continue; saveBarsTF[calculateTF[i]]=0;} // Проверка необходимомти полного пересчета

      if (calculateTF[k]<0) continue;
      i=calculateTF[k];

      if (iBars(NULL, GrossPeriod_[i])-saveBarsTF[i]>1) saveBars=0; // Проверка необходимости пересчета зигзага номер i
      saveBarsTF[i]=iBars(NULL, GrossPeriod_[i]);

      limit=Bars-saveBars;
      calculate=false;

      if (limit>1)
        {
         first=true;
         calculate=true;
         calculatedigit=true;
         initTF (k);
        }
      else
        {
         if (lBar[i]<=iLow(NULL, GrossPeriod_[i], 0) && hBar[i]>=iHigh(NULL, GrossPeriod_[i], 0) && tiZZ[i]==iTime(NULL, GrossPeriod_[i], 0)) continue;
         else {calculate=true; calculatedigit=true; if (tiZZ[i]!=iTime(NULL, GrossPeriod_[i], 0)) {TheExternalBar[i]=false; delete_objects_tf(GrossPeriod_[i]);}}
        }

      if (calculate)
        {
         if (!TheExternalBar[i])
           {
            switch(k)
              {
               case 0: swing(zzl_1, zzh_1, i); break;
               case 1: swing(zzl_2, zzh_2, i); break;
               case 2: swing(zzl_3, zzh_3, i); break;
               case 3: swing(zzl_4, zzh_4, i); 
              }
           }
         saveBars=Bars;
         lBar[i]=iLow(NULL, GrossPeriod_[i], 0); hBar[i]=iHigh(NULL, GrossPeriod_[i], 0); tiZZ[i]=iTime(NULL, GrossPeriod_[i], 0); 
        }

     }

   if (calculatedigit)
     {
      if (first)
        {
         firstbar=firstbarsave;
         first=false;
        }
      else
        {
         tfirst=9000000000;
         for (k=4;k>2;k--)
           {
            if (m3>0)
              {
               if (tfirst>level_4[k][0]) tfirst=level_4[k][0];
              }

            if (m2>0)
              {
               if (tfirst>level_3[k][0]) tfirst=level_3[k][0];
              }

            if (m1>0)
              {
               if (tfirst>level_2[k][0]) tfirst=level_2[k][0];
              }

            if (m0>0)
              {
               if (tfirst>level_1[k][0]) tfirst=level_1[k][0];
              }
           }
         firstbar=iBarShift(NULL, 0, NormalizeDouble(tfirst,0), false);

         nameObj="_"+ExtComplekt+"_digit_"+DoubleToStr(level_1[1][0],0)+DoubleToStr((level_1[1][1]/Point),0);
         ObjectDelete(nameObj);
         nameObj="_"+ExtComplekt+"_digit_"+DoubleToStr(level_2[1][0],0)+DoubleToStr((level_2[1][1]/Point),0);
         ObjectDelete(nameObj);
         nameObj="_"+ExtComplekt+"_digit_"+DoubleToStr(level_3[1][0],0)+DoubleToStr((level_3[1][1]/Point),0);
         ObjectDelete(nameObj);
         nameObj="_"+ExtComplekt+"_digit_"+DoubleToStr(level_4[1][0],0)+DoubleToStr((level_4[1][1]/Point),0);
         ObjectDelete(nameObj);

         nameObj="_"+ExtComplekt+"_digit_"+DoubleToStr(level_1[2][0],0)+DoubleToStr((level_1[2][1]/Point),0);
         ObjectDelete(nameObj);
         nameObj="_"+ExtComplekt+"_digit_"+DoubleToStr(level_2[2][0],0)+DoubleToStr((level_2[2][1]/Point),0);
         ObjectDelete(nameObj);
         nameObj="_"+ExtComplekt+"_digit_"+DoubleToStr(level_3[2][0],0)+DoubleToStr((level_3[2][1]/Point),0);
         ObjectDelete(nameObj);
         nameObj="_"+ExtComplekt+"_digit_"+DoubleToStr(level_4[2][0],0)+DoubleToStr((level_4[2][1]/Point),0);
         ObjectDelete(nameObj);
        }

      ArrayInitialize(level_1,-1.0); ArrayInitialize(level_2,-1.0); ArrayInitialize(level_3,-1.0); ArrayInitialize(level_4,-1.0);

      for (j=firstbar;j>=0;j--)
        {
         if (m0>=0)
           {
            if (hl_first[m0]==dn)
              {
               if (zzl_1[j]>0)
                 {
                  _digitization1 (level_1, zzl_1,  j, 1);
                  hl_first[m0]=up;
                  if (zzh_1[j]>0)
                    {
                     _digitization1 (level_1, zzh_1,  j, 1);
                     hl_first[m0]=dn;
                    }
                 }
              }

            if (hl_first[m0]==up)
              {
               if (zzh_1[j]>0)
                 {
                  _digitization1 (level_1, zzh_1,  j, 1);
                  hl_first[m0]=dn;
                  if (zzl_1[j]>0)
                    {
                     _digitization1 (level_1, zzl_1,  j, 1);
                     hl_first[m0]=up;
                    }
                 }
              }
           }

         if (m1>=0)
           {
            if (hl_first[m1]==dn)
              {
               if (zzl_2[j]>0)
                 {
                  _digitization1 (level_2, zzl_2,  j, 2);
                  hl_first[m1]=up;
                  if (zzh_2[j]>0)
                    {
                     _digitization1 (level_2, zzh_2,  j, 2);
                     hl_first[m1]=dn;
                    }
                 }
              }

            if (hl_first[m1]==up)
              {
               if (zzh_2[j]>0)
                 {
                  _digitization1 (level_2, zzh_2,  j, 2);
                  hl_first[m1]=dn;
                  if (zzl_2[j]>0)
                    {
                     _digitization1 (level_2, zzl_2,  j, 2);
                     hl_first[m1]=up;
                    }
                 }
              }
           }

         if (m2>=0)
           {
            if (hl_first[m2]==dn)
              {
               if (zzl_3[j]>0)
                 {
                  _digitization1 (level_3, zzl_3,  j, 3);
                  hl_first[m2]=up;
                  if (zzh_3[j]>0)
                    {
                     _digitization1 (level_3, zzh_3,  j, 3);
                     hl_first[m2]=dn;
                    }
                 }
              }

            if (hl_first[m2]==up)
              {
               if (zzh_3[j]>0)
                 {
                  _digitization1 (level_3, zzh_3,  j, 3);
                  hl_first[m2]=dn;
                  if (zzl_3[j]>0)
                    {
                     _digitization1 (level_3, zzl_3,  j, 3);
                     hl_first[m2]=up;
                    }
                 }
              }
           }

         if (m3>=0)
           {
            if (hl_first[m3]==dn)
              {
               if (zzl_4[j]>0)
                 {
                  _digitization1 (level_4, zzl_4,  j, 4);
                  hl_first[m3]=up;
                  if (zzh_4[j]>0)
                    {
                     _digitization1 (level_4, zzh_4,  j, 4);
                     hl_first[m3]=dn;
                    }
                 }
              }

            if (hl_first[m3]==up)
              {
               if (zzh_4[j]>0)
                 {
                  _digitization1 (level_4, zzh_4,  j, 4);
                  hl_first[m3]=dn;
                  if (zzl_4[j]>0)
                    {
                     _digitization1 (level_4, zzl_4,  j, 4);
                     hl_first[m3]=up;
                    }
                 }
              }
           }
        }

      return(0);
     }
  }

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

//+------------------------------------------------------------------+
//| Оцифровка. Начало.                                               |
//+------------------------------------------------------------------+
void _digitization1 (double& level[][], double& zz[], int j, int z)
  {
   int i, x;
   string nameObj, tmp="", tmp1=" - *", tmp2=" - *", tmp3=" - *";

   switch (z)
     {
      case 4:
        level[4][4]=level[3][4];
        level[3][4]=level[2][4];
        level[2][4]=level[1][4];
        level[1][4]=level[0][4];
      case 3:
        level[4][3]=level[3][3];
        level[3][3]=level[2][3];
        level[2][3]=level[1][3];
        level[1][3]=level[0][3];
      case 2:
        level[4][2]=level[3][2];
        level[3][2]=level[2][2];
        level[2][2]=level[1][2];
        level[1][2]=level[0][2];
      case 1:
        level[4][0]=level[3][0]; level[4][1]=level[3][1];
        level[3][0]=level[2][0]; level[3][1]=level[2][1];
        level[2][0]=level[1][0]; level[2][1]=level[1][1];
        level[1][0]=level[0][0]; level[1][1]=level[0][1];
        level[0][0]=Time[j];     level[0][1]=zz[j];
     }
     
   x=_digitization(level);

   if (x>0)
     {
      nameObj="_"+ExtComplekt+"_digit_"+DoubleToStr(level[1][0],0)+DoubleToStr((level[1][1]/Point),0);

      switch (z)
        {
         case 1: 
           if (m1>0)
             {
              for (i=0;i<4;i++) {if (level_2[i][0]==level[1][0] && level_2[i][1]==level[1][1]) {level_2[i][2]=x; break;}}
             }

           if (m2>0)
             {
              for (i=0;i<4;i++) {if (level_3[i][0]==level[1][0] && level_3[i][1]==level[1][1]) {level_3[i][2]=x; break;}}
             }

           if (m3>0)
             {
              for (i=0;i<4;i++) {if (level_4[i][0]==level[1][0] && level_4[i][1]==level[1][1]) {level_4[i][2]=x; break;}}
             }

           tmp=""+x;

           break;

         case 2:
           if (m2>0)
             {
              for (i=0;i<4;i++) {if (level_3[i][0]==level[1][0] && level_3[i][1]==level[1][1]) {level_3[i][3]=x; break;}}
             }

           if (m3>0)
             {
              for (i=0;i<4;i++) {if (level_4[i][0]==level[1][0] && level_4[i][1]==level[1][1]) {level_4[i][3]=x; break;}}
             }

           if (m0>0) if (level_2[1][2]>0) tmp1=" - "+DoubleToStr(level_2[1][2],0);
           tmp=""+x+tmp1;

           break;

         case 3:
           if (m3>0)
             {
              for (i=0;i<4;i++) {if (level_4[i][0]==level[1][0] && level_4[i][1]==level[1][1]) {level_4[i][4]=x; break;}}
             }

           if (m0>0) if (level_3[1][2]>0) tmp2=" - "+DoubleToStr(level_3[1][2],0);
           if (m1>0) if (level_3[1][3]>0) tmp1=" - "+DoubleToStr(level_3[1][3],0);
           tmp=""+x+tmp1+tmp2;

           break;

         case 4:

           if (m0>0) if (level_4[1][2]>0) tmp3=" - "+DoubleToStr(level_4[1][2],0);
           if (m1>0) if (level_4[1][3]>0) tmp2=" - "+DoubleToStr(level_4[1][3],0);
           if (m2>0) if (level_4[1][4]>0) tmp1=" - "+DoubleToStr(level_4[1][4],0);
           tmp=""+x+tmp1+tmp2+tmp3;
        }

      ObjectDelete(nameObj);
      if (level[1][1] >= (High[j] + Low[j]) / 2) {
         ObjectCreate(nameObj,OBJ_TEXT,0,level[1][0],level[1][1] + iATR(Symbol(), Period(), 1, j) / 4);  //+Point*3);
      } else {
         ObjectCreate(nameObj,OBJ_TEXT,0,level[1][0],level[1][1]);
      }
      ObjectSetText(nameObj, tmp, SizeText, "Arial", zzColor_[calculateTF[z-1]]) ;

     }

   return (0);
  }
//+------------------------------------------------------------------+
//| Оцифровка. Конец.                                                |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Выдача цифр. Начало.                                             |
//+------------------------------------------------------------------+
int _digitization (double& level[][])
  {
   double x,y;
   if (level[3][1]<0)return (-1);
   x=(level[1][1]-level[0][1])/(level[1][1]-level[2][1]); // первая цифра числа
   y=(level[2][1]-level[3][1])/(level[2][1]-level[1][1]); // вторая цифра числа

   if (x<2-phi) // 1 волна 2 не достигает 38.2% волны 1.
     {
      if (y<=phi-1) return (11);
      if (y<=1)     return (12);
      if (y<=phi)   return (13);
      else          return (14);
     }

   if (x1) // полный пересчет
     {
      if (iBarShift(NULL, TF, Time[Bars-1], false)=0;i1--) {zzh[i1]=0; zzl[i1]=0;}
     }
//---
   for (i1=n;i1>=0;i1--)
     {
      if (hl_first[i]==0)
        {
         if (hl[i]!=0) hl_first[i]=hl[i];
        }

      if (i1==1)
        {
         zzl[1]=0; zzh[1]=0;
         zzl[0]=0; zzh[0]=0;
         // сохраняем переменные для рассчета в "прямом эфире"
         save_lLast[i]=lLast[i]; save_hLast[i]=hLast[i]; save_tLast[i]=tLast[i];
         t_hi[i]=Time[hi[i]]; t_li[i]=Time[li[i]];
         save_hl[i]=hl[i];
         save_tbar1[i]=iTime(NULL, TF, i1);
        }

      if (lLast[i]>iLow(NULL, TF, i1) && hLast[i]>=iHigh(NULL, TF, i1))               // тренд Down
        {
         if (hl[i]==dn) zzl[li[i]]=0; 
         lLast[i]=iLow(NULL, TF, i1); hLast[i]=iHigh(NULL, TF, i1); tLast[i]=iTime(NULL, TF, i1);
         hl[i]=dn; li[i]=searchbarcur(Period(), dn, TF, i); 
         zzl[li[i]]=lLast[i];
        }
      else if (lLast[i]<=iLow(NULL, TF, i1) && hLast[i]=iHigh(NULL, TF, i1) && i1>0) // обработка внутреннего бара. На нулевом баре внутренний бар не рассчитывается.
        {
         if (hl[i]==0) continue;

         //---
         // определяем, что было раньше на предыдущем баре - минимум или максимум
         if (Period()=0;j--)
           {
            hi[i]=searchbarcur(_tf(j, false), up, TF, i); 
            li[i]=searchbarcur(_tf(j, false), dn, TF, i);
            if (hi[i]!=li[i])
              {
               // корректируем прорисовку на предыдущем баре
               if (hl[i]==dn && hi[i]li[i]) {hl[i]=dn; li[i]=searchbarcur(Period(), dn, TF, i); zzl[li[i]]=lLast[i];}
               break;
              }
           }
         //---

         tLast[i]=iTime(NULL, TF, i1); lLast[i]=iLow(NULL, TF, i1); hLast[i]=iHigh(NULL, TF, i1);
         if (hl[i]==dn) {hl[i]=up; hi[i]=searchbarcur(Period(), up, TF, i); zzh[hi[i]]=hLast[i];}      // li=0;
         else if (hl[i]==up) {hl[i]=dn; li[i]=searchbarcur(Period(), dn, TF, i); zzl[li[i]]=lLast[i];} // hi=0;
        }
      else if (lLast[i]>iLow(NULL, TF, i1) && hLast[i]=0;j--)
           {
            hi[i]=searchbarcur(_tf(j, false), up, TF, i); 
            li[i]=searchbarcur(_tf(j, false), dn, TF, i);
            if (hi[i]!=li[i]) break;
           }

         if (hi[i]!=li[i])
           {
            if (hl[i]==dn && li[i]>hi[i]) zzl[save1_li]=0;
            if (hl[i]==up && li[i]hi[i]) hl[i]=up; else hl[i]=dn;
           }
         else
           {
            if (externalBar==0)
              {
               if (hl[i]==dn)
                 {
                  if ((hLast[i]-zzl[save1_li])<(zzl[save1_li]-lLast[i])) {hl[i]=dn;} else {zzl[save1_li]=0; hl[i]=up;}
                 }
               else
                 {
                  if ((hLast[i]-zzh[save1_hi])<(zzh[save1_hi]-lLast[i])) {zzh[save1_hi]=0; hl[i]=dn;} else {hl[i]=up;}
                 }
              }
            else if (externalBar==1)
              {
               if (hl[i]==dn) {zzl[save1_li]=0; hl[i]=up;}
               else {zzh[save1_hi]=0; hl[i]=dn;}
              }
           }
         // Определяем направление луча на внешнем баре. Конец.
         //---

         hi[i]=searchbarcur(Period(), up, TF, i); zzh[hi[i]]=hLast[i];
         li[i]=searchbarcur(Period(), dn, TF, i); zzl[li[i]]=lLast[i];
        }
      else
        {
         lLast[i]=iLow(NULL, TF, i1); hLast[i]=iHigh(NULL, TF, i1); tLast[i]=iTime(NULL, TF, i1);
        }

     }
//---

   lBar[i]=iLow(NULL, TF, 0); hBar[i]=iHigh(NULL, TF, 0); tiZZ[i]=iTime(NULL, TF, 0); 
  }
//+------------------------------------------------------------------+
//| Основной рассчет. Конец.                                         |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Поиск бара на заданном таймфрейме. Начало.                       |
//+------------------------------------------------------------------+
int searchbarcur(int tf, int UpDn, int TF, int i)
  {
   int i1, j, tend;
   double wr;
   string stf;
   i1=-1;
   j=iBarShift(NULL, tf, tLast[i], false); tend=tLast[i]+TF*60;

   while (iTime(NULL, tf, j)=0) j--;
   if (iTime(NULL, tf, j)>tLast[i]) j++;
//   j++;
//   if (Period()==PERIOD_W1 && TF==PERIOD_MN1) j++;
//   if (Period()==PERIOD_W1 && j<0 && TF==PERIOD_MN1) j=0;

   if (iTime(NULL, tf, j)=0)
     {
      if (UpDn==dn)
        {
         wr=1000000;
         while (iTime(NULL, tf, j)=0)
           {
            if (wr>iLow(NULL, tf, j)) {i1=j; wr=iLow(NULL, tf, j); if (NormalizeDouble(wr-lLast[i],Digits)==0 || wr=0)
           {
            if (wrhLast[i]) return (i1);}
            j--;
           }
        }
      return (i1);
     }
   else
     {
/*
      if (tf==Period())
        {
         switch (tf)
           {
            case 1:     {stf="M1";  break;}
            case 5:     {stf="M5";  break;}
            case 15:    {stf="M15"; break;}
            case 30:    {stf="M30"; break;}
            case 60:    {stf="H1";  break;}
            case 240:   {stf="H4";  break;}
            case 1440:  {stf="D1";  break;}
            case 10080: {stf="W1";  break;}
            case 43200: {stf="MN";}
           }

         j=iBarShift(NULL, tf, tLast, false);
         if (j=8) return (PERIOD_MN1);
      else if (tf<0)  return (-1);
     }
  }
//+------------------------------------------------------------------+
//| Преобразование номера таймфрейма. Конец.                         |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Удаление объектов. Начало.                                       |
//+------------------------------------------------------------------+
 void delete_objects_tf(int TF)
  {
   string nameObj="_"+ExtComplekt+"_TheExternalBar_on_"+TF;
   ObjectDelete (nameObj);
  }
//+------------------------------------------------------------------+
//| Удаление объектов. Конец.                                        |
//+------------------------------------------------------------------+
 
//+------------------------------------------------------------------+
//| Удаление объектов. Начало.                                       |
//+------------------------------------------------------------------+
 void delete_objects()
  {
   int i;
   string txt;

   for (i=ObjectsTotal(); i>=0; i--)
     {
      txt=ObjectName(i);
      if (StringFind(txt,"_" + ExtComplekt + "_TheExternalBar_on_")>-1) ObjectDelete (txt);
      if (StringFind(txt,"_" + ExtComplekt + "_digit_")>-1) ObjectDelete (txt);
     }
  }
//+------------------------------------------------------------------+
//| Удаление объектов. Конец.                                        |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Перенос значений параметров из строки в числовой массив. Начало. |
//+------------------------------------------------------------------+
void _stringtointarray (string str, int& arr[], int x)
  {
   int i,j,k=0;
   for (i=0;i        

Recommend