Variant 2. Two lines: fast and slow. The first line is above the slow one — uptrend, fast below slow — downtrend. Two identical sets of standard parameters are required. 

Parameters: 

1. int ama_period1 — AMA period; 
2. int fast_ma_period1 — fast Moving Average period;
3. int slow_ma_period1 — slow Moving Average period; 
4. int ama_shift1 — horizontal shift of the indicator; 
5. ENUM_APPLIED_PRICE  applied_price1 — price type;
6. int ama_period2 — AMA period; 
7. int fast_ma_period2 — fast Moving Average period;
8. int slow_ma_period2 — slow Moving Average period; 
9. int ama_shift2 — horizontal shift of the indicator; 
10. ENUM_APPLIED_PRICE  applied_price2 — price type.

Variant 2. Two lines: fast and slow.

Parameters: 

1. int ma_period1 — averaging period;
2. ENUM_APPLIED_PRICE  applied_price1 — price type;
3. int ma_shift1 — horizontal shift of the indicator; 
4. int ma_period2 — averaging period;
5. ENUM_APPLIED_PRICE  applied_price2 — price type;
6. int ma_shift2 — horizontal shift of the indicator.

Variant 2. Two lines: fast and slow.

1. int ma_period1 — averaging period; 
2. int ma_shift1 — horizontal shift of the indicator; 
3. ENUM_APPLIED_PRICE  applied_price1 — price type;
4. int ma_period2 — averaging period; 
5. int ma_shift2 — horizontal shift of the indicator; 
6. ENUM_APPLIED_PRICE  applied_price2 — price type.

Parameters: 

1. int tenkan_sen — Tenkan-sen line period; 
2. int kijun_sen — Kijun-sen line period; 
3. int senkou_span_b — Senkou Span B period.  

1. int ma_period — averaging period; 
2. int ma_shift — horizontal shift of the indicator; 
3. ENUM_MA_METHOD ma_method — smoothing type; 
4. ENUM_APPLIED_PRICE applied_price — price type;
5. int shift2 — shift of the point relative to which the slope is checked.

Variant 2. Two lines: fast and slow.

Parameters: 

1. int ma_period1 — averaging period; 
2. int ma_shift1 — horizontal shift of the indicator; 
3. ENUM_MA_METHOD ma_method1 — smoothing type; 
4. ENUM_APPLIED_PRICE applied_price1 — price type;
5. int ma_period2 — averaging period; 
6. int ma_shift2 — horizontal shift of the indicator; 
7. ENUM_MA_METHOD ma_method2 — smoothing type; 
8. ENUM_APPLIED_PRICE applied_price2 — price type.

Variant 2. The main and the signal line.

Parameters:

1. int ma_period — averaging period.  

1. int ma_period — averaging period; 
2. int ma_shift — horizontal shift of the indicator; 
3. ENUM_APPLIED_PRICE applied_price — price type;
4. int shift2 — shift of the point relative to which the slope is checked.

Variant 2. Two lines: fast and slow.

Parameters: 

1. int ma_period1 — averaging period; 
2. int ma_shift1 — horizontal shift of the indicator; 
3. ENUM_APPLIED_PRICE applied_price1 — price type;
4. int ma_period2 — averaging period; 
5. int ma_shift2 — horizontal shift of the indicator; 
6. ENUM_APPLIED_PRICE applied_price2 — price type.

1. int ma_period — averaging period; 
2. int ma_shift — horizontal shift of the indicator; 
3. ENUM_APPLIED_PRICE applied_price — price type;
4. int shift2 — shift of the point relative to which the slope is checked.

Variant 2. Two lines: fast and slow.

Parameters: 

1. int ma_period1 — averaging period; 
2. int ma_shift1 — horizontal shift of the indicator; 
3. ENUM_APPLIED_PRICE applied_price1 — price type;
4. int ma_period2 — averaging period; 
5. int ma_shift2 — horizontal shift of the indicator; 
6. ENUM_APPLIED_PRICE applied_price2 — price type.

Parameters: 

