///+-----------------------------------------------------------------+ 
// Final Draft MZZ2           \¦/
// Knowledge of the ancients (т у)
//______________________o0o___(_)___o0o__
//___¦_____¦_____¦mladen¦_____¦_____¦_____¦
//¦_cja_¦_____¦_____¦_____¦_____¦_____¦__
//___¦_____¦_____¦_____¦_Xard¦777__¦_____¦
//¦____¦ihldiaf¦_____¦_____¦_____¦____¦__
//___¦_____¦_____¦_____¦Baba¦Master_¦____¦
//¦FxSniper___¦_____¦_igor_¦_____¦_nen_¦__           March 24th, 2009
//+------------------------------------------------------------------+
#property link   "nen"
#property indicator_chart_window
#property indicator_buffers  8

#property indicator_color1 C'180,24,180'
#property indicator_color2 CLR_NONE
#property indicator_color3 C'24,180,180'
#property indicator_color4 CLR_NONE
#property indicator_color5 CLR_NONE
#property indicator_color6 CLR_NONE
#property indicator_color7 CLR_NONE
#property indicator_color6 CLR_NONE

#property indicator_width1 20
#property indicator_width2 0
#property indicator_width3 14
#property indicator_width4 0
#property indicator_width5 5
#property indicator_width6 0
#property indicator_width7 4
#property indicator_width8 0

#property indicator_style1 0
#property indicator_style2 0
#property indicator_style3 0
#property indicator_style4 0
#property indicator_style5 0
#property indicator_style6 0
#property indicator_style7 0
#property indicator_style8 0
 
string ExtDepth     = "12,12,12,12";
string ExtDeviation = "5,5,5,5";
string ExtBackstep  = "3,3,3,3";
//string ExtMaxBar    = "5000,1000,500,250";  // Количество обсчитываемых баров (0-все)
//string GrossPeriod  = "15,60,240,1440";     // Таймфреймы, на которых рассчитываются зигзаги, 0 - текущий таймфрейм
string ExtMaxBar    = "250,500,1000,5000";  // Количество обсчитываемых баров (0-все)
string GrossPeriod  = "1440,240,60,15";     // Таймфреймы, на которых рассчитываются зигзаги, 0 - текущий таймфрейм


string DinamicPitchfork = "1,1,1,1";        // 1 - вилы выводятся в динамическом режиме, 0 - в статическом.
                                                   // Вилы, расчитываемые от нулевого экстремума, всегда динамические
string numberExtr    = "1,1,1,1";           // указывается номер экстремума справа, являющийся крайним для расчета вил
string PitchforkYes  = "1,1,1,1";           // 1 - вилы рассчитываются и выводятся на график, 0 - вилы не рассчитываются и не выводятся
string PitchStyle    = "2,2,2,2";
string PitchWidth    = "0,0,0,0";
int    ExtReCalculate  = 3;              // Количество экстремумов зигзага старшего таймфрейма, начиная с 0, пересчитываемых
                                                // в режиме реального времени
int    ExtComplekt  = 0;

int ExtDepth_[]={0,0,0,0}, ExtDeviation_[]={0,0,0,0}, ExtBackstep_[]={0,0,0,0}, ExtMaxBar_[]={0,0,0,0}, GrossPeriod_[]={0,0,0,0}, PitchStyle_[]={0,0,0,0}, PitchWidth_[]={0,0,0,0};
int DinamicPitchfork_[]={0,0,0,0}, numberExtr_[]={0,0,0,0}, PitchforkYes_[]={0,0,0,0};
//  Буферы для хранения флагов, разрешающих пересчет и вывод вил Эндрюса.
bool   _yes[4];
//  Буферы для хранения значений максимумов экстремумов для расчета вил
double _max[4][4];
//  Буферы для хранения значений минимумов экстремумов для расчета вил
double _min[4][4];
//  Буферы для хранения значений времени экстремумов для расчета вил
int    _time[4][4];
//  Индикаторные буферы
double LowestBuffer1[],HighestBuffer1[],LowestBuffer2[],HighestBuffer2[],LowestBuffer3[],HighestBuffer3[],LowestBuffer4[],HighestBuffer4[];
//  Вспомогательные буферы
double LowestBufferGross1[],HighestBufferGross1[],LowestBufferGross2[],HighestBufferGross2[],LowestBufferGross3[],HighestBufferGross3[],LowestBufferGross4[],HighestBufferGross4[];
//  Флаги, показывающие, что со старшего тф первоначальное преобразование зигзага произведено
bool Grosstf_DT[]={false, false, false, false};
//  Флаги, показывающие, что на истории зигзаг построен
bool ZZ_tf[]={false, false, false, false};
//  Значение времени начала и конца третьего луча
datetime L2LTime[]={0,0,0,0},L2HTime[]={0,0,0,0};
//  При выходе за значения переменных lBar, hBar и tiZZ производится расчет зигзага
//  То есть только при выходе за пределы уже посчитанного бара производится расчет. 
//  Это позволяет рассчитывать не на каждом тике.
double lBar[]={0,0,0,0}, hBar[]={0,0,0,0};
datetime tiZZ[]={0,0,0,0};
//  Переменная для хранения значения Bars
int saveBars[]={0,0,0,0};
int currentBars;
//  Переменная, хранящая количество баров, на которых рассчитывается зигзаг
int limit;

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

