//+------------------------------------------------------------------+
//|  MultiZigZag                                     MZZ9_fc&ff.mq4  |
//+------------------------------------------------------------------+

#property link   "nen"

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

//  ВХОДНЫЕ ПАРАМЕТРЫ ИНДИКАТОРА 
//extern string ExtDepth       = "12,0,0,0,0,0,0,0,0"; // отладочная последовательность
extern string ExtDepth         = "12,12,12";
extern string ExtDeviation     = "5,5,5";
extern string ExtBackstep      = "8,8,8";
extern string ExtMaxBar        = "1000,300,150";   // Количество обсчитываемых баров (0-все)
extern string GrossPeriod      = "60,240,1440";    // Таймфреймы, на которых рассчитываются зигзаги, 0 - текущий таймфрейм
extern string zzVisible        = "1,1,1";
extern string zzColor          = "Tan,RoyalBlue,Aqua";
extern string extColor         = "Indigo,Olive,Teal";
extern bool   fibofan          = true;
extern string fanVisible       = "1,1,1";
extern string fanStyle         = "2,2,2";
extern string fanWidth         = "0,0,0";
extern string FiboFreeFan      = "0.0,0.118,,0.236,0.382,0.50,0.618,0.786,0.882,1";

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

int ExtDepth_[]={0,0,0}, ExtDeviation_[]={0,0,0}, ExtBackstep_[]={0,0,0}, ExtMaxBar_[]={0,0,0}, GrossPeriod_[]={0,0,0}, zzVisible_[]={0,0,0};
int zzColor_[]={0,0,0}, extColor_[]={0,0,0}, currentBars_[]={0,0,0};
int fanVisible_[]={0,0,0}, fanStyle_[]={0,0,0}, fanWidth_[]={0,0,0}; 
//  Индикаторные буферы
double LowestBuffer1[],HighestBuffer1[],LowestBuffer2[],HighestBuffer2[],LowestBuffer3[],HighestBuffer3[];
//  Вспомогательные буферы
double LowestBufferGross1[],HighestBufferGross1[],LowestBufferGross2[],HighestBufferGross2[],LowestBufferGross3[],HighestBufferGross3[];

//  Флаги, показывающие, что со старшего тф первоначальное преобразование зигзага произведено
bool Grosstf_DT[]={false, false, false};
//  Флаги, показывающие, что на истории зигзаг построен
bool ZZ_tf[]={false, false, false, false};
//  Значение времени начала и конца третьего луча
datetime L2LTime[]={0,0,0},L2HTime[]={0,0,0};
//  При выходе за значения переменных lBar, hBar и tiZZ производится расчет зигзага
//  То есть только при выходе за пределы уже посчитанного бара производится расчет. 
//  Это позволяет рассчитывать не на каждом тике.
double lBar[]={0,0,0}, hBar[]={0,0,0};
datetime tiZZ[]={0,0,0};
//  Массив для хранения значений Bars
int saveBars[]={0,0,0};
int currentBars;
// Массив для хранения порядка рассчета зигзагов. Какой зигзаг за каким рассчитывается.
int ProcedureOfPayments[9][3];
//  Переменная, хранящая количество баров, на которых рассчитывается зигзаг
int limit;
//  Массив цен четырех первых экстремумов зигзага, начиная с нулевого
double _cena[3][3];
//  Массив времени родного таймфрейма четырех первых экстремумов зигзага, начиная с нулевого
datetime _timeGross[3][3];
//  Массив времени текущего таймфрейма четырех первых экстремумов зигзага, начиная с нулевого
datetime _time[3][3];
//  Массив флагов необходимости построения нового фибо канала или нового фибо веера
//bool _draw[9];
// Количество фибо уровней в фибо объектах
int j_f;

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

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

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

   _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);
   _stringtointarray (fanVisible,   fanVisible_,   9);
   _stringtointarray (fanStyle,     fanStyle_,     9);
   _stringtointarray (fanWidth,     fanWidth_,     9);

   j_f=quantityFibo (FiboFreeFan);

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

      if (ExtDepth_[i]<=0) zzVisible_[i]=0;
      if (zzVisible_[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);
        }

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

   ArraySort(ProcedureOfPayments,WHOLE_ARRAY,0,MODE_ASCEND);

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

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

         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[n][2]=j; j++;
        }
     }

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

