Category: METATRADER4C

#property indicator_separate_window
#property indicator_buffers 3
#property indicator_color1  clrLimeGreen
#property indicator_color2  clrOrange
#property indicator_color3  clrOrange
#property indicator_width1  3
#property indicator_width2  3
#property indicator_width3  3
#property strict

//
//
//
//
//

enum enPrices
{
   pr_close,      // Close
   pr_open,       // Open
   pr_high,       // High
   pr_low,        // Low
   pr_median,     // Median
   pr_typical,    // Typical
   pr_weighted,   // Weighted
   pr_average,    // Average (high+low+open+close)/4
   pr_medianb,    // Average median body (open+close)/2
   pr_tbiased,    // Trend biased price
   pr_haclose,    // Heiken ashi close
   pr_haopen ,    // Heiken ashi open
   pr_hahigh,     // Heiken ashi high
   pr_halow,      // Heiken ashi low
   pr_hamedian,   // Heiken ashi median
   pr_hatypical,  // Heiken ashi typical
   pr_haweighted, // Heiken ashi weighted
   pr_haaverage,  // Heiken ashi average
   pr_hamedianb,  // Heiken ashi median body
   pr_hatbiased   // Heiken ashi trend biased price
};
enum enDoWhat
{
   do_cci,  // Make cci using nma as price filter
   do_nma   // Make nma smoothed cci
};
enum enFilterWhat
{
   flt_prc,  // Filter the price
   flt_cci,  // Filter the CCI
   flt_both  // Filter both
};
extern ENUM_TIMEFRAMES    TimeFrame          = PERIOD_CURRENT;// Time frame to use
extern int                pperiod            = 14;            // Calculating period
extern enPrices           pprice             = pr_close;      // Price
extern int                filter             = 40;            // Nma period 
extern int                filterTema         = 10;            // Nma tema period
extern double             pFilter            = 0;             // Filter (<=0, no filter
extern int                pFilterPeriod      = 0;             // Filter period (<=0 for same as calculating period)
extern enFilterWhat       pFilterType        = flt_cci;       // Filter what?
extern enDoWhat           doWhat             = do_cci;        // Make what?
extern bool               alertsOn           = true;          // Turn alerts on
extern bool               alertsOnCurrent    = true;          // Alerts on current (still opened) bar
extern bool               alertsMessage      = true;          // Alerts should display alert message
extern bool               alertsNotification = false;         // Alerts should send alert notification
extern bool               alertsSound        = false;         // Alerts should play alert sound
extern bool               alertsEmail        = false;         // Alerts should send alert email?
extern bool               Interpolate        = true;          // Interpolate in multi time frame mode?
extern int                linesWidth         =  3;            // Lines width


double buffer[];
double bufferda[];
double bufferdb[];
double trend[];
double work[];
double pricef[];
string indicatorFileName;
bool   returnBars;

//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//

int init()
{
   IndicatorBuffers(6);
   SetIndexBuffer(0,buffer,  INDICATOR_DATA); SetIndexStyle(0,EMPTY,EMPTY,linesWidth);
   SetIndexBuffer(1,bufferda,INDICATOR_DATA); SetIndexStyle(1,EMPTY,EMPTY,linesWidth);
   SetIndexBuffer(2,bufferdb,INDICATOR_DATA); SetIndexStyle(2,EMPTY,EMPTY,linesWidth);
   SetIndexBuffer(3,trend   ,INDICATOR_CALCULATIONS);
   SetIndexBuffer(4,work    ,INDICATOR_CALCULATIONS);
   SetIndexBuffer(5,pricef  ,INDICATOR_CALCULATIONS);
   
   indicatorFileName = WindowExpertName();
   returnBars        = TimeFrame==-99;
   TimeFrame         = MathMax(TimeFrame,_Period);
   IndicatorShortName(timeFrameToString(TimeFrame)+" cci nma ("+(string)pperiod+","+(string)filter+","+(string)pFilter+")");
return(0);
}

//
//
//
//
//

