//+------------------------------------------------------------------+
//|                                       TrendRevers Signals_v2.mq4 |
//|                                 Copyright © 2009.06.26, SwingMan |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009.06.26, SwingMan"
#property link      ""
/*+------------------------------------------------------------------+
Source from: HourPower Signals
2009.03.16  Send Signal-Alert and -EMail
            Factor_SignalOffset
2009.03.17  Problem with appear/disappear of signals on the same bar solved
            "transparent" arrows
2009.06.25  Areas for TrendRevers / HullSlope indicator            
2009.06.26  v2 bugs fixed 
//+-----------------------------------------------------------------*/

#property indicator_chart_window

#property indicator_buffers 2

#property indicator_color1 DeepSkyBlue
#property indicator_color2 Magenta
#property indicator_width1 2
#property indicator_width2 2

//---- extern inputs -------------------------------------------------
extern int MaxBars = 200;
//extern double Factor_SignalOffset = 0.5;
//extern double SAR_Step = 0.05;
//extern double SAR_Max  = 0.2;
//extern double Stoch_Kperiod = 5;
//extern double Stoch_Dperiod = 3;
//extern double Stoch_Slowing = 3;
extern bool SendAlert_Signals  = true;
extern bool SendEmail_Signals  = false;
//extern bool PrintAlert_Signals = false;
extern bool ThickArrows = true;
//--------------------------------------------------------------------

bool Slope_HistogramValues = false;


//---- constants
string sTextAlert        = "TrendRevers Signals_v2";
string subjectEmailAlert = "TrendRevers Signals_v2";
string windowsName       = "TrendRevers Signals_v2";

//double limitOverBought = 80;
//double limitOverSold   = 20;
//---- buffers
double signalUP[], signalDN[];
double hMainTrend[], hSlopeMain[], hSlopeSignal[];
int hSignalDirection[], signalTRADE[];
datetime arTimeBegin[], arTimeEnd[];

//---- variables
int AlertSignal, oldSignalTRADE, thisSignalTRADE;
string sPeriod;
datetime signalTime;