1. int ma_period1 — averaging period; 
2. int ma_shift1 — horizontal shift of the indicator; 
3. ENUM_APPLIED_PRICE applied_price1 — price type;
4. int ma_period2 — averaging period; 
5. int ma_shift2 — horizontal shift of the indicator; 
6. ENUM_APPLIED_PRICE applied_price2 — price type.

We have defined the indicators and their application variants. Now let us write an enumeration of all types. In the Includes folder, we create the UniTrend folder, and create the UniTrendDefines.mqh file with an enumeration in it: 

enum EType{
   Type_ADX_PDIMDI,          // position of PDI and MDI lines of the ADX indicator
   Type_ADX_Level,           // position of ADX lines relative to the level
   Type_ADXW_PDIMDI,         // position of PDI and MDI lines of the ADX Wilder indicator
   Type_ADXW_Level,          // position of ADX lines relative to the level for ADX Wilder
   Type_Alligator,           // Alligator
   Type_AMA_Dir,             // direction of АМА      
   Type_AMA_2MA,             // two АМАs
   Type_ATR_Level,           // ATR
   Type_BuBe_Level,          // Bulls/Bears Power and a level
   Type_BuBe_Dir,            // direction of Bulls/Bears Power
   Type_Bands,               // Bollinger Bands   
   Type_CCI_Level,           // CCI and a level
   Type_Chaikin_Level,       // Chaikin oscillator and a level
   Type_DEMA_Dir,            // direction of DEMA     
   Type_DEMA_2MA,            // two DEMAs     
   Type_DeMarker_Level,      // DeMarker and a level
   Type_Envelopes,           // Envelope
   Type_Force_Level,         // Force oscillator and a level
   Type_Fractals,            // fractals
   Type_FrAMA_Dir,           // direction of FrAMA    
   Type_FrAMA_2MA,           // two FrAMAs
   Type_Ichimoku_TK,         // Ichimoku: Tenkan and Kijun
   Type_Ichimoku_SASB,       // Ichimoku: cloud      
   Type_Momentum_Level,      // Momentum and a level
   Type_MFI_Level,           // MFI and a level
   Type_MA_Dir,              // direction of MA       
   Type_MA_2MA,              // two MAs
   Type_OsMA_Dir,            // direction of OsMA 
   Type_OsMA_Level,          // OsMA and a level
   Type_MACD_Dir,            // direction of MACD 
   Type_MACD_Level,          // MACD and a level
   Type_SAR,                 // SAR
   Type_RSI_Level,           // RSI and a level
   Type_RVI_Level,           // RVI and a level
   Type_RVI_MS,              // the main and signal lines of RVI
   Type_STD_Level,           // standard deviation and a level
   Type_Sto_Dir,             // direction of stochastic
   Type_Sto_Level,           // stochastic and a level
   Type_Sto_MS,              // the main and signal lines of stochastic        
   Type_TEMA_Dir,            // direction of TEMA
   Type_TEMA_2MA,            // two TEMAs
   Type_TriX_Dir,            // direction of TriX
   Type_TriX_2MA,            // two TriXs
   Type_VIDyA_Dir,           // direction of VIDyA
   Type_VIDyA_2MA,           // two VIDyAs
   Type_Volumes              // volume        
            };

External Parameters

By analyzing the above indicator descriptions, we can determine the required set of external parameters. All required parameters and their types are given in Table 1. We will basically use variables with the prefix "f_" (which means fast). For variants with the fast and slow moving averages, we will use the second group of parameters with the prefix "s_" (which means slow).

Table 1. External parameters and their types  

In addition to the parameters specified in indicator descriptions, a few additional parameters are available at the bottom of the table: 

• mult — multiplier of parameters measured in points depending on the number of digits in quotes. The values of some indicators, such as MACD and OsMA, are connected with the price, so it is more convenient to set them in points. Parameter values need to be corrected depending on the number of digits in quotes.
• level_digits — the number of decimal places in the level parameter. In the graphical interface, the level value is set using the CSpinBox control (input field with the "+" and "-" buttons), so it would be convenient to set different minimum changes for different indicators (the amount by which the value changes when "+" or "-" is pressed).
• sar_step_digits — the number of decimal places for the step parameter of the SAR indicator.
• sar_maximum_digits — the number of decimal places for the maximum parameter of the SAR indicator.

