//+------------------------------------------------------------------+
//|                                      FXTT_StrategyChecklist.mq4 |
//|                                  Copyright 2016, Carlos Oliveira |
//|                                         https://www.forextradingtools.eu |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, Carlos Oliveira"
#property link      "https://www.forextradingtools.eu/products/indicators/forex-scanner-free-indicator/?utm_campaign=properties.indicator&utm_medium=special&utm_source=mt4terminal"
#property version   "2.00"
#property strict
#property indicator_chart_window

string INDI_NAME="MPSCN-";

input int TimerInterval=60; //Update interval (secs)
input int FontSize=10;  //Font Size
input string FontName="Calibri"; //Font Name
input int ColumnHeight=50; //Max symbols per column

input string Group0; //---------------------------------------------------
input bool ShowPrice=true; //Show Price

input string Group1; //---------------------------------------------------
input bool ShowSpread=true; //Show Spread

input string Group2; //---------------------------------------------------
input bool ShowPrice_Percentage=true; //Show Price % Change
input ENUM_TIMEFRAMES PCTimeframe=PERIOD_H4;


input string Group3; //---------------------------------------------------
input bool ShowATR_Value=true; //Show ATR Value
input bool ShowATR_Percentage=true; //Show ATR Percentage
input ENUM_TIMEFRAMES AtrTimeframe=PERIOD_H1; //ATR Timeframe
input int AtrPeriod=20; //ATR Period
input int EnableATRAlert = true;
input int AtrAlertLevel = 100; //ATR Alert Level


input string Group4; //---------------------------------------------------
input bool ShowVolume=true; //Show Volume
input ENUM_TIMEFRAMES VolumeTimeframe=PERIOD_H1; //Volume Timeframe
input int VolumePeriod=60; //Volume Period

input string Group5; //---------------------------------------------------
input bool ShowRsi=true; //Show RSI
input ENUM_TIMEFRAMES RsiTimeframe=PERIOD_H1; //RSI Timeframe
//original RSI levle was 75 and 25 but that is a bit extream
input int RsiPeriod=14; //RSI Period
input int RsiUpperLevel = 70; //RSI Upper Level
input int RsiLowerLevel = 30; //RSI Lower Level
input int EnableRSIAlert = true;

input string Group6; //---------------------------------------------------
input bool ShowStoch=true; //Show Stochastic
input ENUM_TIMEFRAMES StochTimeframe=PERIOD_H1; //Stoch Timeframe
input int StochK = 5;   //%K period
input int StochD = 3;   //%D period
input int StochSlow = 3;//Slowing
input ENUM_MA_METHOD StochMethod=MODE_EMA; //MA Method
input ENUM_STO_PRICE StochPrice=STO_LOWHIGH; //Price Field
input int StochUpperLevel = 80; //Stoch Upper Level
input int StochLowerLevel = 20; //Stoch Lower Level
input int EnableStochAlert = true;


input string Group7; //---------------------------------------------------
input bool ShowAdx=true; //Show ADX
input ENUM_TIMEFRAMES AdxTimeframe=PERIOD_H1; //ADX Timeframe
input int AdxPeriod=20; //ADX Period
input ENUM_APPLIED_PRICE AdxAppliedPrice=PRICE_CLOSE; //ADX Applied Price

input string Group8; //---------------------------------------------------
input bool ShowPivots=true; //Show Pivots

input string Group9; //---------------------------------------------------
input bool ShowMA=true; //Show MA
input ENUM_TIMEFRAMES MATimeframe=PERIOD_H4; //MA Timeframe
input int MAPeriod=13; //MA Period
input ENUM_MA_METHOD MAMethod=MODE_EMA; //MA Method
input ENUM_APPLIED_PRICE MAAppliedPrice=PRICE_CLOSE; //MA Applied

input string Group10; //---------------------------------------------------
input bool ShowExtremes=true; //Show Extreme Col
input int EnableExtremesAlert = true;
input int ExtremesAlertLevel = 4;


extern string  _AlertSetting = "---Alert Settings ---";
extern bool   alertsOn            = true;  //Turn alerts on?
extern bool   alertsMessage       = true;  //Alerts Message true/false?
extern bool   alertsSound         = true;   //Alerts sound true/false?
extern bool   alertsNotification  = false;  //Alerts push notification true/false?
extern bool   alertsEmail         = false;  //Alerts email true/false?
extern string  soundFile = "alert.wav";



int GUIXOffset = 20;
int GUIYOffset = 45;

int GUIHeaderXOffset = 20;
int GUIHeaderYOffset = 0;

int GUIColOffset=100;

int ListXOffset = 10;
int ListYOffset = 15;

int ListXMultiplier = 10;
int ListYMultiplier = 15;


 MqlRates       PCBar[];
 
 bool StochAlert = false;
 bool RSIAlert = false;
 bool ATRAlert = false;
 
 int AlertExtremes = 0;
 
 

datetime TimeMissing;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping      
   ChartColorSet(CHART_COLOR_BACKGROUND,clrBlack);
   ChartColorSet(CHART_COLOR_FOREGROUND,clrWhite);
   ChartColorSet(CHART_COLOR_GRID,clrNONE);
   ChartColorSet(CHART_COLOR_VOLUME,clrNONE);
   ChartColorSet(CHART_COLOR_CHART_UP,clrNONE);
   ChartColorSet(CHART_COLOR_CHART_DOWN,clrNONE);
   ChartColorSet(CHART_COLOR_CHART_LINE,clrNONE);
   ChartColorSet(CHART_COLOR_CANDLE_BULL,clrNONE);
   ChartColorSet(CHART_COLOR_CANDLE_BEAR,clrNONE);
   ChartColorSet(CHART_COLOR_BID,clrNONE);
   ChartColorSet(CHART_COLOR_ASK,clrNONE);
   ChartColorSet(CHART_COLOR_LAST,clrNONE);
   ChartColorSet(CHART_COLOR_STOP_LEVEL,clrNONE);
   ChartModeSet(CHART_LINE);