//---- areas
//-- signals
int areaNumber;
datetime beginArea, endArea, thisTime, oldTime;
double highArea, lowArea;
color colorUpArea = Olive;//C'98,98,255'; //Blue; Green
color colorDnArea = LightSalmon;//C'255,128,79'; //OrangeRed;
int limitBars, limitAreas;
string sOldArea;
//-- daily range
datetime beginAreaD, endAreaD, thisTimeD, oldTimeD;
double highAreaD, lowAreaD, R2, S2;
string sOldAreaD, sOldAreaR2, sOldAreaS2;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
   areaNumber = 0;
   beginArea = 0; 
   endArea = 0;
   highArea = 0;
   lowArea = 0;
   //Comment(windowsName);
   
   ArraySetAsSeries(hMainTrend, true);
   ArraySetAsSeries(hSlopeMain, true);
   ArraySetAsSeries(hSlopeSignal, true);     
   ArraySetAsSeries(hSignalDirection, true);   
   ArraySetAsSeries(signalTRADE, true);
   ArraySetAsSeries(arTimeBegin, true);
   ArraySetAsSeries(arTimeEnd, true);
   
   int iArrowUP, iArrowDN;
   if (ThickArrows == false) {
      iArrowUP = 241;
      iArrowDN = 242;
   } 
   else {
      iArrowUP = 233;
      iArrowDN = 234;
   }
   SetIndexBuffer(0, signalUP);  SetIndexStyle(0, DRAW_ARROW, EMPTY, 2); 
   SetIndexArrow(0,iArrowUP); SetIndexLabel(0, "Buy");
   SetIndexBuffer(1, signalDN);  SetIndexStyle(1, DRAW_ARROW, EMPTY, 2); 
   SetIndexArrow(1,iArrowDN); SetIndexLabel(1, "Sell");
   
   sPeriod = Get_sPeriod(Period());

   return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
{   
   ObjectsDeleteAll();
   Comment("");
   return(0);
}
   int iii;
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{
//   Comment(windowsName + "  " + TimeToStr(TimeCurrent(),TIME_MINUTES|TIME_SECONDS));
   int counted_bars, limit, i;

   ArrayResize(hMainTrend, Bars);
   ArrayResize(hSlopeMain, Bars);
   ArrayResize(hSlopeSignal, Bars);   
   ArrayResize(hSignalDirection, Bars);   
   ArrayResize(signalTRADE, Bars);
   ArrayResize(arTimeBegin, Bars);
   ArrayResize(arTimeEnd, Bars);
   
   counted_bars = IndicatorCounted();
   if (counted_bars < 0) return(-1);
   if (counted_bars > 0) counted_bars--;

   /*if (Bars > MaxBars) 
        limit = MaxBars - counted_bars; 
   else limit = Bars - counted_bars;  */
   limit = Bars - counted_bars;
   
//   if (limit< 0) limit = 200;
//Comment(counted_bars,"  ",limit,"  iii=",iii,"  Time:",TimeToStr(Time[i],TIME_MINUTES|TIME_SECONDS),"  current:",TimeToStr(TimeCurrent(),TIME_MINUTES|TIME_SECONDS));
   //===================================================================
   //---- 1. calculate indicators ======================================
   if (limit > MaxBars) limitBars = MaxBars; else limitBars = limit;
   for (i = limitBars+1; i >= 0; i--) {   
      //---- Main trend / Hull(27) ..................................
      int Hull_period27 = 27;
      /*double iTrend;
      double HullValue;
      Get_HullTrend(Symbol(), Period(), Hull_period27, iTrend, HullValue, i);
      hMainTrend[i] = iTrend;*/

      //---- slope Hull(27) .................................      
      int smooth_period = 5;
      double treshold = 10.0;
      double slopeH27, slopeH8;
      Get_HullSlope(Symbol(), Period(), Hull_period27, smooth_period, treshold, slopeH27, i);
      hSlopeMain[i] = slopeH27;
      //---- slope Hull(8) .................................      
      /*int Hull_period8 = 8;
      Get_HullSlope(Symbol(), Period(), Hull_period8, smooth_period, treshold, slopeH8, i);      
      hSlopeSignal[i]  = slopeH8;*/
//if (i==0)
//Comment("MainTrend=",iTrend, "  SlopeMain=",slopeH27,"  SlopeSignal=",slopeH8);
   }
   
   //===================================================================
   //---- 2. draw areas ================================================
if (iii < 4){   
iii++;       
}     
//if (iii>2) limitAreas = 2; else 
limitAreas = limitBars;
   string sName;
   for (i = limitAreas; i >= 0; i--) {
      double slope0 = hSlopeMain[i];
      double slope1 = hSlopeMain[i+1];
      thisTime = Time[i];
      if (thisTime != oldTime) {
         oldTime = thisTime;
         bool newBar = true;
      }
      else
         newBar = false;

      if (newBar == true)
         sName = "ar_" + TimeToStr(Time[i+1],TIME_DATE|TIME_MINUTES|TIME_SECONDS);
//if (i==16)
//Comment("slope0=",slope0,"  slope1=",slope1);      
      //--- color is changed
      //if (slope0 != slope1 && newBar == true) {
      if (slope0 != slope1 && newBar == true && arTimeBegin[i] == 0) {
         //-- first area
         //if (beginArea == 0) {
            //areaNumber++;
            //sName = "ar_" + areaNumber;
            
            beginArea = Time[i];
            arTimeBegin[i] = beginArea;            
            double dATR2  = iATR(Symbol(),Period(),34,1) / 2.0;
            double middle = (High[i]+Low[i])/2.0;
            highArea  = NormalizeDouble(middle+dATR2, Digits);
            lowArea   = NormalizeDouble(middle-dATR2, Digits);
            
            endArea = 0;
            sOldArea="";
            arTimeEnd[i] = endArea;
//Comment(i," ",arTimeBegin[i],"  ",limitAreas,"C. Time:",TimeToStr(Time[i],TIME_MINUTES|TIME_SECONDS),"  current:",TimeToStr(TimeCurrent(),TIME_MINUTES|TIME_SECONDS));            
            //---- signal arrows
            if (slope0 > 0) signalUP[i] = Low[i] - dATR2 * 0.80; else
            if (slope0 < 0) signalDN[i] = High[i] + dATR2 * 0.80;
            
            //---- send alerts
            if (i == 0) {
               if (slope0 > 0) AlertSignal = 1; else
               if (slope0 < 0) AlertSignal = -1;
               SendAlerts();
            }
         /*}
         else
         if (endArea == 0 && beginArea != Time[i]) {
            endArea = Time[i];            
         }*/
      }
      else
      //--- color is not changed
      if (slope0 == slope1 && newBar == true) {

         if (endArea == 0) {
         //if (endArea == 0 && beginArea != Time[i]) {
            endArea = Time[i];
            arTimeEnd[i] = endArea;
            if (slope0 > 0) color dColor = colorUpArea; else dColor = colorDnArea;
            Draw_Area(sName, dColor, beginArea, highArea, endArea, lowArea);
            sOldArea = sName;
            beginArea= 0;

//Comment(limit,"A.  iii=",iii,"  Time:",TimeToStr(Time[i],TIME_MINUTES|TIME_SECONDS),"  current:",TimeToStr(TimeCurrent(),TIME_MINUTES|TIME_SECONDS));
         }
         else
         if (endArea != 0) {
         //if (endArea != 0 && endArea != Time[i]) {
            endArea = Time[i];
            arTimeEnd[i] = endArea;
            Change_Area(sOldArea, 1, endArea, lowArea);

//Comment(limit,"B.  iii=",iii,"  Time:",TimeToStr(Time[i],TIME_MINUTES|TIME_SECONDS),"  current:",TimeToStr(TimeCurrent(),TIME_MINUTES|TIME_SECONDS));            
         }
      }      
   }
int srPoints = 20;   
   //===================================================================
   //---- 3. DailyPivots ===============================================
   for (i = limitAreas; i >= 0; i--) {
      thisTimeD = Time[i];
      if (thisTimeD != oldTimeD) {
         oldTimeD = thisTime;
         newBar = true;
      }
      else
         newBar = false;

      if (newBar == true) {
         string sHour = TimeToStr(Time[i],TIME_MINUTES|TIME_SECONDS);
//Comment(sHour);         
         if (sHour == "00:00:00") {            
         //if (thisTimeD == StrToTime("00:00")) {            
            string sNameD  = "arD_" + TimeToStr(Time[i],TIME_DATE|TIME_MINUTES|TIME_SECONDS);
            string sNameS2 = "arS2_" + TimeToStr(Time[i],TIME_DATE|TIME_MINUTES|TIME_SECONDS);
            string sNameR2 = "arR2_" + TimeToStr(Time[i],TIME_DATE|TIME_MINUTES|TIME_SECONDS);
            //-- get pivot
            double dHigh = -100000;
            double dLow  = 100000;
            double dClose = Close[i+1];
            int iBar = 0;
            while (iBar < 1000) {
               iBar++;
               string sHourBar = TimeToStr(Time[i+iBar],TIME_MINUTES|TIME_SECONDS);
               if (sHourBar != "00:00:00") {                  
               //if (Time[i+iBar] != StrToTime("00:00")) {                  
                  if (High[i+iBar] > dHigh) dHigh = High[i+iBar];
                  if (Low[i+iBar]  < dLow)  dLow  = Low[i+iBar];                  
               }
               else
                  break;            
            }
            double dPivot  = (dHigh+dLow+dClose) / 3.0;
            double dMiddle = (dHigh+dLow) / 2.0;
            double diff = MathAbs(dPivot - dMiddle);
            highAreaD = dPivot + diff;  
            lowAreaD  = dPivot - diff;
            //-- support, resistance 2
            R2 = dPivot + (dHigh-dLow);
            S2 = dPivot - (dHigh-dLow);
//Comment(TimeToStr(Time[i],TIME_DATE|TIME_MINUTES|TIME_SECONDS), "  dHigh=",dHigh,"  dLow=",dLow);
Comment(TimeToStr(Time[i],TIME_DATE|TIME_MINUTES|TIME_SECONDS), "  dPivot=",dPivot,"  R2=",R2,"  S2=",S2);
            //-- area
            beginAreaD = Time[i];
            endAreaD   = 0;
         }
         else
         {  
            if (endAreaD == 0) {
               endAreaD = Time[i];
               Draw_Area(sNameD, Yellow, beginAreaD, highAreaD, endAreaD, lowAreaD);
               ObjectSet(sNameD, OBJPROP_BACK, false);               
               sOldAreaD = sNameD;
               Draw_Area(sNameS2, Yellow, beginAreaD, S2, endAreaD, S2-srPoints*Point);
               Draw_Area(sNameR2, Yellow, beginAreaD, R2, endAreaD, R2+srPoints*Point);
               sOldAreaS2 = sNameS2;
               sOldAreaR2 = sNameR2;
            }
            else
            {
               endAreaD = Time[i];
               Change_Area(sOldAreaD, 1, endAreaD, lowAreaD);  
               Change_Area(sOldAreaS2, 1, endAreaD, S2-srPoints*Point);  
               Change_Area(sOldAreaR2, 1, endAreaD, R2+srPoints*Point);  
            }
         }         
      }
   }   

   
/*   //---- calculate signals =========================================
   for (i = limit; i >= 0; i--) {
      //---- Trend and Slope signals -----------------------------------------
      hSignalDirection[i] = 0;
      if (hMainTrend[i] > 0 && hSlopeMain[i] > 0 && hSlopeSignal[i] > 0) hSignalDirection[i] =  1; else
      if (hMainTrend[i] < 0 && hSlopeMain[i] < 0 && hSlopeSignal[i] < 0) hSignalDirection[i] =  -1;
   }
   
   //---- TRADE signals =============================================
   for (i = limit; i >= 0; i--) {
      signalTRADE[i] = hSignalDirection[i];

      //---- signals for the last bar / avoid repainting !! ---------
      if (i == 0)
      {
         //---- delete signal 
         if (signalTRADE[i] == 0 && thisSignalTRADE != 0) {
            Delete_Signal(i, thisSignalTRADE);
            thisSignalTRADE = 0;
         }
         else
         //---- new signal
         if (signalTRADE[i] != 0 && thisSignalTRADE == 0) {
            Set_NewSignal(i);
            thisSignalTRADE = signalTRADE[i];
            oldSignalTRADE  = signalTRADE[i];
         }       
      }      
      else
      
      //---- signals for history bars -------------------------------
      if (i > 0 && iTime(Symbol(),Period(),i) == signalTime)
      {
         if (signalTRADE[i] != 0 && 
             signalTRADE[i] != signalTRADE[i+1])
         {            
            Set_NewSignal(i);
            oldSignalTRADE  = signalTRADE[i];
         }      
      }
      else
      
      //---- signal on a new bar ....................................
      if (i > 0 && iTime(Symbol(),Period(),i) != signalTime)
      {
         signalTime = iTime(Symbol(),Period(),i);
      
         if (signalTRADE[i] != 0 && 
             signalTRADE[i] != signalTRADE[i+1])
         {            
            Set_NewSignal(i);
            oldSignalTRADE  = signalTRADE[i];
         }
      }
   }*/
   return(0);
}
//+------------------------------------------------------------------+