// Имена для окон данных и лэйбы для субъокон
   for (n=0;n<9;n++)
     {
      if (GrossPeriod_[ProcedureOfPayments[n][1]]==0) str=""+Period(); else str=""+GrossPeriod_[ProcedureOfPayments[n][1]];
      if (ProcedureOfPayments[n][2]==1)
        {
         SetIndexLabel(0,"Low1_"+str );
         SetIndexLabel(1,"High1_"+str);
        }
      else if (ProcedureOfPayments[n][2]==2)
        {
         SetIndexLabel(2,"Low2_"+str );
         SetIndexLabel(3,"High2_"+str);
        }
      else if (ProcedureOfPayments[n][2]==3)
        {
         SetIndexLabel(4,"Low3_"+str );
         SetIndexLabel(5,"High3_"+str);
        }
      else if (ProcedureOfPayments[n][2]==4)
        {
         SetIndexLabel(6,"Low4_"+str );
         SetIndexLabel(7,"High4_"+str);
        }
     }

   ArrayInitialize(_cena,0); ArrayInitialize(_timeGross,0); ArrayInitialize(_time,0);

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

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


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


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

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

   currentBars=Bars;

   for (n=0;n<9;n++)
     {
      i=ProcedureOfPayments[n][1];

      if (zzVisible_[i]==0) continue;

      if (iBars(NULL, GrossPeriod_[i])-currentBars_[i]>1) {saveBars[i]=0;}
      currentBars_[i]=iBars(NULL, GrossPeriod_[i]);

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

         if (ProcedureOfPayments[n][2]==1)
           {
            ArrayInitialize(LowestBuffer1,0); ArrayInitialize(HighestBuffer1,0);
           }
         else if (ProcedureOfPayments[n][2]==2)
           {
            ArrayInitialize(LowestBuffer2,0); ArrayInitialize(HighestBuffer2,0); 
           }
         else if (ProcedureOfPayments[n][2]==3)
           {
            ArrayInitialize(LowestBuffer3,0); ArrayInitialize(HighestBuffer3,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, n);
         else if (i==1) _Gross(LowestBufferGross2, HighestBufferGross2, limit, n);
         else if (i==2) _Gross(LowestBufferGross3, HighestBufferGross3, limit, n);

        }

     }

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


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

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

int _Gross(double& GLB[],double& GHB[],int limit_,int n)
  {
   int x=ProcedureOfPayments[n][1];

   if (GrossPeriod_[x]==0)
    {
     if      (ProcedureOfPayments[n][2]==1) ZigZag_(LowestBuffer1, HighestBuffer1, x);
     else if (ProcedureOfPayments[n][2]==2) ZigZag_(LowestBuffer2, HighestBuffer2, x);
     else if (ProcedureOfPayments[n][2]==3) ZigZag_(LowestBuffer3, HighestBuffer3, 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[n][2]==1) ZigZagDT (LowestBuffer1, HighestBuffer1, GLB, GHB, x);
        else if (ProcedureOfPayments[n][2]==2) ZigZagDT (LowestBuffer2, HighestBuffer2, GLB, GHB, x);
        else if (ProcedureOfPayments[n][2]==3) ZigZagDT (LowestBuffer3, HighestBuffer3, GLB, GHB, x);
       }
    }

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


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

