外汇EA编写教程：带有图形界面的通用通道

有各种不同类型的通道, 如 Donchian 通道 (价格通道)。通常它以创建边界线 (价格范围) 开始, 之后计算中心线的数值 (在范围中间)。然而, 此通道也可以通过上述方案来构建: 即首先我们绘制一条中心线, 这条中心线被定义为价格区间的中间价, 然后我们在等于价格范围一半的距离上绘制通道边界。当然, 这比通常通道需要更多的计算。然而, 由于本文的主要目的是创建一个通用指标, 我们可以允许一些例外, 而此方法将增加中心线与边界的可能组合的数量。例如, 我们将能够创建一个在价格通道中带有中心线的指标, 边界位于标准偏差的距离, 如布林带等。 

让我们再次使用 CUniChannel 作为我们基类的基础。保存指标中心线数值的缓冲区和两个保存通道边界的缓冲区将在方法中用计算出的数值填充, 并将被传递给 Calculate 类的方法。与 CUniChannel 对比, 此处我们将分别为每个边界计算选项创建 Calculate 子类。这些子类将加载指标, 并在其中形成指标和缓冲区的名称。我们还需要稍微修改基类: 为通道宽度添加一个变量 – 变量的值将通过子类构造函数设置。

我们来将 CUniChannel.mqh 文件保存为 CUniChannelWidth.mqh 并对其进行修改。首先我们删除所有的子类, 只剩下基类和 Calculate。将 CChannelUni 重命名为 CChannelUniWidth (不要忘记子类中的构造函数, 析构函数和父类名称也需要更改)。结果文件如下:

class CChannelUniWidth{
   protected:
      int m_handle;           // 指标句柄
      string m_name;          // 指标名称
      string m_label1;        // 缓冲区 1 名称     
      string m_help;          // 指标参数提示
      double m_width;         // 通道宽度
   public:
  
      // 构造器
      void CChannelUniWidth(){
         m_handle=INVALID_HANDLE;
      }
      
      // 析构器
      void ~CChannelUniWidth(){
         if(m_handle!=INVALID_HANDLE){
            IndicatorRelease(m_handle);
         }
      }
  
      // 从指标的 OnCalculate() 函数里调用主方法
      virtual int Calculate( const int rates_total,
                     const int prev_calculated,
                     double & bufferCentral[],
                     double & bufferUpper[],
                     double & bufferLower[],
      ){
         return(rates_total);
      }
      
      // 得到加载指标的句柄
      int Handle(){
         return(m_handle);
      }
      
      // 句柄检查方法, 能够检查指标是否已加载成功  
      bool CheckHandle(){
         return(m_handle!=INVALID_HANDLE);
      }
      
      // 得到指标名称
      string Name(){
         return(m_name);
      }    
      // 得到缓冲区的标签文本
      string Label1(){
         return(m_label1);
      }
      
      // 得到参数提示
      string Help(){
         return(m_help);
      }
};
  

我们将 CChannelUni_Calculate 类重命名为 CChannelUni_Calculate_ATR, 并向其内添加一个构造函数。构造函数可以从通用振荡器的 COscUni_ATR 类中获取, 但是我们需要重新命名它, 将宽度参数添加其内。还有哪些需要修改的: 我们需要添加指标和缓冲区名称生成。最后, 基于 ATR 计算边界的类如下:

class CChannelUni_Calculate_ATR:public CChannelUniWidth{
   public:
      // 构造器
      // 开始两个是所有子类的标准参数 
      // 紧随加载指标的参数
      // 最后一个参数是通道宽度
      void CChannelUni_Calculate_ATR(bool use_default,
                                     bool keep_previous,
                                     int & ma_period,
                                     double & ch_width){
         if(use_default){ // 使用选择的省缺值
            if(keep_previous){ // 以前使用的参数无需修改
               if(ma_period==-1)ma_period=14;
               if(ch_width==-1)ch_width=2;
            }
            else{
               ma_period=14;
               ch_width=2;
            }      
         } 
         
         // 保存计算方法中用到的宽度参数  
         m_width=ch_width; 
         // 加载指标
         m_handle=iATR(Symbol(),Period(),ma_period);
         // 指标名形成的线
         m_name=StringFormat("ATR(%i)",ma_period);
         // 缓存区名称字符串
         m_label1=m_name;
         // 参数提示 
         m_help=StringFormat("ma_period - Period1(%i)",ma_period); // 提示   
      }   
      
