//+------------------------------------------------------------------+
//|                                                      ProjectName |
//|                                      Copyright 2012, CompanyName |
//|                                       http://www.companyname.net |
//+------------------------------------------------------------------+
#property copyright "http://dmffx.com"
#property link      "http://dmffx.com"

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 CLR_NONE
#property indicator_color2 DeepSkyBlue
#property indicator_color3 Red
#property indicator_width2 1
#property indicator_width3 1

extern int  HLPeriod    =  7;    // Параметр зигзага аналогичый параметру ExtDepth индикатора ZigZag
extern int  MinHeight   =  0;    // Минимальная высота колена зигзага по вертикали (в пунктах)

//---- buffers
double zz[];

double lht[];
double llt[];
double buy[];
double sell[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   IndicatorBuffers(5);

   SetIndexStyle(0,DRAW_SECTION);
   SetIndexBuffer(0,zz);
   SetIndexEmptyValue(0,0.0);

   SetIndexStyle(1,DRAW_ARROW);
   SetIndexBuffer(1,buy);
   SetIndexArrow(1,233);
   SetIndexEmptyValue(1,0.0);

   SetIndexStyle(2,DRAW_ARROW);
   SetIndexBuffer(2,sell);
   SetIndexArrow(2,234);
   SetIndexEmptyValue(2,0.0);

   SetIndexBuffer(3,lht);
   SetIndexBuffer(4,llt);

   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----

//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {

//int cb=IndicatorCounted();
//int limit=Bars-cb-1;

   int cb=IndicatorCounted();
   if(cb<0) return(-1);
   if(cb>0) cb--;
   int limit=Bars-cb;
   if(cb==0)
     {
      limit-=1+1;
      ArrayInitialize(lht,0);
      ArrayInitialize(llt,0);
     }

   static datetime LastTime=0;
   static int cDir=0;
   static int pDir=0;
   static double cBackUp=0;
   static double pBackUp=0;
   static double cNeckUp=0;
   static double pNeckUp=0;
   static double cTailUp=0;
   static double pTailUp=0;
   static double cBackDn=0;
   static double pBackDn=0;
   static double cNeckDn=0;
   static double pNeckDn=0;
   static double cTailDn=0;
   static double pTailDn=0;

   static int cTailBarUp=0;
   static int pTailBarUp=0;

   if(cb==0)
     {
      LastTime=0;
      cDir=0;
      pDir=0;
      cBackUp=0;
      pBackUp=0;
      cNeckUp=0;
      pNeckUp=0;
      cTailUp=0;
      pTailUp=0;
      cBackDn=0;
      pBackDn=0;
      cNeckDn=0;
      pNeckDn=0;
      cTailDn=0;
      pTailDn=0;

      cTailBarUp=0;
      pTailBarUp=0;
     }

   for(int i=limit;i>=0;i--)
     {
      if(Time[i]>LastTime)
        {
         LastTime=Time[i];
         pDir=cDir;
         pBackUp=cBackUp;
         pNeckUp=cNeckUp;
         pTailUp=cTailUp;
         pBackDn=cBackDn;
         pNeckDn=cNeckDn;
         pTailDn=cTailDn;

         pTailBarUp=cTailBarUp;
        }
      else
        {
         cDir=pDir;
         cBackUp=pBackUp;
         cNeckUp=pNeckUp;
         cTailUp=pTailUp;
         cBackDn=pBackDn;
         cNeckDn=pNeckDn;
         cTailDn=pTailDn;

         cTailBarUp=pTailBarUp;
        }

      lht[i]=lht[i+1];
      llt[i]=llt[i+1];
      zz[i]=0;
      int lhb;
      int llb;
      int hb=iHighest(NULL,0,MODE_HIGH,HLPeriod,i);
      int lb=iLowest(NULL,0,MODE_LOW,HLPeriod,i);
      lhb=Bars-lht[i]-1;
      llb=Bars-llt[i]-1;
      if(llb>lhb)
        {
         zz[lhb]=High[lhb];
        }
      else
        {
         zz[llb]=Low[llb];
        }
      if(hb==lb)
        {
         if(hb==i)
           {
            switch(cDir)
              {
               case 1:
                  if(High[i]>zz[lhb])
                    {
                     zz[lhb]=0;
                     zz[i]=High[i];
                     lht[i]=Bars-i-1;
                    }
                  else
                    {
                     if(Low[i]<=zz[lhb]-Point*MinHeight)
                       {
                        zz[i]=Low[i];
                        llt[i]=Bars-i-1;
                        cDir=-1;
                       }
                    }
                  break;
               case -1:
                  if(Low[i]<zz[llb])
                    {
                     zz[llb]=0;
                     zz[i]=Low[i];
                     llt[i]=Bars-i-1;
                    }
                  else
                    {
                     if(High[i]>=zz[llb]+Point*MinHeight)
                       {
                        zz[i]=High[i];
                        lht[i]=Bars-i-1;
                        cDir=1;
                       }
                    }
                  break;
              }
           }

        }
      else if(lb>hb)
        {
         if(hb==i)
           {
            if(cDir==1)
              {
               if(High[i]>zz[lhb])
                 {
                  zz[lhb]=0;
                  zz[i]=High[i];
                  lht[i]=Bars-i-1;
                 }
              }
            else
              {
               if(High[i]>=zz[llb]+Point*MinHeight)
                 {
                  zz[i]=High[i];
                  lht[i]=Bars-i-1;
                  cDir=1;
                 }
              }
           }
        }
      else if(hb>lb)
        {
         if(lb==i)
           {
            if(cDir==-1)
              {
               if(Low[i]<zz[llb])
                 {
                  zz[llb]=0;
                  zz[i]=Low[i];
                  llt[i]=Bars-i-1;
                 }
              }
            else
              {
               if(Low[i]<=zz[lhb]-Point*MinHeight)
                 {
                  zz[i]=Low[i];
                  llt[i]=Bars-i-1;
                  cDir=-1;
                 }
              }
           }
        }

      buy[i]=0;
      if(cDir==-1)
        {
         if(pDir==1)
           {
            int z=Bars-lht[i]-1;
            int z1=Bars-llt[z]-1;
            int z2=Bars-lht[z1]-1;
            int z3=Bars-llt[z2]-1;
            if(zz[z3]>zz[z])
              {
               cTailUp=zz[z3];
               cBackUp=zz[z];
               cNeckUp=0;
              }
            if(cTailUp!=0)
              {
               if(cNeckUp==0 && zz[z]<cTailUp)
                 {
                  cBackUp=MathMax(cBackUp,zz[z]);
                 }
               if(zz[z]>cTailUp)
                 {
                  cNeckUp=cBackUp;
                 }
              }
           }
        }
      if(cNeckUp!=0)
        {
         if(cDir==1)
           {
            if(pDir==-1)
              {
               z=Bars-llt[i]-1;
               if(zz[z]>cNeckUp)
                 {
                  cTailUp=0;
                  cNeckUp=0;
                  cBackUp=0;
                  buy[i]=Low[i]-Point*5;
                 }
              }
           }
        }

      sell[i]=0;
      if(cDir==1)
        {
         if(pDir==-1)
           {
            z=Bars-llt[i]-1;
            z1=Bars-lht[z]-1;
            z2=Bars-llt[z1]-1;
            z3=Bars-lht[z2]-1;
            if(zz[z3]<zz[z])
              {
               cTailDn=zz[z3];
               cBackDn=zz[z];
               cNeckDn=0;
              }
            if(cTailDn!=0)
              {
               if(cNeckDn==0 && zz[z]>cTailDn)
                 {
                  cBackDn=MathMin(cBackDn,zz[z]);
                 }
               if(zz[z]<cTailDn)
                 {
                  cNeckDn=cBackDn;
                 }
              }
           }
        }
      if(cNeckDn!=0)
        {
         if(cDir==-1)
           {
            if(pDir==1)
              {
               z=Bars-lht[i]-1;
               if(zz[z]<cNeckDn)
                 {
                  cTailDn=0;
                  cNeckDn=0;
                  cBackDn=0;
                  sell[i]=High[i]+Point*5;
                 }
              }
           }
        }

     }

   return(0);
  }
//+------------------------------------------------------------------+