void Draw_Area(string sName, color dColor, datetime time1, double price1, datetime time2, double price2)
{
   ObjectCreate(sName,OBJ_RECTANGLE,0,time1,price1,time2,price2);
   ObjectSet(sName, OBJPROP_COLOR, dColor);
}   

void Change_Area(string sName, int point, datetime time1, double price1)
{
   ObjectMove(sName,point,time1,price1);
}   

          
//+------------------------------------------------------------------+
//    Set New Signal
//+------------------------------------------------------------------+
void Set_NewSignal(int iBar)
{
/*   double dOffset = iATR(Symbol(), Period(), 13, 1) * Factor_SignalOffset;
   if (signalTRADE[iBar] ==  1) signalUP[iBar] = Low[iBar] - dOffset; else
   if (signalTRADE[iBar] == -1) signalDN[iBar] = High[iBar]+ dOffset;
   if (iBar == 0) {
      AlertSignal = signalTRADE[iBar];
      SendAlerts();
   }*/
}

//####################################################################
//+------------------------------------------------------------------+
//    function SendAlerts
//+------------------------------------------------------------------+
void SendAlerts()
{   
   if (SendAlert_Signals == false && SendEmail_Signals == false) return;
   //if (SendAlert_Signals == false && SendEmail_Signals == false && PrintAlert_Signals == false) return;
   if (AlertSignal == 0) return;
   
   string st;
   string sSymbol = Symbol();
   
   int iOrderType = AlertSignal;
   string sPrice = DoubleToStr(iClose(sSymbol,Period(),0), Digits);
   string sTime  = TimeToStr(TimeCurrent(),TIME_MINUTES|TIME_SECONDS);
   
   switch (iOrderType) {
      case  1: st = "Buy "; break;
      case -1: st = "Sell "; break;
   }
   st = st + sSymbol + "  " + sPrice + "   (" + sPeriod + ")  " + sTextAlert + "  " + sTime;

   if (SendAlert_Signals == true) Alert(st);   
   if (SendEmail_Signals == true) SendMail(subjectEmailAlert, st);
   //if (PrintAlert_Signals== true) Print("##" + st);
   AlertSignal = 0;

   return;
}