      // 从指标的 OnCalculate() 函数调用的主函数
      // 前两个参数类似于
      // OnCalculate() 函数的前两个参数
      // 之后传递指标缓存区 
      int Calculate( const int rates_total,
                     const int prev_calculated,
                     double & bufferCentral[],
                     double & bufferUpper[],
                     double & bufferLower[],
      ){
      
         // 计算开始定义
         
         int start;
         
         if(prev_calculated==0){
            start=0; 
         }
         else{ 
            start=prev_calculated-1;
         }  
         // 计算的主循环和缓存区填充 
         for(int i=start;i<rates_total;i++){
            
            // 得到指标数据用于计算柱线
            double tmp[1];
            if(CopyBuffer(m_handle,0,rates_total-i-1,1,tmp)<=0){
               return(0);
            }
            
            // 乘以宽度参数
            tmp[0]*=m_width;   
            // 计算上下边界的值
            bufferUpper[i]=bufferCentral[i]+tmp[0];
            bufferLower[i]=bufferCentral[i]-tmp[0];
         }   
         
         return(rates_total);
      }
        };

请注意, 主循环内仅复制一根柱线的 ATR 指标值。此变体比之将数值序列复制到缓冲区慢得多。但是这种方法可以为我们节省一个指标缓冲区, 当手工将指标挂载到图表时, 速度损失才可见。但延迟十分之几秒对于用户无所谓。在策略测试器中, 测试开始时, 图表上可以看到少量的柱线, 因此在复制每根柱线的数据时所丧失的时间并不明显。

一些通道宽度计算选项不需要额外的指标 — 例如, 如果宽度设置为点, 或包络通道。在此情况下, 我们将把 0 分配给基类的 m_handle 变量 (它与 INVALID_HANDLE 值不同)。

以下附件包含 CUniChannelWidth.mqh 文件, 其中包含其它通道计算选项的子类。   

创建通用通道指标

// 中心线类型枚举
enum ECType{
   UniCh_C_AMA,
   UniCh_C_DEMA,
   UniCh_C_FrAMA,
   UniCh_C_MA,
   UniCh_C_TEMA,
   UniCh_C_VIDyA,
   UniCh_C_PrCh
};
// 边界线类型枚举
enum EWType{
   UniCh_W_ATR,
   UniCh_W_StdDev,
   UniCh_W_Points,
   UniCh_W_Percents,
   UniCh_W_PrCh
            };

#include <UniChannel/UniChannelDefines.mqh>
#include <UniChannel/CUniChannel.mqh>
#include <UniChannel/CUniChannelWidth.mqh>
    

// 中心线参数
input ECType               CentralType   =  UniCh_C_MA;
input int                  c_Period1     =  5;
input int                  c_Period2     =  10;
input int                  c_Period3     =  15;
input int                  c_Shift       =  0;
input ENUM_MA_METHOD       c_Method      =  MODE_SMA;
input ENUM_APPLIED_PRICE   c_Price       =  PRICE_CLOSE;
// 边界参数
input EWType               WidthType     =  UniCh_W_StdDev;
input int                  w_Period      =  20;
input int                  w_Shift       =  0;
input ENUM_MA_METHOD       w_Method      =  MODE_SMA;
input ENUM_APPLIED_PRICE   w_Price       =  PRICE_CLOSE;
      input double               w_Width       =  2.0;

bool                 UseDefault  =  false;
      bool                 KeepPrev    =  false;

ECType               _CentralType;
int                  _ma_Period1;
int                  _ma_Period2;
int                  _ma_Period3;
int                  _ma_Shift;
long                 _ma_Method;
long                 _ma_Price;
EWType               _WidthType;
int                  _w_Period;
int                  _w_Shift;
long                 _w_Method;
long                 _w_Price;
      double               _w_Width;

void PrepareParameters(){
   _CentralType=CentralType;
   _WidthType=WidthType;
  
   if(UseDefault && KeepPrev){
      _c_Period1=-1;
      _c_Period2=-1;
      _c_Period3=-1;
      _c_Shift=0;
      _c_Method=-1;
      _c_Price=-1;
      _w_Period=-1;
      _w_Shift=0;
      _w_Method=-1;
      _w_Price=-1;
      _w_Width=-1;
   }
   else{  
      _c_Period1=c_Period1;
      _c_Period2=c_Period2;
      _c_Period3=c_Period3;
      _c_Shift=c_Shift;
      _c_Method=c_Method;
      _c_Price=c_Price;
      _w_Period=w_Period;
      _w_Shift=w_Shift;
      _w_Method=w_Method;
      _w_Price=w_Price;
      _w_Width=w_Width;
   }
            }