int start()
{
   int counted_bars=IndicatorCounted();
      if(counted_bars<0) return(-1);
      if(counted_bars>0) counted_bars--;
            int limit=MathMin(Bars-counted_bars,Bars-2);
            if (returnBars) { buffer[0] = MathMin(limit+1,Bars-1); return(0); }
            if (TimeFrame != Period())
            {
               if (trend[limit]==-1) CleanPoint(limit,bufferda,bufferdb);
               for(int i=limit; i>=0; i--)
               {
                  int y = iBarShift(NULL,TimeFrame,Time[i]);
                  buffer[i]   = iCustom(NULL,TimeFrame,indicatorFileName,PERIOD_CURRENT,pperiod,pprice,filter,filterTema,pFilter,pFilterPeriod,pFilterType,doWhat,alertsOn,alertsOnCurrent,alertsMessage,alertsNotification,alertsSound,alertsEmail,0,y);
                  trend[i]    = iCustom(NULL,TimeFrame,indicatorFileName,PERIOD_CURRENT,pperiod,pprice,filter,filterTema,doWhat,pFilterPeriod,pFilterType,alertsOn,alertsOnCurrent,alertsMessage,alertsNotification,alertsSound,alertsEmail,3,y);
                  bufferda[i] = EMPTY_VALUE;
                  bufferdb[i] = EMPTY_VALUE;
                  if (!Interpolate || (i>0 && y==iBarShift(NULL,TimeFrame,Time[i-1]))) continue;
                  
                  //
                  //
                  //
                  //
                  //
                  
                  int n,k; datetime time = iTime(NULL,TimeFrame,y);
                     for(n = 1; (i+n)= time; n++) continue;	
                     for(k = 1; k=0; i--) if (trend[i] == -1) PlotPoint(i,bufferda,bufferdb,buffer);
               return(0);
            }

   //
   //
   //
   //
   //

   if (trend[limit]==-1) CleanPoint(limit,bufferda,bufferdb);
   for(int i=limit; i>=0; i--)
   {
      int    tperiod = pFilterPeriod; if (tperiod<=1) tperiod = pperiod;
      double pfilter = pFilter; if (pFilterType==flt_cci) pfilter=0;
      double cfilter = pFilter; if (pFilterType==flt_prc) cfilter=0;
      if (doWhat==do_cci)
            pricef[i] = iNma(iFilter(getPrice(pprice,Open,Close,High,Low,i),pfilter,tperiod,i,0),filter,filterTema,i);
      else  pricef[i] =      iFilter(getPrice(pprice,Open,Close,High,Low,i),pfilter,tperiod,i,0);
      double avg = 0; for(int k=0; kbuffer[i+1]) trend[i] =  1;
         if (buffer[i]=0; k++) workFil[i][instanceNo+_fachang] += workFil[i-k][instanceNo+_fchange];
                                            workFil[i][instanceNo+_fachang] /= period;
    
   double stddev = 0; for (int k=0;  k=0; k++) stddev += MathPow(workFil[i-k][instanceNo+_fchange]-workFil[i-k][instanceNo+_fachang],2);
          stddev = MathSqrt(stddev/(double)period); 
   double filtev = tfilter * stddev;
   if( MathAbs(workFil[i][instanceNo+_fprice]-workFil[i-1][instanceNo+_fprice]) < filtev ) workFil[i][instanceNo+_fprice]=workFil[i-1][instanceNo+_fprice];
        return(workFil[i][instanceNo+_fprice]);
}

//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//

#define _nmaInstances 1
#define _nmaPrice     3
#define _nmaMom       4
#define _nmaValue     5
double workNma[][_nmaInstances*6];

double iNma(double price, int period, int temaperiod, int i, int instanceNo=0)
{
   if (period<=1) return(price);
   if (ArrayRange(workNma,0)!=Bars) ArrayResize(workNma,Bars); i = Bars-i-1; instanceNo*=6;

   //
   //
   //
   //
   //

   double alpha = 2.0 /(1.0 + temaperiod);
   if (i < 1)
   {
      workNma[i][instanceNo+_nmaPrice] = price;
      workNma[i][instanceNo+_nmaValue] = price;
      workNma[i][instanceNo+_nmaMom]   = 0;
      workNma[i][instanceNo+0]         = price;
      workNma[i][instanceNo+1]         = price;
      workNma[i][instanceNo+2]         = price;
   }
   else
   {
      workNma[i][instanceNo+0]         = workNma[i-1][instanceNo+0]+alpha*(price                   -workNma[i-1][instanceNo+0]);
      workNma[i][instanceNo+1]         = workNma[i-1][instanceNo+1]+alpha*(workNma[i][instanceNo+0]-workNma[i-1][instanceNo+1]);
      workNma[i][instanceNo+2]         = workNma[i-1][instanceNo+2]+alpha*(workNma[i][instanceNo+1]-workNma[i-1][instanceNo+2]);
      workNma[i][instanceNo+_nmaPrice] = 3*workNma[i][instanceNo+0] - 3*workNma[i][instanceNo+1] + workNma[i][instanceNo+2];
      workNma[i][instanceNo+_nmaMom]   = workNma[i][instanceNo+_nmaPrice]-workNma[i-1][instanceNo+_nmaPrice];
         
      //
      //
      //
      //
      //
   
      double momRatio = 0.00;
      double sumMomen = 0.00;
      double ratio    = 0.00;
      
      for (int k = 0; k=0; k++)
      {
         sumMomen += MathAbs(workNma[i-k][instanceNo+_nmaMom]);
         momRatio +=         workNma[i-k][instanceNo+_nmaMom]*(MathSqrt(k+1)-MathSqrt(k));
      }
      if (sumMomen != 0) ratio = MathAbs(momRatio)/sumMomen;
      workNma[i][instanceNo+_nmaValue] =  workNma[i-1][instanceNo+_nmaValue]+ratio*(price-workNma[i-1][instanceNo+_nmaValue]);
   }         
   return(workNma[i][instanceNo+_nmaValue]);
}

//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
//
//
//
//
//

void CleanPoint(int i,double& first[],double& second[])
{
   if ((second[i]  != EMPTY_VALUE) && (second[i+1] != EMPTY_VALUE))
        second[i+1] = EMPTY_VALUE;
   else
      if ((first[i] != EMPTY_VALUE) && (first[i+1] != EMPTY_VALUE) && (first[i+2] == EMPTY_VALUE))
          first[i+1] = EMPTY_VALUE;
}

//
//
//
//
//

void PlotPoint(int i,double& first[],double& second[],double& from[])
{
   if (i>=Bars-2) return;
   if (first[i+1] == EMPTY_VALUE)
         {
            if (first[i+2] == EMPTY_VALUE) 
                  { first[i]  = from[i]; first[i+1]  = from[i+1]; second[i] = EMPTY_VALUE; }
            else  { second[i] = from[i]; second[i+1] = from[i+1]; first[i]  = EMPTY_VALUE; }
         }
   else  { first[i] = from[i]; second[i] = EMPTY_VALUE; }
}

//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
//

double workHa[][4];
double getPrice(int tprice, const double& open[], const double& close[], const double& high[], const double& low[], int i, int instanceNo=0)
{
  if (tprice>=pr_haclose)
   {
      if (ArrayRange(workHa,0)!= Bars) ArrayResize(workHa,Bars);
         int r = Bars-i-1;
         
         //
         //
         //
         //
         //
         
         double haOpen;
         if (r>0)
                haOpen  = (workHa[r-1][instanceNo+2] + workHa[r-1][instanceNo+3])/2.0;
         else   haOpen  = (open[i]+close[i])/2;
         double haClose = (open[i] + high[i] + low[i] + close[i]) / 4.0;
         double haHigh  = MathMax(high[i], MathMax(haOpen,haClose));
         double haLow   = MathMin(low[i] , MathMin(haOpen,haClose));

         if(haOpen  haOpen)
                     return((haHigh+haClose)/2.0);
               else  return((haLow+haClose)/2.0);        
         }
   }
   
   //
   //
   //
   //
   //
   
   switch (tprice)
   {
      case pr_close:     return(close[i]);
      case pr_open:      return(open[i]);
      case pr_high:      return(high[i]);
      case pr_low:       return(low[i]);
      case pr_median:    return((high[i]+low[i])/2.0);
      case pr_medianb:   return((open[i]+close[i])/2.0);
      case pr_typical:   return((high[i]+low[i]+close[i])/3.0);
      case pr_weighted:  return((high[i]+low[i]+close[i]+close[i])/4.0);
      case pr_average:   return((high[i]+low[i]+close[i]+open[i])/4.0);
      case pr_tbiased:   
               if (close[i]>open[i])
                     return((high[i]+close[i])/2.0);
               else  return((low[i]+close[i])/2.0);        
   }
   return(0);
}   

//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
//
//
//
//
//

string sTfTable[] = {"M1","M5","M10","M15","M30","H1","H4","D1","W1","MN"};
int    iTfTable[] = {1,5,10,15,30,60,240,1440,10080,43200};

string timeFrameToString(int tf)
{
   for (int i=ArraySize(iTfTable)-1; i>=0; i--) 
         if (tf==iTfTable[i]) return(sTfTable[i]);
                              return("");
}

//------------------------------------------------------------------
//                                                                  
//------------------------------------------------------------------
//
//
//
//
//

void doAlert(string doIt)
{
   static string   previousAlert="nothing";
   static datetime previousTime;
   string message;
   
      if (previousAlert != doIt || previousTime != Time[0]) {
          previousAlert  = doIt;
          previousTime   = Time[0];

          //
          //
          //
          //
          //

          message =  StringConcatenate(Symbol()," ",timeFrameToString(_Period)," at ",TimeToStr(TimeLocal(),TIME_SECONDS)," cci + nma ",doIt);
             if (alertsMessage)      Alert(message);
             if (alertsNotification) SendNotification(message);
             if (alertsEmail)        SendMail(StringConcatenate(Symbol()," cci + nma "),message);
             if (alertsSound)        PlaySound("alert2.wav");
      }
}

----------------------+
//| CandleCountdown.mq4
//| Based on EJ_CandleTime
//| !!! this file is created with Tab size 4 and no space indentation
//+------------------------------------------------------------------+
#property indicator_chart_window
#property indicator_buffers 0

#define OBJECT_NAME		"CandleCountdown"
#define MSG_PREFIX		"   "
#define MAX_VALUE		"999d hh:mm:ss"
#define DEFAULT_FONT	"Arial"
#define DEFAULT_SIZE	12


extern int Right_Shift_from_Bar = 4;
extern color	col			=Lime;


int		DAY_SECONDS; // constant
string	MAX_PADDING;
int		MAX_LENGTH; // constant
	

int		fontSize	= DEFAULT_SIZE;

int init() {
	DAY_SECONDS	= PERIOD_D1 * 60; // constant

	MAX_PADDING = "";
	/*	the coordinates for OBJ_TEXT point to the middle of the string. To make actual text begin where 
		'time' parameter is, the string must be twice longer in pixels. Using space padding to do that.
		number of spaces required = usable string length. The actual string is not known at this point,
		therefore take the maximum possible and strip extra spaces later.
	*/
	int totalSpaces = StringLen(MSG_PREFIX + MAX_VALUE);
	for( int i = totalSpaces*1.5 + 1; i > 0; i--) // see the 'start()' method for explanation of 1.5
		MAX_PADDING = StringConcatenate(MAX_PADDING, " ");
	MAX_LENGTH = StringLen(MAX_PADDING);
	
	return(0);
}
	
int deinit() {
	switch( UninitializeReason() ) {
		case REASON_CHARTCLOSE:
		case REASON_REMOVE:
		case REASON_RECOMPILE:
			Comment("");
			ObjectDelete( OBJECT_NAME );
			break;
		case REASON_CHARTCHANGE:	// leave the object the way it is if simply switching timeframes
		case REASON_PARAMETERS:
		case REASON_ACCOUNT:
			break;
	}
	return(0);
}

int start() {
	datetime	barOpenTime 	= Time[0];	// number of seconds elapsed from 00:00 January 1, 1970.
	bool		hasHours		= (Period() > PERIOD_H1);	// need to display hours if timeframe is more than 1H 
	bool		hasDays			= (Period() > PERIOD_D1);	// need to display days left 
	datetime	barCloseTime	= barOpenTime + Period()*60;
	datetime	leftUntilClose	= barCloseTime - TimeCurrent();
	string		msg				= "";
	bool		exists			= false;
	datetime	objectX			= barOpenTime + Period()*60*Right_Shift_from_Bar;
	double		objectY;
	string		fontName		= NULL;	// do not change the font
	
	if( leftUntilClose <= 0 )
		leftUntilClose = 1;
		
	if( hasDays ) {
		msg = msg + (leftUntilClose / DAY_SECONDS) + "d ";
		leftUntilClose %= DAY_SECONDS;
	}
	msg	= msg + TimeToStr( leftUntilClose, TIME_SECONDS );
	
	if( !hasHours ) // '!hasHours' and 'hasDays' can not be 'true' at the same time
		msg = StringSubstr( msg, 3 ); // strip "hh:" portion

	// the coordinates are the upper middle (wtf?) of the rectangle, so text "hangs" down. make it inside the bar by using whatever higher from open/close.
	if( Open[0] >= Close[0] )
		objectY = Open[0];
	else
		objectY = Close[0];
	
	Comment( msg + " left to bar end" );
	msg = MSG_PREFIX + msg;

	// now, as the X is the middle - exactly half of the text will be on the right of the desired point - so double the number of chars.
	// the problem is that in a proportional font the space uses less width that normal character. about 1.5 times less.
	// depends on the font, of course.
	msg = StringSubstr( MAX_PADDING, MAX_LENGTH - StringLen(msg)*1.5 ) + msg;
	
	if( ObjectFind( OBJECT_NAME ) == -1 ) {
		ObjectCreate	( OBJECT_NAME, OBJ_TEXT, 0, objectX, objectY );
		ObjectSet		( OBJECT_NAME, OBJPROP_COLOR, col );
		ObjectSetText	( OBJECT_NAME, msg, fontSize, DEFAULT_FONT );
	}
	saveProperties();
	ObjectMove		( OBJECT_NAME, 0, objectX, objectY );
	ObjectSetText	( OBJECT_NAME, msg, fontSize );

	return(0);
}

void saveProperties() {
	col			= ObjectGet( OBJECT_NAME, OBJPROP_COLOR );
	fontSize	= ObjectGet( OBJECT_NAME, OBJPROP_FONTSIZE );
}

//+++======================================================================+++
//+++                      Candle Signal AA CM+FS+TT                       +++
//+++======================================================================+++
#property description "Индикатор выдает Стрелку/Сигнал при совпадении свечей с нескольких ТФ."
#property version  "1.23"
//---
#property strict
#property indicator_chart_window
#property indicator_buffers 2
//---
//#property  indicator_color1  clrBlue
//#property  indicator_color2  clrRed
////------
//#property indicator_style1  STYLE_DASH
//#property indicator_style2  STYLE_DOT
//**************************************************************************//
//***                   Custom indicator ENUM settings                     ***
//**************************************************************************//
enum showAR  { HideArrows, aINSIDE, aCENTER, aOUTSIDE };  //enum showAR { aDoNotCALC, HideArrows, aOnCHART, aOnINDIK }; 
//+++======================================================================+++
//+++                 Custom indicator input parameters                    +++
//+++======================================================================+++

extern int         CountTF  =  3;
extern showAR   ShowArrows  =  aOUTSIDE;  
//extern int      ARROWBAR  =  0;    
//extern double FilterPips  =  2.5;
extern color       ArrowUP  =  clrLightCyan,  
                   ArrowDN  =  clrMagenta;    
extern int          ArrGap  =  3,    
                  ArrCodUP  =  233,  
                  ArrCodDN  =  234,  
                   ArrSize  =  1;    

extern string    SoundFile  =  "alert2.wav";   
extern int       SIGNALBAR  =  1;   
extern bool  AlertsMessage  =  true,   
               AlertsSound  =  true,  
               AlertsEmail  =  false,
              AlertsMobile  =  false;
              
//На каком баре рисовать Стрелку: =0 - рисовать на текущем (до закрытия - может исчезнуть)                    
//Aqua,    //White,   //DarkTurquoise,  //LimeGreen,  //FireBrick,   //,   // 
//Gold;    //Red;   //HotPink;  //Orange;   //SlateBlue;   //DodgerBlue;   //;   //Lavender;  //
//Дистанция от High/Low свечи    
//241,  //217,  //147,  116, 117, 234,   //226
//242,  //218,   //181,  233,   //225
//"news.wav";  //"expert.wav";  //   //"stops.wav"   //
//На каком баре сигналить....
//+++======================================================================+++
//+++                     Custom indicator buffers                         +++
//+++======================================================================+++
double ARRUP[], ARRDN[];   datetime TimeBar=0;   //datetime TimeAlert=0;
int TF[9]={1,5,15,30,60,240,1440,10080,43200};
int n, nn, S=0;  bool arrow;
//+++======================================================================+++
//+++              Custom indicator initialization function                +++
//+++======================================================================+++
int OnInit()
{
   for (int i=0; i<9; i++) if (_Period==TF[i]) n=i; 
   //---
   nn=n+CountTF;
   if (n+CountTF>8) nn=8;
//------
//------
   IndicatorBuffers(2);   IndicatorDigits(Digits);   if (Digits==2 || Digits==3) IndicatorDigits(Digits-1);
//------ 2 распределенных буфера индикатора   
                              int ART=DRAW_NONE;  if (ShowArrows!=0) ART=DRAW_ARROW;
   SetIndexBuffer(0,ARRUP);   SetIndexStyle(0,ART,EMPTY,ArrSize,ArrowUP);  SetIndexArrow(0,ArrCodUP);   SetIndexLabel(0,"Arrow BUY   ["+(string)CountTF+"]");   //SetIndexShift(2,Shift2);
   SetIndexBuffer(1,ARRDN);   SetIndexStyle(1,ART,EMPTY,ArrSize,ArrowDN);  SetIndexArrow(1,ArrCodDN);   SetIndexLabel(1,"Arrow SELL  ["+(string)CountTF+"]");   //SetIndexShift(3,Shift2);   

//------ "короткое имя" для DataWindow и подокна индикатора + и/или "уникальное имя индикатора"   ///WindowExpertName()+
   IndicatorShortName(stringMTF(_Period)+": Candle Signal ["+(string)CountTF+"]");   
//**************************************************************************//
//**************************************************************************//
//------
return(INIT_SUCCEEDED);
}
//+++======================================================================+++
//+++              Custom indicator deinitialization function              +++
//+++======================================================================+++
void OnDeinit(const int reason)  { Comment("");  /*ObjectsDeleteAll(0,PREF,-1,-1);*/ }     
//int deinit()  { Comment("");  return(0); }  ///ALL_OBJ_DELETE(); 
//+++======================================================================+++
//+++                 Custom indicator iteration function                  +++
//+++======================================================================+++
int OnCalculate(const int rates_total, const int prev_calculated, const datetime &time[],
                const double &open[],  const double &close[],
                const double &low[],   const double &high[],
                const long &tick_volume[], const long &volume[], const int &spread[])
{                
//**************************************************************************//
//**************************************************************************//
   
   int i, j, limit=rates_total-prev_calculated-1;
   if (rates_total<1) return(0);
   //double d=(high[1]-low[1]+high[2]-low[2])/2;
   //------
   for (i=0; i<=1; i++) { 
        SetIndexEmptyValue(i,0.0);                         //--- значение 0 отображаться не будет 
        /*if (History>MAX)  SetIndexDrawBegin(i,Bars-History); //--- пропуск отрисовки первых баров
        if (History<=MAX)*/ SetIndexDrawBegin(i,_Period); }  //MAX*2); }        //--- пропуск отрисовки первых баров        
//**************************************************************************//
//***                      Candle Signal AA CM+FS+TT                       ***
//**************************************************************************//

   for (i=limit; i>=0; i--)
    {
     ARRUP[i]=0;  ARRDN[i]=0;   
     //---
     if (S<1)
      {
       arrow=true;
       for (j=n; j<=nn; j++) if (iOpen(NULL,TF[j],iBarShift(NULL,TF[j],time[i],false)) > iClose(NULL,TF[j],iBarShift(NULL,TF[j],time[i],false)))  { arrow=false;  break; }
       //if (arrow) { ARRUP[i]=low[i]-d;  if (i==1 && TimeAlert!=time[i]) Alert(Symbol()," сигнал на покупку");  TimeAlert=time[i];  S=1; } }
       if (arrow) { ARRUP[i] = setArrow("buy",i);  S=1; }
      }
   //------
   //------
     if (S>-1)
      {
       arrow=true;
       for (j=n; j=0; i--) 
//+++======================================================================+++
//+++                      Candle Signal AA CM+FS+TT                       +++
//+++======================================================================+++

   if (AlertsMessage || AlertsEmail || AlertsMobile || AlertsSound) 
    {  ///string sufix;   ////
     string messageUP = WindowExpertName()+" >> "+_Symbol+", "+stringMTF(_Period)+"  >> Arrow UP >> BUY";   
     string messageDN = WindowExpertName()+" << "+_Symbol+", "+stringMTF(_Period)+"  << Arrow DN << SELL";   
   //------
     if (TimeBar!=Time[0] && ARRUP[SIGNALBAR]!=0) {
         if (AlertsMessage) Alert(messageUP);
         if (AlertsEmail)   SendMail(_Symbol,messageUP);
         if (AlertsMobile)  SendNotification(messageUP);
         if (AlertsSound)   PlaySound(SoundFile);   //"stops.wav"   //"news.wav"
         TimeBar=Time[0]; }  //return(0);
   //------
     else 
     if (TimeBar!=Time[0] && ARRDN[SIGNALBAR]!=0) { 
         if (AlertsMessage) Alert(messageDN);
         if (AlertsEmail)   SendMail(_Symbol,messageDN);
         if (AlertsMobile)  SendNotification(messageDN);
         if (AlertsSound)   PlaySound(SoundFile);   //"stops.wav"   //"news.wav"
         TimeBar=Time[0]; }  //return(0);
    }  ///*конец* АЛЕРТОВ для всех.....             
//**************************************************************************//
//**************************************************************************//
//------
return(rates_total);
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//%%%                      VMMA StDev 2MA AA MTF BDG+TT                    %%%
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
double arrUP, arrDN, exit;   
//------
double setArrow(string BuySell, int i)
{
   double GAP=ArrGap*_Point;   if (Digits==3 || Digits==5) GAP*=10;
   //---
   switch(ShowArrows)
    {  ////enum showARR { HideArrows, aINSIDE, aCENTER, aOUTSIDE };
     case 0: arrUP=888;                 arrDN=-888;  break;
     case 1: arrUP=High[i]+GAP;         arrDN=Low[i]-GAP; break;
     case 2: arrUP=(High[i]+Low[i])/2;  arrDN=(High[i]+Low[i])/2; break;
     case 3: arrUP=Low[i]-GAP;          arrDN=High[i]+GAP; break;
    } 
   //---
   if (BuySell=="buy")  exit = arrUP;
   if (BuySell=="sell") exit = arrDN;
//---   
return(exit);
}      
//+++======================================================================+++
//+++                      Candle Signal AA CM+FS+TT                       +++
//+++======================================================================+++
string stringMTF(int perMTF)
{  
   if (perMTF==0)      perMTF=_Period;
   if (perMTF==1)      return("M1");
   if (perMTF==5)      return("M5");
   if (perMTF==15)     return("M15");
   if (perMTF==30)     return("M30");
   if (perMTF==60)     return("H1");
   if (perMTF==240)    return("H4");
   if (perMTF==1440)   return("D1");
   if (perMTF==10080)  return("W1");
   if (perMTF==43200)  return("MN1");
   if (perMTF== 2 || 3  || 4  || 6  || 7  || 8  || 9 ||       /// нестандартные периоды для грфиков Renko
               10 || 11 || 12 || 13 || 14 || 16 || 17 || 18)  return("M"+(string)_Period);
//------
   return("Ошибка периода");
}
//**************************************************************************//
//***                      Candle Signal AA CM+FS+TT                       ***
//**************************************************************************//

#property indicator_separate_window
#property indicator_buffers    4
#property indicator_color1     Red
#property indicator_color2     Blue
#property indicator_color3     Gray
#property indicator_color4     Gray
#property indicator_levelcolor MediumOrchid


extern int Processed        = 2000;
extern int Control_Period   = 14;

extern int Signal_Period    = 5;
extern int Signal_Method    = MODE_SMA;

extern int BB_Up_Period     = 12;
extern int BB_Up_Deviation  = 2;

extern int BB_Dn_Period     = 12;
extern int BB_Dn_Deviation  = 2;

extern double levelOb       = 6;
extern double levelOs       = -6;

extern bool   alertsOn        = false;
extern bool   alertsOnCurrent = false;
extern bool   alertsMessage   = false;
extern bool   alertsSound     = false;
extern bool   alertsEmail     = false;
extern string soundfile       = "alert2.wav";



double values[];
double signal[];
double band_up[];
double band_dn[];
double trend[];

int init() 
{
  IndicatorBuffers(5);
  SetIndexBuffer(0, values);
  SetIndexBuffer(1, signal);
  SetIndexBuffer(2, band_up);
  SetIndexBuffer(3, band_dn);  
  SetIndexBuffer(4, trend); 
  SetIndexStyle (0,DRAW_LINE);
  SetIndexStyle (1,DRAW_LINE);
  SetIndexStyle (2,DRAW_LINE);
  SetIndexStyle (3,DRAW_LINE); 
  SetLevelValue(0,levelOb);
  SetLevelValue(1,levelOs);
  return (0);
}

int deinit() {
  return (0);
}

int start() {
  datetime bar_time;
  int idx, counter, offset, bar_shft, bar_cont;
  double price_high, price_close, price_low, trigger_high, trigger_low;
  double sum_up, sum_dn, complex_up, complex_dn;

  int counted = IndicatorCounted();
  if (counted < 0) return (-1);
  if (counted > 0) counted--;
  int limit = Bars - counted;
  if (limit > Processed) limit = Processed;

  for (idx = limit; idx >= 0; idx--) {
    counter = 0;
    complex_up = 0; complex_dn = 0;
    trigger_high = -999999; trigger_low  = 999999;

    while (counter < Control_Period) {
      sum_up = 0; sum_dn = 0;
         
      offset = idx + counter;
      bar_time = iTime(Symbol(), 0, offset);
      bar_shft = iBarShift(Symbol(), 0, bar_time, FALSE);
      bar_cont = bar_shft - Period(); if (bar_cont < 0) bar_cont = 0;
         
      for (int jdx = bar_shft; jdx >= bar_cont; jdx--) {   
        price_high  = iHigh(Symbol(), 0, jdx); 
        price_close = iClose(Symbol(), 0, jdx); 
        price_low   = iLow(Symbol(), 0, jdx);
        if (price_high > trigger_high) {trigger_high = price_high; sum_up += price_close;}
        if (price_low  < trigger_low ) {trigger_low  = price_low;  sum_dn += price_close;}
      }
     
      counter++;
      complex_up += sum_up; complex_dn += sum_dn;        
    }
    if (complex_dn != 0.0 && complex_up != 0.0) 
      values[idx] = complex_dn / complex_up - complex_up / complex_dn;
  }
  
  for (idx = limit; idx >= 0; idx--) { 
    signal[idx]  = iMAOnArray(values, 0, Signal_Period, 0, Signal_Method, idx); 
    band_up[idx] = iBandsOnArray(values, 0, BB_Up_Period, BB_Up_Deviation, 0, MODE_UPPER, idx); 
    band_dn[idx] = iBandsOnArray(values, 0, BB_Dn_Period, BB_Dn_Deviation, 0, MODE_LOWER, idx); 
    trend[idx] = trend[idx+1];
    if (values[idx]>levelOb) trend[idx] =-1;
    if (values[idx]