#define ADX_LEVEL_DIGITS         0 // for the ADX indicator
#define ADXW_LEVEL_DIGITS        0 // for the ADX Wilder indicator
#define ATR_LEVEL_DIGITS         1 // for the ATR indicator
#define BUBE_LEVELS_DIGITS       1 // for the Bulls/Bears Power indicators
#define CCI_LEVEL_DIGITS         0 // for the CCI indicator
#define CHAIKIN_LEVEL_DIGITS     0 // for the Chaikin oscillator
#define DEMARKER_LEVEL_DIGITS    2 // for the Demarker indicator 
#define FORCE_LEVEL_DIGITS       3 // for the Force indicator
#define MOMENTUM_LEVEL_DIGITS    2 // for the Momentum indicator 
#define MFI_LEVEL_DIGITS         0 // for the MFI indicator
#define OSMA_LEVBEL_DIGITS       2 // for the OsMA indicator
#define MACD_LEVEL_DIGITS        2 // for the MACD indicator
#define RSI_LEVEL_DIGITS         0 // for the RSI indicator
#define RVI_LEVEL_DIGITS         2 // for the RVI indicator
#define STD_LEVEL_DIGITS         1 // for the STD indicator
#define STO_LEVEL_DIGITS         0 // for the Stochastic indicator
#define BANDS_LEVEL_DIGITS       1 // for Bollinger Bands
#define ENVELOPES_LEVEL_DIGITS   2 // for the Envelopes indicator
#define SAR_STEP_DIGITS          3 // for the SAR indicator (the step parameter)
      #define SAR_MAXIMUM_DIGITS       2 // for the SAR indicator (the maximum parameter)

Let us create the following structure based on the Table 1:

struct SExtParams{
   int                 f_period1;
   int                 f_shift1;
   int                 f_period2;
   int                 f_shift2;
   int                 f_period3;
   int                 f_shift3;
   long                f_method;
   long                f_price;
   long                f_volume;
   long                f_sto_price;
   double              f_level;
   int                 f_dot2shift;
   double              f_step;  
   double              f_maximum;  
   int                 s_period1;
   int                 s_shift1;
   int                 s_period2;
   int                 s_shift2;
   int                 s_period3;
   int                 s_shift3;
   long                s_method;
   long                s_price;
   int                 mult;
   int                 level_digits;
   int                 sar_step_digits;
   int                 sar_maximum_digits;      
            };

Combining parameters into a structure allows us to separate them from the rest of the code. It will be very convenient if we need to revise the indicator by adding new trend detection types, in case the available options are not enough. Also, this greatly simplifies the transfer of parameters to functions and class methods.

Since the indicator generated in the article will show the trend as a row of characters (this is the same for all indicators), we can easily add to the indicator a function notifying about the beginning of the trend. Someone may be interested in being notified of a completely formed trend (indications on a completed bar), and someone wants to catch the first moment of new trend emergence (on the emerging bar). Therefore, we will write enumerations for selecting the type of notification:

enum EAlerts{
   Alerts_off=0, // notification disabled
   Alerts_Bar0=1, // notification on the emerging bar
   Alerts_Bar1=2 // notification on a completed bar
            };  

Creating an Indicator

Creation of classes for universal indicators is considered in detail in articles "Universal oscillator with a graphical interface" and "Universal channel with the graphical interface". Let's consider the specific features of their creation in relation to this article.

All of the above methods for determining the trend are divided into two categories: one or two indicators. In one group, after loading the indicator we need to check one handle, and in the second one we check two of them. This means that the base class will have two child classes with different ways to check the handles. In turn, these child classes will have their own child classes, in which trend will be determined.

The base class:

class CUniTrend{
   protected:
  
      int m_handle1;
      int m_handle2;
      