CChannelUni * central;
            CChannelUniWidth * width;

void LoadCentral(){
   switch(_CentralType){ // 根据所选的类型创建一个适当的类
      case UniCh_C_AMA:
         central=new CChannelUni_AMA(  UseDefault,
                                       KeepPrev,
                                       _c_Period1,
                                       _c_Period2,
                                       _c_Period3,
                                       shift0,
                                       _c_Price);
      break;
      case UniCh_C_DEMA:
         central=new CChannelUni_DEMA( UseDefault,
                                       KeepPrev,
                                       _c_Period1,
                                       shift0,
                                       _c_Price);
      break;
      case UniCh_C_FrAMA:
         central=new CChannelUni_FrAMA(UseDefault,
                                       KeepPrev,
                                       _c_Period1,
                                       shift0,
                                       _c_Price);
      break;
      case UniCh_C_MA:
         central=new CChannelUni_MA(   UseDefault,
                                       KeepPrev,
                                       _c_Period1,
                                       shift0,
                                       _c_Method,
                                       _c_Price);
      break;
      case UniCh_C_TEMA:
         central=new CChannelUni_TEMA( UseDefault,
                                       KeepPrev,
                                       _c_Period1,
                                       shift0,
                                       _c_Price);
      break;
      case UniCh_C_VIDyA:
         central=new CChannelUni_VIDyA(UseDefault,
                                       KeepPrev,
                                       _c_Period1,
                                       _c_Period2,
                                       shift0,
                                       _c_Price);
      break;
      case UniCh_C_PrCh:
         central=new CChannelUni_PriceChannel(  UseDefault,
                                                KeepPrev,
                                                _c_Period1);
      break;
   }
}
    

   if(Auto5Digits && (Digits()==3 || Digits()==5)){
      mult=10; // 参数的点数值将乘以 10
   }
   else{
      mult=1; // 参数的点数值不必调整
         }

void LoadWidth(){
   switch(_WidthType){ // 根据所选的类型创建一个适当的类
      case UniCh_W_ATR:
         width=new CChannelUni_Calculate_ATR(UseDefault,KeepPrev,_w_Period,_w_Width);
      break;
      case UniCh_W_StdDev:
         width=new CChannelUni_Calculate_StdDev(UseDefault,KeepPrev,_w_Period,shift0,_w_Method,_w_Price,_w_Width);
      break;
      case UniCh_W_Points:
         width=new CChannelUni_Calculate_InPoints(UseDefault,KeepPrev,_w_Width,mult);
      break;
      case UniCh_W_Percents:
         width=new CChannelUni_Calculate_Envelopes(UseDefault,KeepPrev,_w_Width);
      break;
      case UniCh_W_PrCh:
         width=new CChannelUni_Calculate_PriceChannel(UseDefault,KeepPrev,_w_Period,_w_Width);
      break;
   }
            }

Print("中心线参数匹配:",central.Help());
      Print("宽度参数匹配:",width.Help());  

void SetStyles(){
   // 缓冲区名称
   PlotIndexSetString(0,PLOT_LABEL,"中心: "+central.Label1());
   PlotIndexSetString(1,PLOT_LABEL,"上边界: "+width.Label1());  
   PlotIndexSetString(2,PLOT_LABEL,"下边界: "+width.Label1());  
  
   // 缓冲区移位
   PlotIndexSetInteger(0,PLOT_SHIFT,_c_Shift);
   PlotIndexSetInteger(1,PLOT_SHIFT,_w_Shift);
   PlotIndexSetInteger(2,PLOT_SHIFT,_w_Shift);
            }

int OnInit(){
  
   // 准备一个乘数来调整参数
   if(Auto5Digits && (Digits()==3 || Digits()==5)){
      mult=10;
   }
   else{
      mult=1;
   }
  
   // 准备参数
   PrepareParameters();
  
   // 加载中心线指标
   LoadCentral();
  
   // 检查中心线是否已成功加载 
   if(!central.CheckHandle()){
      Alert("中心线错误 "+central.Name());
      return(INIT_FAILED);
   }    
  
   // 加载宽度计算指标
   LoadWidth();
  
   // 检查宽度计算指标是否已成功加载
   if(!width.CheckHandle()){
      Alert("宽度错误 "+width.Name());
      return(INIT_FAILED);
   }      
   // 显示参数提示
   Print("中心线参数匹配: "+central.Help());
   Print("宽度参数匹配: "+width.Help());  
  
   // 设置名称
   ShortName="iUniChannel";  
   IndicatorSetString(INDICATOR_SHORTNAME,ShortName);  
  
   // OnInit 函数的标准部分
   SetIndexBuffer(0,Label1Buffer,INDICATOR_DATA);
   SetIndexBuffer(1,Label2Buffer,INDICATOR_DATA);
   SetIndexBuffer(2,Label3Buffer,INDICATOR_DATA);
  
   // 设置标签和缓存区平移
   SetStyles();
   return(INIT_SUCCEEDED);
            }