// По два индикаторных буффера использовано для счёта каждого зигзага
   SetIndexBuffer(0,LowestBuffer1);
   SetIndexBuffer(1,HighestBuffer1);
   SetIndexBuffer(2,LowestBuffer2);
   SetIndexBuffer(3,HighestBuffer2);
   SetIndexBuffer(4,LowestBuffer3);
   SetIndexBuffer(5,HighestBuffer3);
   SetIndexBuffer(6,LowestBuffer4);
   SetIndexBuffer(7,HighestBuffer4);
// Стиль исполнения графика в виде ломаной ZigZag 
   SetIndexStyle(0,DRAW_ZIGZAG);
   SetIndexStyle(1,DRAW_ZIGZAG);
   SetIndexStyle(2,DRAW_ZIGZAG);
   SetIndexStyle(3,DRAW_ZIGZAG);
   SetIndexStyle(4,DRAW_ZIGZAG);
   SetIndexStyle(5,DRAW_NONE);
   SetIndexStyle(6,DRAW_NONE);
   SetIndexStyle(7,DRAW_NONE);
// Установка значений индикатора, которые не будут видимы на графике
   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");

   _stringtoarray (ExtDepth, ExtDepth_, 4);
   _stringtoarray (ExtDeviation, ExtDeviation_, 4);
   _stringtoarray (ExtBackstep, ExtBackstep_, 4);
   _stringtoarray (ExtMaxBar, ExtMaxBar_, 4);
   _stringtoarray (GrossPeriod, GrossPeriod_, 4);
   _stringtoarray (PitchStyle, PitchStyle_, 4);
   _stringtoarray (PitchWidth, PitchWidth_, 4);
   _stringtoarray (DinamicPitchfork, DinamicPitchfork_, 4);
   _stringtoarray (numberExtr, numberExtr_, 4);
   _stringtoarray (PitchforkYes, PitchforkYes_, 4);

   for (i=0;i<4;i++)
     {
      Grosstf_DT[i]=false; ZZ_tf[i]=false;
      j=GrossPeriod_[i];
      GrossPeriod_[i]=_period(i,j);
//      if (ExtDepth_[i]>=ExtBackstep_[i]) m=ExtDepth_[i]; else m=ExtBackstep_[i];
      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);
        }
     }

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

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