//+------------------------------------------------------------------+
//    Delete Signal
//+------------------------------------------------------------------+
void Delete_Signal(int iBar, int oldSignalTRADE)
{
   signalUP[iBar] = EMPTY_VALUE;
   signalDN[iBar] = EMPTY_VALUE;
   
   if (SendAlert_Signals == false && SendEmail_Signals == false) return;   
   //if (SendAlert_Signals == false && SendEmail_Signals == false && PrintAlert_Signals == false) return;   
   
   string st;
   string sSymbol = Symbol();
   string sPrice = DoubleToStr(iClose(sSymbol,Period(),0), Digits);
   string sTime  = TimeToStr(TimeCurrent(),TIME_MINUTES|TIME_SECONDS);
   
   switch (oldSignalTRADE) {
      case  1: st = "Delete Buy "; break;
      case -1: st = "Delete Sell "; break;
   }
   st = st + sSymbol + "  " + sPrice + "   (" + sPeriod + ")  " + sTextAlert + "  " + sTime;

   if (SendAlert_Signals == true) Alert(st);   
   if (SendEmail_Signals == true) SendMail(subjectEmailAlert, st);
   //if (PrintAlert_Signals== true) Print("##" + st);

   return;   
}  


//####################################################################
//+------------------------------------------------------------------+
//    Get sPeriod
//+------------------------------------------------------------------+
string Get_sPeriod(int timeframe)
{
   if (timeframe == PERIOD_M1) return("M1");
   if (timeframe == PERIOD_M5) return("M5");
   if (timeframe == PERIOD_M15) return("M15");
   if (timeframe == PERIOD_M30) return("M30");
   if (timeframe == PERIOD_H1) return("H1");
   if (timeframe == PERIOD_H4) return("H4");
   if (timeframe == PERIOD_D1) return("D1");
   if (timeframe == PERIOD_W1) return("W1");
   if (timeframe == PERIOD_MN1) return("MN1");
}