enum ELockTo{
   LockTo_Off,
   LockTo_Period1,
   LockTo_Period2,
   LockTo_Period3
            };

switch(w_LockPeriod){ // 依据加锁类型
   case LockTo_Period1:
      _w_Period=_c_Period1;
   break;
   case LockTo_Period2:
      _w_Period=_c_Period2;      
   break;
   case LockTo_Period3:
      _w_Period=_c_Period3;      
   break;
            }

void PrintColl(string caption,string message){
   Print(caption); // 打印标题
   string res[];
   // 切分消息
   int cnt=StringSplit(message,',',res);
   // 按部分打印消息
   for(int i=0;i<cnt;i++){
      StringTrimLeft(res[i]);
      Print(res[i]);
   }
            }

PrintColl("中心线参数匹配:",central.Help());
            PrintColl("宽度参数匹配:",width.Help());    

图形界面将基于通用振荡器的图形界面。将 UniOsc / UniOscGUI.mqh 复制到 UniChannel 文件夹, 并将其名称更改为 UniChannelGUI.mqh。通用通道的图形界面与通用振荡器的界面区别很大, 所以我们需要在这里做很多工作。

主要区别在于通用通道需要独立选择两个指标 (中心线和边界), 所以应该有两个主要指标选择列表。第一个列表应跟随控件来管理中心线参数。然后进入针对边界参数的第二个列表和控件。因此, 第二个列表没有固定的坐标, 它们必须要经过计算。除了两种类型选择列表之外, 表单应始终有两个用于偏移值的输入字段。字段的坐标也不是固定的。另一个重点是选择与 w_LockPeriod 参数对应的变量的列表。在所有需要显示宽度控件组中 w_Period 参数输入字段的情况下, 应显示一个额外的下拉列表。

首先, 我们在 UniChannelGUI.mqh 文件中进行一般修改:

1. 枚举文件的路径:

需要由以下替换:

2. 添加一个带有 ELockTo 枚举值的数组:

ELockTo e_lockto[]={LockTo_Off,LockTo_Period1,LockTo_Period2,LockTo_Period3};
  

3. 使用 ENUM_APPLIED_VOLUME 和 ENUM_STO_PRICE 枚举删除数组。

我们现在继续修改 CUniOscControls 类。  

中心线控件类

1. CUniOscControls 类被重新命名为 CUniChannelCentralControls。

2. 变量 m_volume 和 m_sto_price 的声明应从类中删除。相应地, 我们从 SetPointers(), Hide() 和 Events() 方法中删除与这些控件相关联的所有内容。

3. 添加 m_last_y 变量, 其中将记录组中最后一个控件的 Y 坐标。添加一个接收该变量值的方法 — GetLastY()。我们不再需要 FormHeight() 方法, 所以我们删除它。代之, 我们需要添加 ControlsCount() 方法, 返回子类中的控件数量。该数字将用于计算表单的高度。

此处是结果父类:

class CUniChannelCentralControls{
   protected:
      CSpinInputBox * m_value1; // 周期 1
      CSpinInputBox * m_value2; // 周期 2
      CSpinInputBox * m_value3; // 周期 3
      CComBox * m_price;        // 价格
      CComBox * m_method;       // 方法
      int m_last_y;             // 最后控件的 Y 坐标
   public:
  
   // 得到最后控件的 Y 坐标
   int GetLastY(){
      return(m_last_y);
   }
  
   // 传递对象指针至对象的方法
   void SetPointers(CSpinInputBox & value1,
                        CSpinInputBox & value2,      
                        CSpinInputBox & value3,
                        CComBox & price,
                        CComBox & method){
      m_value1=GetPointer(value1);
      m_value2=GetPointer(value2);      
      m_value3=GetPointer(value3);            
      m_price=GetPointer(price);
      m_method=GetPointer(method);
   }
  
   // 隐藏控件群
   void Hide(){
      m_value1.Hide();
      m_value2.Hide();
      m_value3.Hide();
      m_price.Hide();
      m_method.Hide();
   }
  