//---
   EventSetTimer(1);

   DrawHeader();
   DrawScanner();

   return(INIT_SUCCEEDED);
  }
//+-------------------------------------------------------------------------------------------+
int deinit()
  {
   ObjectsDeleteAll(ChartID(),INDI_NAME);
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   DrawMissingTime();
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
   DrawMissingTime();
   if(TimeSeconds(TimeCurrent())%TimerInterval==0)
     {
      DrawScanner();
      
      
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
long getAvgVolume(string symbol,int period)
  {
   long volume_total=0;
   for(int i=0; i<period; i++)
     {
      volume_total+=iVolume(symbol,VolumeTimeframe,i);
     }
   return volume_total / period;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double getRange(string symbol,int period)
  {
   int DataPeriod=PERIOD_D1;
   int DataBar=iBarShift(symbol,DataPeriod,Time[0]);
   double range = iHigh(symbol, period, DataBar) - iLow(symbol, period, DataBar);
   double point = MarketInfo(symbol, MODE_POINT);
   if(point > 0) return (NormalizeDouble(range / point, 0));
   return 1;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawMissingTime(int deltaY=0)
  {
   int x=GUIXOffset+ListXOffset,y=20;

   DrawLabel("CurTimeLbl",x,y,"Server Time:"+TimeToStr(TimeCurrent(),TIME_MINUTES),FontSize,FontName,clrWhite);
   DrawLabel("LocalTimeLbl",x+=150,y,"Local Time:"+TimeToStr(TimeLocal(),TIME_MINUTES),FontSize,FontName,clrWhite);
   DrawLabel("TimeLeftLbl",x+=150,y,"Time until Candle close:",FontSize,FontName,clrWhite);
   DrawTimeMissingColum(PERIOD_M1,x+=150,y);
   DrawTimeMissingColum(PERIOD_M5,x+=GUIColOffset,y);
   DrawTimeMissingColum(PERIOD_M15,x+=GUIColOffset,y,30);
   DrawTimeMissingColum(PERIOD_H1,x+=GUIColOffset, y);
   DrawTimeMissingColum(PERIOD_H4,x+=GUIColOffset, y);
   DrawTimeMissingColum(PERIOD_D1,x+=GUIColOffset, y);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawTimeMissingColum(int period,int x,int y,int dxOffset=25)
  {
   int dx=x;
   color timeColor;
   string periodStr= GetPeriodStr(period);
   string timeLeft = GetTimeToClose(period, timeColor);

   DrawLabel("TimeLeftLbl_"+periodStr,dx,y,periodStr+":",FontSize,FontName,clrWhite);
   DrawLabel("TimeLeftVal_"+periodStr,dx+=dxOffset,y,timeLeft,FontSize,FontName,timeColor);

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string GetTimeToClose(int period,color &timeColor)
  {
   int periodMinutes = periodToMinutes(period);
   int shift         = periodMinutes*60;
   int currentTime   = (int)TimeCurrent();
   int localTime     = (int)TimeLocal();
   int barTime       = (int)iTime(period);
   int diff          = (int)MathMax(round((currentTime-localTime)/3600.0)*3600,-24*3600);

   string time=getTime(barTime+periodMinutes*60-localTime-diff,timeColor);
   time=(TerminalInfoInteger(TERMINAL_CONNECTED)) ? time : time+" x";

   return time;
  }
//+------------------------------------------------------------------+

void DrawLabel(string name,int x,int y,string label,int size=9,string font="Arial",color clr=DimGray,string tooltip="")
  {
   name=INDI_NAME+":"+name;
   ObjectDelete(name);
   ObjectCreate(name,OBJ_LABEL,0,0,0);
   ObjectSetText(name,label,size,font,clr);
   ObjectSet(name,OBJPROP_CORNER,0);
   ObjectSet(name,OBJPROP_XDISTANCE,x);
   ObjectSet(name,OBJPROP_YDISTANCE,y);
   ObjectSetString(0,name,OBJPROP_TOOLTIP,tooltip);
//--- justify text
//ObjectSet(name, OBJPROP_ANCHOR, 0);
//ObjectSetString(0, name, OBJPROP_TOOLTIP, tooltip);
//ObjectSet(name, OBJPROP_SELECTABLE, 0);
//---
  }
//+------------------------------------------------------------------+
//| The function sets chart background color.                        |
//+------------------------------------------------------------------+
bool ChartColorSet(int prop_id,const color clr,const long chart_ID=0)
  {
//--- reset the error value
   ResetLastError();
//--- set the chart background color
   if(!ChartSetInteger(chart_ID,prop_id,clr))
     {
      //--- display the error message in Experts journal
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- successful execution
   return(true);
  }
//+------------------------------------------------------------------+
//| Set chart display type (candlesticks, bars or                    |
//| line).                                                           |
//+------------------------------------------------------------------+
bool ChartModeSet(const long value,const long chart_ID=0)
  {
//--- reset the error value
   ResetLastError();
//--- set property value
   if(!ChartSetInteger(chart_ID,CHART_MODE,value))
     {
      //--- display the error message in Experts journal
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- successful execution
   return(true);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
void DrawScanner()
  {
   Print("=============>DrawScanner");
 
   for(int x=0; x<SymbolsTotal(true); x++)
     {
      DrawSymbol(SymbolName(x,true),x);
    
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawSymbol(string symbolName,int symbolIdx)
  {
   AlertExtremes = 0;
   int yMult = (int)fmod(symbolIdx, ColumnHeight);
   int xMult = (symbolIdx/ColumnHeight);
   int x= (GUIXOffset+GUIHeaderXOffset) + (NumVisibleColumns()*GUIColOffset)*xMult;
   int y= GUIYOffset+ListYOffset + ListYMultiplier * yMult;
   int colOffset=GUIColOffset;

   DrawSymbolColumn(symbolName,x,y,symbolName,FontSize,FontName);

   if(ShowPrice)
      DrawPriceColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
   if(ShowSpread)
      DrawSpreadColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
   if(ShowPrice_Percentage)
      DrawPCColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
   if(ShowATR_Value)
      DrawATRValueColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
   if(ShowATR_Percentage)
      DrawATRPercentageColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
   if(ShowVolume)
      DrawVolumeColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
   if(ShowRsi)
      DrawRsiColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
   if(ShowStoch)
      DrawStochColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
   if(ShowAdx)
      DrawAdxColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
   if(ShowPivots)
      DrawPivotsColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
   if(ShowMA)
      DrawMAColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
   if(ShowExtremes)
      DrawExtremesColumn(symbolName,x+=colOffset,y,symbolName,FontSize,FontName);
    WindowRedraw();
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

double getPoint(string symbol)
  {
   return MarketInfo(symbol,MODE_POINT);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double getModifier(string symbol)
  {
   int digits=(int)MarketInfo(symbol,MODE_DIGITS);
   double modifier=1;
   if(digits==3 || digits==5)
      modifier=10.0;
   return modifier;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawRsiColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
  {
  
   static datetime PrevTime = TimeCurrent();
   static string PreviousAlert;


   double rsi=NormalizeDouble(iRSI(symbolName,RsiTimeframe,RsiPeriod,PRICE_CLOSE,0),0);
   string tooltip=symbolName+"\n.: "+GetPeriodStr(RsiTimeframe)+" RSI ("+IntegerToString(RsiPeriod)+"):.\nCurrent  ("+DoubleToStr(rsi,1)+")";
   DrawLabel("rsi_"+symbolName,x,y,DoubleToStr(rsi,1),fontSize,fontName,GetRsiColor(rsi),tooltip);
   
   if (rsi <=  RsiLowerLevel || rsi >  RsiUpperLevel) 
    {
       RSIAlert = true;
       AlertExtremes++;
    }
   else 
       RSIAlert = false;
       
   if (EnableRSIAlert && RSIAlert)
   {
       string msg = symbolName + ", " + TF2Str(AtrTimeframe); 
       string AlertMsg =  msg + " FX Scanner RSI Extream Alert: " + DoubleToStr(rsi,2) + " @ " + TimeToStr(Time[0],TIME_SECONDS);
             
      if (PreviousAlert != AlertMsg && PrevTime != Time[0])
         {
             PreviousAlert  = AlertMsg;
             PrevTime   = Time[0];
      
        
             //
      
           //  message =  StringConcatenate(Symbol(),", ",timeFrameToString(_Period)," HP ",doWhat," @ ",TimeToStr(TimeLocal(),TIME_SECONDS));
                if (alertsMessage)      Alert(AlertMsg);
                if (alertsEmail)        SendMail(StringConcatenate(Symbol(),"FX Scanner "),AlertMsg);
                if (alertsNotification) SendNotification(AlertMsg);
                if (alertsSound)        PlaySound("alert.wav");
         }
   
   
   }
         
       
   
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawStochColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
  {
  


   double stoch=iStochastic(symbolName,StochTimeframe,StochK,StochD,StochSlow,StochMethod,StochPrice,MODE_MAIN,0);
   string tooltip=symbolName+"\n.: "+GetPeriodStr(StochTimeframe)+" Stoch :.\nCurrent  ("+DoubleToStr(stoch,1)+")";
   DrawLabel("stoch_"+symbolName,x,y,DoubleToStr(stoch,1),fontSize,fontName,GetStochColor(stoch),tooltip);
   
   if(stoch>=StochUpperLevel || stoch<=StochLowerLevel )
   {
   
      StochAlert = true; 
      AlertExtremes++;
   }
   else
      StochAlert = false;
   
    if (EnableStochAlert && StochAlert)
   {
       string msg = symbolName  + ", " + TF2Str(AtrTimeframe); 
       string AlertMsg =  msg + " FX Scanner Stoch Extremes Alert: " + DoubleToString(stoch,2) + " @ " + TimeToStr(Time[0],TIME_SECONDS);
             
          doAlert(symbolName,"stoch",AlertMsg,Time[0]);
   
   
   }
      

   
   
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawAdxColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
  {
   double adx=iADX(symbolName,AdxTimeframe,AdxPeriod,AdxAppliedPrice,MODE_MAIN,0);
   string tooltip=symbolName+"\n.: "+GetPeriodStr(AdxTimeframe)+" ADX ("+IntegerToString(AdxPeriod)+"):.\nCurrent  ("+DoubleToStr(adx,1)+")";
   DrawLabel("adx_"+symbolName,x,y,GetAdxStr(adx),fontSize,fontName,GetAdxColor(adx),tooltip);
   
   if(adx>=50)
   {
      AlertExtremes++;
   }
   
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string GetAdxStr(double adx)
  {
   if(adx<25)
      return "No Trend";
   if(adx>=25 && adx < 50)
      return "Weak Trend";
   if(adx>=50 && adx < 75)
      return "Strong Trend";
   return "Very Strong Trend";
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
color GetAdxColor(double adx)
  {
   if(adx<25)
      return clrWhite;
   if(adx>=25 && adx < 50)
      return clrGreen;
    if(adx>=50 && adx < 75)
      return clrRed;
   return clrRed;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawPriceColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
  {
   int digits=(int)MarketInfo(symbolName,MODE_DIGITS);
   double vAsk=NormalizeDouble(MarketInfo(symbolName,MODE_ASK),digits);
   double vBid=NormalizeDouble(MarketInfo(symbolName,MODE_BID),digits);
   double vSpread=NormalizeDouble(MarketInfo(symbolName,MODE_SPREAD),digits);
   string tooltip=symbolName+"\n.: Price :.\nAsk: "+(string)vAsk+"\nBid: "+(string)vBid+"\nSpread: "+(string)vSpread;
   DrawLabel("price_"+symbolName,x,y,DoubleToString(vBid,digits),fontSize,fontName,clrWhite,tooltip);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawSpreadColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
  {
   int digits=(int)MarketInfo(symbolName,MODE_DIGITS);
   double vAsk=NormalizeDouble(MarketInfo(symbolName,MODE_ASK),digits);
   double vBid=NormalizeDouble(MarketInfo(symbolName,MODE_BID),digits);
   double vSpread=NormalizeDouble(MarketInfo(symbolName,MODE_SPREAD),digits);
   string tooltip=symbolName+"\n.: SPREAD :.\nAsk: "+(string)vAsk+"\nBid: "+(string)vBid+"\nSpread: "+(string)vSpread;
   DrawLabel("spread_"+symbolName,x,y,(string)vSpread,fontSize,fontName,clrWhite,tooltip);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawPivotsColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
  {
   double pivots[7];
   int digits=(int)MarketInfo(symbolName,MODE_DIGITS);
   double vAsk=MarketInfo(symbolName,MODE_BID);
   double pivot=NormalizeDouble((GetPivotValue(symbolName,PERIOD_D1)),digits);

   pivots[0]=pivot;

   pivots[1]=NormalizeDouble((GetPivotResistance(symbolName,PERIOD_D1,pivot,1)),digits);
   pivots[2]=NormalizeDouble((GetPivotResistance(symbolName,PERIOD_D1,pivot,2)),digits);
   pivots[3]=NormalizeDouble((GetPivotResistance(symbolName,PERIOD_D1,pivot,3)),digits);

   pivots[4]=NormalizeDouble((GetPivotSupport(symbolName,PERIOD_D1,pivot,1)),digits);
   pivots[5]=NormalizeDouble((GetPivotSupport(symbolName,PERIOD_D1,pivot,2)),digits);
   pivots[6]=NormalizeDouble((GetPivotSupport(symbolName,PERIOD_D1,pivot,3)),digits);

   int closestIdx=GetClosestPivot(vAsk,pivots);
   double pips=vAsk-pivots[closestIdx];

   string tooltip=symbolName+"\n.: Daily Pivots :.\nPP: "+DoubleToStr(pivots[0])+"\nR1: "+DoubleToStr(pivots[1]);
   string pivotText=GetPivotDirection(pips)+" "+GetPivotStr(closestIdx);

   DrawLabel("pivots_"+symbolName,x,y,pivotText,fontSize,fontName,GetPivotColor(closestIdx),tooltip);
   
   if (closestIdx > 3)
      AlertExtremes++;
   
   
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawMAColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
  {
   double ma=iMA(symbolName,MATimeframe,MAPeriod,0,MAMethod,MAAppliedPrice,0);
  
   string tooltip=symbolName+"\n.: "+GetPeriodStr(MATimeframe)+" MA ("+IntegerToString(MAPeriod)+"):.\nCurrent  ("+DoubleToStr(ma,1)+")";
   DrawLabel("ma_"+symbolName,x,y,GetMAStr(symbolName,ma),fontSize,fontName,GetMAColor(symbolName,ma),tooltip);
   
  }
  
 void DrawPCColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
 {
   
   if(CopyRates(symbolName,PCTimeframe,0,2,PCBar)!=2)
    {
         printf("Not all data available yet (%s) !",symbolName);
         return;
    }

      //--- Calculates daily percent change
      double percentagechange = ((PCBar[1].close/PCBar[0].close)-1)*100;
  
   string tooltip=symbolName+"\n.: "+"Prev Close: " + DoubleToStr(PCBar[0].close) + "\n" + "Current Close: " + DoubleToStr(PCBar[0].close);
   DrawLabel("PC_"+symbolName,x,y,DoubleToStr(percentagechange,2) +"%",fontSize,fontName,GetPCColor(percentagechange),tooltip);
   
 }
 
  void DrawExtremesColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
 {
 
   
   string tooltip=symbolName+"\n.";
   DrawLabel("Extremes_"+symbolName,x,y,IntegerToString(AlertExtremes),fontSize,fontName,GetAlertExtremesColor(AlertExtremes),tooltip);
   
   if (EnableExtremesAlert && AlertExtremes >= ExtremesAlertLevel)
   {
       string msg = symbolName + ", "; 
       string AlertMsg =  msg + " FX Scanner Extremes Alert is over " + IntegerToString(AlertExtremes) +   " @ " + TimeToStr(Time[0],TIME_SECONDS);
             
           doAlert(symbolName,"Extremes",AlertMsg,Time[0]);
   
   
   }
      
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
color GetAlertExtremesColor(int aExtremes)
  {
  //4 or higher 
   if(aExtremes==0)
      return clrWhite;
   if(aExtremes< 3)
      return clrGreen;
   return clrRed;
   
   
  }
 
//+

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
color GetPivotColor(int pivotIdx)
  {
   if(pivotIdx==0)
      return clrWhite;
   if(pivotIdx<=3)
      return clrGreen;
   return clrRed;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int GetClosestPivot(double ask,double &pivots[])
  {
   int idx=0;
   double minDistance=1.7976931348623158e+308;
   for(int i=0;i<ArraySize(pivots);i++)
     {
      double dist=MathAbs(ask-pivots[i]);
      if(dist<minDistance)
        {
         minDistance=dist;
         idx=i;
        }
     }
   return idx;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string GetPivotDirection(double value)
  {
   if(value>0)
      return "Above";
   return "Bellow";
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double GetPivotValue(string symbolName,int timeframe)
  {
//Pivot point (PP) = (High + Low + Close) / 3
   return (iHigh(symbolName,timeframe,1)+iLow(symbolName,timeframe,1)+iClose(symbolName,timeframe,1))/3;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double GetPivotResistance(string symbolName,int timeframe,double pivotValue,int resistanceIdx=1)
  {
   switch(resistanceIdx)
     {
      case 3:
         //Third resistance (R3) = High + 2(PP – Low)
         return iHigh(symbolName,timeframe,1) + 2*(pivotValue - iLow(symbolName,timeframe,1));
      case 2:
         //Second resistance (R2) = PP + (High – Low)
         return pivotValue + (iHigh(symbolName,timeframe,1)-iLow(symbolName,timeframe,1));
      default:
         //First resistance (R1) = (2 x PP) – Low
         return (2*pivotValue) - iLow(symbolName,timeframe,1);
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double GetPivotSupport(string symbolName,int timeframe,double pivotValue,int supportIdx=1)
  {
   switch(supportIdx)
     {
      case 3:
         //Third support (S3) = Low – 2(High – PP)
         return iLow(symbolName,timeframe,1) - 2*(iHigh(symbolName,timeframe,1)-pivotValue);
      case 2:
         //Second support (S2) = PP – (High – Low)
         return pivotValue - (iHigh(symbolName,timeframe,1) - iLow(symbolName,timeframe,1));
      default:
         //First support (S1) = (2 x PP) – High
         return (2*pivotValue) - iHigh(symbolName,timeframe,1);
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawVolumeColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
  {
   long volume=iVolume(symbolName,VolumeTimeframe,0);
   double volAvg=(double)getAvgVolume(symbolName,VolumePeriod);
   if(volAvg==0) volAvg=1;
   double volPercent=(volume/volAvg)*100;
   string tooltip=symbolName+"\n.: "+GetPeriodStr(VolumeTimeframe)+" Volume ("+IntegerToString(VolumePeriod)+"):.\nCurrent  ("+DoubleToStr(volume,0)+")\nAverage ("+DoubleToStr(volAvg,0)+")";

   DrawLabel("vol"+symbolName,x,y,DoubleToStr(volPercent,2)+"%",fontSize,fontName,GetPercentColor(volPercent),tooltip);
   
   if (volPercent > 100)
      AlertExtremes++;
   
   
  }
  
  //+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawATRValueColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
  {
   double atr=0;
   double point=getPoint(symbolName);
   double modifier=getModifier(symbolName);

   if(point>0) atr=(NormalizeDouble(iATR(symbolName,AtrTimeframe,AtrPeriod,0)/point,0))/modifier;
   if(atr==0) atr=1;
   double range=getRange(symbolName,AtrTimeframe)/modifier;
   double rangePercent=(range/atr)*100;
   string tooltip=symbolName+"\n.: "+GetPeriodStr(AtrTimeframe)+" ATR ("+IntegerToString(AtrPeriod)+"):.\nCurrent  ("+DoubleToStr(range,1)+")\nAverage ("+DoubleToStr(atr,1)+")";

   DrawLabel("atr_V_"+symbolName,x,y,DoubleToStr(atr,1),fontSize,fontName,GetPercentColor(rangePercent),tooltip);
  }
  
  
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawATRPercentageColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
  {
   double atr=0;
   double point=getPoint(symbolName);
   double modifier=getModifier(symbolName);
   

   if(point>0) atr=(NormalizeDouble(iATR(symbolName,AtrTimeframe,AtrPeriod,0)/point,0))/modifier;
   if(atr==0) atr=1;
   double atrrange=getRange(symbolName,AtrTimeframe)/modifier;
   double atrrangePercent=(atrrange/atr)*100;
   string tooltip=symbolName+"\n.: "+GetPeriodStr(AtrTimeframe)+" ATR ("+IntegerToString(AtrPeriod)+"):.\nCurrent  ("+DoubleToStr(atrrange,1)+")\nAverage ("+DoubleToStr(atr,1)+")";

   DrawLabel("atr_"+symbolName,x,y,DoubleToStr(atrrangePercent,1)+"%",fontSize,fontName,GetPercentColor(atrrangePercent),tooltip);
   
   if (atrrangePercent >= AtrAlertLevel )
      {
        ATRAlert = true;
        AlertExtremes++;
      }
   else
      ATRAlert = false;
   
   if (EnableATRAlert && ATRAlert)
   {
       string msg = symbolName + ", " + TF2Str(AtrTimeframe); 
       string AlertMsg =  msg + " FX Scanner ATR Extremes  Alert: " + DoubleToStr(atrrangePercent,2) + "% "  " @ " + TimeToStr(Time[0],TIME_SECONDS);
       
       doAlert(symbolName,"atr",AlertMsg,Time[0]);
   
   
   }
   
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
color GetRsiColor(double value)
  {
   if(value>=RsiUpperLevel)
      return clrGreen;
   if(value<=RsiLowerLevel)
      return clrRed;
   return clrWhite;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
color GetMAColor(string symbolName, double value)
  {
   double pAsk = MarketInfo(symbolName,MODE_ASK);
   
   if(pAsk>value)
   
      return clrGreen;
   else
      return clrRed;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string GetMAStr(string symbolName, double value)
  {
   double  pAsk = MarketInfo(symbolName,MODE_ASK);
   
   if(pAsk>value)
      return "up";
   else
      return "down";
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
color GetStochColor(double value)
  {
   if(value>=StochUpperLevel)
      return clrGreen;
   if(value<=StochLowerLevel)
      return clrRed;
   return clrWhite;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
color GetPercentColor(double value)
  {
   if(value<=25)
      return clrWhite;
   if(value<=50)
      return clrGreen;
   if(value<=75)
      return clrYellow;
   if(value<=90)
      return clrOrange;
   return clrRed;
  }
  
  color GetPCColor(double value)
  {
   if(value< 0)
      return clrRed;
   if(value>=0 )
      return clrGreen;
   return clrPurple;
  }
  
  
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawSymbolColumn(string symbolName,int x,int y,string text,int fontSize=8,string fontName="Calibri")
  {
   DrawLabel("lbl_"+symbolName,x,y,text,fontSize,fontName,clrWhite,symbolName);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawHeader()
  {
   string objName="Header";
   int numColumns=(SymbolsTotal(true)/ColumnHeight)+1;
   int i=0;
   do
     {
      int x=(GUIXOffset+GUIHeaderXOffset)+(NumVisibleColumns()*GUIColOffset)*i;
      int y=GUIYOffset+GUIHeaderYOffset;
      string n=IntegerToString(i);

      DrawLabel(objName+"name"+n,x,y,"Name",FontSize,FontName,clrWhite,"Name");
      DrawHorizontalLine(objName+"namehline"+n,x,y,15);

      if(ShowPrice)
        {
         DrawLabel(objName+"price"+n,x+=GUIColOffset,y,"Price",FontSize,FontName,clrWhite,"Price");
         DrawHorizontalLine(objName+"pricehline"+n,x,y,15);
        }
      if(ShowSpread)
        {
         DrawLabel(objName+"spread"+n,x+=GUIColOffset,y,"Spread",FontSize,FontName,clrWhite,"Spread");
         DrawHorizontalLine(objName+"spreadhline"+n,x,y,15);
        }
      if(ShowPrice_Percentage)
        {
         DrawLabel(objName+"PC"+n,x+=GUIColOffset,y,"P Change("+GetPeriodStr(PCTimeframe)+")",FontSize,FontName,clrWhite,"DCP");
         DrawHorizontalLine(objName+"pcline"+n,x,y,15);
        }  
       if(ShowATR_Value)
        {
         DrawLabel(objName+"rangeV"+n,x+=GUIColOffset,y,"ATR_V("+GetPeriodStr(AtrTimeframe)+")",FontSize,FontName,clrWhite,"Range_V");
         DrawHorizontalLine(objName+"rangehline_V"+n,x,y,15);
        }
        
      if(ShowATR_Percentage)
        {
         DrawLabel(objName+"range"+n,x+=GUIColOffset,y,"ATR ("+GetPeriodStr(AtrTimeframe)+")",FontSize,FontName,clrWhite,"Range");
         DrawHorizontalLine(objName+"rangehline"+n,x,y,15);
        }
      if(ShowVolume)
        {
         DrawLabel(objName+"curvolume"+n,x+=GUIColOffset,y,"Vol ("+GetPeriodStr(VolumeTimeframe)+")",FontSize,FontName,clrWhite,"Volume");
         DrawHorizontalLine(objName+"volhline"+n,x,y,15);
        }
      if(ShowRsi)
        {
         DrawLabel(objName+"rsi"+n,x+=GUIColOffset,y,"RSI ("+GetPeriodStr(RsiTimeframe)+")",FontSize,FontName,clrWhite,"Pivots");
         DrawHorizontalLine(objName+"rsihline"+n,x,y,15);
        }
      if(ShowStoch)
        {
         DrawLabel(objName+"stoch"+n,x+=GUIColOffset,y,"Stoch ("+GetPeriodStr(StochTimeframe)+")",FontSize,FontName,clrWhite,"Stochastic");
         DrawHorizontalLine(objName+"stochhline"+n,x,y,15);
        }
      if(ShowAdx)
        {
         DrawLabel(objName+",adx"+n,x+=GUIColOffset,y,"ADX ("+GetPeriodStr(AdxTimeframe)+")",FontSize,FontName,clrWhite,"ADX");
         DrawHorizontalLine(objName+"adxhline"+n,x,y,15);
        }

      if(ShowPivots)
        {
         DrawLabel(objName+"pivots"+n,x+=GUIColOffset,y,"Pivots",FontSize,FontName,clrWhite,"Pivots");
         DrawHorizontalLine(objName+"pvotshline"+n,x,y,15);
        }

      if(ShowMA)
        {
         DrawLabel(objName+"ma"+n,x+=GUIColOffset,y,"MA"+"(" + GetPeriodStr(MATimeframe)+ ")",FontSize,FontName,clrWhite,"MA");
         DrawHorizontalLine(objName+"maline"+n,x,y,15);
        }
     if(ShowExtremes)
        {
         DrawLabel(objName+"Extremes"+n,x+=GUIColOffset,y,"Extremes",FontSize,FontName,clrWhite,"Extremes");
         DrawHorizontalLine(objName+"Extremesline"+n,x,y,15);
        }
      i++;
     }
   while(i<numColumns);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int NumVisibleColumns()
  {
   int x=1;
   if(ShowPrice)
     {
      x++;
     }
   if(ShowSpread)
     {
      x++;
     }
   if(ShowPrice_Percentage)
     {
      x++;
     }
   if(ShowATR_Value)
     {
      x++;
     }
   if(ShowATR_Percentage)
     {
      x++;
     }
   if(ShowVolume)
     {
      x++;
     }
   if(ShowRsi)
     {
      x++;
     }
   if(ShowStoch)
     {
      x++;
     }
   if(ShowAdx)
     {
      x++;
     }
   if(ShowPivots)
     {
      x++;
     }
   if(ShowMA)
     {
      x++;
     }
  
  if(ShowExtremes)
     {
      x++;
     }
     
   return x;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawHorizontalLine(string objName,int x,int y,int length=250)
  {
   string line;
   for(int i=0;i<length;i++)
      line += "_";

   DrawLabel(objName+"1",x,y,line,FontSize,FontName,clrWhite,"");
//DrawLabel(objName+"2",x+380,y,line,FontSize,FontName,clrWhite,"");
  }
//+------------------------------------------------------------------+
int periodToMinutes(int period)
  {
   int i;
   static int _per[]={1,2,3,4,5,6,10,12,15,20,30,60,120,180,240,360,480,720,1440,10080,43200,0x4001,0x4002,0x4003,0x4004,0x4006,0x4008,0x400c,0x4018,0x8001,0xc001};
   static int _min[]={1,2,3,4,5,6,10,12,15,20,30,60,120,180,240,360,480,720,1440,10080,43200};
//---
   if(period==PERIOD_CURRENT)
      period=Period();
   for(i=0;i<20;i++) if(period==_per[i]) break;
   return(_min[i]);
  }
//+------------------------------------------------------------------+
datetime iTime(int period)
  {
   datetime times[];
   if(CopyTime(Symbol(),period,0,1,times)<=0)
      return(TimeLocal());
   return(times[0]);
  }
//+------------------------------------------------------------------+
string getTime(int times,color &theColor)
  {
   string stime="";
   int    seconds;
   int    minutes;
   int    hours;

   if(times<0)
     {
      theColor=clrRed;
      times=(int)fabs(times);
     }
   else if(times>0)
     {
      theColor=clrYellow;
     }

   seconds = (times%60);
   hours   = (times-times%3600)/3600;
   minutes = (times-seconds)/60-hours*60;
//---
   if(hours>0)
      if(minutes<10)
         stime = stime+(string)hours+":0";
   else  stime = stime+(string)hours+":";
   stime=stime+(string)minutes;
   if(seconds<10)
      stime=stime+":0"+(string)seconds;
   else  stime=stime+":"+(string)seconds;
   return(stime);
  }
//+------------------------------------------------------------------+
string GetPivotStr(int pivotIdx)
  {
   switch(pivotIdx)
     {
      case 1:
         return "R1";
      case 2:
         return "R2";
      case 3:
         return "R3";
      case 4:
         return "S1";
      case 5:
         return "S2";
      case 6:
         return "S3";
      default:
         return "PP";
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string GetPeriodStr(int period)
  {
   string TMz="";
   switch(period)
     {
      case 1:     TMz = "M1";  break;
      case 2:     TMz = "M2";  break;
      case 3:     TMz = "M3";  break;
      case 4:     TMz = "M4";  break;
      case 5:     TMz = "M5";  break;
      case 6:     TMz = "M6";  break;
      case 7:     TMz = "M7";  break;
      case 8:     TMz = "M8";  break;
      case 9:     TMz = "M9";  break;
      case 10:    TMz = "M10"; break;
      case 11:    TMz = "M11"; break;
      case 12:    TMz = "M12"; break;
      case 13:    TMz = "M13"; break;
      case 14:    TMz = "M14"; break;
      case 15:    TMz = "M15"; break;
      case 20:    TMz = "M20"; break;
      case 25:    TMz = "M25"; break;
      case 30:    TMz = "M30"; break;
      case 40:    TMz = "M40"; break;
      case 45:    TMz = "M45"; break;
      case 50:    TMz = "M50"; break;
      case 60:    TMz = "H1";  break;
      case 120:   TMz = "H2";  break;
      case 180:   TMz = "H3";  break;
      case 240:   TMz = "H4";  break;
      case 300:   TMz = "H5";  break;
      case 360:   TMz = "H6";  break;
      case 420:   TMz = "H7";  break;
      case 480:   TMz = "H8";  break;
      case 540:   TMz = "H9";  break;
      case 600:   TMz = "H10"; break;
      case 660:   TMz = "H11"; break;
      case 720:   TMz = "H12"; break;
      case 1440:  TMz = "D1";  break;
      case 10080: TMz = "W1";  break;
      case 43200: TMz = "M1";  break;
     }
   return TMz;
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Create a trend line by the given coordinates                     |
//+------------------------------------------------------------------+
bool TrendCreate(const long            chart_ID=0,        // chart's ID
                 const string          name="TrendLine",  // line name
                 const int             sub_window=0,      // subwindow index
                 datetime              time1=0,           // first point time
                 double                price1=0,          // first point price
                 datetime              time2=0,           // second point time
                 double                price2=0,          // second point price
                 const color           clr=clrRed,        // line color
                 const ENUM_LINE_STYLE style=STYLE_SOLID, // line style
                 const int             width=1,           // line width
                 const bool            back=false,        // in the background
                 const bool            selection=true,    // highlight to move
                 const bool            ray_right=false,   // line's continuation to the right
                 const bool            hidden=true,       // hidden in the object list
                 const long            z_order=0)         // priority for mouse click
  {
//--- set anchor points' coordinates if they are not set
   ChangeTrendEmptyPoints(time1,price1,time2,price2);
//--- reset the error value
   ResetLastError();
//--- create a trend line by the given coordinates
   if(!ObjectCreate(chart_ID,name,OBJ_TREND,sub_window,time1,price1,time2,price2))
     {
      Print(__FUNCTION__,
            ": failed to create a trend line! Error code = ",GetLastError());
      return(false);
     }
//--- set line color
   ObjectSetInteger(chart_ID,name,OBJPROP_COLOR,clr);
//--- set line display style
   ObjectSetInteger(chart_ID,name,OBJPROP_STYLE,style);
//--- set line width
   ObjectSetInteger(chart_ID,name,OBJPROP_WIDTH,width);
//--- display in the foreground (false) or background (true)
   ObjectSetInteger(chart_ID,name,OBJPROP_BACK,back);
//--- enable (true) or disable (false) the mode of moving the line by mouse
//--- when creating a graphical object using ObjectCreate function, the object cannot be
//--- highlighted and moved by default. Inside this method, selection parameter
//--- is true by default making it possible to highlight and move the object
   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTABLE,selection);
   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTED,selection);
//--- enable (true) or disable (false) the mode of continuation of the line's display to the right
   ObjectSetInteger(chart_ID,name,OBJPROP_RAY_RIGHT,ray_right);
//--- hide (true) or display (false) graphical object name in the object list
   ObjectSetInteger(chart_ID,name,OBJPROP_HIDDEN,hidden);
//--- set the priority for receiving the event of a mouse click in the chart
   ObjectSetInteger(chart_ID,name,OBJPROP_ZORDER,z_order);
//--- successful execution
   return(true);
  }
//+------------------------------------------------------------------+
//| Check the values of trend line's anchor points and set default   |
//| values for empty ones                                            |
//+------------------------------------------------------------------+
void ChangeTrendEmptyPoints(datetime &time1,double &price1,
                            datetime &time2,double &price2)
  {
//--- if the first point's time is not set, it will be on the current bar
   if(!time1)
      time1=TimeCurrent();
//--- if the first point's price is not set, it will have Bid value
   if(!price1)
      price1=SymbolInfoDouble(Symbol(),SYMBOL_BID);
//--- if the second point's time is not set, it is located 9 bars left from the second one
   if(!time2)
     {
      //--- array for receiving the open time of the last 10 bars
      datetime temp[10];
      CopyTime(Symbol(),Period(),time1,10,temp);
      //--- set the second point 9 bars left from the first one
      time2=temp[0];
     }
//--- if the second point's price is not set, it is equal to the first point's one
   if(!price2)
      price2=price1;
  }
//+------------------------------------------------------------------+

struct alert_struct
{
  string Symbolname;
  string AlertType;
  string AlertString;
  datetime AlertTime;
};


void doAlert(string symbolName, string alerttype, string doWhat, datetime alerttime)
{
 //keep track of 1000 alerts
   static alert_struct  previousAlert[1000];
      
   bool PreviousStringAlreadyIssued = false;
   int  alertindex = 0;
   
   
   
   for(int x=0; x<1000; x++)
   {
      //GO until empty value
      if (  previousAlert[x].Symbolname == "" ||
            previousAlert[x].AlertType == ""
          )
         {
           alertindex = x;
           break;
         }
    
      //symbol and type match, check if msg and time match
      if ( previousAlert[x].Symbolname == symbolName &&
           previousAlert[x].AlertType == alerttype &&
           previousAlert[x].AlertString == doWhat  &&
           previousAlert[x].AlertTime == alerttime 
         )
         {
            PreviousStringAlreadyIssued = true;   //all matched, no alert 
            alertindex = x;
            break;
         }
         
       if ( previousAlert[x].Symbolname == symbolName &&
           previousAlert[x].AlertType == alerttype &&
           previousAlert[x].AlertString != doWhat  &&
           previousAlert[x].AlertTime != alerttime 
         )
         {
            PreviousStringAlreadyIssued = false;   //all matched, no alert 
            alertindex = x;
            break;
         }  
      
      
               
   }
   
   if  ( PreviousStringAlreadyIssued == false)
   {
            //update array
             previousAlert[alertindex].Symbolname = symbolName; 
             previousAlert[alertindex].AlertType  = alerttype;
             previousAlert[alertindex].AlertString = doWhat;
             previousAlert[alertindex].AlertTime = alerttime;
             
             if (alertsMessage)      Alert(doWhat);
             if (alertsEmail)        SendMail(StringConcatenate(Symbol(),"FX Scanner "),doWhat);
             if (alertsNotification) SendNotification(doWhat);
             if (alertsSound)        PlaySound("alert.wav");
   }
       
 
  
 

}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string TF2Str(int nperiod)
  {
   switch(nperiod)
     {
      case PERIOD_M1: return("M1");
      case PERIOD_M5: return("M5");
      case PERIOD_M15: return("M15");
      case PERIOD_M30: return("M30");
      case PERIOD_H1: return("H1");
      case PERIOD_H4: return("H4");
      case PERIOD_D1: return("D1");
      case PERIOD_W1: return("W1");
      case PERIOD_MN1: return("MN");
     }
   return((string)Period());
  }
//+------------------------------------------------------------------+