      string m_name;
      string m_help;
      
      int m_ci;
      
      double m_b1[1];
      double m_b2[1];      
      double m_b3[1];    
      double m_b4[1];
            
      int m_shift;
      int m_shift1;    
      int m_shift2;
      int m_shift3;
      
      int m_dot2shift;
      
      double m_level;      
      
   public:
  
      void CUniTrend(){
         m_handle1=INVALID_HANDLE;
         m_handle2=INVALID_HANDLE;
      }
      
      void ~CUniTrend(){
         if(m_handle1!=INVALID_HANDLE){
            IndicatorRelease(m_handle1);
         }
         if(m_handle2!=INVALID_HANDLE){
            IndicatorRelease(m_handle2);
         }        
      }
  
      virtual int Calculate( const int rates_total,
                     const int prev_calculated,
                     double & upBuffer[],
                     double & dnBuffer[]
      ){
         return(rates_total);
      }
      
      virtual bool Calculated(){
         return(false);
      }
      
      virtual bool CheckHandles(){
         return(true);
      }      
      
      string Name(){
         return(m_name);
      }    
      string Help(){
         return(m_help);
      }
            };

The protected section contains declarations of various auxiliary variables, which will be useful in child classes. Variables for indicator handles are initialized in the constructor, the handles are released in the destructor. The remaining methods are virtual.

A child class for a variant with one indicator:

class CUniTrend1:public CUniTrend{
   public:
      bool Calculated(){
         if(BarsCalculated(m_handle1)>0){
            return(true);
         }  
         else{
            return(false);
         }    
      }
      
      bool CheckHandles(){
         return(m_handle1!=INVALID_HANDLE);
      }
            };

The class has two real methods: CheckHandle() — it allows to check whether the indicator could be loaded, and Calculated() — allows to find out if the indicator is fully calculated and if the contents of buffers displaying the trend can be updated.

A child class for a variant with two indicators:

class CUniTrend2:public CUniTrend{
   public:
      bool Calculated(){
         if(BarsCalculated(m_handle1)>0 && BarsCalculated(m_handle2)>0){
            return(true);
         }  
         else{
            return(false);
         }    
      }      
      
      bool CheckHandles(){
         return(m_handle1!=INVALID_HANDLE && m_handle2!=INVALID_HANDLE);
      }
            };

All classes with different variants of trend identification will be child classes of CUniTrend1 or CUniTrend2. Consider the following child class:

class CUniTrend_ADX_PDIMDI:public CUniTrend1{
   private:  
   public:
  
      void CUniTrend_ADX_PDIMDI( bool use_default,
                                 bool keep_previous,
                                 SExtParams & par){
        
         // setting default parameters
        
         if(use_default){
            if(keep_previous){
               if(par.f_period1==PARAMETER_EMPTY)par.f_period1=14;
            }
            else{
               par.f_period1=14;
            }      
         }          
         // loading the indicator
         m_handle1=iADX(Symbol(),Period(),par.f_period1);
         // forming the name of the indicator and a hint for parameters
         m_name=StringFormat( "iADX_PDIMDI(%i)",
                              par.f_period1
                            );
  
         m_help=StringFormat( "adx_period - f_period1(%i)",
                              par.f_period1
                            );
      }
      
      int Calculate( const int rates_total,
                     const int prev_calculated,
                     double & upBuffer[],
                     double & dnBuffer[]
      ){
         int start;
        
         if(prev_calculated==0){
            start=1;
         }
         else{
            start=prev_calculated-1;
         }
      
         for(int i=start;i<rates_total;i++){
        
            upBuffer[i]=EMPTY_VALUE;        
            dnBuffer[i]=EMPTY_VALUE;
        
            m_ci=rates_total-i-1;
            
            if(CopyBuffer(m_handle1,PLUSDI_LINE,m_ci,1,m_b1)==-1){
               return(0);
            }
            
            if(CopyBuffer(m_handle1,MINUSDI_LINE,m_ci,1,m_b2)==-1){
               return(0);
            }
            
            if(m_b1[0]>m_b2[0]){
               upBuffer[i]=1;
            }
            else if(m_b1[0]<m_b2[0]){
               dnBuffer[i]=-1;            
            }
            
         }      
      
         return(rates_total);
      }
            };

