//+------------------------------------------------------------------+
//|                        MultiZigZag                     MZZ9.mq4  |
//+------------------------------------------------------------------+
/*

  26 апреля 2009 г.


Внешние параметры - строковые переменные. 
В каждую переменную записываются параметры для девяти зигзагов. 
Первая цифра - для первого зигзага, вторая - для второго, третья - для третьего, четвертая - для четвертого и т.д.. Через запятую.

Выводится четыре первых зигзага, считая от текущего таймфрейма. Рассчитывается максимум 9 зигзагов.

ExtDepth, ExtDeviation и ExtBackstep - стандартные параметры для зигзага.
Если задать ExtDepth=0, то соответствующий зигзаг выводиться не будет.
ExtMaxBar - количество баров, на которых рассчитывается зигзаг.
GrossPeriod - периоды графиков, выраженные в минутах, по данным с которых строится зигзаг. При записи 0 зигзаг выводится на текущем таймфрейме.
zzVisible 0 - соответствующий зигзаг не рассчитывается и не выводится на график, 1 - зигзаг рассчитывается.
zzColor  - задаются цвета для каждого таймфрейма.
extColor - дополнительные цвета, если на одном таймфрейме выводится несколько зигзагов.

ExtProcedureOfPayments - последовательность рассчета зигзагов: true - в порядке возрастания таймфрейма, false - в порядке убывания.

showZigZag - варианты показа зигзагов. 0 - в виде ломаной линии. 1 - в виде ромбиков на экстремумах. 2 - в виде рядов точек на участке, 
             принадлежащем бару того таймфрейма, по данным которого рассчитывается зигзаг, Как в DT-ZigZag

ExtReCalculate - количество экстремумов зигзага, начиная с 0, пересчитываемых в режиме реального времени. Применяется для зигзагов со старших таймфреймов.

ExtComplect - у нескольких индикаторов, запущенных  на одной валютной паре в одном окне должны быть разные значения этого параметра
*/

#property link   "nen"

//  Отрисовка индикатора в основном окне
#property indicator_chart_window
//  Количество индикаторных буфферов
#property indicator_buffers  8

//  ВХОДНЫЕ ПАРАМЕТРЫ ИНДИКАТОРА 
//extern string ExtDepth     = "12,0,0,0,0,0,0,0,0"; // отладочная последовательность
extern string ExtDepth     = "12,12,12,12,12,12,12,12,12";
extern string ExtDeviation = "5,5,5,5,5,5,5,5,5";
extern string ExtBackstep  = "3,3,3,3,3,3,3,3,3";
extern string ExtMaxBar    = "5000,1000,350,350,350,350,350,350,350,350";    // Количество обсчитываемых баров (0-все)
extern string GrossPeriod  = "1,5,15,30,60,240,1440,10080,43200";     // Таймфреймы, на которых рассчитываются зигзаги, 0 - текущий таймфрейм
extern string zzVisible    = "1,1,1,0,1,1,1,1,1";
extern string zzColor      = "Tan,RoyalBlue,Aqua,SaddleBrown,Red,Yellow,Magenta,Purple,MediumSpringGreen";
extern string extColor     = "Indigo,Olive,Teal";

extern bool   ExtProcedureOfPayments = false;
extern int    showZigZag=0;
extern int    ExtReCalculate  = 3;              // Количество экстремумов зигзага старшего таймфрейма, начиная с 0, пересчитываемых
                                                // в режиме реального времени
extern int    ExtComplect  = 0;