//+------------------------------------------------------------------+
//    Set Label Object
//+------------------------------------------------------------------+
void SetLabelObject(string sName, string sText, color dColor, int xx, int yy)
{
   int iWindow = 0;
   int iCorner = 1;
   ObjectCreate(sName, OBJ_LABEL, iWindow, 0, 0);
        ObjectSetText(sName,sText,10, "Arial Bold", dColor);
        ObjectSet(sName, OBJPROP_CORNER, iCorner);
        ObjectSet(sName, OBJPROP_XDISTANCE, xx);
        ObjectSet(sName, OBJPROP_YDISTANCE, yy);
}


//####################################################################
//####################################################################
//####################################################################
//+------------------------------------------------------------------+
//    Get Hull Slope
//+------------------------------------------------------------------+
void Get_HullSlope(string sSymbol, int iTF, int Hull_period, int smooth_period, double treshold,
         double& iTrend, int iBar)
{
   if (Slope_HistogramValues == true) {
      //---- values
      double trendUP = iCustom(sSymbol, iTF,"smHullSlope v2", Hull_period,smooth_period,treshold, 4,iBar);
      double trendDN = iCustom(sSymbol, iTF,"smHullSlope v2", Hull_period,smooth_period,treshold, 5,iBar);   
      //---- signals
      iTrend = 0;      
      if (trendUP > 0 && trendDN == EMPTY_VALUE) iTrend = 1;  else 
      if (trendUP == EMPTY_VALUE && trendDN < 0) iTrend = -1;
   }
   else
   if (Slope_HistogramValues == false) {
      //---- values
      trendUP = iCustom(sSymbol, iTF,"smHullSlope v2", Hull_period,smooth_period,treshold, 2,iBar);
      trendDN = iCustom(sSymbol, iTF,"smHullSlope v2", Hull_period,smooth_period,treshold, 3,iBar);   
      //---- signals
      iTrend = 0;      
      if (trendUP == 0 && trendDN == EMPTY_VALUE) iTrend = 1;  else 
      if (trendUP == EMPTY_VALUE && trendDN == 0) iTrend = -1;
   }
   
//if (iBar==0 && Hull_period == 8)
//Comment("trendUP=",trendUP, "  trendDN=",trendDN);
   
   return;
}