The main important points in the class constructor are commented, and the Calculate() method is an analog of the standard OnCalculate() function of the indicator. The code of this function is created similar to the indicator code.

In the article attachments, all indicator classes are located in the file Include/UniTrend/UniTrendIndicators.mqh.

Now that we have prepared all classes, we can create a simple indicator for determining the trend, just as we did in the articles about the universal oscillator and the universal channel. A ready indicator without a graphical interface is available in the attachment, in the Indicators/iUniTrend.mq5 file.

Creating a Graphical Interface

All classes of the graphical interface are located in files UniTrendForm.mqh and UniTrendControl.mqh. The form class is available in the UniTrendForm.mqh file, and the UniTrendControl.mqh file contains classes of the universal control for entering the indicator parameters. No need to discuss the creation of a form class in detail, because it has already been considered in articles about the universal oscillator and the universal channel. It is also considered in detail in the article "Custom Graphical Controls. Part 3. Forms". Let us consider creating a universal control.

The basis of the universal control is the CUniTrendControl base class. The public section of the class only contains virtual methods, the protected section contains some auxiliary methods for working with drop-down lists: methods for filling the lists with variants and methods for setting selected items in the list. Here is the base class code with comments:

class CUniTrendControl{
   protected:
      
      /* Function for calculating the minimal value change
         by the number of decimal places for the level parameter
      */
      double SolveChange(int d){
         return(NormalizeDouble(1.0/pow(10,d),d));  
      }
      
      // filling the list with ENUM_MA_METHOD variants
      void AddVariantsMethod(CComBox & cb){
         for(int i=0;i<ArraySize(e_method);i++){
            cb.AddItem(EnumToString((ENUM_MA_METHOD)e_method[i]));
         }
      }
      
      // filling the list with ENUM_APPLIED_PRICE variants
      void AddVariantsPrice(CComBox & cb){
         for(int i=0;i<ArraySize(e_price);i++){
            cb.AddItem(EnumToString((ENUM_APPLIED_PRICE)e_price[i]));
         }
      }      
      
      // filling the list with ENUM_APPLIED_VOLUME variants
      void AddVariantsVolume(CComBox & cb){
         for(int i=0;i<ArraySize(e_volume);i++){
            cb.AddItem(EnumToString((ENUM_APPLIED_VOLUME)e_volume[i]));
         }
      }  
      
      // filling the list with ENUM_STO_PRICE variants     
      void AddVariantsStoPrice(CComBox & cb){
         for(int i=0;i<ArraySize(e_sto_price);i++){
            cb.AddItem(EnumToString((ENUM_STO_PRICE)e_sto_price[i]));
         }
      }      
      
      // getting the value index for ENUM_MA_METHOD  
      int MethodIndex(long val){
         for(int i=ArraySize(e_method)-1;i>=0;i--){
            if(e_method[i]==val){
               return(i);
            }
         }
         return(-1);
      }
      
      // getting the value index for ENUM_APPLIED_PRICE
      int PriceIndex(long val){
         for(int i=ArraySize(e_price)-1;i>=0;i--){
            if(e_price[i]==val){
               return(i);
            }
         }
         return(-1);
      }  
      
      // getting the value index for ENUM_APPLIED_VOLUME   
      int VolumeIndex(long val){
         for(int i=ArraySize(e_volume)-1;i>=0;i--){
            if(e_volume[i]==val){
               return(i);
            }
         }
         return(-1);
      }  
      
      // getting the value index for ENUM_STO_PRICE     
      int StoPriceIndex(long val){
         for(int i=ArraySize(e_sto_price)-1;i>=0;i--){
            if(e_sto_price[i]==val){
               return(i);
            }
         }
         return(-1);
      }      
      
   public:
      
      // Initialization of controls
      virtual void Init(SExtParams & par){}
      