int ExtDepth_[]={0,0,0,0,0,0,0,0,0}, ExtDeviation_[]={0,0,0,0,0,0,0,0,0}, ExtBackstep_[]={0,0,0,0,0,0,0,0,0}, ExtMaxBar_[]={0,0,0,0,0,0,0,0,0}, GrossPeriod_[]={0,0,0,0,0,0,0,0,0}, zzVisible_[]={0,0,0,0,0,0,0,0,0};
int zzColor_[]={0,0,0,0,0,0,0,0,0}, extColor_[]={0,0,0}, currentBars_[]={0,0,0,0,0,0,0,0,0};
//  Индикаторные буферы
double LowestBuffer1[],HighestBuffer1[],LowestBuffer2[],HighestBuffer2[],LowestBuffer3[],HighestBuffer3[],LowestBuffer4[],HighestBuffer4[];
//  Вспомогательные буферы
double LowestBufferGross1[],HighestBufferGross1[],LowestBufferGross2[],HighestBufferGross2[],LowestBufferGross3[],HighestBufferGross3[],LowestBufferGross4[],HighestBufferGross4[];
double LowestBufferGross5[],HighestBufferGross5[],LowestBufferGross6[],HighestBufferGross6[],LowestBufferGross7[],HighestBufferGross7[],LowestBufferGross8[],HighestBufferGross8[];
double LowestBufferGross9[],HighestBufferGross9[];
datetime time2[]={0,0,0,0,0,0,0,0,0};
//  Флаги, показывающие, что со старшего тф первоначальное преобразование зигзага произведено
bool Grosstf_DT[]={false, false, false, false, false, false, false, false, false};
//  Флаги, показывающие, что на истории зигзаг построен
bool ZZ_tf[]={false, false, false, false, false, false, false, false, false};
//  Значение времени начала и конца третьего луча
datetime L2LTime[]={0,0,0,0,0,0,0,0,0},L2HTime[]={0,0,0,0,0,0,0,0,0};
//  При выходе за значения переменных lBar, hBar и tiZZ производится расчет зигзага
//  То есть только при выходе за пределы уже посчитанного бара производится расчет. 
//  Это позволяет рассчитывать не на каждом тике.
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};
//  Массив для хранения значений Bars
int saveBars[]={0,0,0,0,0,0,0,0,0};
int currentBars;
// Массив для хранения порядка рассчета зигзагов. Какой зигзаг за каким рассчитывается.
int ProcedureOfPayments[9][3];
//  Переменная, хранящая количество баров, на которых рассчитывается зигзаг
int limit;