//####################################################################
//+------------------------------------------------------------------+
//    Get Hull Trend
//+------------------------------------------------------------------+
void Get_HullTrend(string sSymbol, int iTF, int Hull_period,
         double& iTrend, double& HullValue, int iBar)
{
double Hull_periodDivisor = 1.5;
int Hull_method = 3;
int Hull_price  = 0;
/*double trend, trend1, dUpTrend, dDnTrend, dExtHullBuffer;

   Internal_HullMAvg(sSymbol, iTF, iBar, 
                     trend, trend1, dUpTrend, dDnTrend, dExtHullBuffer,
                     Hull_period, Hull_periodDivisor, Hull_method, Hull_price);
   if (trend ==  1) {iTrend= 1; HullValue = dUpTrend;} else
   if (trend == -1) {iTrend=-1; HullValue = dDnTrend;}*/
   

   //---- Hull trend H1
   double UpTrend0 = iCustom(sSymbol, iTF,"smHull Mavg",
                   Hull_period,Hull_periodDivisor,Hull_method,Hull_price,
                   0,iBar);
   double DnTrend0 = iCustom(sSymbol, iTF,"smHull Mavg",
                   Hull_period,Hull_periodDivisor,Hull_method,Hull_price,
                   1,iBar);
                   
   double UpTrend1 = iCustom(sSymbol, iTF,"smHull Mavg",
                   Hull_period,Hull_periodDivisor,Hull_method,Hull_price,
                   0,iBar+1);
   double DnTrend1 = iCustom(sSymbol, iTF,"smHull Mavg",
                   Hull_period,Hull_periodDivisor,Hull_method,Hull_price,
                   1,iBar+1);
                                      
   //---- signals
   if (UpTrend0 != DnTrend0) {
      if (UpTrend0 != EMPTY_VALUE) {iTrend=1; HullValue=UpTrend0;}
      else
      if (DnTrend0 != EMPTY_VALUE) {iTrend=-1; HullValue=DnTrend0;}
   }
   else {
      if (UpTrend1 != EMPTY_VALUE) {iTrend=1; HullValue=UpTrend1;}
      else
      if (DnTrend1 != EMPTY_VALUE) {iTrend=-1; HullValue=DnTrend1;}
   }
   return;
}

/*
//###################################################################
//###################################################################
//###################################################################
//+------------------------------------------------------------------+ 
//|      Internal HullMAvg
//+------------------------------------------------------------------+ 
void Internal_HullMAvg(string sSymbol, int iTF, int iBar, 
                       double& trend, double& trend1, double& dUpTrend, double& dDnTrend, double& dExtHullBuffer,
                       int Hull_period, double Hull_periodDivisor, int Hull_method, int Hull_price)
{
int i, e = 200; // nBars
double vect[];
static double dExtHullBuffer1;
ArraySetAsSeries(vect, true); ArrayResize(vect, e);    
  
   int p = MathFloor(MathSqrt(Hull_period));
   int perVector = MathFloor(Hull_period/Hull_periodDivisor);   
   
   //---- first Hull vector / 200 bars
   for(i = 0; i < e; i++) 
      vect[i] = 2*WMA(sSymbol, iTF, iBar+i, perVector, Hull_method, Hull_price) -
                  WMA(sSymbol, iTF, iBar+i, Hull_period, Hull_method, Hull_price);
  
   dExtHullBuffer  = iMAOnArray(vect, 0, p, 0, Hull_method, 0);
   dExtHullBuffer1 = iMAOnArray(vect, 0, p, 0, Hull_method, 1);

   trend1 = trend;
   if (dExtHullBuffer > dExtHullBuffer1) trend=1;
   if (dExtHullBuffer < dExtHullBuffer1) trend=-1;   

   if (trend > 0) {
      dUpTrend = dExtHullBuffer;
      dDnTrend = EMPTY_VALUE;
   }
   else
   if (trend < 0) {
      dDnTrend = dExtHullBuffer;
      dUpTrend = EMPTY_VALUE;
   }
   return;
}

//+------------------------------------------------------------------+ 
//|      WMA
//+------------------------------------------------------------------+ 
double WMA(string sSymbol, int iTF, int iBar, 
           int iPeriodAvg, int Hull_method, int Hull_price) 
{ 
   return(iMA(sSymbol, iTF, iPeriodAvg, 0, Hull_method, Hull_price, iBar));
} */