      // setting values
      virtual void SetValues(SExtParams & par){}      
      
      // getting values
      virtual void GetValues(SExtParams & par){}
      
      // displaying controls
      virtual void Show(int x,int y){}      
      
      // hiding controls
      virtual void Hide(){}      
      
      // number of controls for calculating the form height
      virtual int ControlsCount(){
         return(0);
      }
      
      // handling events
      virtual int Event(int id,long lparam,double dparam,string sparam){
         return(0);
      }
      
};
    

Let us consider a child class for trend detection based on ADX and the level (two controls):

class CUniTrendControl_ADX_Level: public CUniTrendControl{
   private:
  
      // pointers to simple controls
      CSpinInputBox m_f_period1;
      CSpinInputBox m_f_level;
  
   public:
  
      // Initialization of controls
      void Init(SExtParams & par){
         m_f_period1.Init("f_period1",SPIN_BOX_WIDTH,1," adx_period");
         m_f_period1.SetMinValue(1);
         m_f_period1.SetReadOnly(false);
         m_f_level.Init("f_level",COMBO_BOX_WIDTH,this.SolveChange(par.level_digits)," level");
         m_f_level.SetMinValue(0);
         m_f_level.SetReadOnly(false);
      }
  
      // setting values
      void SetValues(SExtParams & par){        
         m_f_period1.SetValue(par.f_period1);
         m_f_level.SetValue(par.f_level);
      }
  
      // getting values
      void GetValues(SExtParams & par){
         par.f_period1=(int)m_f_period1.Value();
         par.f_level=m_f_level.Value();
      }    
  
      // displaying controls
      void Show(int x,int y){
         m_f_period1.Show(x,y);
         y+=20;
         m_f_level.Show(x,y);
      }      
  
      // hiding controls
      void Hide(){
         m_f_period1.Hide();
         m_f_level.Hide();
      }
  
      // number of controls for calculating the form height
      int ControlsCount(){
         return(2);
      }
  
      // executing the control events
      int Event(int id,long lparam,double dparam,string sparam){
         int e1=m_f_period1.Event(id,lparam,dparam,sparam);
         int e2=m_f_level.Event(id,lparam,dparam,sparam);
         if(e1!=0 || e2!=0){
            return(1);
         }
         return(0);
      }
};
    

A variable of type SExtParam is passed to methods SetValues() and GetValues(), only required fields of the structure are used in each child class. We need to set the minimum change value for the level control; this can be done during the control initialization, therefore a structure with parameters is also passed to the Init() method. In general, the creation of child classes corresponds to all the principles of controls creation described in the article "Custom Graphical Controls. Part 1: Creating a Simple Control", expect that here only the necessary methods are created, not all of them. 

Combining the GUI with the indicator

This stage of indicator creation is much similar to the corresponding stage of universal trend indicator creation and universal channel creation. Let's consider the differences.

Earlier, when the indicator was operating with default values ​​(UseDefault=true), all parameters were initialized with -1. Now this option is not suitable, because the level parameter for some indicators can be negative. Therefore, initialization of variables is performed by the value of the PARAMETER_EMPTY constant declared in the UniTrendDefines.mqh file. The constant has the value of INT_MAX (a value that greatly exceeds the limits of real values ​​of levels).

Another small difference is the OnTimer() function. The Calculated() method is called to check if the indicator is calculated, because for some variants of the trend we need to check one indicator, and for others we check two indicators. This can only be known inside the indicator class.

As a result, we get another universal and very convenient indicator (Fig. 10).

Fig. 10. A universal trend indicator with the graphical interface

Note: in addition to displaying the name of the selected variant in the list on the form, the type of indicator used is also displayed in the indicator sub-window in the upper left corner. In addition to the type, the values of all parameters (in brackets) are displayed. If the level value is specified in points, an expression for calculating the real level value is written (Fig. 11).

 
Fig. 11. Displaying the parameter specified in points

The ready indicator is available in the below attachment, the file name is Indicators/iUniTrendGUI.mq5.  

Conclusion