//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
   int i;
   string txt;

   for (i=ObjectsTotal(); i>=0; i--)
     {
      txt=ObjectName(i);
      if (StringFind(txt,"balbesik06_"+ExtComplekt+"_")>-1) ObjectDelete (txt);
     }
  }


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

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

   currentBars=Bars;

   for (i=0;i<4;i++)
     {
      // проверки для корректного расчёта индикатора
      if (ExtDepth_[i]==0) continue;
      m=ExtBackstep_[i]+ExtDepth_[i];
      if ((iBars(NULL,GrossPeriod_[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);

            ArrayInitialize(LowestBuffer1,0); ArrayInitialize(HighestBuffer1,0);
           }
         else if (i==1)
           {
            arr_resize(LowestBufferGross2, HighestBufferGross2, limit+m, i);

            ArrayInitialize(LowestBuffer2,0); ArrayInitialize(HighestBuffer2,0); 
           }
         else if (i==2)
           {
            arr_resize(LowestBufferGross3, HighestBufferGross3, limit+m, i);

            ArrayInitialize(LowestBuffer3,0); ArrayInitialize(HighestBuffer3,0); 
          }
         else if (i==3)
           {
            arr_resize(LowestBufferGross4, HighestBufferGross4, limit+m, i);

            ArrayInitialize(LowestBuffer4,0); ArrayInitialize(HighestBuffer4,0); 
          }

         if (PitchforkYes_[i]==0) _yes[i]=false; else _yes[i]=true;

         _min[i][0]=0;  _min[i][1]=0;  _min[i][2]=0;  _min[i][3]=0;
         _max[i][0]=0;  _max[i][1]=0;  _max[i][2]=0;  _max[i][3]=0;
         _time[i][0]=0; _time[i][1]=0; _time[i][2]=0; _time[i][3]=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)
        {
         switch (i)
           {
            case 0:
              {
               if (GrossPeriod_[i]==0)
                 {
                  ZigZag_(LowestBuffer1, HighestBuffer1, i);
                 }
               else
                 {
                  if (limit==2) Shift_elements(LowestBufferGross1,HighestBufferGross1);

                  if (ZigZag_(LowestBufferGross1, HighestBufferGross1, i)==0)
                    {
                     ZigZagDT (LowestBuffer1, HighestBuffer1, LowestBufferGross1, HighestBufferGross1, i);
                    }
                 }

               if (_yes[i])
                 {
                  _Pitchfork_balbesik06(LowestBuffer1, HighestBuffer1, i);
                 }

               break;
              }
            case 1:
              {
               if (GrossPeriod_[i]==0)
                 {
                  ZigZag_(LowestBuffer2, HighestBuffer2, i);
                 }
               else
                 {
                  if (limit==2) Shift_elements(LowestBufferGross2,HighestBufferGross2);

                  if (ZigZag_(LowestBufferGross2, HighestBufferGross2, i)==0)
                    {
                     ZigZagDT (LowestBuffer2, HighestBuffer2, LowestBufferGross2, HighestBufferGross2, i);
                    }
                 }

               if (_yes[i])
                 {
                  _Pitchfork_balbesik06(LowestBuffer2, HighestBuffer2, i);
                 }

               break;
              }
            case 2:
              {
               if (GrossPeriod_[i]==0)
                 {
                  ZigZag_(LowestBuffer3, HighestBuffer3, i);
                 }
               else
                 {
                  if (limit==2) Shift_elements(LowestBufferGross3,HighestBufferGross3);

                  if (ZigZag_(LowestBufferGross3, HighestBufferGross3, i)==0)
                    {
                     ZigZagDT (LowestBuffer3, HighestBuffer3, LowestBufferGross3, HighestBufferGross3, i);
                    }
                 }

               if (_yes[i])
                 {
                  _Pitchfork_balbesik06(LowestBuffer3, HighestBuffer3, i);
                 }

               break;
              }
            case 3:
              {
               if (GrossPeriod_[i]==0)
                 {
                  ZigZag_(LowestBuffer4, HighestBuffer4, i);
                 }
               else
                 {
                  if (limit==2) Shift_elements(LowestBufferGross4,HighestBufferGross4);

                  if (ZigZag_(LowestBufferGross4, HighestBufferGross4, i)==0)
                    {
                     ZigZagDT (LowestBuffer4, HighestBuffer4, LowestBufferGross4, HighestBufferGross4, i);
                    }
                 }

               if (_yes[i])
                 {
                  _Pitchfork_balbesik06(LowestBuffer4, HighestBuffer4, i);
                 }

               break;
              }
           }

        }

     }

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


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

//+------------------------------------------------------------------+
//|  Основной 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;
   double el=-1, eh=-1;
   datetime t1;

   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++; 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) {LB[jl]=el; el=-1; ext3++;}
           }

         if  (HBG[i]>0)
           {
            if (eh<=High[j]) {eh=High[j]; jh=j;}
           }
         else
           {
            if (eh>0) {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++; 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) {LB[jl]=el; el=-1;}
           }

         if  (HBG[i]>0)
           {
            if (eh<=High[j]) {eh=High[j]; jh=j;}
           }
         else
           {
            if (eh>0) {HB[jh]=eh; eh=-1;}
           } 
        }
     }

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

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

   switch (tf)
     {
      case 0     : {return (0);}
      case 1     : {return (1);}
      case 5     : {return (5);}
      case 15    : {return (15);}
      case 30    : {return (30);}
      case 60    : {return (60);}
      case 240   : {return (240);}
      case 1440  : {return (1440);}
      case 10080 : {return (10080);}
      case 43200 : {return (43200);}
      default    : {ExtDepth_[x]=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 _stringtoarray (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 _Pitchfork_balbesik06 (double& arrL[], double& arrH[], int x)
  {
   int i, j, k, m, n, max;
   bool new=false;
   color  cPitch;
   datetime _t;
   int  number[4];
   double  a=0,b=0,c=0,a1=0,b1=0,c1=0, kx=0, tangensab, tangensa1b1, t, t1, tx;
   int     na=0,nb=0,nc=0,na1=0,nb1=0,nc1=0;
   double  na_=0,nb_=0,nc_=0,na1_=0,nb1_=0,nc1_=0;
   string  nameObj="balbesik06_" + ExtComplekt+"_"+x;

   m=ExtBackstep_[x]+ExtDepth_[x];
   if ((ExtMaxBar_[x]>iBars(NULL,GrossPeriod_[x])-m) || (ExtMaxBar_[i]==0)) max=iBars(NULL,GrossPeriod_[x])- m; else max=ExtMaxBar_[i];
   _t=iTime(NULL,GrossPeriod_[x],max);
   max=iBarShift(NULL,0,_t,false);
   // заполнение буферов.
   if (_time[x][0]==0)
     {
      j=0; k=0; n=4;
      for (i=0;i<=max && k<n;i++)
        {
         if (arrL[i]>0 || arrH[i]>0)
           {
             if (j>=numberExtr_[x])
               {
                _min[x][k]=arrL[i]; _max[x][k]=arrH[i]; _time[x][k]=Time[i];
                number[k]=i;

                k++;
               }

             j++;
           }
        }

      new=true;
     }
   else
     {
      j=0; k=0; n=2;
      for (i=0;i<=max && k<n;i++)
        {
         if (arrL[i]>0 || arrH[i]>0)
           {
             if (j>=numberExtr_[x])
               {
                if (arrL[i]!=_min[x][k] || arrH[i]!=_max[x][k] || new) {_min[x][k]=arrL[i]; _max[x][k]=arrH[i]; _time[x][k]=Time[i]; new=true; n=4;}
                number[k]=i;
                k++;
               }

             j++;
           }
        }
     }

   if (new)
     {
      ObjectDelete(nameObj);

      // определение параметров точек привязки вспомогательных вил
      if (_min[x][0]==0)
        {
         c=_max[x][0]; nc=number[0];
         b=_min[x][1]; nb=number[1];
         if (_min[x][1]>0 && _max[x][1]>0) {a=_max[x][1]; na=number[1]; a1=_min[x][2]; na1=number[2];}
         else
           {
            a=_max[x][2]; na=number[2];
            if (_min[x][2]>0 && _max[x][2]>0) {a1=_min[x][2]; na1=number[2];}
            else {a1=_min[x][3]; na1=number[3];}
           }
        }
      else if (_max[x][0]==0)
        {
         c=_min[x][0]; nc=number[0];
         b=_max[x][1]; nb=number[1];
         if (_min[x][1]>0 && _max[x][1]>0) {a=_min[x][1]; na=number[1]; a1=_max[x][2]; na1=number[2];}
         else
           {
            a=_min[x][2]; na=number[2];
            if (_min[x][2]>0 && _max[x][2]>0) {a1=_max[x][2]; na1=number[2];}
            else {a1=_max[x][3]; na1=number[3];}
           }
        }
      if (na==0 || nb==0 || nc==0 || na1==0) return (-1);
      c1=b;  nc1=nb;
      b1=a; nb1=na;

      na_=na; nb_=nb; nc_=nc; na1_=na1; nb1_=nb1; nc1_=nc1;

      t=na_-(nc_+nb_)/2;
      tangensab=((b+c)/2-a)/t;
      t1=na1_-(nc1_+nb1_)/2;
      tangensa1b1=((b1+c1)/2-a1)/t1;

      kx=(a1-a+tangensa1b1*(na1_-na_))/(tangensab-tangensa1b1);

      switch (x)
        {
         case 0: {cPitch=CLR_NONE; break;}
         case 1: {cPitch=CLR_NONE; break;}
         case 2: {cPitch=CLR_NONE; break;}
         case 3: {cPitch=CLR_NONE;}
        }

      ObjectCreate(nameObj,OBJ_PITCHFORK,0,Time[na],(kx*tangensab+a),Time[nb],b,Time[nc],c);
      ObjectSet(nameObj,OBJPROP_STYLE,PitchStyle_[x]);
      ObjectSet(nameObj,OBJPROP_WIDTH,PitchWidth_[x]);
      ObjectSet(nameObj,OBJPROP_BACK, 1);
      ObjectSet(nameObj,OBJPROP_COLOR,cPitch);

     }

   if (DinamicPitchfork_[x]==0 && numberExtr_[x]>0) _yes[x]=false;
  }
//+------------------------------------------------------------------+
//| Построение вил Эндрюса. Конец.                                   |
//+------------------------------------------------------------------+