   // 事件处理
   int Event(int id,long lparam,double dparam,string sparam){
      int e1=m_value1.Event(id,lparam,dparam,sparam);
      int e2=m_value2.Event(id,lparam,dparam,sparam);
      int e3=m_value3.Event(id,lparam,dparam,sparam);
      int e4=m_price.Event(id,lparam,dparam,sparam);
      int e5=m_method.Event(id,lparam,dparam,sparam);
      if(e1!=0 || e2!=0 || e3!=0 || e4!=0 || e5!=0){
         return(1);
      }
      return(0);
   }
  
   // 控件初始化方法 (修改标签) 
   virtual void InitControls(){
   }  
  
   // 显示控件群
   virtual void Show(int x,int y){
   }  
  
   // 得到群内控件数量
   virtual int ControlsCount(){
      return(0);
   }      
        };

我们来修改 CUniOscControls_ATR 子类:

1. 将其名称更改为 CUniChannelCentralControls_AMA, 这将是 AMA 指标的类。

2. 遵照 表 1 的 “参数” 列, 我们在 InitControls() 方法中初始化所有控件, 并在 Show() 方法中调用所有控件的 Show() 方法。最后一个控件的值应分配到 m_last_y 变量。

3. 现在我们删除 FormHeight() 方法, 并添加 ControlsCount() 代之。

此处是结果类:

class CUniChannelCentralControls_AMA:public CUniChannelCentralControls{
   void InitControls(){
      // 控件初始化
      m_value1.Init("c_value1",SPIN_BOX_WIDTH,1," ama_period");
      m_value2.Init("c_value2",SPIN_BOX_WIDTH,1," fast_ma_period");      
      m_value3.Init("c_value3",SPIN_BOX_WIDTH,1," slow_ma_period");      
   }
  
   // 显示 
   void Show(int x,int y){
      m_value1.Show(x,y);
      y+=20;
      m_value2.Show(x,y);
      y+=20;
      m_value3.Show(x,y);
      y+=20;
      m_price.Show(x,y);
      m_last_y=y;
   }
  
   // 得到群内控件数量
   int ControlsCount(){
      return(4);
   }
        };

类似地, 我们为中心线使用的其余指标创建类, 并删除所有不必要的振荡器子类。

宽度计算控件的类

基于 CUniChannelCentralControls 类, 我们创建一个用于管理通道宽度参数的类。制作 CUniChannelCentralControls 类的副本, 并将其名称更改为 CUniChannelWidthControls。在这个类中, 我们需要两个输入字段 (周期和宽度), 平均类型和价格的两个标准枚举, 以及 w_LockPeriod 参数枚举。作为结果, 我们得到如下类:

class CUniChannelWidthControls{
   protected:
      CSpinInputBox * m_value1; // 周期
      CSpinInputBox * m_value2; // 宽度
      CComBox * m_price;        // 价格
      CComBox * m_method;       // 方法
      CComBox * m_lockto;       // 锁定类型
      int m_last_y;             // 最后控件的 Y 坐标 
   public:
  
   // 得到最后控件的 Y 坐标
   int GetLastY(){
      return(m_last_y);
   }
  
   // 传递对象指针至对象的方法
   void SetPointers(CSpinInputBox & value1,
                        CSpinInputBox & value2,      
                        CComBox & price,
                        CComBox & method,
                        CComBox & lockto){
      m_value1=GetPointer(value1);
      m_value2=GetPointer(value2);      
      m_price=GetPointer(price);
      m_method=GetPointer(method);
      m_lockto=GetPointer(lockto);      
   }
  
   // 隐藏控件群
   void Hide(){
      m_value1.Hide();
      m_value2.Hide();
      m_price.Hide();
      m_method.Hide();
   }
  
   // 事件处理
   int Event(int id,long lparam,double dparam,string sparam){
      int e1=m_value1.Event(id,lparam,dparam,sparam);
      int e2=m_value2.Event(id,lparam,dparam,sparam);
      int e4=m_price.Event(id,lparam,dparam,sparam);
      int e5=m_method.Event(id,lparam,dparam,sparam);
      int e6=m_lockto.Event(id,lparam,dparam,sparam);      
      if(e1!=0 || e2!=0 || e4!=0 || e5!=0 || e6){
         return(1);
      }
      return(0);
   }
  
   // 控件初始化方法 (修改标签) 
   virtual void InitControls(){
   }  
  
   // 显示控件群
   virtual void Show(int x,int y){
   }  
  
   // 得到群内控件数量
   virtual int ControlsCount(){
      return(0);
   }    
        };

我们来创建它的子类。与中心线类的主要区别是, 在周期输入字段后, 我们需要为 w_LockPeriod 参数创建一个下拉列表。此处的类使用 ATR 进行宽度计算:

class CUniChannelWidthControls_ATR:public CUniChannelWidthControls{
   void InitControls(){
      // 控件初始化
      m_value1.Init("w_value1",SPIN_BOX_WIDTH,1," period");
   }
  
   // 显示控件群
   void Show(int x,int y){
      m_value1.Show(x,y);
      y+=20;
      m_lockto.Show(x,y);
      m_last_y=y;
   }  
  
   // 得到群内控件数量
   int ControlsCount(){
      return(2);
   }    
        };

通道宽度计算的所有其它变体的类与上述这个类似。 

现在, UniChannelGUI.mqh 文件包含两个基本类的控件, 它们的子类和一个表单类。后者需要进行调整。由于尺寸较大, 使用该文件可能不方便, 因此我们将在其它文件中准备控件类。我们创建 UniChannel/CUniChannelCentralControls.mqh 文件, 并将 CUniChannelCentralControls 类及其所有子类移至此文件。我们还在其内包括其它文件: 

#include <IncGUI_v4.mqh>
    #include <UniChannel/UniChannelDefines.mqh>

常量的定义 FORM_WIDTH, SPIN_BOX_WIDTH, COMBO_BOX_WIDTH 将被移至 UniChannelDefines.mqh 文件中。之后, 可以编译 CUniChannelCentralControls 文件以便检查错误。CUniChannelWidthControls 类也应移至单独的文件里。之后, 利用表单类进行操作会更方便。 

表单类

将两个新创建的文件包含到 UniChannelGUI.mqh 中:

#include <UniChannel/CUniChannelCentralControls.mqh>
    #include <UniChannel/CUniChannelWidthControls.mqh>

将 CUniOscForm 重命名为 CUniChannelForm。在公有部分, 我们删除 CUniOscControls 类型的指针。代之, 我们声明两个指针变量: CUniChannelCentralControls 和 CUniChannelWidthControls, 并确定表单类的其它控件。以下变量将位于公有部分:

CComBox           m_c_cmb_main;  // 中心线选择列表
CSpinInputBox     m_c_value1;    // 周期 1 的输入字段
CSpinInputBox     m_c_value2;    // 周期 2 的输入字段
CSpinInputBox     m_c_value3;    // 周期 3 的输入字段
CComBox           m_c_price;     // 价格选择列表
CComBox           m_c_method;    // 方法选择列表
CSpinInputBox     m_c_shift;     // 平移字段
CComBox           m_w_cmb_main;  // 边界选择列表
CSpinInputBox     m_w_value1;    // 周期输入字段
CSpinInputBox     m_w_value2;    // 宽度输入字段
CComBox           m_w_price;     // 价格选择字段
CComBox           m_w_method;    // 方法选择字段
CComBox           m_w_lockto;    // 锁定选项选择字段     
CSpinInputBox     m_w_shift;     // 平移输入字段          
// 中心线控件的群
CUniChannelCentralControls * m_central_controls;
// 边界控件的群
        CUniChannelWidthControls * m_width_controls;  

在 MainProperties() 方法中, 我们更改 m_Name 和 m_Caption 变量的值, 所有其它变量保持不变:

void MainProperties(){
      m_Name         =  "UniChannelForm";
      m_Width        =  FORM_WIDTH;
      m_Height       =  150;
      m_Type         =  0;
      m_Caption      =  "UniChannel";
      m_Movable      =  true;
      m_Resizable    =  true;
      m_CloseButton  =  true;
        }

在 OnInitEvent() 方法中, 我们使用不变的标签 (对应于所选指标的控件集合) 调用所有控件的 Init() 方法, 并填充下拉列表:

void OnInitEvent(){
   // 不包括在群中的控件初始化
  
   m_c_cmb_main.Init("cb_c_main",COMBO_BOX_WIDTH," 选择中心");
   m_w_cmb_main.Init("cb_w_main",COMBO_BOX_WIDTH," 选择边带");
   m_c_price.Init("c_price",COMBO_BOX_WIDTH," 价格");
   m_c_method.Init("c_method",COMBO_BOX_WIDTH," 方法");
   m_c_shift.Init("c_shift",COMBO_BOX_WIDTH,1," 平移");    
  
   m_w_price.Init("w_price",COMBO_BOX_WIDTH," 价格");
   m_w_method.Init("w_method",COMBO_BOX_WIDTH," 方法");
   m_w_shift.Init("w_shift",COMBO_BOX_WIDTH,1," 平移");    
  
   m_w_lockto.Init("cb_w_lockto",COMBO_BOX_WIDTH," 锁定周期");
   m_w_value2.Init("w_value2",SPIN_BOX_WIDTH,0.001," 宽度");
  
   // 填充下拉列表
  
   for(int i=0;i<ArraySize(e_price);i++){
      m_c_price.AddItem(EnumToString(e_price[i]));
      m_w_price.AddItem(EnumToString(e_price[i]));
   }
   for(int i=0;i<ArraySize(e_method);i++){
      m_c_method.AddItem(EnumToString(e_method[i]));
      m_w_method.AddItem(EnumToString(e_method[i]));
   }            
   for(int i=0;i<ArraySize(e_lockto);i++){
      m_w_lockto.AddItem(EnumToString(e_lockto[i]));            
   }
  
   // 允许使用键盘输入平移值            
   m_c_shift.SetReadOnly(false);
   m_w_shift.SetReadOnly(false);                        
        }  

在OnShowEvent() 方法中, 我们显示控件。在显示元素群之后, 我们获得 Y 坐标, 并根据该坐标显示以下控件:

void OnShowEvent(int aLeft, int aTop){
   m_c_cmb_main.Show(aLeft+10,aTop+10);        // 中心线类型选择列表
   m_central_controls.Show(aLeft+10,aTop+30);  // 中心线参数控件群
   int m_y=m_central_controls.GetLastY();      // 得到最后控件的坐标
   m_c_shift.Show(aLeft+10,m_y+20);            // 平移参数输入字段
   m_w_cmb_main.Show(aLeft+10,m_y+40);         // 通道选择列表
   m_width_controls.Show(aLeft+10,m_y+60);     // 通道参数控件群
   m_y=m_width_controls.GetLastY();            // 得到最后控件的坐标
   m_w_value2.Show(aLeft+10,m_y+20);           // 宽度输入字段
   m_w_shift.Show(aLeft+10,m_y+40);            // 平移参数输入字段
        }

控件可以隐藏在 OnHideEvent() 方法中:

void OnHideEvent(){
   m_c_cmb_main.Hide();       // 中心线类型选择列表     
   m_central_controls.Hide(); // 中心线参数控件群
   m_c_shift.Hide();          // 平移参数输入字段
   m_w_cmb_main.Hide();       // 通道选择字段
   m_width_controls.Hide();   // 通道参数控件群
   m_w_shift.Hide();          // 平移参数输入字段
   m_w_lockto.Hide();         // 周期锁定类型选择
   m_width_controls.Hide();   // 宽度输入字段
    }

在 SetValues() 方法中进行更改。更改方法参数集合, 为方法中的所有控件设置对应于这些参数的值:

void SetValues(int c_value1,
               int c_value2,
               int c_value3,
               long c_method,
               long c_price,
               long c_shift,                    
               int w_value1,
               int w_value2,
               long w_method,
               long w_price,
               long w_lockto,
               long w_shift  
){
   // 中心线输入字段
   m_c_value1.SetValue(c_value1);
   m_c_value2.SetValue(c_value2);      
   m_c_value3.SetValue(c_value3);
   m_c_shift.SetValue(c_shift);        
   // 通道参数输入字段
   m_w_value1.SetValue(w_value1);
   m_w_value2.SetValue(w_value2);        
   m_w_shift.SetValue(w_shift);            
  
   // 显示在平滑方法选择列表中所选的类型
   for(int i=0;i<ArraySize(e_method);i++){
      if(c_method==e_method[i]){
         m_c_method.SetSelectedIndex(i);
      }
      if(w_method==e_method[i]){
         m_w_method.SetSelectedIndex(i);
      }            
   }
  
   // 显示在价格类型选择列表中所选的类型
   for(int i=0;i<ArraySize(e_price);i++){
      if(c_price==e_price[i]){
         m_c_price.SetSelectedIndex(i);
      }
      if(w_price==e_price[i]){
         m_w_price.SetSelectedIndex(i);
      }            
   }
   // 显示所选的通道周期锁定类型
   for(int i=0;i<ArraySize(e_lockto);i++){
      if(w_lockto==e_lockto[i]){
         m_w_lockto.SetSelectedIndex(i);
         break;
      }
   }                    
        }  

替代 SetType(), 我们创建两个方法: SetCentralType() 用于设置中心线类型, SetWidthType() 用于设置边框类型。在每个方法结尾处, 一旦对象创建, 属性将设置为控件, 允许使用键盘输入数值。我们还设置最小允许值, 并调用表单高度计算的私有方法:  

方法 SetCentralType():