//+------------------------------------------------------------------+
//| Initialization function. Начало.                                 |
//+------------------------------------------------------------------+
int init()
  {
   int i,j,m,n,q;

// По два индикаторных буффера использовано для вывода на график каждого зигзага
   SetIndexBuffer(0,LowestBuffer1);
   SetIndexBuffer(1,HighestBuffer1);
   SetIndexBuffer(2,LowestBuffer2);
   SetIndexBuffer(3,HighestBuffer2);
   SetIndexBuffer(4,LowestBuffer3);
   SetIndexBuffer(5,HighestBuffer3);
   SetIndexBuffer(6,LowestBuffer4);
   SetIndexBuffer(7,HighestBuffer4);

// Установка значений индикатора, которые не будут видимы на графике
   SetIndexEmptyValue(0,0.0);
   SetIndexEmptyValue(1,0.0);
   SetIndexEmptyValue(2,0.0);
   SetIndexEmptyValue(3,0.0);
   SetIndexEmptyValue(4,0.0);
   SetIndexEmptyValue(5,0.0);
   SetIndexEmptyValue(6,0.0);
   SetIndexEmptyValue(7,0.0);

// Имена для окон данных и лэйбы для субъокон
   SetIndexLabel(0,"Low1" );
   SetIndexLabel(1,"High1");
   SetIndexLabel(2,"Low2" );
   SetIndexLabel(3,"High2");
   SetIndexLabel(4,"Low3" );
   SetIndexLabel(5,"High3");
   SetIndexLabel(6,"Low4" );
   SetIndexLabel(7,"High4");

   _stringtointarray (ExtDepth,     ExtDepth_,     9);
   _stringtointarray (ExtDeviation, ExtDeviation_, 9);
   _stringtointarray (ExtBackstep,  ExtBackstep_,  9);
   _stringtointarray (ExtMaxBar,    ExtMaxBar_,    9);
   _stringtointarray (GrossPeriod,  GrossPeriod_,  9);
   _stringtointarray (zzVisible,    zzVisible_,    9);
   _stringtocolorarray (zzColor,    zzColor_,      9);
   _stringtocolorarray (extColor,   extColor_,     3);

   for (i=0;i<9;i++)
     {
      Grosstf_DT[i]=false; ZZ_tf[i]=false;
      j=GrossPeriod_[i];
      GrossPeriod_[i]=_period(i,j);

      if (zzVisible_[i]>0 && ExtDepth_[i]>0)
        {
         m=ExtBackstep_[i]+ExtDepth_[i];
         if ((ExtMaxBar_[i]>iBars(NULL,GrossPeriod_[i])-m) || (ExtMaxBar_[i]==0)) limit=iBars(NULL,GrossPeriod_[i])- m; else limit=ExtMaxBar_[i];

         if (i==0) arr_resize(LowestBufferGross1, HighestBufferGross1, limit+m, i);
         else if (i==1) arr_resize(LowestBufferGross2, HighestBufferGross2, limit+m, i);
         else if (i==2) arr_resize(LowestBufferGross3, HighestBufferGross3, limit+m, i);
         else if (i==3) arr_resize(LowestBufferGross4, HighestBufferGross4, limit+m, i);
         else if (i==4) arr_resize(LowestBufferGross5, HighestBufferGross5, limit+m, i);
         else if (i==5) arr_resize(LowestBufferGross6, HighestBufferGross6, limit+m, i);
         else if (i==6) arr_resize(LowestBufferGross7, HighestBufferGross7, limit+m, i);
         else if (i==7) arr_resize(LowestBufferGross8, HighestBufferGross8, limit+m, i);
         else if (i==8) arr_resize(LowestBufferGross9, HighestBufferGross9, limit+m, i);
        }

      ProcedureOfPayments[i][0]=GrossPeriod_[i];
      ProcedureOfPayments[i][1]=i;
     }

   ArraySort(ProcedureOfPayments,WHOLE_ARRAY,0,MODE_DESCEND);

   if (showZigZag<0) showZigZag=0;
   if (showZigZag>2) showZigZag=2;

   j=1;n=0;q=-1;
   for (i=0;i<9;i++)
     {
      if (ExtDepth_[i]==0 || zzVisible_[i]==0 || j>4) ProcedureOfPayments[i][2]=0;
      else if (GrossPeriod_[i]==0 || GrossPeriod_[i]>Period())
        {
         if (GrossPeriod_[i]==q)
           {
            zzColor_[i]=extColor_[n];
            n++;
           }

         q=GrossPeriod_[i];

         if (j==1)
           {
            if (showZigZag==0)
              {
               SetIndexStyle(0,DRAW_ZIGZAG, EMPTY, 0, zzColor_[i]);
               SetIndexStyle(1,DRAW_ZIGZAG, EMPTY, 0, zzColor_[i]);
              }
            else
              {
               SetIndexStyle(0,DRAW_ARROW, EMPTY, 0, zzColor_[i]);
               SetIndexStyle(1,DRAW_ARROW, EMPTY, 0, zzColor_[i]);
               if (showZigZag==1)
                 {
                  SetIndexArrow(0, 116); 
                  SetIndexArrow(1, 116);
                 }
               else
                 {
                  SetIndexArrow(0, 159); 
                  SetIndexArrow(1, 159);
                 }
              }
           }
         else if (j==2)
           {
            if (showZigZag==0)
              {
               SetIndexStyle(2,DRAW_ZIGZAG, EMPTY, 0, zzColor_[i]);
               SetIndexStyle(3,DRAW_ZIGZAG, EMPTY, 0, zzColor_[i]);
              }
            else
              {
               SetIndexStyle(2,DRAW_ARROW, EMPTY, 0, zzColor_[i]);
               SetIndexStyle(3,DRAW_ARROW, EMPTY, 0, zzColor_[i]);
               if (showZigZag==1)
                 {
                  SetIndexArrow(2, 116); 
                  SetIndexArrow(3, 116);
                 }
               else
                 {
                  SetIndexArrow(2, 159); 
                  SetIndexArrow(3, 159);
                 }
              }
           }
         else if (j==3)
           {
            if (showZigZag==0)
              {
               SetIndexStyle(4,DRAW_ZIGZAG, EMPTY, 0, zzColor_[i]);
               SetIndexStyle(5,DRAW_ZIGZAG, EMPTY, 0, zzColor_[i]);
              }
            else
              {
               SetIndexStyle(4,DRAW_ARROW, EMPTY, 0, zzColor_[i]);
               SetIndexStyle(5,DRAW_ARROW, EMPTY, 0, zzColor_[i]);
               if (showZigZag==1)
                 {
                  SetIndexArrow(4, 116); 
                  SetIndexArrow(5, 116);
                 }
               else
                 {
                  SetIndexArrow(4, 159); 
                  SetIndexArrow(5, 159);
                 }
              }
           }
         else if (j==4)
           {
            if (showZigZag==0)
              {
               SetIndexStyle(6,DRAW_ZIGZAG, EMPTY, 0, zzColor_[i]);
               SetIndexStyle(7,DRAW_ZIGZAG, EMPTY, 0, zzColor_[i]);
              }
            else
              {
               SetIndexStyle(6,DRAW_ARROW, EMPTY, 0, zzColor_[i]);
               SetIndexStyle(7,DRAW_ARROW, EMPTY, 0, zzColor_[i]);
               if (showZigZag==1)
                 {
                  SetIndexArrow(6, 116); 
                  SetIndexArrow(7, 116);
                 }
               else
                 {
                  SetIndexArrow(6, 159); 
                  SetIndexArrow(7, 159);
                 }
              }
           }
         ProcedureOfPayments[i][2]=j; j++;
        }
     }

   if (ExtProcedureOfPayments) ArraySort(ProcedureOfPayments,WHOLE_ARRAY,0,MODE_ASCEND); else ArraySort(ProcedureOfPayments,WHOLE_ARRAY,0,MODE_DESCEND);

   currentBars=0;
// Завершение инициализации

   return(0);
  }
