//+------------------------------------------------------------------+ //| Trend.mqh | //| Copyright 2000-2025, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #include "Indicator.mqh" //+------------------------------------------------------------------+ //| Class CiADX. | //| Purpose: Class of the "Average Directional Index" indicator. | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiADX : public CIndicator { protected: int m_ma_period; public: CiADX(void); ~CiADX(void); //--- methods of access to protected data int MaPeriod(void) const { return(m_ma_period); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period); //--- methods of access to indicator data double Main(const int index) const; double Plus(const int index) const; double Minus(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_ADX); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiADX::CiADX(void) : m_ma_period(-1) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiADX::~CiADX(void) { } //+------------------------------------------------------------------+ //| Create the "Average Directional Index" indicator | //+------------------------------------------------------------------+ bool CiADX::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iADX(symbol,period,ma_period); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,ma_period)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiADX::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,(int)params[0].integer_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiADX::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period) { if(CreateBuffers(symbol,period,3)) { //--- string of status of drawing m_name ="ADX"; m_status="("+symbol+","+PeriodDescription()+","+IntegerToString(ma_period)+") H="+IntegerToString(m_handle); //--- save settings m_ma_period=ma_period; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("MAIN_LINE"); ((CIndicatorBuffer*)At(1)).Name("PLUS_LINE"); ((CIndicatorBuffer*)At(2)).Name("MINUS_LINE"); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to Main buffer of "Average Directional Index" | //+------------------------------------------------------------------+ double CiADX::Main(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Access to Plus buffer of "Average Directional Index" | //+------------------------------------------------------------------+ double CiADX::Plus(const int index) const { CIndicatorBuffer *buffer=At(1); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Access to Minus buffer of "Average Directional Index" | //+------------------------------------------------------------------+ double CiADX::Minus(const int index) const { CIndicatorBuffer *buffer=At(2); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiADXWilder. | //| Purpose: Class of the "Average Directional Index | //| by Welles Wilder" indicator. | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiADXWilder : public CIndicator { protected: int m_ma_period; public: CiADXWilder(void); ~CiADXWilder(void); //--- methods of access to protected data int MaPeriod(void) const { return(m_ma_period); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period); //--- methods of access to indicator data double Main(const int index) const; double Plus(const int index) const; double Minus(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_ADXW); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiADXWilder::CiADXWilder(void) : m_ma_period(-1) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiADXWilder::~CiADXWilder(void) { } //+------------------------------------------------------------------+ //| Create indicator "Average Directional Index by Welles Wilder" | //+------------------------------------------------------------------+ bool CiADXWilder::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iADXWilder(symbol,period,ma_period); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,ma_period)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiADXWilder::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,(int)params[0].integer_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiADXWilder::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period) { if(CreateBuffers(symbol,period,3)) { //--- string of status of drawing m_name ="ADXWilder"; m_status="("+symbol+","+PeriodDescription()+","+IntegerToString(ma_period)+") H="+IntegerToString(m_handle); //--- save settings m_ma_period=ma_period; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("MAIN_LINE"); ((CIndicatorBuffer*)At(1)).Name("PLUS_LINE"); ((CIndicatorBuffer*)At(2)).Name("MINUS_LINE"); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to Main buffer of "Average Directional Index | //| by Welles Wilder" | //+------------------------------------------------------------------+ double CiADXWilder::Main(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Access to Plus buffer of "Average Directional Index | //| by Welles Wilder" | //+------------------------------------------------------------------+ double CiADXWilder::Plus(const int index) const { CIndicatorBuffer *buffer=At(1); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Access to Minus buffer of "Average Directional Index | //| by Welles Wilder" | //+------------------------------------------------------------------+ double CiADXWilder::Minus(const int index) const { CIndicatorBuffer *buffer=At(2); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiBands. | //| Purpose: Class of the "Bollinger Bands" indicator. | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiBands : public CIndicator { protected: int m_ma_period; int m_ma_shift; double m_deviation; int m_applied; public: CiBands(void); ~CiBands(void); //--- methods of access to protected data int MaPeriod(void) const { return(m_ma_period); } int MaShift(void) const { return(m_ma_shift); } double Deviation(void) const { return(m_deviation); } int Applied(void) const { return(m_applied); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const double deviation,const int applied); //--- methods of access to indicator data double Base(const int index) const; double Upper(const int index) const; double Lower(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_BANDS); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const double deviation,const int applied); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiBands::CiBands(void) : m_ma_period(-1), m_ma_shift(-1), m_deviation(EMPTY_VALUE), m_applied(-1) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiBands::~CiBands(void) { } //+------------------------------------------------------------------+ //| Create indicator "Bollinger Bands" | //+------------------------------------------------------------------+ bool CiBands::Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const double deviation,const int applied) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iBands(symbol,period,ma_period,ma_shift,deviation,applied); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,ma_period,ma_shift,deviation,applied)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiBands::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value, params[2].double_value,(int)params[3].integer_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiBands::Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const double deviation,const int applied) { if(CreateBuffers(symbol,period,3)) { //--- string of status of drawing m_name ="Bands"; m_status="("+symbol+","+PeriodDescription()+","+ IntegerToString(ma_period)+","+IntegerToString(ma_shift)+","+ DoubleToString(deviation)+","+PriceDescription(applied)+") H="+IntegerToString(m_handle); //--- save settings m_ma_period=ma_period; m_ma_shift =ma_shift; m_deviation=deviation; m_applied =applied; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("BASE_LINE"); ((CIndicatorBuffer*)At(0)).Offset(ma_shift); ((CIndicatorBuffer*)At(1)).Name("UPPER_BAND"); ((CIndicatorBuffer*)At(1)).Offset(ma_shift); ((CIndicatorBuffer*)At(2)).Name("LOWER_BAND"); ((CIndicatorBuffer*)At(2)).Offset(ma_shift); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to Base buffer of "Bollinger Bands" | //+------------------------------------------------------------------+ double CiBands::Base(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Access to Upper buffer of "Bollinger Bands" | //+------------------------------------------------------------------+ double CiBands::Upper(const int index) const { CIndicatorBuffer *buffer=At(1); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Access to Lower buffer of "Bollinger Bands" | //+------------------------------------------------------------------+ double CiBands::Lower(const int index) const { CIndicatorBuffer *buffer=At(2); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiEnvelopes. | //| Purpose: Class of the "Envelopes" indicator. | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiEnvelopes : public CIndicator { protected: int m_ma_period; int m_ma_shift; ENUM_MA_METHOD m_ma_method; int m_applied; double m_deviation; public: CiEnvelopes(void); ~CiEnvelopes(void); //--- methods of access to protected data int MaPeriod(void) const { return(m_ma_period); } int MaShift(void) const { return(m_ma_shift); } ENUM_MA_METHOD MaMethod(void) const { return(m_ma_method); } int Applied(void) const { return(m_applied); } double Deviation(void) const { return(m_deviation); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift,const ENUM_MA_METHOD ma_method, const int applied,const double deviation); //--- methods of access to indicator data double Upper(const int index) const; double Lower(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_ENVELOPES); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift,const ENUM_MA_METHOD ma_method, const int applied,const double deviation); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiEnvelopes::CiEnvelopes(void) : m_ma_period(-1), m_ma_shift(-1), m_ma_method(WRONG_VALUE), m_applied(-1), m_deviation(EMPTY_VALUE) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiEnvelopes::~CiEnvelopes(void) { } //+------------------------------------------------------------------+ //| Create indicator "Envelopes" | //+------------------------------------------------------------------+ bool CiEnvelopes::Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift,const ENUM_MA_METHOD ma_method, const int applied,const double deviation) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iEnvelopes(symbol,period,ma_period,ma_shift,ma_method,applied,deviation); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,ma_period,ma_shift,ma_method,applied,deviation)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiEnvelopes::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value, (ENUM_MA_METHOD)params[2].integer_value,(int)params[3].integer_value, (int)params[4].double_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiEnvelopes::Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift,const ENUM_MA_METHOD ma_method, const int applied,const double deviation) { if(CreateBuffers(symbol,period,2)) { //--- string of status of drawing m_name="Envelopes"; m_status="("+symbol+","+PeriodDescription()+","+ IntegerToString(ma_period)+","+IntegerToString(ma_shift)+","+ MethodDescription(ma_method)+","+PriceDescription(applied)+","+ DoubleToString(deviation)+") H="+IntegerToString(m_handle); //--- save settings m_ma_period=ma_period; m_ma_shift =ma_shift; m_ma_method=ma_method; m_applied =applied; m_deviation=deviation; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("UPPER_LINE"); ((CIndicatorBuffer*)At(0)).Offset(ma_shift); ((CIndicatorBuffer*)At(1)).Name("LOWER_LINE"); ((CIndicatorBuffer*)At(1)).Offset(ma_shift); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to Upper buffer of "Envelopes" | //+------------------------------------------------------------------+ double CiEnvelopes::Upper(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Access to Lower buffer of "Envelopes" | //+------------------------------------------------------------------+ double CiEnvelopes::Lower(const int index) const { CIndicatorBuffer *buffer=At(1); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiIchimoku. | //| Purpose: Class of the "Ichimoku Kinko Hyo" indicator. | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiIchimoku : public CIndicator { protected: int m_tenkan_sen; int m_kijun_sen; int m_senkou_span_b; public: CiIchimoku(void); ~CiIchimoku(void); //--- methods of access to protected data int TenkanSenPeriod(void) const { return(m_tenkan_sen); } int KijunSenPeriod(void) const { return(m_kijun_sen); } int SenkouSpanBPeriod(void) const { return(m_senkou_span_b); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period, const int tenkan_sen,const int kijun_sen,const int senkou_span_b); //--- methods of access to indicator data double TenkanSen(const int index) const; double KijunSen(const int index) const; double SenkouSpanA(const int index) const; double SenkouSpanB(const int index) const; double ChinkouSpan(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_ICHIMOKU); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int tenkan_sen,const int kijun_sen,const int senkou_span_b); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiIchimoku::CiIchimoku(void) : m_tenkan_sen(-1), m_kijun_sen(-1), m_senkou_span_b(-1) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiIchimoku::~CiIchimoku(void) { } //+------------------------------------------------------------------+ //| Create indicator "Ichimoku Kinko Hyo" | //+------------------------------------------------------------------+ bool CiIchimoku::Create(const string symbol,const ENUM_TIMEFRAMES period, const int tenkan_sen,const int kijun_sen,const int senkou_span_b) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iIchimoku(symbol,period,tenkan_sen,kijun_sen,senkou_span_b); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,tenkan_sen,kijun_sen,senkou_span_b)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiIchimoku::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,(int)params[2].integer_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiIchimoku::Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int tenkan_sen,const int kijun_sen,const int senkou_span_b) { if(CreateBuffers(symbol,period,5)) { //--- string of status of drawing m_name ="Ichimoku"; m_status="("+symbol+","+PeriodDescription()+","+ IntegerToString(tenkan_sen)+","+IntegerToString(kijun_sen)+","+ IntegerToString(senkou_span_b)+") H="+IntegerToString(m_handle); //--- save settings m_tenkan_sen =tenkan_sen; m_kijun_sen =kijun_sen; m_senkou_span_b=senkou_span_b; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("TENKANSEN_LINE"); ((CIndicatorBuffer*)At(1)).Name("KIJUNSEN_LINE"); ((CIndicatorBuffer*)At(2)).Name("SENKOUSPANA_LINE"); ((CIndicatorBuffer*)At(2)).Offset(kijun_sen); ((CIndicatorBuffer*)At(3)).Name("SENKOUSPANB_LINE"); ((CIndicatorBuffer*)At(3)).Offset(kijun_sen); ((CIndicatorBuffer*)At(4)).Name("CHIKOUSPAN_LINE"); ((CIndicatorBuffer*)At(4)).Offset(-kijun_sen); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to TenkanSen buffer of "Ichimoku Kinko Hyo" | //+------------------------------------------------------------------+ double CiIchimoku::TenkanSen(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Access to KijunSen buffer of "Ichimoku Kinko Hyo" | //+------------------------------------------------------------------+ double CiIchimoku::KijunSen(const int index) const { CIndicatorBuffer *buffer=At(1); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Access to SenkouSpanA buffer of "Ichimoku Kinko Hyo" | //+------------------------------------------------------------------+ double CiIchimoku::SenkouSpanA(const int index) const { CIndicatorBuffer *buffer=At(2); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Access to SenkouSpanB buffer of "Ichimoku Kinko Hyo" | //+------------------------------------------------------------------+ double CiIchimoku::SenkouSpanB(const int index) const { CIndicatorBuffer *buffer=At(3); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Access to ChikouSpan buffer of "Ichimoku Kinko Hyo" | //+------------------------------------------------------------------+ double CiIchimoku::ChinkouSpan(const int index) const { CIndicatorBuffer *buffer=At(4); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiMA. | //| Purpose: Class of the "Moving Average" indicator. | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiMA : public CIndicator { protected: int m_ma_period; int m_ma_shift; ENUM_MA_METHOD m_ma_method; int m_applied; public: CiMA(void); ~CiMA(void); //--- methods of access to protected data int MaPeriod(void) const { return(m_ma_period); } int MaShift(void) const { return(m_ma_shift); } ENUM_MA_METHOD MaMethod(void) const { return(m_ma_method); } int Applied(void) const { return(m_applied); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const ENUM_MA_METHOD ma_method,const int applied); //--- methods of access to indicator data double Main(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_MA); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const ENUM_MA_METHOD ma_method,const int applied); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiMA::CiMA(void) : m_ma_period(-1), m_ma_shift(-1), m_ma_method(WRONG_VALUE), m_applied(-1) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiMA::~CiMA(void) { } //+------------------------------------------------------------------+ //| Create indicator "Moving Average" | //+------------------------------------------------------------------+ bool CiMA::Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const ENUM_MA_METHOD ma_method,const int applied) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iMA(symbol,period,ma_period,ma_shift,ma_method,applied); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,ma_period,ma_shift,ma_method,applied)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value, (ENUM_MA_METHOD)params[2].integer_value,(int)params[3].integer_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const ENUM_MA_METHOD ma_method,const int applied) { if(CreateBuffers(symbol,period,1)) { //--- string of status of drawing m_name ="MA"; m_status="("+symbol+","+PeriodDescription()+","+ IntegerToString(ma_period)+","+IntegerToString(ma_shift)+","+ MethodDescription(ma_method)+","+PriceDescription(applied)+") H="+IntegerToString(m_handle); //--- save settings m_ma_period=ma_period; m_ma_shift =ma_shift; m_ma_method=ma_method; m_applied =applied; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("MAIN_LINE"); ((CIndicatorBuffer*)At(0)).Offset(ma_shift); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to buffer of "Moving Average" | //+------------------------------------------------------------------+ double CiMA::Main(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiSAR. | //| Purpose: Class of the "Parabolic Stop And Reverse System" | //| indicator. | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiSAR : public CIndicator { protected: double m_step; double m_maximum; public: CiSAR(void); ~CiSAR(void); //--- methods of access to protected data double SarStep(void) const { return(m_step); } double Maximum(void) const { return(m_maximum); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period,const double step,const double maximum); //--- methods of access to indicator data double Main(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_SAR); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const double step,const double maximum); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiSAR::CiSAR(void) : m_step(EMPTY_VALUE), m_maximum(EMPTY_VALUE) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiSAR::~CiSAR(void) { } //+------------------------------------------------------------------+ //| Create indicator "Parabolic Stop And Reverse System" | //+------------------------------------------------------------------+ bool CiSAR::Create(const string symbol,const ENUM_TIMEFRAMES period,const double step,const double maximum) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iSAR(symbol,period,step,maximum); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,step,maximum)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiSAR::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,params[0].double_value,params[1].double_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiSAR::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const double step,const double maximum) { if(CreateBuffers(symbol,period,1)) { //--- string of status of drawing m_name ="SAR"; m_status="("+symbol+","+PeriodDescription()+","+ DoubleToString(step,4)+","+DoubleToString(maximum,4)+","+") H="+IntegerToString(m_handle); //--- save settings m_step =step; m_maximum=maximum; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("MAIN_LINE"); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to buffer of "Parabolic Stop And Reverse System" | //+------------------------------------------------------------------+ double CiSAR::Main(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiStdDev. | //| Purpose: Class indicator "Standard Deviation". | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiStdDev : public CIndicator { protected: int m_ma_period; int m_ma_shift; ENUM_MA_METHOD m_ma_method; int m_applied; public: CiStdDev(void); ~CiStdDev(void); //--- methods of access to protected data int MaPeriod(void) const { return(m_ma_period); } int MaShift(void) const { return(m_ma_shift); } ENUM_MA_METHOD MaMethod(void) const { return(m_ma_method); } int Applied(void) const { return(m_applied); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const ENUM_MA_METHOD ma_method,const int applied); //--- methods of access to indicator data double Main(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_STDDEV); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const ENUM_MA_METHOD ma_method,const int applied); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiStdDev::CiStdDev(void) : m_ma_period(-1), m_ma_shift(-1), m_ma_method(WRONG_VALUE), m_applied(-1) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiStdDev::~CiStdDev(void) { } //+------------------------------------------------------------------+ //| Create indicator "Standard Deviation" | //+------------------------------------------------------------------+ bool CiStdDev::Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const ENUM_MA_METHOD ma_method,const int applied) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iStdDev(symbol,period,ma_period,ma_shift,ma_method,applied); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,ma_period,ma_shift,ma_method,applied)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiStdDev::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value, (ENUM_MA_METHOD)params[2].integer_value,(int)params[3].integer_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiStdDev::Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift, const ENUM_MA_METHOD ma_method,const int applied) { if(CreateBuffers(symbol,period,1)) { //--- string of status of drawing m_name ="StdDev"; m_status="("+symbol+","+PeriodDescription()+","+ IntegerToString(ma_period)+","+IntegerToString(ma_shift)+","+ MethodDescription(ma_method)+") H="+IntegerToString(m_handle); //--- save settings m_ma_period=ma_period; m_ma_shift =ma_shift; m_ma_method=ma_method; m_applied =applied; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("MAIN_LINE"); ((CIndicatorBuffer*)At(0)).Offset(ma_shift); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to buffer of "Standard Deviation" | //+------------------------------------------------------------------+ double CiStdDev::Main(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiDEMA. | //| Purpose: Class indicator "Double Exponential Moving Average". | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiDEMA : public CIndicator { protected: int m_ma_period; int m_ind_shift; int m_applied; public: CiDEMA(void); ~CiDEMA(void); //--- methods of access to protected data int MaPeriod(void) const { return(m_ma_period); } int IndShift(void) const { return(m_ind_shift); } int Applied(void) const { return(m_applied); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ind_shift,const int applied); //--- methods of access to indicator data double Main(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_DEMA); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ind_shift,const int applied); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiDEMA::CiDEMA(void) : m_ma_period(-1), m_ind_shift(-1), m_applied(-1) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiDEMA::~CiDEMA(void) { } //+------------------------------------------------------------------+ //| Create indicator "Double Exponential Moving Average" | //+------------------------------------------------------------------+ bool CiDEMA::Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ind_shift,const int applied) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iDEMA(symbol,period,ma_period,ind_shift,applied); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,ma_period,ind_shift,applied)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiDEMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,(int)params[2].integer_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiDEMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ind_shift,const int applied) { if(CreateBuffers(symbol,period,1)) { //--- string of status of drawing m_name ="DEMA"; m_status="("+symbol+","+PeriodDescription()+","+ IntegerToString(ma_period)+","+IntegerToString(ind_shift)+","+ PriceDescription(applied)+") H="+IntegerToString(m_handle); //--- save settings m_ma_period=ma_period; m_ind_shift=ind_shift; m_applied =applied; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("MAIN_LINE"); ((CIndicatorBuffer*)At(0)).Offset(ind_shift); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to buffer of "Double Exponential Moving Average" | //+------------------------------------------------------------------+ double CiDEMA::Main(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiTEMA. | //| Purpose: Class indicator "Triple Exponential Moving Average". | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiTEMA : public CIndicator { protected: int m_ma_period; int m_ind_shift; int m_applied; public: CiTEMA(void); ~CiTEMA(void); //--- methods of access to protected data int MaPeriod(void) const { return(m_ma_period); } int IndShift(void) const { return(m_ind_shift); } int Applied(void) const { return(m_applied); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift,const int applied); //--- methods of access to indicator data double Main(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_TEMA); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ma_shift,const int applied); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiTEMA::CiTEMA(void) : m_ma_period(-1), m_ind_shift(-1), m_applied(-1) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiTEMA::~CiTEMA(void) { } //+------------------------------------------------------------------+ //| Create indicator "Triple Exponential Moving Average" | //+------------------------------------------------------------------+ bool CiTEMA::Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ind_shift,const int applied) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iTEMA(symbol,period,ma_period,ind_shift,applied); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,ma_period,ind_shift,applied)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiTEMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,(int)params[2].integer_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiTEMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ind_shift,const int applied) { if(CreateBuffers(symbol,period,1)) { //--- string of status of drawing m_name ="TEMA"; m_status="("+symbol+","+PeriodDescription()+","+ IntegerToString(ma_period)+","+IntegerToString(ind_shift)+","+ PriceDescription(applied)+") H="+IntegerToString(m_handle); //--- save settings m_ma_period=ma_period; m_ind_shift=ind_shift; m_applied =applied; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("MAIN_LINE"); ((CIndicatorBuffer*)At(0)).Offset(ind_shift); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to buffer of "Triple Exponential Moving Average" | //+------------------------------------------------------------------+ double CiTEMA::Main(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiFrAMA. | //| Purpose: Class indicator "Fractal Adaptive Moving Average". | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiFrAMA : public CIndicator { protected: int m_ma_period; int m_ind_shift; int m_applied; public: CiFrAMA(void); ~CiFrAMA(void); //--- methods of access to protected data int MaPeriod(void) const { return(m_ma_period); } int IndShift(void) const { return(m_ind_shift); } int Applied(void) const { return(m_applied); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ind_shift,const int applied); //--- methods of access to indicator data double Main(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_FRAMA); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ind_shift,const int applied); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiFrAMA::CiFrAMA(void) : m_ma_period(-1), m_ind_shift(-1), m_applied(-1) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiFrAMA::~CiFrAMA(void) { } //+------------------------------------------------------------------+ //| Create indicator "Fractal Adaptive Moving Average" | //+------------------------------------------------------------------+ bool CiFrAMA::Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ind_shift,const int applied) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iFrAMA(symbol,period,ma_period,ind_shift,applied); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,ma_period,ind_shift,applied)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiFrAMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,(int)params[2].integer_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiFrAMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int ind_shift,const int applied) { if(CreateBuffers(symbol,period,1)) { //--- string of status of drawing m_name ="FrAMA"; m_status="("+symbol+","+PeriodDescription()+","+ IntegerToString(ma_period)+","+IntegerToString(ind_shift)+","+ PriceDescription(applied)+") H="+IntegerToString(m_handle); //--- save settings m_ma_period=ma_period; m_applied =applied; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("MAIN_LINE"); ((CIndicatorBuffer*)At(0)).Offset(ind_shift); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to buffer of "Fractal Adaptive Moving Average" | //+------------------------------------------------------------------+ double CiFrAMA::Main(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiAMA. | //| Purpose: Class indicator "Adaptive Moving Average". | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiAMA : public CIndicator { protected: int m_ma_period; int m_fast_ema_period; int m_slow_ema_period; int m_ind_shift; int m_applied; public: CiAMA(void); ~CiAMA(void); //--- methods of access to protected data int MaPeriod(void) const { return(m_ma_period); } int FastEmaPeriod(void) const { return(m_fast_ema_period); } int SlowEmaPeriod(void) const { return(m_slow_ema_period); } int IndShift(void) const { return(m_ind_shift); } int Applied(void) const { return(m_applied); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int fast_ema_period,const int slow_ema_period, const int ind_shift,const int applied); //--- methods of access to indicator data double Main(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_AMA); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int fast_ema_period,const int slow_ema_period, const int ind_shift,const int applied); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiAMA::CiAMA(void) : m_ma_period(-1), m_fast_ema_period(-1), m_slow_ema_period(-1), m_ind_shift(-1), m_applied(-1) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiAMA::~CiAMA(void) { } //+------------------------------------------------------------------+ //| Create indicator "Adaptive Moving Average" | //+------------------------------------------------------------------+ bool CiAMA::Create(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int fast_ema_period,const int slow_ema_period, const int ind_shift,const int applied) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iAMA(symbol,period,ma_period,fast_ema_period,slow_ema_period,ind_shift,applied); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,ma_period,fast_ema_period,slow_ema_period,ind_shift,applied)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiAMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value, (int)params[2].integer_value,(int)params[3].integer_value, (int)params[4].integer_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiAMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int ma_period,const int fast_ema_period,const int slow_ema_period, const int ind_shift,const int applied) { if(CreateBuffers(symbol,period,1)) { //--- string of status of drawing m_name ="AMA"; m_status="("+symbol+","+PeriodDescription()+","+ IntegerToString(ma_period)+","+IntegerToString(fast_ema_period)+","+IntegerToString(slow_ema_period)+","+ IntegerToString(ind_shift)+","+PriceDescription(applied)+") H="+IntegerToString(m_handle); //--- save settings m_ma_period =ma_period; m_fast_ema_period=fast_ema_period; m_slow_ema_period=slow_ema_period; m_ind_shift =ind_shift; m_applied =applied; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("MAIN_LINE"); ((CIndicatorBuffer*)At(0)).Offset(ind_shift); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to buffer of "Adaptive Moving Average" | //+------------------------------------------------------------------+ double CiAMA::Main(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+ //| Class CiVIDyA. | //| Purpose: Class indicator "Variable Index DYnamic Average". | //| Derives from class CIndicator. | //+------------------------------------------------------------------+ class CiVIDyA : public CIndicator { protected: int m_cmo_period; int m_ema_period; int m_ind_shift; int m_applied; public: CiVIDyA(void); ~CiVIDyA(void); //--- methods of access to protected data int CmoPeriod(void) const { return(m_cmo_period); } int EmaPeriod(void) const { return(m_ema_period); } int IndShift(void) const { return(m_ind_shift); } int Applied(void) const { return(m_applied); } //--- method of creation bool Create(const string symbol,const ENUM_TIMEFRAMES period, const int cmo_period,const int ema_period, const int ind_shift,const int applied); //--- methods of access to indicator data double Main(const int index) const; //--- method of identifying virtual int Type(void) const { return(IND_VIDYA); } protected: //--- methods of tuning virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]); bool Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int cmo_period,const int ema_period, const int ind_shift,const int applied); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CiVIDyA::CiVIDyA(void) : m_cmo_period(-1), m_ema_period(-1), m_ind_shift(-1), m_applied(-1) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CiVIDyA::~CiVIDyA(void) { } //+------------------------------------------------------------------+ //| Create indicator "Variable Index DYnamic Average" | //+------------------------------------------------------------------+ bool CiVIDyA::Create(const string symbol,const ENUM_TIMEFRAMES period, const int cmo_period,const int ema_period, const int ind_shift,const int applied) { //--- check history if(!SetSymbolPeriod(symbol,period)) return(false); //--- create m_handle=iVIDyA(symbol,period,cmo_period,ema_period,ind_shift,applied); //--- check result if(m_handle==INVALID_HANDLE) return(false); //--- indicator successfully created if(!Initialize(symbol,period,cmo_period,ema_period,ind_shift,applied)) { //--- initialization failed IndicatorRelease(m_handle); m_handle=INVALID_HANDLE; return(false); } //--- ok return(true); } //+------------------------------------------------------------------+ //| Initialize the indicator with universal parameters | //+------------------------------------------------------------------+ bool CiVIDyA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]) { //--- return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value, (int)params[2].integer_value,(int)params[3].integer_value)); } //+------------------------------------------------------------------+ //| Initialize indicator with the special parameters | //+------------------------------------------------------------------+ bool CiVIDyA::Initialize(const string symbol,const ENUM_TIMEFRAMES period, const int cmo_period,const int ema_period, const int ind_shift,const int applied) { if(CreateBuffers(symbol,period,1)) { //--- string of status of drawing m_name ="VIDyA"; m_status="("+symbol+","+PeriodDescription()+","+ IntegerToString(cmo_period)+","+IntegerToString(ema_period)+","+IntegerToString(ind_shift)+","+ PriceDescription(applied)+") H="+IntegerToString(m_handle); //--- save settings m_cmo_period=cmo_period; m_ema_period=ema_period; m_ind_shift =ind_shift; m_applied =applied; //--- create buffers ((CIndicatorBuffer*)At(0)).Name("MAIN_LINE"); ((CIndicatorBuffer*)At(0)).Offset(ind_shift); //--- ok return(true); } //--- error return(false); } //+------------------------------------------------------------------+ //| Access to buffer of "Variable Index DYnamic Average" | //+------------------------------------------------------------------+ double CiVIDyA::Main(const int index) const { CIndicatorBuffer *buffer=At(0); //--- check if(buffer==NULL) return(EMPTY_VALUE); //--- return(buffer.At(index)); } //+------------------------------------------------------------------+