void SetCentralType(long type){
   // 如果一个对象已经被创建, 我们需要删除它
   if(CheckPointer(m_central_controls)==POINTER_DYNAMIC){
      delete(m_central_controls);
      m_central_controls=NULL;
   }
   switch((ECType)type){ // 根据所选的类创建一个对象
      case UniCh_C_AMA:
         m_central_controls=new CUniChannelCentralControls_AMA();
      break;
      case UniCh_C_DEMA:
         m_central_controls=new CUniChannelCentralControls_DEMA();            
      break;
      case UniCh_C_FrAMA:
         m_central_controls=new CUniChannelCentralControls_FrAMA();            
      break;
      case UniCh_C_MA:
         m_central_controls=new CUniChannelCentralControls_MA();            
      break;
      case UniCh_C_TEMA:
         m_central_controls=new CUniChannelCentralControls_TEMA();            
      break;
      case UniCh_C_VIDyA:
         m_central_controls=new CUniChannelCentralControls_VIDyA();            
      break;
      case UniCh_C_PrCh:
         m_central_controls=new CUniChannelCentralControls_PrCh();            
      break;
   }    
  
   // 将指针传递给控件对象
   m_central_controls.SetPointers(m_c_value1,m_c_value2,m_c_value3,m_c_price,m_c_method);
   // 控件群的初始化
   m_central_controls.InitControls();
  
   // 允许从键盘输入数值
   m_c_value1.SetReadOnly(false);
   m_c_value2.SetReadOnly(false);
   m_c_value3.SetReadOnly(false);
  
   // 设置最小允许值
   m_c_value1.SetMinValue(1);        
   m_c_value2.SetMinValue(1);
   m_c_value3.SetMinValue(1);            
  
   // 计算表单的高度
   this.SolveHeight();
        }

 方法 SetWidthType():

void SetWidthType(long type){
   // 如果一个对象已经被创建, 我们需要删除它
   if(CheckPointer(m_width_controls)==POINTER_DYNAMIC){
      delete(m_width_controls);
      m_width_controls=NULL;
   }
   switch((EWType)type){ // 根据所选的类创建一个对象
      case UniCh_W_ATR:
         m_width_controls=new CUniChannelWidthControls_ATR();
      break;
      case UniCh_W_StdDev:
         m_width_controls=new CUniChannelWidthControls_StdDev();            
      break;
      case UniCh_W_Points:
         m_width_controls=new CUniChannelWidthControls_InPoints();            
      break;
      case UniCh_W_Percents:
         m_width_controls=new CUniChannelWidthControls_Envelopes();            
      break;
      case UniCh_W_PrCh:
         m_width_controls=new CUniChannelWidthControls_PrCh();                        
      break;
   }    
   // 将指针传递给控件对象
   m_width_controls.SetPointers(m_w_value1,m_w_value2,m_w_price,m_w_method);
   // 控件群初始化
   m_width_controls.InitControls();
  
   // 设置最小允许值
   m_w_value1.SetReadOnly(false);
   m_w_value2.SetReadOnly(false);
  
   // 设置最小允许值
   m_w_value1.SetMinValue(1);        
   m_w_value2.SetMinValue(0);
  
   // 计算表单的高度
   this.SolveHeight();
              
        }  

在 SetCentralType() 和 SetWidthType() 方法的末尾, 调用计算表单高度的 SolveHeight() 方法:

void SolveHeight(){
   // 如果两个对象均存在 (中心线和宽度)
   if(CheckPointer(m_central_controls)==POINTER_DYNAMIC && CheckPointer(m_width_controls)==POINTER_DYNAMIC){
      m_Height=(m_width_controls.ControlsCount()+m_central_controls.ControlsCount()+6)*20+10;
   }      
        }  

我们接着去连接指标和用户图形界面。  

尽管通用振荡器使用了大量的现成代码, 但通用通道的创建仍然需要大量额外的工作。与通用振荡器的主要区别是存在两个独立的单元: 中心线和通道边界。这一困难使工作量增加了近两倍。通用通道包括更复杂的参数变化算法, 而这些是与周期锁定函数相连的。新指标的加载也变得更加复杂, 因为现在使用了两个指标。我们还增加了新的功能 — 在切换时间帧时保存参数。作为结果, 我们创造了一个有益且便利的指标。另外, 这个指标显著地扩展了通道思路的功能, 因为现在您可以单独选择中心线以及构建通道边界的方法。这就提供了大范围的可能组合。通过使用图形界面增加指标应用的速度, 可直观地分析所有这些组合。

附件