//+------------------------------------------------------------------+
//| Initialization function. Конец.                                  |
//+------------------------------------------------------------------+


//+------------------------------------------------------------------+
//| Custom indicator deinitialization function. Начало.              |
//+------------------------------------------------------------------+
int deinit()
  {
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function. Конец.               |
//+------------------------------------------------------------------+


//+------------------------------------------------------------------+
//| Расчет индикатора. Начало.                                       |
//+------------------------------------------------------------------+
int start()
  {
   int i, m, n;
   bool calculate;

   if (Bars-currentBars>1)
     {
      for (i=0;i<9;i++)
        {
         if (ProcedureOfPayments[i][2]>0) {saveBars[i]=0; currentBars_[i]=0;}
        }
     }

   currentBars=Bars;

   for (n=0;n<9;n++)
     {
      i=ProcedureOfPayments[n][1];
      if (iBars(NULL, GrossPeriod_[i])-currentBars_[i]>1) {saveBars[i]=0;}
      currentBars_[i]=iBars(NULL, GrossPeriod_[i]);
      // проверки для корректного расчёта индикатора
      if ((ExtDepth_[i]*zzVisible_[i])==0) continue;
      m=ExtBackstep_[i]+ExtDepth_[i];
      if ((currentBars_[i]-1<m) || (m<=0)) continue;

      calculate=false;

      limit=iBars(NULL,GrossPeriod_[i])-saveBars[i]+1;

      if (limit>2)
        {
         calculate=true;
         Grosstf_DT[i]=false;
         ZZ_tf[i]=false;

         if ((ExtMaxBar_[i]>iBars(NULL,GrossPeriod_[i])-m) || (ExtMaxBar_[i]==0)) limit=iBars(NULL,GrossPeriod_[i])- m; else limit=ExtMaxBar_[i];

         if (i==0) arr_resize(LowestBufferGross1, HighestBufferGross1, limit+m, i);
         else if (i==1) arr_resize(LowestBufferGross2, HighestBufferGross2, limit+m, i);
         else if (i==2) arr_resize(LowestBufferGross3, HighestBufferGross3, limit+m, i);
         else if (i==3) arr_resize(LowestBufferGross4, HighestBufferGross4, limit+m, i);
         else if (i==4) arr_resize(LowestBufferGross5, HighestBufferGross5, limit+m, i);
         else if (i==5) arr_resize(LowestBufferGross6, HighestBufferGross6, limit+m, i);
         else if (i==6) arr_resize(LowestBufferGross7, HighestBufferGross7, limit+m, i);
         else if (i==7) arr_resize(LowestBufferGross8, HighestBufferGross8, limit+m, i);
         else if (i==8) arr_resize(LowestBufferGross9, HighestBufferGross9, limit+m, i);

         if (ProcedureOfPayments[i][2]==1)
           {
            ArrayInitialize(LowestBuffer1,0); ArrayInitialize(HighestBuffer1,0);
           }
         else if (ProcedureOfPayments[i][2]==2)
           {
            ArrayInitialize(LowestBuffer2,0); ArrayInitialize(HighestBuffer2,0); 
           }
         else if (ProcedureOfPayments[i][2]==3)
           {
            ArrayInitialize(LowestBuffer3,0); ArrayInitialize(HighestBuffer3,0); 
          }
         else if (ProcedureOfPayments[i][2]==4)
           {
            ArrayInitialize(LowestBuffer4,0); ArrayInitialize(HighestBuffer4,0); 
          }

        }
      else
        {
         if (lBar[i]>iLow(NULL,GrossPeriod_[i],0) || hBar[i]<iHigh(NULL,GrossPeriod_[i],0) || tiZZ[i]!=iTime(NULL,GrossPeriod_[i],0))
           {
            calculate=true;
           }
        }

      if (calculate)
        {

         if (i==0) _Gross(LowestBufferGross1, HighestBufferGross1, limit, i);
         else if (i==1) _Gross(LowestBufferGross2, HighestBufferGross2, limit, i);
         else if (i==2) _Gross(LowestBufferGross3, HighestBufferGross3, limit, i);
         else if (i==3) _Gross(LowestBufferGross4, HighestBufferGross4, limit, i);
         else if (i==4) _Gross(LowestBufferGross5, HighestBufferGross5, limit, i);
         else if (i==5) _Gross(LowestBufferGross6, HighestBufferGross6, limit, i);
         else if (i==6) _Gross(LowestBufferGross7, HighestBufferGross7, limit, i);
         else if (i==7) _Gross(LowestBufferGross8, HighestBufferGross8, limit, i);
         else if (i==8) _Gross(LowestBufferGross9, HighestBufferGross9, limit, i);

        }

     }

 // Завершение вычислений индикатора
   return(0);
  }
//+------------------------------------------------------------------+
//| Расчет индикатора. Конец.                                        |
//+------------------------------------------------------------------+


//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|               Подпрограммы и функции                             |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Подбор массивов для расчета Grossperiod. Начало.                 |
//+------------------------------------------------------------------+

int _Gross(double& GLB[],double& GHB[],int limit,int x)
  {
   if (GrossPeriod_[x]==0)
    {
     if (ProcedureOfPayments[x][2]==1) ZigZag_(LowestBuffer1, HighestBuffer1, x);
     else if (ProcedureOfPayments[x][2]==2) ZigZag_(LowestBuffer2, HighestBuffer2, x);
     else if (ProcedureOfPayments[x][2]==3) ZigZag_(LowestBuffer3, HighestBuffer3, x);
     else if (ProcedureOfPayments[x][2]==4) ZigZag_(LowestBuffer4, HighestBuffer4, x);
     else
      {
       if (limit==2) Shift_elements(GLB,GHB);
       ZigZag_(GLB, GHB, x);
      }
    }
   else
    {
     if (limit==2) Shift_elements(GLB,GHB);
     if (ZigZag_(GLB, GHB, x)==0)
       {
        if (ProcedureOfPayments[x][2]==1) ZigZagDT (LowestBuffer1, HighestBuffer1, GLB, GHB, x);
        else if (ProcedureOfPayments[x][2]==2) ZigZagDT (LowestBuffer2, HighestBuffer2, GLB, GHB, x);
        else if (ProcedureOfPayments[x][2]==3) ZigZagDT (LowestBuffer3, HighestBuffer3, GLB, GHB, x);
        else if (ProcedureOfPayments[x][2]==4) ZigZagDT (LowestBuffer4, HighestBuffer4, GLB, GHB, x);
//Print ("GrossPeriod_["+x+"] = ",GrossPeriod_[x]);
       }
    }

   return(0);
  }
//+------------------------------------------------------------------+
//| Подбор массивов для расчета Grossperiod. Конец.                  |
//+------------------------------------------------------------------+


//+------------------------------------------------------------------+
//|  Основной ZigZag. Начало.                                        |
//+------------------------------------------------------------------+

int ZigZag_(double& LB[],double& HB[],int x)
  {
   int j,jl,jh,bar_l,bar_h, limit1, maxbar_;

   int    bar,back,lasthighpos=-1,lastlowpos=-1;
   double curlow,curhigh,lasthigh,lastlow,val;


   if (ZZ_tf[x]) // Режим реального времени.
     {
      // Определение бара, с которого начинается расчет
      bar_l=iBarShift(NULL,GrossPeriod_[x],L2LTime[x],true);
      bar_h=iBarShift(NULL,GrossPeriod_[x],L2HTime[x],true);

      if ((bar_l<0) || (bar_h<0)) {saveBars[x]=0; return (-1);}
      if (L2LTime[x]<=L2HTime[x]) limit=bar_l; else limit=bar_h;

      limit1=limit-1;

      // Восстановление переменных
      lastlow=iLow(NULL,GrossPeriod_[x],bar_l);
      lasthigh=iHigh(NULL,GrossPeriod_[x],bar_h);

     }
   else // Построение зигзага на истории.
     {
      ZZ_tf[x]=true;
      bar_l=limit;
      bar_h=limit;

      limit1=limit;
     }

   // Начало первого большого цикла
   for(bar=limit1; bar>=0; bar--)
     {
      //--- low
      if (bar<bar_l)
        {
         j=iLowest(NULL,GrossPeriod_[x],MODE_LOW,ExtDepth_[x],bar);
         val=iLow(NULL,GrossPeriod_[x],j);

         if(val==lastlow) val=0.0;
         else 
           { 
            lastlow=val; 
            if((iLow(NULL,GrossPeriod_[x],bar)-val)>(ExtDeviation_[x]*Point))val=0.0;
            else
              {
               for(back=1; back<=ExtBackstep_[x]; back++)
                 {
                  if(val<LB[j+back])LB[j+back]=0.0; 
                 }
              }
           } 

         if (j==bar) LB[j]=val;
        }

      //--- high
      if (bar<bar_h)
        {
         j=iHighest(NULL,GrossPeriod_[x],MODE_HIGH,ExtDepth_[x],bar);
         val=iHigh(NULL,GrossPeriod_[x],j);

         if(val==lasthigh) val=0.0;
         else 
           {
            lasthigh=val;
            if((val-iHigh(NULL,GrossPeriod_[x],bar))>(ExtDeviation_[x]*Point))val=0.0;
            else
              {
               for(back=1; back<=ExtBackstep_[x]; back++)
                 {
                  if(val>HB[j+back])HB[j+back]=0.0; 
                 } 
              }
           }

         if (j==bar) HB[j]=val;
        }
     }
   // Конец первого большого цикла

   // Начало второго большого цикла
   lasthigh=-1; lastlow=-1;

   for(bar=limit; bar>=0; bar--)
     {
      curlow=LB[bar];
      curhigh=HB[bar];

      if((curlow==0)&&(curhigh==0)) continue;

      if(curhigh!=0)
        {
         if(lasthigh>0) 
           {
            if(lasthigh<curhigh) HB[lasthighpos]=0;
            else HB[bar]=0;
           }

         if(lasthigh<curhigh || lasthigh<0)
           {
            lasthigh=curhigh;
            lasthighpos=bar;
           }
         lastlow=-1;
        }

      if(curlow!=0)
        {
         if(lastlow>0)
           {
            if(lastlow>curlow) LB[lastlowpos]=0;
            else LB[bar]=0;
           }

         if((curlow<lastlow)||(lastlow<0))
           {
            lastlow=curlow;
            lastlowpos=bar;
           } 
         lasthigh=-1;
        }
     } 
   // Конец второго большого цикла

   // Обновление переменных
   saveBars[x]=iBars(NULL,GrossPeriod_[x]);
   lBar[x]=iLow(NULL,GrossPeriod_[x],0); hBar[x]=iHigh(NULL,GrossPeriod_[x],0); tiZZ[x]=iTime(NULL,GrossPeriod_[x],0);

   // Сохранение времени начала и окончания третьего луча или последнего луча, меньше третьего
   jl=0;jh=0;
   for (bar=0;bar<saveBars[x];bar++)
     {
      if (LB[bar]>0) {if (jl<=1) {L2LTime[x]=iTime(NULL,GrossPeriod_[x],bar);} jl++;}
      if (HB[bar]>0) {if (jh<=1) {L2HTime[x]=iTime(NULL,GrossPeriod_[x],bar);} jh++;}
      if (jl>1 && jh>1) break;
     }

   return(0);
  }
//+------------------------------------------------------------------+
//|  Основной ZigZag. Конец.                                         |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Преобразование зигзага со старшего таймфрейма на текущий. Начало.|
//+------------------------------------------------------------------+
int ZigZagDT (double& LB[], double& HB[], double& LBG[], double& HBG[], int x)
  {
   int i=0, j, jl, jh, ext3=0, end, k;
   double el=-1, eh=-1;
   datetime t1, t2;

   if (Grosstf_DT[x]) // Режим реального времени.
     {
      end=ExtReCalculate+1;

      t1=iTime(NULL, GrossPeriod_[x],i);
      for (j=0;ext3<end && j<Bars;j++)
        {
         if (Time[j]<t1) {i++; if (showZigZag==2) {t2=t1+GrossPeriod_[x]*60;} t1=iTime(NULL, GrossPeriod_[x],i);}

         LB[j]=0;
         HB[j]=0;
         if (LBG[i]>0)
           {
            if (el>=Low[j] || el<0) {el=Low[j]; jl=j;}
           }
         else
           {
            if (el>0)
              {
               if (showZigZag==2)
                 {
                  for (k=j-1;Time[k]<t2;k--)
                    {
                     if (k<0) break;
                     LB[k]=el;
                    }
                 }

               LB[jl]=el; el=-1; ext3++;
              }
           }

         if  (HBG[i]>0)
           {
            if (eh<=High[j]) {eh=High[j]; jh=j;}
           }
         else
           {
            if (eh>0)
              {
               if (showZigZag==2)
                 {
                  for (k=j-1;Time[k]<t2;k--)
                    {
                     if (k<0) break;
                     HB[k]=eh;
                    }
                 }

               HB[jh]=eh; eh=-1; ext3++;
              }
           } 

        }
     }
   else // Построение зигзага на истории.
     {
      if (limit<=ExtDepth_[x]+ExtBackstep_[x]) {saveBars[x]=0; return (-1);}
      end=iBarShift(NULL,Period(),iTime(NULL, GrossPeriod_[x],limit),false);

      if (end<=0) {saveBars[x]=0; return (-1);}

      Grosstf_DT[x]=true;

      t1=iTime(NULL, GrossPeriod_[x],i);
      for (j=0;j<end;j++)
        {
         if (Time[j]<t1) {i++; if (showZigZag==2) {t2=t1+GrossPeriod_[x]*60;} t1=iTime(NULL, GrossPeriod_[x],i);}

         if (LBG[i]>0)
           {
            if (el>=Low[j] || el<0) {el=Low[j]; jl=j;}
           }
         else
           {
            if (el>0)
              {
               if (showZigZag==2)
                 {
                  for (k=j-1;Time[k]<t2;k--)
                    {
                     if (k<0) break;
                     LB[k]=el;
                    }
                 }

               LB[jl]=el; el=-1;
              }
           }

         if  (HBG[i]>0)
           {
            if (eh<=High[j]) {eh=High[j]; jh=j;}
           }
         else
           {
            if (eh>0)
              {
               if (showZigZag==2)
                 {
                  for (k=j-1;Time[k]<t2;k--)
                    {
                     if (k<0) break;
                     HB[k]=eh;
                    }
                 }

               HB[jh]=eh; eh=-1;
              }
           } 
        }
     }

   return (0);
  }
//+------------------------------------------------------------------+
//| Преобразование зигзага со старшего таймфрейма на текущий. Конец. |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Проверка корректности задания таймфрейма. Начало.                |
//+------------------------------------------------------------------+
int _period(int x, int tf)
  {
   if (tf<Period() && tf>0) ExtDepth_[x]=0;
   if (tf==Period()) return (0);
   return (tf);
  }
//+------------------------------------------------------------------+
//| Проверка корректности задания таймфрейма. Конец.                 |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Сдвиг элементов массива на 1 от 0 элемента в сторону увеличения  |
//| индекса. Начало.                                                 |
//+------------------------------------------------------------------+
void Shift_elements (double& arr[], double& arr1[])
  {
   int i,j;

   j=ArraySize(arr)-1;
   for (i=j;i>0;i--)
     {
      arr[i]=arr[i-1];
      arr1[i]=arr1[i-1];
     }
   arr[0]=0;
   arr1[0]=0;
  }
//-------------------------------------------------------------------+
//| Сдвиг элементов массива на 1 от 0 элемента в сторону увеличения  |
//| индекса. Конец.                                                  |
//-------------------------------------------------------------------+


//+------------------------------------------------------------------+
//| Изменение размера массивов и присвоение всем элементам значения 0|
//| Начало.                                                          |
//+------------------------------------------------------------------+
void arr_resize (double& arr[], double& arr1[], int size, int x)
  {
   if (GrossPeriod_[x]>0)
     {
      ArrayResize(arr,size); ArrayResize(arr1,size);
      ArrayInitialize(arr,0); ArrayInitialize(arr1,0);
     }
  }
//+------------------------------------------------------------------+
//| Изменение размера массивов и присвоение всем элементам значения 0|
//| Конец.                                                           |
//+------------------------------------------------------------------+

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

//+------------------------------------------------------------------+
//| Перенос значений параметров из строки в числовой массив. Начало. |
//+------------------------------------------------------------------+
void _stringtocolorarray (string str, int& arr[], int x)
  {
   int i,j,k=0;
   for (i=0;i<x;i++)
     {
      j=StringFind(str,",",k);
      if (j<0) {arr[i]=fStrToColor(StringSubstr(str,k)); break;}
      arr[i]=fStrToColor(StringSubstr(str,k,j-k));
      k=j+1;
     }
  }
//+------------------------------------------------------------------+
//| Перенос значений параметров из строки в числовой массив.Конец.   |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Преобразование строки в цвет. Начало.                            |
//| Функцию написал Integer.  http://forum.mql4.com/ru/7134          |
//+------------------------------------------------------------------+
color fStrToColor(string aName)
  {
 
   color tColor[]={  Black, DarkGreen, DarkSlateGray, Olive, Green, Teal, Navy, Purple, 
                     Maroon, Indigo, MidnightBlue, DarkBlue, DarkOliveGreen, SaddleBrown, 
                     ForestGreen, OliveDrab, SeaGreen, DarkGoldenrod, DarkSlateBlue, 
                     Sienna, MediumBlue, Brown, DarkTurquoise, DimGray, LightSeaGreen, 
                     DarkViolet, FireBrick, MediumVioletRed, MediumSeaGreen, Chocolate, 
                     Crimson, SteelBlue, Goldenrod, MediumSpringGreen, LawnGreen, 
                     CadetBlue, DarkOrchid, YellowGreen, LimeGreen, OrangeRed, DarkOrange, 
                     Orange, Gold, Yellow, Chartreuse, Lime, SpringGreen, Aqua, DeepSkyBlue, 
                     Blue, Magenta, Red, Gray, SlateGray, Peru, BlueViolet, LightSlateGray, 
                     DeepPink, MediumTurquoise, DodgerBlue, Turquoise, RoyalBlue, SlateBlue, 
                     DarkKhaki, IndianRed, MediumOrchid, GreenYellow, MediumAquamarine, 
                     DarkSeaGreen, Tomato, RosyBrown, Orchid, MediumPurple, PaleVioletRed, 
                     Coral, CornflowerBlue, DarkGray, SandyBrown, MediumSlateBlue, Tan, 
                     DarkSalmon, BurlyWood, HotPink, Salmon, Violet, LightCoral, SkyBlue, 
                     LightSalmon, Plum, Khaki, LightGreen, Aquamarine, Silver, LightSkyBlue, 
                     LightSteelBlue, LightBlue, PaleGreen, Thistle, PowderBlue, PaleGoldenrod, 
                     PaleTurquoise, LightGray, Wheat, NavajoWhite, Moccasin, LightPink, 
                     Gainsboro, PeachPuff, Pink, Bisque, LightGoldenrod, BlanchedAlmond, 
                     LemonChiffon, Beige, AntiqueWhite, PapayaWhip, Cornsilk, LightYellow, 
                     LightCyan, Linen, Lavender, MistyRose, OldLace, WhiteSmoke, Seashell, 
                     Ivory, Honeydew, AliceBlue, LavenderBlush, MintCream, Snow, White
                  };  
   string tName[]={   "Black", "DarkGreen", "DarkSlateGray", "Olive", "Green", "Teal", "Navy", "Purple", 
                     "Maroon", "Indigo", "MidnightBlue", "DarkBlue", "DarkOliveGreen", "SaddleBrown", 
                     "ForestGreen", "OliveDrab", "SeaGreen", "DarkGoldenrod", "DarkSlateBlue", 
                     "Sienna", "MediumBlue", "Brown", "DarkTurquoise", "DimGray", "LightSeaGreen", 
                     "DarkViolet", "FireBrick", "MediumVioletRed", "MediumSeaGreen", "Chocolate", 
                     "Crimson", "SteelBlue", "Goldenrod", "MediumSpringGreen", "LawnGreen", 
                     "CadetBlue", "DarkOrchid", "YellowGreen", "LimeGreen", "OrangeRed", "DarkOrange", 
                     "Orange", "Gold", "Yellow", "Chartreuse", "Lime", "SpringGreen", "Aqua", "DeepSkyBlue", 
                     "Blue", "Magenta", "Red", "Gray", "SlateGray", "Peru", "BlueViolet", "LightSlateGray", 
                     "DeepPink", "MediumTurquoise", "DodgerBlue", "Turquoise", "RoyalBlue", "SlateBlue", 
                     "DarkKhaki", "IndianRed", "MediumOrchid", "GreenYellow", "MediumAquamarine", 
                     "DarkSeaGreen", "Tomato", "RosyBrown", "Orchid", "MediumPurple", "PaleVioletRed", 
                     "Coral", "CornflowerBlue", "DarkGray", "SandyBrown", "MediumSlateBlue", "Tan", 
                     "DarkSalmon", "BurlyWood", "HotPink", "Salmon", "Violet", "LightCoral", "SkyBlue", 
                     "LightSalmon", "Plum", "Khaki", "LightGreen", "Aquamarine", "Silver", "LightSkyBlue", 
                     "LightSteelBlue", "LightBlue", "PaleGreen", "Thistle", "PowderBlue", "PaleGoldenrod", 
                     "PaleTurquoise", "LightGray", "Wheat", "NavajoWhite", "Moccasin", "LightPink", 
                     "Gainsboro", "PeachPuff", "Pink", "Bisque", "LightGoldenrod", "BlanchedAlmond", 
                     "LemonChiffon", "Beige", "AntiqueWhite", "PapayaWhip", "Cornsilk", "LightYellow", 
                     "LightCyan", "Linen", "Lavender", "MistyRose", "OldLace", "WhiteSmoke", "Seashell", 
                     "Ivory", "Honeydew", "AliceBlue", "LavenderBlush", "MintCream", "Snow", "White"
                  };

   aName=StringTrimLeft(StringTrimRight(aName));      
   for(int i=0;i<ArraySize(tName);i++)
     {
      if(aName==tName[i])return(tColor[i]);
     }

  return(Red);                                     
                
 }
//+------------------------------------------------------------------+
//| Преобразование строки в цвет. Конец.                             |
//| Функцию написал Integer.  http://forum.mql4.com/ru/7134          |
//+------------------------------------------------------------------+