int ZigZag_(double& LB[],double& HB[],int x)
  {
   int j, jl, jh, bar_l, bar_h, limit1, k, hl_=0, i, i_, t_;

   int    bar, back, lasthighpos=-1, lastlowpos=-1;
   double curlow, curhigh, lasthigh, lastlow, val, deviation=ExtDeviation_[x]*Point,h_, l_, fi;
   bool _draw=false;
   string nameObj, str, str1;

   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)>deviation) 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))>deviation) 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;
   if (fibofan != 0) k=0; else k=4;

   for (bar=0;bar<saveBars[x];bar++)
     {
      if (k<4)
        {
         if (LB[bar]>0 || HB[bar]>0)
           {
            if (hl_==0)
              {
               if (k==0)
                 {
                  _timeGross[x][0]=iTime(NULL,GrossPeriod_[x],bar); 
                  if (LB[bar]>0 && HB[bar]>0)
                    {
                     l_=LB[bar]; h_=HB[bar];
                     if (_timeGross[x][1]!=_timeGross[x][0])
                       {
                        _timeGross[x][1]=_timeGross[x][0];
                        _draw=true;
                        k++;
                       }
                      else k=4;
                    }
                  else if (LB[bar]>0)
                    {
                     _cena[x][0]=LB[bar];
                     hl_=-1;
                    }
                  else if (HB[bar]>0)
                    {
                     _cena[x][0]=HB[bar];
                     hl_=1;
                    }
                  k++;
                 }
               else
                 {
                  _timeGross[x][2]=iTime(NULL,GrossPeriod_[x],bar);
                  if (LB[bar]>0)
                    {
                     _cena[x][0]=l_; _cena[x][1]=h_; _cena[x][2]=LB[bar];
                     hl_=-1;
                    }
                  else if (HB[bar]>0)
                    {
                     _cena[x][0]=h_; _cena[x][1]=l_; _cena[x][2]=HB[bar];
                     hl_=1;
                    }
                  k++;
                 }
              }
            else
              {
               if (k==1)
                 {
                  if (_timeGross[x][1]!=iTime(NULL,GrossPeriod_[x],bar))
                    {
                     _timeGross[x][1]=iTime(NULL,GrossPeriod_[x],bar); 
                     _draw=true;
                     if (LB[bar]>0 && HB[bar]>0)
                       {
                        _timeGross[x][2]=_timeGross[x][1];
                        if (hl_==-1) {_cena[x][1]=HB[bar]; _cena[x][2]=LB[bar];}
                        else {_cena[x][1]=LB[bar]; _cena[x][2]=HB[bar];}
                        k++;
                       }
                     else if (LB[bar]>0)
                       {
                        _cena[x][1]=LB[bar]; hl_=-1;
                       }
                     else if (HB[bar]>0)
                       {
                        _cena[x][1]=HB[bar]; hl_=1;
                       }

                     k++;
                    }
                  else k=4;
                 }
               else if (k==2)
                 {
                  _timeGross[x][2]=iTime(NULL,GrossPeriod_[x],bar); 
                  if (LB[bar]>0 && HB[bar]>0)
                    {
                     _timeGross[x][3]=_timeGross[x][2];
                     if (hl_==-1) {_cena[x][2]=HB[bar]; _cena[x][3]=LB[bar];}
                     else {_cena[x][2]=LB[bar]; _cena[x][3]=HB[bar];}

                     k++;
                    }
                  else if (LB[bar]>0)
                    {
                     _cena[x][2]=LB[bar]; hl_=-1;
                    }
                  else if (HB[bar]>0)
                    {
                     _cena[x][2]=HB[bar]; hl_=1;
                    }

                  k++;
                 }
               else if (k==3)
                 {
                  _timeGross[x][3]=iTime(NULL,GrossPeriod_[x],bar); 
                  if (LB[bar]>0 && HB[bar]>0)
                    {
                     if (hl_==-1) _cena[x][3]=HB[bar];
                     else _cena[x][3]=LB[bar];
                    }
                  else if (LB[bar]>0) _cena[x][3]=LB[bar];
                  else if (HB[bar]>0) _cena[x][3]=HB[bar];

                  k++;
                 }
              }
           }
        }

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

   if (!_draw) return(0);

   // Корректировка времени экстремумов старших таймфреймов
   if (fibofan != 0)
     {
      if (GrossPeriod_[x]==0 || GrossPeriod_[x]==Period())
        {
         _time[x][0]=_timeGross[x][0];
         _time[x][1]=_timeGross[x][1];
         _time[x][2]=_timeGross[x][2];
         _time[x][3]=_timeGross[x][3];
        }
      else
        {
         if (_cena[x][0]>_cena[x][1]) hl_=1; else hl_=-1;
         h_=_cena[x][1];
         for (k=0;k<4;k++)
           {
            if (_timeGross[x][k]==0) continue;
            bar=iBarShift(NULL,0,_timeGross[x][k],false); i_=bar;
            t_=_timeGross[x][k]+GrossPeriod_[x]*60;
            if (t_>Time[Bars-1])
              {
               for (i=bar;iTime(NULL,0,i)<t_ && i>=0;i--)
                 {
                  if (hl_<0)
                    {
                     l_=iLow(NULL,0,i);
                     if (h_>l_) {h_=l_; i_=i;}
                    }
                  else
                    {
                     l_=iHigh(NULL,0,i);
                     if (h_<l_) {h_=l_; i_=i;}
                    }
                 }
               _time[x][k]=iTime(NULL,0,i_);
              }

            if (hl_>0) {hl_=-1; h_=1000000;} else {hl_=1; h_=0;}

           // if (!fiboChannel && k==2) k=4;
           }
        }
     }

   // Вывод фибо вееров
   if (fibofan && _time[x][2]>0 && _time[x][1] && fanVisible_[x]==1)
     {
      nameObj="f_"+ExtComplect+"_"+x+"_ff";
      ObjectDelete(nameObj);
      ObjectCreate(nameObj, OBJ_FIBO, 0, _time[x][2], _cena[x][2], _time[x][1], _cena[x][1]);
      ObjectSet(nameObj, OBJPROP_COLOR, CLR_NONE);
      ObjectSet(nameObj, OBJPROP_LEVELCOLOR, zzColor_[x]);
      ObjectSet(nameObj, OBJPROP_LEVELSTYLE, fanStyle_[x]);
      ObjectSet(nameObj, OBJPROP_LEVELWIDTH, fanWidth_[x]);
      ObjectSet(nameObj,OBJPROP_FIBOLEVELS, j_f);
      str=FiboFreeFan;

      for (i=0; i<=j_f; i++)
        {
         k=StringFind(str, ",", 0);
         str1=StringTrimLeft(StringTrimRight(StringSubstr(str,0,k)));
         fi=StrToDouble(str1);
         if (fi<1) str1=StringSubstr(str1,1);

         ObjectSet(nameObj,OBJPROP_FIRSTLEVEL+i,fi);
         ObjectSetFiboDescription(nameObj, i, str1);

         if (k>=0) str=StringSubstr(str,k+1);
        }
     }

   // Вывод фибо каналов


   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, t3=GrossPeriod_[x]*60-1;
   bool tdelta=false;

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

      t1=iTime(NULL, GrossPeriod_[x],i);
      for (j=0;ext3<end && j<Bars;j++)
        {

         if (Period()==10080)
           {
            if (el<0 && eh<0) tdelta=Time[j]<t1;
            else tdelta=Time[j]+t3<t1;
           }
         else
           {
            tdelta=Time[j]<t1;
           }

         if (tdelta) {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 (Period()==10080)
           {
            if (el<0 && eh<0) tdelta=Time[j]<t1;
            else tdelta=Time[j]+t3<t1;
           }
         else
           {
            tdelta=Time[j]<t1;
           }

         if (tdelta) {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          |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Удаление фибо инструментов. Начало.                              |
//+------------------------------------------------------------------+
void _delete_fibo ()
  {
   int i;
   string txt;

   for (i=ObjectsTotal(); i>=0; i--)
     {
      txt=ObjectName(i);
      if (StringFind(txt,"f_"+ExtComplect+"_")>-1) ObjectDelete (txt);
     }
  }
//+------------------------------------------------------------------+
//| Удаление фибо инструментов. Конец.                               |
//+------------------------------------------------------------------+

//--------------------------------------------------------
// Счетчик фиб. Начало.
//--------------------------------------------------------
int quantityFibo (string sFibo)
  {
   int j=0,i,k;

   while (true)
     {
      k=StringFind(sFibo, ",",i+1);
      if (k>0) {j++; i=k;}
      else return (j+1); return(0);
     }
     return(0);
  }
//--------------------------------------------------------
// Счетчик фиб. Конец.
//--------------------------------------------------------