![Trabajando con las series temporales en la biblioteca DoEasy (Parte 42): La clase del objeto de búfer de indicador abstracto](https://c.mql5.com/i/articles/overlay.png)
Trabajando con las series temporales en la biblioteca DoEasy (Parte 42): La clase del objeto de búfer de indicador abstracto
Contenido
- Concepto
- La clase de búfer abstracto CBuffer
- Comprobando la creación de los objetos de búfer en el indicador
- ¿Qué es lo próximo?
Concepto
En el artículo anterior, creamos un ejemplo de indicador que usa en su construcción los objetos de las series temporales de la biblioteca DoEasy. Para guardar los datos de los búferes y obtener acceso a ellos, hemos creado una estructura de búfer que incluye todos los datos necesarios para identificar correctamente la pertenencia de un búfer al símbolo y al periodo del gráfico, así como los datos para construir y dibujar las líneas del indicador en forma de velas japonesas. No obstante, resulta incómodo y poco práctico crear para cara indicador estructuras cuyos campos se correspondan con el tipo necesario de dibujado de líneas. Es mucho más cómodo tener entre nuestras herramientas de trabajo una clase objeto de búfer de indicador que permita crear fácilmente cualquier tipo de búfer de acuerdo con el estilo y el método de dibujado.
En este artículo, comenzaremos a crear dicho instrumental.
La estructura de los objetos constará de una clase básica de búfer de indicador, llamada "objeto de búfer abstracto", que contendrá todas las propiedades generales propias de los búferes de indicador, independientemente del tipo de dibujado. Y ya partiendo de este búfer abstracto, se heredarán las clases de los objetos de búfer, en las que habrá información detallada sobre un tipo concreto de búfer. Estas clases herederas definirán con exactitud el tipo de dibujado, y tendrán propiedades individuales propias solo de este tipo de búfer de indicador.
Hoy, escribiremos la clase del objeto de búfer de indicador abstracto. El objeto contendrá todas las propiedades del búfer de indicador de las enumeraciones ENUM_PLOT_PROPERTY_INTEGER, ENUM_PLOT_PROPERTY_DOUBLE, ENUM_PLOT_PROPERTY_STRINGy varias propiedades adicionales:
- para indicar el tipo de búfer:
- el bufer de datos,
- el bufer de cálculo;
- el estado del búfer (determina el tipo de dibujado de las líneas de indicador)
Según el estado del búfer, se dividirán los objetos herederos: para cada estado, se creará su propia clase heredera de la clase de búfer abstracto; - símbolo de trabajo del búfer:
- actual,
- rigurosamente establecido;
- marco temporal del búfer:
- actual,
- rigurosamente establecido;
- Número ordinal del búfer de dibujado: es el número de los búferes representados en la ventana de datos DataWindow del terminal (estos números no coinciden con los índices de las matrices double asignadas al búfer);
- Bandera de uso del búfer: en el indicador, podremos activar/desactivar la representación de líneas del búfer y los valores en la ventana DataWindow estableciendo/quitando la bandera;
- Índice del búfer básico de datos: información auxiliar sobre el índice de la primera matriz de todas las matrices utilizadas para dibujar las líneas del búfer;
- Número de búferes de datos: información de servicio sobre el número real de matrices utilizadas para dibujar las construcciones gráficas del búfer. Es necesaria para calcular el índice del búfer de color y el índice de la próxima matriz a la que se puede asignar este índice como búfer básico de datos;
- Índice del búfer de color: información de servicio sobre el índice de la matriz utilizada como búfer de color;
- Índice de la matriz libre para designar el siguiente búfer de indicador: información auxiliar sobre el índice calculado del búfer básico de datos para el siguiente objeto de búfer.
Finalmente, tras crear todas las clases necesarias para trabajar con los búferes de los indicadores, tendremos la posibilidad de simplemente "decir" a nuestro programa: "crea un búfer de tal tipo", y la biblioteca creará por sí misma este búfer y cualquier búfer siguiente, sin necesidad de declarar matrices, designar propiedades para las mismas y conectarlas con los búferes de indicador. Simplemente obtendremos una lista de búferes desde la que recurriremos a cualquier búfer de indicador creado anteriormente, así como a los datos del mismo.
Dado que en MQL5 existe la posibilidad de crear dos tipos de estilos de dibujado iguales: de color único y a color, todos los búferes creados por la biblioteca serán a color. Si tenemos que crear una línea monocroma, simplemente estableceremos un color para todos los datos representados por el búfer.
Al utilizar colores diferentes para colorear las barras, se usará el número de colores establecido para representar las líneas en cada barra.
La clase de búfer abstracto CBuffer
Para que la clase funcione, necesitaremos mensajes de texto con las descripciones de las propiedades del búfer.
Abrimos el archivo \MQL5\Include\DoEasy\Datas.mqh y le añadimos los índices de los nuevos mensajes:
MSG_LIB_TEXT_WAIT, // Wait MSG_LIB_TEXT_END, // End MSG_LIB_TEXT_PERIOD_CURRENT, // Current chart period
...
MSG_LIB_TEXT_TS_TEXT_ATTEMPT, // Attempt: MSG_LIB_TEXT_TS_TEXT_WAIT_FOR_SYNC, // Waiting for data synchronization ... //--- CBuffer MSG_LIB_TEXT_BUFFER_TEXT_INDEX_BASE, // Base data buffer index MSG_LIB_TEXT_BUFFER_TEXT_INDEX_PLOT, // Plotted buffer serial number MSG_LIB_TEXT_BUFFER_TEXT_INDEX_COLOR, // Color buffer index MSG_LIB_TEXT_BUFFER_TEXT_NUM_DATAS, // Number of data buffers MSG_LIB_TEXT_BUFFER_TEXT_INDEX_NEXT, // Index of the free array to be assigned as the next indicator buffer MSG_LIB_TEXT_BUFFER_TEXT_TIMEFRAME, // Buffer (timeframe) data period MSG_LIB_TEXT_BUFFER_TEXT_STATUS, // Buffer status MSG_LIB_TEXT_BUFFER_TEXT_TYPE, // Buffer type MSG_LIB_TEXT_BUFFER_TEXT_ACTIVE, // Active MSG_LIB_TEXT_BUFFER_TEXT_ARROW_CODE, // Arrow code MSG_LIB_TEXT_BUFFER_TEXT_ARROW_SHIFT, // The vertical shift of the arrows MSG_LIB_TEXT_BUFFER_TEXT_DRAW_BEGIN, // The number of initial bars that are not drawn and values in DataWindow MSG_LIB_TEXT_BUFFER_TEXT_DRAW_TYPE, // Graphical construction type MSG_LIB_TEXT_BUFFER_TEXT_SHOW_DATA, // Display construction values in DataWindow MSG_LIB_TEXT_BUFFER_TEXT_SHIFT, // Indicator graphical construction shift by time axis in bars MSG_LIB_TEXT_BUFFER_TEXT_LINE_STYLE, // Line style MSG_LIB_TEXT_BUFFER_TEXT_LINE_WIDTH, // Line width MSG_LIB_TEXT_BUFFER_TEXT_COLOR_NUM, // Number of colors MSG_LIB_TEXT_BUFFER_TEXT_COLOR, // Drawing color MSG_LIB_TEXT_BUFFER_TEXT_EMPTY_VALUE, // Empty value for plotting where nothing will be drawn MSG_LIB_TEXT_BUFFER_TEXT_SYMBOL, // Buffer symbol MSG_LIB_TEXT_BUFFER_TEXT_LABEL, // Name of the graphical indicator series displayed in DataWindow MSG_LIB_TEXT_BUFFER_TEXT_STATUS_NAME, // Indicator buffer with graphical construction type MSG_LIB_TEXT_BUFFER_TEXT_STATUS_NONE, // No drawing MSG_LIB_TEXT_BUFFER_TEXT_STATUS_FILLING, // Color filling between two levels MSG_LIB_TEXT_BUFFER_TEXT_STATUS_LINE, // Line MSG_LIB_TEXT_BUFFER_TEXT_STATUS_HISTOGRAM, // Histogram from the zero line MSG_LIB_TEXT_BUFFER_TEXT_STATUS_ARROW, // Drawing with arrows MSG_LIB_TEXT_BUFFER_TEXT_STATUS_SECTION, // Section MSG_LIB_TEXT_BUFFER_TEXT_STATUS_HISTOGRAM2, // Histogram on two indicator buffers MSG_LIB_TEXT_BUFFER_TEXT_STATUS_ZIGZAG, // Zigzag MSG_LIB_TEXT_BUFFER_TEXT_STATUS_BARS, // Display as bars MSG_LIB_TEXT_BUFFER_TEXT_STATUS_CANDLES, // Display as candles MSG_LIB_TEXT_BUFFER_TEXT_TYPE_CALCULATE, // Calculated buffer MSG_LIB_TEXT_BUFFER_TEXT_TYPE_DATA, // Colored data buffer MSG_LIB_TEXT_BUFFER_TEXT_STYLE_SOLID, // Solid line MSG_LIB_TEXT_BUFFER_TEXT_STYLE_DASH, // Dashed line MSG_LIB_TEXT_BUFFER_TEXT_STYLE_DOT, // Dotted line MSG_LIB_TEXT_BUFFER_TEXT_STYLE_DASHDOT, // Dot-dash line MSG_LIB_TEXT_BUFFER_TEXT_STYLE_DASHDOTDOT, // Dash - two dots }; //+------------------------------------------------------------------+
y los textos de los mensajes que se corresponden con los índices recién creados:
{"Ожидание","Wait"}, {"Окончание","End"}, {"Текущий период графика","Current chart period"},
...
{"Попытка: ","Attempt: "}, {"Ожидание синхронизации данных ...","Waiting for data synchronization ..."}, {"Индекс базового буфера данных","Index of Base data buffer"}, {"Порядковый номер рисуемого буфера","Plot buffer sequence number"}, {"Индекс буфера цвета","Color buffer index"}, {"Количество буферов данных","Number of data buffers"}, {"Индекс массива для назначения следующим индикаторным буфером","Array index for assignment as the next indicator buffer"}, {"Период данных буфера (таймфрейм)","Buffer data Period (Timeframe)"}, {"Статус буфера","Buffer status"}, {"Тип буфера","Buffer type"}, {"Активен","Active"}, {"Код стрелки","Arrow code"}, {"Смещение стрелок по вертикали","Vertical shift of arrows"}, {"Количество начальных баров без отрисовки и значений в DataWindow","Number of initial bars without drawing and values in the DataWindow"}, {"Тип графического построения","Type of graphical construction"}, {"Отображение значений построения в окне DataWindow","Display construction values in the DataWindow"}, {"Сдвиг графического построения индикатора по оси времени в барах","Shift of indicator plotting along the time axis in bars"}, {"Стиль линии отрисовки","Drawing line style "}, {"Толщина линии отрисовки","The thickness of the drawing line"}, {"Количество цветов","The number of colors"}, {"Цвет отрисовки","The index of a buffer containing the drawing color"}, {"Пустое значение для построения, для которого нет отрисовки","An empty value for plotting, for which there is no drawing"}, {"Символ буфера","Buffer Symbol"}, {"Имя индикаторной графической серии, отображаемое в окне DataWindow","The name of the indicator graphical series to display in the DataWindow"}, {"Индикаторный буфер с типом графического построения","Indicator buffer with graphic plot type"}, {"Нет отрисовки","No drawing"}, {"Цветовая заливка между двумя уровнями","Color fill between the two levels"}, {"Линия","Line"}, {"Гистограмма от нулевой линии","Histogram from the zero line"}, {"Отрисовка стрелками","Drawing arrows"}, {"Отрезки","Section"}, {"Гистограмма на двух индикаторных буферах","Histogram of the two indicator buffers"}, {"Зигзаг","Zigzag"}, {"Отображение в виде баров","Display as a sequence of bars"}, {"Отображение в виде свечей","Display as a sequence of candlesticks"}, {"Расчётный буфер","Calculated buffer"}, {"Цветной буфер данных","Colored Data buffer"}, {"Сплошная линия","Solid line"}, {"Прерывистая линия","Broken line"}, {"Пунктирная линия","Dotted line"}, {"Штрих-пунктирная линия","Dash-dot line"}, {"Штрих - две точки","Dash - two points"}, }; //+---------------------------------------------------------------------+
Cuando creamos algún objeto para la biblioteca y después guardamos este en la colección de objetos que le pertenece, a cada objeto se le asigna el identificador de la colección en la que se encuentra. Lo mismo haremos con los objetos de búfer: creamos el identificador de la colección de búferes de indicador, y asignamos este al objeto de búfer abstracto. Por consiguiente, cada objeto heredero de la clase de búfer abstracto tendrá un identificador que indique su pertenencia a la colección de búferes.
Para crear un objeto de búfer abstracto, necesitamos definir y describir todas sus propiedades. Según estas propiedades, siempre podremos encontrar el objeto de búfer necesario en la colección de búferes para trabajar posteriormente con ellos.
Abrimos el archivo \MQL5\Include\DoEasy\Defines.mqh y le añadimos el identificador de la colección de los búferes de indicador:
//--- Collection list IDs #define COLLECTION_HISTORY_ID (0x777A) // Historical collection list ID #define COLLECTION_MARKET_ID (0x777B) // Market collection list ID #define COLLECTION_EVENTS_ID (0x777C) // Event collection list ID #define COLLECTION_ACCOUNT_ID (0x777D) // Account collection list ID #define COLLECTION_SYMBOLS_ID (0x777E) // Symbol collection list ID #define COLLECTION_SERIES_ID (0x777F) // Timeseries collection list ID #define COLLECTION_BUFFERS_ID (0x7780) // Indicator buffer collection list ID //--- Data parameters for file operations
Al final del archivo añadimos las enumeraciones con el estado del objeto de búfery su tipo, definimos las propiedades de tipo entero, real y string del objeto, y también añadimos los posibles criterios de clasificación de los objetos de búfer en su lista de colección:
//+------------------------------------------------------------------+ //| Data for working with indicator buffers | //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //| Abstract buffer status (by drawing style) | //+------------------------------------------------------------------+ enum ENUM_BUFFER_STATUS { BUFFER_STATUS_NONE, // No drawing BUFFER_STATUS_FILLING, // Color filling between two levels (MQL5) BUFFER_STATUS_LINE, // Line BUFFER_STATUS_HISTOGRAM, // Histogram from the zero line BUFFER_STATUS_ARROW, // Drawing with arrows BUFFER_STATUS_SECTION, // Section BUFFER_STATUS_HISTOGRAM2, // Histogram on two indicator buffers BUFFER_STATUS_ZIGZAG, // Zigzag style BUFFER_STATUS_BARS, // Display as bars (MQL5) BUFFER_STATUS_CANDLES, // Display as candles (MQL5) }; //+------------------------------------------------------------------+ //| Buffer type | //+------------------------------------------------------------------+ enum ENUM_BUFFER_TYPE { BUFFER_TYPE_CALCULATE, // Calculated buffer BUFFER_TYPE_DATA, // Colored data buffer }; //+------------------------------------------------------------------+ //| Buffer integer properties | //+------------------------------------------------------------------+ enum ENUM_BUFFER_PROP_INTEGER { BUFFER_PROP_INDEX_PLOT = 0, // Plotted buffer serial number BUFFER_PROP_STATUS, // Buffer status (by drawing style) from the ENUM_BUFFER_STATUS enumeration BUFFER_PROP_TYPE, // Buffer type (from the ENUM_BUFFER_TYPE enumeration) BUFFER_PROP_TIMEFRAME, // Buffer period data (timeframe) BUFFER_PROP_ACTIVE, // Buffer usage flag BUFFER_PROP_ARROW_CODE, // Arrow code for DRAW_ARROW style BUFFER_PROP_ARROW_SHIFT, // The vertical shift of the arrows for DRAW_ARROW style BUFFER_PROP_DRAW_BEGIN, // The number of initial bars that are not drawn and values in DataWindow BUFFER_PROP_SHOW_DATA, // Flag of displaying construction values in DataWindow BUFFER_PROP_DRAW_TYPE, // Graphical construction type (from the ENUM_DRAW_TYPE enumeration) BUFFER_PROP_SHIFT, // Indicator graphical construction shift by time axis in bars BUFFER_PROP_LINE_STYLE, // Line style BUFFER_PROP_LINE_WIDTH, // Line width BUFFER_PROP_COLOR_INDEXES, // Number of colors BUFFER_PROP_COLOR, // Drawing color BUFFER_PROP_NUM_DATAS, // Number of data buffers BUFFER_PROP_INDEX_BASE, // Base data buffer index BUFFER_PROP_INDEX_COLOR, // Color buffer index BUFFER_PROP_INDEX_NEXT, // Index of the free array to be assigned as the next indicator buffer }; #define BUFFER_PROP_INTEGER_TOTAL (19) // Total number of integer bar properties #define BUFFER_PROP_INTEGER_SKIP (6) // Number of buffer properties not used in sorting //+------------------------------------------------------------------+ //| Buffer real properties | //+------------------------------------------------------------------+ enum ENUM_BUFFER_PROP_DOUBLE { BUFFER_PROP_EMPTY_VALUE = BUFFER_PROP_INTEGER_TOTAL, // Empty value for plotting where nothing will be drawn }; #define BUFFER_PROP_DOUBLE_TOTAL (1) // Total number of real buffer properties #define BUFFER_PROP_DOUBLE_SKIP (0) // Number of buffer properties not used in sorting //+------------------------------------------------------------------+ //| Buffer string properties | //+------------------------------------------------------------------+ enum ENUM_BUFFER_PROP_STRING { BUFFER_PROP_SYMBOL = (BUFFER_PROP_INTEGER_TOTAL+BUFFER_PROP_DOUBLE_TOTAL), // Buffer symbol BUFFER_PROP_LABEL, // Name of the graphical indicator series displayed in DataWindow }; #define BUFFER_PROP_STRING_TOTAL (2) // Total number of string buffer properties //+------------------------------------------------------------------+ //| Possible buffer sorting criteria | //+------------------------------------------------------------------+ #define FIRST_BUFFER_DBL_PROP (BUFFER_PROP_INTEGER_TOTAL-BUFFER_PROP_INTEGER_SKIP) #define FIRST_BUFFER_STR_PROP (BUFFER_PROP_INTEGER_TOTAL-BUFFER_PROP_INTEGER_SKIP+BUFFER_PROP_DOUBLE_TOTAL-BUFFER_PROP_DOUBLE_SKIP) enum ENUM_SORT_BUFFER_MODE { //--- Sort by integer properties SORT_BY_BUFFER_INDEX_PLOT = 0, // Sort by the plotted buffer serial number SORT_BY_BUFFER_STATUS, // Sort by buffer drawing style (status) from the ENUM_BUFFER_STATUS enumeration SORT_BY_BUFFER_TYPE, // Sort by buffer type (from the ENUM_BUFFER_TYPE enumeration) SORT_BY_BUFFER_TIMEFRAME, // Sort by the buffer data period (timeframe) SORT_BY_BUFFER_ACTIVE, // Sort by the buffer usage flag SORT_BY_BUFFER_ARROW_CODE, // Sort by the arrow code for DRAW_ARROW style SORT_BY_BUFFER_ARROW_SHIFT, // Sort by the vertical shift of the arrows for DRAW_ARROW style SORT_BY_BUFFER_DRAW_BEGIN, // Sort by the number of initial bars that are not drawn and values in DataWindow SORT_BY_BUFFER_SHOW_DATA, // Sort by the flag of displaying construction values in DataWindow SORT_BY_BUFFER_DRAW_TYPE, // Sort by graphical construction type (from the ENUM_DRAW_TYPE enumeration) SORT_BY_BUFFER_SHIFT, // Sort by the indicator graphical construction shift by time axis in bars SORT_BY_BUFFER_LINE_STYLE, // Sort by the line style SORT_BY_BUFFER_LINE_WIDTH, // Sort by the line width SORT_BY_BUFFER_COLOR_INDEXES, // Sort by a number of attempts SORT_BY_BUFFER_COLOR, // Sort by the drawing color //--- Sort by real properties SORT_BY_BUFFER_EMPTY_VALUE = FIRST_BUFFER_DBL_PROP, // Sort by the empty value for plotting where nothing will be drawn //--- Sort by string properties SORT_BY_BUFFER_SYMBOL = FIRST_BUFFER_STR_PROP, // Sort by the buffer symbol SORT_BY_BUFFER_LABEL, // Sort by the name of the graphical indicator series displayed in DataWindow }; //+------------------------------------------------------------------+
Todas esta propiedades, así como su definición, designación y uso, son estándar para la biblioteca: ya las hemos visto más de una vez, por lo que no analizaremos de nuevo aquí la misión de cada enumeración y macrosustitución. Esperamos que el lector lleve ya tiempo familiarizado con su cometido y no requiera aclaraciones adicionales. No obstante, si el lector tiene cualquier duda al respecto, podrá formularla en los comentarios al artículo; la resolveremos con mucho gusto.
Bien, ya hemos preparado todos los datos necesarios. Es el momento ideal para comenzar a crear la clase del objeto de búfer abstracto.
Creamos en el directorio de la biblioteca \MQL5\Include\DoEasy\Objects\ la nueva carpeta Indicators\, y en ella, el nuevo archivo Buffer.mqh de la clase CBuffer.
Como clase básica para la clase del objeto de búfer abstracto, estableceremos la clase del objeto básico de todos los objetos de la biblioteca CBaseObj,
cuyo archivo incluiremos en el archivo de la clase del búfer:
//+------------------------------------------------------------------+ //| Buffer.mqh | //| Copyright 2020, MetaQuotes Software Corp. | //| https://mql5.com/es/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2020, MetaQuotes Software Corp." #property link "https://mql5.com/es/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Archivos de inclusión | //+------------------------------------------------------------------+ #include "..\..\Objects\BaseObj.mqh" //+------------------------------------------------------------------+ //| Abstract indicator buffer class | //+------------------------------------------------------------------+ class CBuffer : public CBaseObj {
El conjunto de métodos principales de los objetos de la biblioteca es estándar para cada objeto, y permite trabajar con las propiedades de cada objeto de la misma forma para cada uno de ellos. Ya analizamos los principios de construcción del objeto cuando comenzamos a describir la biblioteca.
Aquí, todo es también bastante estándar: tres matrices con las propiedades del objeto (enteras, reales y string), los métodos de retorno de los índices reales de las propiedades reales y string y los métodos de establecimiento y obtención, así como la muestra de la descripción de la propiedadad indicada de estas matrices. Tres métodos virtuales, dos métodos de comparaciónpara realizar búsquedas y clasificaciones en la colección según la propiedad establecida, y también para comprobar si dos objetos son iguales. Dos constructores, uno por defecto y otro paramétrico cerrado; y dos métodos para mostrar en el diario todas las propiedades del objeto de búfer y su descripción breve:
//+------------------------------------------------------------------+ //| Abstract indicator buffer class | //+------------------------------------------------------------------+ class CBuffer : public CBaseObj { private: long m_long_prop[BUFFER_PROP_INTEGER_TOTAL]; // Integer properties double m_double_prop[BUFFER_PROP_DOUBLE_TOTAL]; // Real properties string m_string_prop[BUFFER_PROP_STRING_TOTAL]; // String properties //--- Return the index of the array the buffer's (1) double and (2) string properties are located at int IndexProp(ENUM_BUFFER_PROP_DOUBLE property) const { return(int)property-BUFFER_PROP_INTEGER_TOTAL; } int IndexProp(ENUM_BUFFER_PROP_STRING property) const { return(int)property-BUFFER_PROP_INTEGER_TOTAL-BUFFER_PROP_DOUBLE_TOTAL; } //--- Set the graphical construction type void SetDrawType(void); public: //--- Array of the (1) drawn indicator buffer and (2) color buffer double DataArray[]; double ColorArray[]; //--- Set buffer's (1) integer, (2) real and (3) string properties void SetProperty(ENUM_BUFFER_PROP_INTEGER property,long value) { this.m_long_prop[property]=value; } void SetProperty(ENUM_BUFFER_PROP_DOUBLE property,double value) { this.m_double_prop[this.IndexProp(property)]=value; } void SetProperty(ENUM_BUFFER_PROP_STRING property,string value) { this.m_string_prop[this.IndexProp(property)]=value; } //--- Return (1) integer, (2) real and (3) string buffer properties from the properties array long GetProperty(ENUM_BUFFER_PROP_INTEGER property) const { return this.m_long_prop[property]; } double GetProperty(ENUM_BUFFER_PROP_DOUBLE property) const { return this.m_double_prop[this.IndexProp(property)]; } string GetProperty(ENUM_BUFFER_PROP_STRING property) const { return this.m_string_prop[this.IndexProp(property)]; } //--- Get description of buffer's (1) integer, (2) real and (3) string properties string GetPropertyDescription(ENUM_BUFFER_PROP_INTEGER property); string GetPropertyDescription(ENUM_BUFFER_PROP_DOUBLE property); string GetPropertyDescription(ENUM_BUFFER_PROP_STRING property); //--- Return the flag of the buffer supporting the property virtual bool SupportProperty(ENUM_BUFFER_PROP_INTEGER property) { return true; } virtual bool SupportProperty(ENUM_BUFFER_PROP_DOUBLE property) { return true; } virtual bool SupportProperty(ENUM_BUFFER_PROP_STRING property) { return true; } //--- Compare CBuffer objects by all possible properties (for sorting the lists by a specified buffer object property) virtual int Compare(const CObject *node,const int mode=0) const; //--- Compare CBuffer objects by all properties (to search for equal buffer objects) bool IsEqual(CBuffer* compared_obj) const; //--- Constructor por defecto CBuffer(void){;} //protected: //--- Constructor paramétrico protegido CBuffer(ENUM_BUFFER_STATUS status_buffer,ENUM_BUFFER_TYPE buffer_type,const uint index_plot,const uint index_base_array); public: //--- Send description of buffer properties to the journal (full_prop=true - all properties, false - only supported ones) void Print(const bool full_prop=false); //--- Display a short buffer description in the journal (implementation in the descendants) virtual void PrintShort(void) {;}
Aquí, destacamos con color los datos y métodos estándar para todos los objetos de la biblioteca.
El constructor paramétrico protegido debe estar en la sección protegida de la clase, pero hoy, para comprobar el funcionamiento del objeto creado, el constructor será público.
Por eso, aquí el especificador de acceso protected: está comentado.
Ha quedado sin comentar el método privado para establecer el tipo de la construcción gráfica del búfer, dos matrices públicas a vincular como matriz de datos y la matriz de color del búfer de indicador:
//--- Set the graphical construction type void SetDrawType(void); public: //--- Array of the (1) drawn indicator buffer and (2) color buffer double DataArray[]; double ColorArray[];
Dependiendo del estado del búfer (a su estado se "vincularán" los objetos herederos), determinaremos el tipo de construcción gráfica del búfer.
Si miramos atentamente las constantes de enumeración del estado del búfer
//+------------------------------------------------------------------+ //| Abstract buffer status (by drawing style) | //+------------------------------------------------------------------+ enum ENUM_BUFFER_STATUS { BUFFER_STATUS_NONE, // No drawing BUFFER_STATUS_FILLING, // Color filling between two levels (MQL5) BUFFER_STATUS_LINE, // Line BUFFER_STATUS_HISTOGRAM, // Histogram from the zero line BUFFER_STATUS_ARROW, // Drawing with arrows BUFFER_STATUS_SECTION, // Section BUFFER_STATUS_HISTOGRAM2, // Histogram on two indicator buffers BUFFER_STATUS_ZIGZAG, // Zigzag style BUFFER_STATUS_BARS, // Display as bars (MQL5) BUFFER_STATUS_CANDLES, // Display as candles (MQL5) }; //+------------------------------------------------------------------+
y comparamos el orden secuencial de las constantes con el orden secuencial de las constantes homónimas (casi) en la enumeración ENUM_DRAW_TYPE con la ayuda de un ciclo sencillo por el número de constantes en la enumeración;
for(int i=0;i<18;i++) Print(EnumToString((ENUM_DRAW_TYPE)i)," = ",i); 2020.04.15 12:51:53.725 DRAW_NONE = 0 2020.04.15 12:51:53.725 DRAW_LINE = 1 2020.04.15 12:51:53.725 DRAW_HISTOGRAM = 2 2020.04.15 12:51:53.725 DRAW_ARROW = 3 2020.04.15 12:51:53.725 DRAW_SECTION = 4 2020.04.15 12:51:53.725 DRAW_HISTOGRAM2 = 5 2020.04.15 12:51:53.725 DRAW_ZIGZAG = 6 2020.04.15 12:51:53.725 DRAW_FILLING = 7 2020.04.15 12:51:53.725 DRAW_BARS = 8 2020.04.15 12:51:53.725 DRAW_CANDLES = 9 2020.04.15 12:51:53.725 DRAW_COLOR_LINE = 10 2020.04.15 12:51:53.725 DRAW_COLOR_HISTOGRAM = 11 2020.04.15 12:51:53.725 DRAW_COLOR_ARROW = 12 2020.04.15 12:51:53.725 DRAW_COLOR_SECTION = 13 2020.04.15 12:51:53.725 DRAW_COLOR_HISTOGRAM2 = 14 2020.04.15 12:51:53.725 DRAW_COLOR_ZIGZAG = 15 2020.04.15 12:51:53.725 DRAW_COLOR_BARS = 16 2020.04.15 12:51:53.725 DRAW_COLOR_CANDLES = 17
veremos que coincide el orden secuencial según el tipo de construcción gráfica.
La única diferencia es que en la enumeración de los estilos de dibujado, existen las constantes para los búferes monocromos y de color, y hay un estilo que no necesita búfer de color (relleno de color entre dos niveles).
Todos nuestros búferes serán de color. Por eso, para establecer el estilo de dibujado, comprobamos el estado del búfer y el tipo de dibujado transmitidos al método SetDrawType(), y, dependiendo de ellos, o bien establecemos la ausencia de dibujado, o bien el rellenado a color del espacio entre dos niveles, o bien desplazamos el índice de la enumeración del estado en 8 unidades, de forma que el valor de la constante se corresponda con el valor del búfer de color de la enumeración de estilos de dibujado.
Fuera del cuerpo de la clase, implementamos este método:
//+------------------------------------------------------------------+ //| Set the graphical construction type | //+------------------------------------------------------------------+ void CBuffer::SetDrawType(void) { ENUM_DRAW_TYPE type=(!this.TypeBuffer() || !this.Status() ? DRAW_NONE : this.Status()==BUFFER_STATUS_FILLING ? DRAW_FILLING : ENUM_DRAW_TYPE(this.Status()+8)); this.SetProperty(BUFFER_PROP_DRAW_TYPE,type); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_DRAW_TYPE,type); } //+------------------------------------------------------------------+
Si el tipo de búfer es BUFFER_TYPE_CALCULATE (valor 0) o el estado del búfer es BUFFER_STATUS_NONE (valor 0), el estilo de dibujado se establecerá como "No hay dibujado"; si el estado del búfer es BUFFER_STATUS_FILLING (rellenado de color), el estilo de dibujado se establecerá como el correspondiente. Todos los demás valores simplemente se establecen en 8: precisamente este desplazamiento indicará la constante del estilo de color del dibujado.
Más abajo, mostramos un ejemplo del aumento de la constante de enumeración ENUM_BUFFER_STATUS en 8,
y en qué valor de la enumeración ENUM_DRAW_TYPE cae en este caso:
enum ENUM_BUFFER_STATUS { BUFFER_STATUS_NONE, // 0 // No drawing BUFFER_STATUS_FILLING, // 1 // Color filling between two levels (MQL5) BUFFER_STATUS_LINE, // 2 +8 = 10 // Line BUFFER_STATUS_HISTOGRAM, // 3 +8 = 11 // Histogram from the zero line BUFFER_STATUS_ARROW, // 4 +8 = 12 // Drawing with arrows BUFFER_STATUS_SECTION, // 5 +8 = 13 // Section BUFFER_STATUS_HISTOGRAM2, // 6 +8 = 14 // Histogram on two indicator buffers BUFFER_STATUS_ZIGZAG, // 7 +8 = 15 // Zigzag style BUFFER_STATUS_BARS, // 8 +8 = 16 // Display as bars (MQL5) BUFFER_STATUS_CANDLES, // 9 +8 = 17 // Display as candles (MQL5) }; 2020.04.15 12:51:53.725 DRAW_NONE = 0 2020.04.15 12:51:53.725 DRAW_LINE = 1 2020.04.15 12:51:53.725 DRAW_HISTOGRAM = 2 2020.04.15 12:51:53.725 DRAW_ARROW = 3 2020.04.15 12:51:53.725 DRAW_SECTION = 4 2020.04.15 12:51:53.725 DRAW_HISTOGRAM2 = 5 2020.04.15 12:51:53.725 DRAW_ZIGZAG = 6 2020.04.15 12:51:53.725 DRAW_FILLING = 7 2020.04.15 12:51:53.725 DRAW_BARS = 8 2020.04.15 12:51:53.725 DRAW_CANDLES = 9 2020.04.15 12:51:53.725 DRAW_COLOR_LINE = 10 2020.04.15 12:51:53.725 DRAW_COLOR_HISTOGRAM = 11 2020.04.15 12:51:53.725 DRAW_COLOR_ARROW = 12 2020.04.15 12:51:53.725 DRAW_COLOR_SECTION = 13 2020.04.15 12:51:53.725 DRAW_COLOR_HISTOGRAM2 = 14 2020.04.15 12:51:53.725 DRAW_COLOR_ZIGZAG = 15 2020.04.15 12:51:53.725 DRAW_COLOR_BARS = 16 2020.04.15 12:51:53.725 DRAW_COLOR_CANDLES = 17
De esta forma, partiendo del valor del estado del búfer, también establecemos su estilo de dibujado.
Vamos a añadir a la sección pública de la clase todos los demás métodos para esteblecer y retornar las propiedades del búfer y mostrar la descricpción de sus propiedades en el diario:
public: //--- Set (1) the arrow code, (2) vertical shift of arrows, (3) symbol, (4) timeframe, (5) buffer activity flag //--- (6) number of initial bars without drawing, (7) flag of displaying construction values in DataWindow, //--- (8) shift of the indicator graphical construction along the time axis, (9) line style, (10) line width, //--- (11) number of colors, (12) drawing color, (13) empty value and (14) graphical series name displayed in DataWindow virtual void SetArrowCode(const uchar code) { return; } virtual void SetArrowShift(const int shift) { return; } void SetSymbol(const string symbol) { this.SetProperty(BUFFER_PROP_SYMBOL,symbol); } void SetTimeframe(const ENUM_TIMEFRAMES timeframe) { this.SetProperty(BUFFER_PROP_TIMEFRAME,timeframe); } void SetActive(const bool flag) { this.SetProperty(BUFFER_PROP_ACTIVE,flag); } void SetDrawBegin(const int value); void SetShowData(const bool flag); void SetShift(const int shift); void SetStyle(const ENUM_LINE_STYLE style); void SetWidth(const int width); void SetColorNumbers(const int number); void SetColor(const color colour); void SetEmptyValue(const double value); void SetLabel(const string label); //--- Return (1) the serial number of the drawn buffer, (2) bound array index, (3) color buffer index, //--- (4) index of the first free bound array, (5) buffer data period (timeframe) (6) buffer status, //--- (7) buffer type, (8) buffer usage flag, (9) arrow code, (10) arrow shift for DRAW_ARROW style, //--- (11) Number of initial bars that are not drawn and values in DataWindow, (12) graphical construction type, //--- (13) flag of displaying construction values in DataWindow, (14) indicator graphical construction shift along the time axis, //--- (15) drawing line style, (16) drawing line width, (17) number of colors, (18) drawing color, //--- (19) set empty value, (20) buffer symbol and (21) name of the indicator graphical series displayed in DataWindow int IndexPlot(void) const { return (int)this.GetProperty(BUFFER_PROP_INDEX_PLOT); } int IndexBase(void) const { return (int)this.GetProperty(BUFFER_PROP_INDEX_BASE); } int IndexColor(void) const { return (int)this.GetProperty(BUFFER_PROP_INDEX_COLOR); } int IndexNextBuffer(void) const { return (int)this.GetProperty(BUFFER_PROP_INDEX_NEXT); } ENUM_TIMEFRAMES Timeframe(void) const { return (ENUM_TIMEFRAMES)this.GetProperty(BUFFER_PROP_TIMEFRAME); } ENUM_BUFFER_STATUS Status(void) const { return (ENUM_BUFFER_STATUS)this.GetProperty(BUFFER_PROP_STATUS); } ENUM_BUFFER_TYPE TypeBuffer(void) const { return (ENUM_BUFFER_TYPE)this.GetProperty(BUFFER_PROP_TYPE); } bool IsActive(void) const { return (bool)this.GetProperty(BUFFER_PROP_ACTIVE); } uchar ArrowCode(void) const { return (uchar)this.GetProperty(BUFFER_PROP_ARROW_CODE); } int ArrowShift(void) const { return (int)this.GetProperty(BUFFER_PROP_ARROW_SHIFT); } int DrawBegin(void) const { return (int)this.GetProperty(BUFFER_PROP_DRAW_BEGIN); } ENUM_DRAW_TYPE DrawType(void) const { return (ENUM_DRAW_TYPE)this.GetProperty(BUFFER_PROP_DRAW_TYPE); } bool IsShowData(void) const { return (bool)this.GetProperty(BUFFER_PROP_SHOW_DATA); } int Shift(void) const { return (int)this.GetProperty(BUFFER_PROP_SHIFT); } ENUM_LINE_STYLE LineStyle(void) const { return (ENUM_LINE_STYLE)this.GetProperty(BUFFER_PROP_LINE_STYLE); } int LineWidth(void) const { return (int)this.GetProperty(BUFFER_PROP_LINE_WIDTH); } int NumberColors(void) const { return (int)this.GetProperty(BUFFER_PROP_COLOR_INDEXES); } color Color(void) const { return (color)this.GetProperty(BUFFER_PROP_COLOR); } double EmptyValue(void) const { return this.GetProperty(BUFFER_PROP_EMPTY_VALUE); } string Symbol(void) const { return this.GetProperty(BUFFER_PROP_SYMBOL); } string Label(void) const { return this.GetProperty(BUFFER_PROP_LABEL); } //--- Return descriptions of the (1) buffer status, (2) buffer type, (3) buffer usage flag, (4) flag of displaying construction values in DataWindow, //--- (5) drawing line style, (6) set empty value, (7) graphical construction type and (8) used timeframe string GetStatusDescription(bool draw_type=false)const; string GetTypeBufferDescription(void) const; string GetActiveDescription(void) const; string GetShowDataDescription(void) const; string GetLineStyleDescription(void) const; string GetEmptyValueDescription(void) const; string GetDrawTypeDescription(void) const; string GetTimeframeDescription(void) const; //--- Return the size of the data buffer array int GetDataTotal(void) const { return ::ArraySize(this.DataArray); } }; //+------------------------------------------------------------------+
Echemos un vistazo a la implementación de los métodos y el constructor paramétrico cerrado.
Constructor paramétrico cerrado:
//+------------------------------------------------------------------+ //| Constructor paramétrico cerrado | //+------------------------------------------------------------------+ CBuffer::CBuffer(ENUM_BUFFER_STATUS buffer_status,ENUM_BUFFER_TYPE buffer_type,const uint index_plot,const uint index_base_array) { this.m_type=COLLECTION_BUFFERS_ID; //--- Guardando las propiedades de tipo entero this.m_long_prop[BUFFER_PROP_STATUS] = buffer_status; this.m_long_prop[BUFFER_PROP_TYPE] = buffer_type; this.m_long_prop[BUFFER_PROP_TIMEFRAME] = PERIOD_CURRENT; this.m_long_prop[BUFFER_PROP_ACTIVE] = false; this.m_long_prop[BUFFER_PROP_ARROW_CODE] = 0xFB; this.m_long_prop[BUFFER_PROP_ARROW_SHIFT] = 0; this.m_long_prop[BUFFER_PROP_DRAW_BEGIN] = 0; this.m_long_prop[BUFFER_PROP_SHOW_DATA] = (buffer_type>BUFFER_TYPE_CALCULATE ? true : false); this.m_long_prop[BUFFER_PROP_SHIFT] = 0; this.m_long_prop[BUFFER_PROP_LINE_STYLE] = STYLE_SOLID; this.m_long_prop[BUFFER_PROP_LINE_WIDTH] = 1; this.m_long_prop[BUFFER_PROP_COLOR_INDEXES] = 1; this.m_long_prop[BUFFER_PROP_COLOR] = clrRed; this.m_long_prop[BUFFER_PROP_NUM_DATAS] = 1; this.m_long_prop[BUFFER_PROP_INDEX_PLOT] = index_plot; this.m_long_prop[BUFFER_PROP_INDEX_BASE] = index_base_array; this.m_long_prop[BUFFER_PROP_INDEX_COLOR] = this.GetProperty(BUFFER_PROP_INDEX_BASE)+this.GetProperty(BUFFER_PROP_NUM_DATAS); this.m_long_prop[BUFFER_PROP_INDEX_NEXT] = this.GetProperty(BUFFER_PROP_INDEX_COLOR)+1; this.SetDrawType(); //--- Guardando las propiedades de tipo real this.m_double_prop[this.IndexProp(BUFFER_PROP_EMPTY_VALUE)] = EMPTY_VALUE; //--- Guardando las propiedades de tipo string this.m_string_prop[this.IndexProp(BUFFER_PROP_SYMBOL)] = ::Symbol(); this.m_string_prop[this.IndexProp(BUFFER_PROP_LABEL)] = (this.TypeBuffer()>BUFFER_TYPE_CALCULATE ? "Buffer "+(string)this.IndexPlot() : NULL); //--- Bind indicator buffers with arrays ::SetIndexBuffer((int)this.GetProperty(BUFFER_PROP_INDEX_BASE),this.DataArray,INDICATOR_DATA); ::SetIndexBuffer((int)this.GetProperty(BUFFER_PROP_INDEX_COLOR),this.ColorArray,INDICATOR_COLOR_INDEX); //--- Set integer buffer parameters ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_DRAW_TYPE,(ENUM_PLOT_PROPERTY_INTEGER)this.GetProperty(BUFFER_PROP_DRAW_TYPE)); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_ARROW,(ENUM_PLOT_PROPERTY_INTEGER)this.GetProperty(BUFFER_PROP_ARROW_CODE)); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_ARROW_SHIFT,(ENUM_PLOT_PROPERTY_INTEGER)this.GetProperty(BUFFER_PROP_ARROW_SHIFT)); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_DRAW_BEGIN,(ENUM_PLOT_PROPERTY_INTEGER)this.GetProperty(BUFFER_PROP_DRAW_BEGIN)); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_SHOW_DATA,(ENUM_PLOT_PROPERTY_INTEGER)this.GetProperty(BUFFER_PROP_SHOW_DATA)); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_SHIFT,(ENUM_PLOT_PROPERTY_INTEGER)this.GetProperty(BUFFER_PROP_SHIFT)); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_LINE_STYLE,(ENUM_PLOT_PROPERTY_INTEGER)this.GetProperty(BUFFER_PROP_LINE_STYLE)); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_LINE_WIDTH,(ENUM_PLOT_PROPERTY_INTEGER)this.GetProperty(BUFFER_PROP_LINE_WIDTH)); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_COLOR_INDEXES,(ENUM_PLOT_PROPERTY_INTEGER)this.GetProperty(BUFFER_PROP_COLOR_INDEXES)); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_LINE_COLOR,(ENUM_PLOT_PROPERTY_INTEGER)this.GetProperty(BUFFER_PROP_COLOR)); //--- Set real buffer parameters ::PlotIndexSetDouble((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_EMPTY_VALUE,this.GetProperty(BUFFER_PROP_EMPTY_VALUE)); //--- Set string buffer parameters ::PlotIndexSetString((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_LABEL,this.GetProperty(BUFFER_PROP_LABEL)); } //+------------------------------------------------------------------+
En los parámetros de entrada del constructor, se transmiten el estado y el tipo del objeto de búfer transmitido, el índice del búfer dibujado (índice en la ventana "Observación de mercado") y el índice de la matriz básica (la matriz básica es la primera matriz de la lista general de matrices utilizadas para construir el búfer).
Asignamos al objeto el tipo de pertenencia a la colección de objetos de búfer y rellenamos las propiedades de tipo entero, real y string del objeto con los valores por defecto.
A continuación, vinculamos los búferes de indicador con las matrices, y asignamos al búfer dibujado las propiedades de tipo entero, real y string de los valores por defecto recién rellenados de las propiedades de tipo único del objeto de búfer.
Estas acciones bastan para crear un búfer de indicador monocromo con el tipo de dibujado indicado. En este caso, además, para crear este búfer, no será necesario declarar, escribir o asignar ninguna matriz desde el indicador: todo se encuentra ya en el objeto de búfer, y al crear este, todo se registrará y asignará correctamente. La propiedad BUFFER_PROP_INDEX_PLOT contiene el índice del búfer dibujado al que debemos recurrir para establecer y obtener los datos de dicho búfer desde nuestro programa-indicador.
En cuanto a los métodos estándar para los objetos de la biblioteca, nos limitaremos a indicarlos sin realizar ningún análisis adicional, ya que en los anteriores artículos, de una u otra forma, ya estudiamos metodos semejantes. Además, al crear el primer objeto de la biblioteca, estos métodos se detallaron en profundidad:
Métodos de compración para realizar la búsqueda y la clasificación y para retornar la bandera que indica que los dos objetos comprados son idénticos:
//+------------------------------------------------------------------+ //| Class methods | //+------------------------------------------------------------------+ //+------------------------------------------------------------------+ //| Compare CBuffer objects by all possible properties | //+------------------------------------------------------------------+ int CBuffer::Compare(const CObject *node,const int mode=0) const { const CBuffer *compared_obj=node; //--- compare integer properties of two buffers if(mode<BUFFER_PROP_INTEGER_TOTAL) { long value_compared=compared_obj.GetProperty((ENUM_BUFFER_PROP_INTEGER)mode); long value_current=this.GetProperty((ENUM_BUFFER_PROP_INTEGER)mode); return(value_current>value_compared ? 1 : value_current<value_compared ? -1 : 0); } //--- compare real properties of two buffers else if(mode<BUFFER_PROP_INTEGER_TOTAL+BUFFER_PROP_DOUBLE_TOTAL) { double value_compared=compared_obj.GetProperty((ENUM_BUFFER_PROP_DOUBLE)mode); double value_current=this.GetProperty((ENUM_BUFFER_PROP_DOUBLE)mode); return(value_current>value_compared ? 1 : value_current<value_compared ? -1 : 0); } //--- compare string properties of two buffers else if(mode<BUFFER_PROP_INTEGER_TOTAL+BUFFER_PROP_DOUBLE_TOTAL+BUFFER_PROP_STRING_TOTAL) { string value_compared=compared_obj.GetProperty((ENUM_BUFFER_PROP_STRING)mode); string value_current=this.GetProperty((ENUM_BUFFER_PROP_STRING)mode); return(value_current>value_compared ? 1 : value_current<value_compared ? -1 : 0); } return 0; } //+------------------------------------------------------------------+ //| Compare CBuffer objects by all properties | //+------------------------------------------------------------------+ bool CBuffer::IsEqual(CBuffer *compared_obj) const { int beg=0, end=BUFFER_PROP_INTEGER_TOTAL; for(int i=beg; i<end; i++) { ENUM_BUFFER_PROP_INTEGER prop=(ENUM_BUFFER_PROP_INTEGER)i; if(this.GetProperty(prop)!=compared_obj.GetProperty(prop)) return false; } beg=end; end+=BUFFER_PROP_DOUBLE_TOTAL; for(int i=beg; i<end; i++) { ENUM_BUFFER_PROP_DOUBLE prop=(ENUM_BUFFER_PROP_DOUBLE)i; if(this.GetProperty(prop)!=compared_obj.GetProperty(prop)) return false; } beg=end; end+=BUFFER_PROP_STRING_TOTAL; for(int i=beg; i<end; i++) { ENUM_BUFFER_PROP_STRING prop=(ENUM_BUFFER_PROP_STRING)i; if(this.GetProperty(prop)!=compared_obj.GetProperty(prop)) return false; } return true; } //+------------------------------------------------------------------+
Método para mostrar en el diario todas las propiedades del objeto de búfer:
//+------------------------------------------------------------------+ //| Display buffer properties in the journal | //+------------------------------------------------------------------+ void CBuffer::Print(const bool full_prop=false) { ::Print("============= ", CMessage::Text(MSG_LIB_PARAMS_LIST_BEG),": ", this.GetTypeBufferDescription(),"[",(string)this.IndexPlot(),"] \"",this.GetStatusDescription(true),"\"", " ==================" ); int beg=0, end=BUFFER_PROP_INTEGER_TOTAL; for(int i=beg; i<end; i++) { ENUM_BUFFER_PROP_INTEGER prop=(ENUM_BUFFER_PROP_INTEGER)i; if(!full_prop && !this.SupportProperty(prop)) continue; ::Print(this.GetPropertyDescription(prop)); } ::Print("------"); beg=end; end+=BUFFER_PROP_DOUBLE_TOTAL; for(int i=beg; i<end; i++) { ENUM_BUFFER_PROP_DOUBLE prop=(ENUM_BUFFER_PROP_DOUBLE)i; if(!full_prop && !this.SupportProperty(prop)) continue; ::Print(this.GetPropertyDescription(prop)); } ::Print("------"); beg=end; end+=BUFFER_PROP_STRING_TOTAL; for(int i=beg; i<end; i++) { ENUM_BUFFER_PROP_STRING prop=(ENUM_BUFFER_PROP_STRING)i; if(!full_prop && !this.SupportProperty(prop)) continue; ::Print(this.GetPropertyDescription(prop)); } ::Print("================== ", CMessage::Text(MSG_LIB_PARAMS_LIST_END),": ", this.GetTypeBufferDescription(),"[",(string)this.IndexPlot(),"] \"",this.GetStatusDescription(true),"\"", " ==================\n" ); } //+------------------------------------------------------------------+
Métodos que retornan la descripción de las propiedades de tipo entero, real y string del objeto de búfer:
//+------------------------------------------------------------------+ //| Return description of a buffer's integer property | //+------------------------------------------------------------------+ string CBuffer::GetPropertyDescription(ENUM_BUFFER_PROP_INTEGER property) { return ( property==BUFFER_PROP_INDEX_PLOT ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_INDEX_PLOT)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_NUM_DATAS ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_NUM_DATAS)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_INDEX_NEXT ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_INDEX_NEXT)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_TIMEFRAME ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_TIMEFRAME)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.GetTimeframeDescription() ) : property==BUFFER_PROP_STATUS ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.GetStatusDescription() ) : property==BUFFER_PROP_TYPE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_TYPE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.GetTypeBufferDescription() ) : property==BUFFER_PROP_ACTIVE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_ACTIVE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.GetActiveDescription() ) : property==BUFFER_PROP_ARROW_CODE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_ARROW_CODE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_ARROW_SHIFT ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_ARROW_SHIFT)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_DRAW_BEGIN ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_DRAW_BEGIN)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_DRAW_TYPE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_DRAW_TYPE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.GetDrawTypeDescription() ) : property==BUFFER_PROP_SHOW_DATA ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_SHOW_DATA)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.GetShowDataDescription() ) : property==BUFFER_PROP_SHIFT ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_SHIFT)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_LINE_STYLE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_LINE_STYLE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.GetLineStyleDescription() ) : property==BUFFER_PROP_LINE_WIDTH ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_LINE_WIDTH)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_COLOR_INDEXES ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_COLOR_NUM)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_COLOR ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_COLOR)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+ColorToString(this.Color(),true) ) : property==BUFFER_PROP_INDEX_BASE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_INDEX_BASE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_NUM_DATAS ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_NUM_DATAS)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_INDEX_COLOR ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_INDEX_COLOR)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_INDEX_NEXT ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_INDEX_NEXT)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+ColorToString(this.Color(),true) ) : "" ); } //+------------------------------------------------------------------+ //| Return description of a buffer's real property | //+------------------------------------------------------------------+ string CBuffer::GetPropertyDescription(ENUM_BUFFER_PROP_DOUBLE property) { return ( property==BUFFER_PROP_EMPTY_VALUE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_EMPTY_VALUE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.GetEmptyValueDescription() ) : "" ); } //+------------------------------------------------------------------+ //| Return description of a buffer's string property | //+------------------------------------------------------------------+ string CBuffer::GetPropertyDescription(ENUM_BUFFER_PROP_STRING property) { return ( property==BUFFER_PROP_SYMBOL ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_SYMBOL)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.Symbol() ) : property==BUFFER_PROP_LABEL ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_LABEL)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(this.Label()==NULL || this.Label()=="" ? CMessage::Text(MSG_LIB_PROP_NOT_SET) : this.Label()) ) : "" ); } //+------------------------------------------------------------------+
Vamos a echar un vistazo a la implementación de los demás métodos añadidos a la sección pública de la clase.
Método que retorna la descripción del estado del búfer:
//+------------------------------------------------------------------+ //| Return the buffer status description | //+------------------------------------------------------------------+ string CBuffer::GetStatusDescription(bool draw_type=false) const { string type= ( this.Status()==BUFFER_STATUS_NONE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS_NONE) : this.Status()==BUFFER_STATUS_ARROW ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS_ARROW) : this.Status()==BUFFER_STATUS_BARS ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS_BARS) : this.Status()==BUFFER_STATUS_CANDLES ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS_CANDLES) : this.Status()==BUFFER_STATUS_FILLING ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS_FILLING) : this.Status()==BUFFER_STATUS_HISTOGRAM ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS_HISTOGRAM) : this.Status()==BUFFER_STATUS_HISTOGRAM2 ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS_HISTOGRAM2) : this.Status()==BUFFER_STATUS_LINE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS_LINE) : this.Status()==BUFFER_STATUS_SECTION ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS_SECTION) : this.Status()==BUFFER_STATUS_ZIGZAG ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS_ZIGZAG) : "Unknown" ); return(!draw_type ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STATUS_NAME)+" \""+type+"\"" : type); } //+------------------------------------------------------------------+
Dado que el estado del búfer al mismo tiempo define el estilo de dibujado, transmitimos al método la bandera que indica cómo retornar la descripción:
si se ha solicitado el estado del búfer (draw_type ha sido establecido en false), se retornará el estado del búfer como
Buffer status: Indicator buffer with graphical construction type "Line"
si se ha solicitado el tipo de dibujado (draw_type ha sido establecido en true), se retornará el tipo de dibujado como
Graphical construction type: Line
Todos los métodos que retornan las descripciones de las propiedades del objeto son bastante sencillos, así que los dejaremos para el estudio individual:
//+------------------------------------------------------------------+ //| Return the buffer type description | //+------------------------------------------------------------------+ string CBuffer::GetTypeBufferDescription(void) const { return ( this.TypeBuffer()==BUFFER_TYPE_DATA ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_TYPE_DATA) : this.TypeBuffer()==BUFFER_TYPE_CALCULATE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_TYPE_CALCULATE) : "Unknown" ); } //+------------------------------------------------------------------+ //| Return description of the buffer usage flag | //+------------------------------------------------------------------+ string CBuffer::GetActiveDescription(void) const { return(this.IsActive() ? CMessage::Text(MSG_LIB_TEXT_YES) : CMessage::Text(MSG_LIB_TEXT_NO)); } //+---------------------------------------------------------------------+ //|Return description of displaying construction values in DataWindow | //+---------------------------------------------------------------------+ string CBuffer::GetShowDataDescription(void) const { return(this.IsShowData() ? CMessage::Text(MSG_LIB_TEXT_YES) : CMessage::Text(MSG_LIB_TEXT_NO)); } //+------------------------------------------------------------------+ //| Return description of the drawing line style | //+------------------------------------------------------------------+ string CBuffer::GetLineStyleDescription(void) const { return ( this.LineStyle()==STYLE_SOLID ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STYLE_SOLID) : this.LineStyle()==STYLE_DASH ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STYLE_DASH) : this.LineStyle()==STYLE_DOT ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STYLE_DOT) : this.LineStyle()==STYLE_DASHDOT ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STYLE_DASHDOT) : this.LineStyle()==STYLE_DASHDOTDOT ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_STYLE_DASHDOTDOT) : "Unknown" ); } //+------------------------------------------------------------------+ //| Return description of the set empty value | //+------------------------------------------------------------------+ string CBuffer::GetEmptyValueDescription(void) const { return(this.EmptyValue()<EMPTY_VALUE ? ::DoubleToString(this.EmptyValue(),(this.EmptyValue()==0 ? 1 : 8)) : "EMPTY_VALUE"); } //+------------------------------------------------------------------+ //| Return description of the graphical construction type | //+------------------------------------------------------------------+ string CBuffer::GetDrawTypeDescription(void) const { return this.GetStatusDescription(true); } //+------------------------------------------------------------------+ //| Return description of the used timeframe | //+------------------------------------------------------------------+ string CBuffer::GetTimeframeDescription(void) const { string timeframe=TimeframeDescription(this.Timeframe()); return(this.Timeframe()==PERIOD_CURRENT ? CMessage::Text(MSG_LIB_TEXT_PERIOD_CURRENT)+" ("+timeframe+")" : timeframe); } //+------------------------------------------------------------------+
Métodos para asignar las diferentes propiedades al objeto de búfer:
//+------------------------------------------------------------------+ //| Set the number of initial bars | //| without drawing and values in DataWindow | //+------------------------------------------------------------------+ void CBuffer::SetDrawBegin(const int value) { this.SetProperty(BUFFER_PROP_DRAW_BEGIN,value); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_DRAW_BEGIN,value); } //+------------------------------------------------------------------+ //| Set the flag of displaying | //| construction values in DataWindow | //+------------------------------------------------------------------+ void CBuffer::SetShowData(const bool flag) { this.SetProperty(BUFFER_PROP_SHOW_DATA,flag); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_SHOW_DATA,flag); } //+------------------------------------------------------------------+ //| Set the indicator graphical construction shift | //+------------------------------------------------------------------+ void CBuffer::SetShift(const int shift) { this.SetProperty(BUFFER_PROP_SHIFT,shift); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_SHIFT,shift); } //+------------------------------------------------------------------+ //| Set the line style | //+------------------------------------------------------------------+ void CBuffer::SetStyle(const ENUM_LINE_STYLE style) { this.SetProperty(BUFFER_PROP_LINE_STYLE,style); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_LINE_STYLE,style); } //+------------------------------------------------------------------+ //| Set the line width | //+------------------------------------------------------------------+ void CBuffer::SetWidth(const int width) { this.SetProperty(BUFFER_PROP_LINE_WIDTH,width); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_LINE_WIDTH,width); } //+------------------------------------------------------------------+ //| Set the number of colors | //+------------------------------------------------------------------+ void CBuffer::SetColorNumbers(const int number) { this.SetProperty(BUFFER_PROP_COLOR_INDEXES,number); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_COLOR_INDEXES,number); } //+------------------------------------------------------------------+ //| Set the drawing color | //+------------------------------------------------------------------+ void CBuffer::SetColor(const color colour) { this.SetProperty(BUFFER_PROP_COLOR,colour); ::PlotIndexSetInteger((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_LINE_COLOR,colour); } //+------------------------------------------------------------------+ //| Set the "empty" value for construction | //| without drawing | //+------------------------------------------------------------------+ void CBuffer::SetEmptyValue(const double value) { this.SetProperty(BUFFER_PROP_EMPTY_VALUE,value); ::PlotIndexSetDouble((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_EMPTY_VALUE,value); } //+------------------------------------------------------------------+ //| Set the drawing color | //+------------------------------------------------------------------+ void CBuffer::SetLabel(const string label) { this.SetProperty(BUFFER_PROP_LABEL,label); ::PlotIndexSetString((int)this.GetProperty(BUFFER_PROP_INDEX_PLOT),PLOT_LABEL,label); } //+------------------------------------------------------------------+
Primero, el valor transmitido al método se registra en la propiedad correspondiente del objeto de búfer, y a continuación, esta propiedad se establece para el búfer dibujado según su índice.
Por el momento, esto es todo lo que debemos hacer para crear el objeto de búfer de indicador abstracto.
Comprobando la creación de los objetos de búfer en el indicador
Para comprobar el funcionamiento del objeto de búfer abstracto, tomaremos el indicador del artículo anterior y
y lo guardaremos en la carpeta \MQL5\Indicators\TestDoEasy\Part42\ con el nuevo nombre TestDoEasyPart42.mq5.
Eliminamos todo lo sobrante del indicador.
No necisitamos ningún botón, ni ninguna función para procesar la pulsación de los botones o alguna función para rellenar los datos de los búferes: eliminaremos todo esto del código, dejando solo lo directamente relacionado con el funcionamiento de la biblioteca.
Además, trasladaremos al archivo de funciones de servicio de la biblioteca el código de indicador de las funciones encargadas de copiar los datos de OnCalculate() en la estructura de precios de la biblioteca. Abrimos el archivo \MQL5\Include\DoEasy\Services\DELib.mqh y le añadimos dos funciones:
//+------------------------------------------------------------------+ //| Copy data from the first OnCalculate() form to the structure | //+------------------------------------------------------------------+ void CopyData(const int rates_total, const int prev_calculated, const int begin, const double &price[]) { //--- Get the array indexing flag as in the timeseries. If failed, //--- set the indexing direction for the array as in the timeseries bool as_series_price=ArrayGetAsSeries(price); if(!as_series_price) ArraySetAsSeries(price,true); //--- Copy the array zero bar to the OnCalculate() SDataCalculate data structure rates_data.rates_total=rates_total; rates_data.prev_calculated=prev_calculated; rates_data.begin=begin; rates_data.price=price[0]; //--- Return the array's initial indexing direction if(!as_series_price) ArraySetAsSeries(price,false); } //+------------------------------------------------------------------+ //| Copy data from the second OnCalculate() form to the structure | //+------------------------------------------------------------------+ void CopyData(const int rates_total, const int prev_calculated, const datetime &time[], const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], const int &spread[]) { //--- Get the array indexing flags as in the timeseries. If failed, //--- set the indexing direction or the arrays as in the timeseries bool as_series_time=ArrayGetAsSeries(time); if(!as_series_time) ArraySetAsSeries(time,true); bool as_series_open=ArrayGetAsSeries(open); if(!as_series_open) ArraySetAsSeries(open,true); bool as_series_high=ArrayGetAsSeries(high); if(!as_series_high) ArraySetAsSeries(high,true); bool as_series_low=ArrayGetAsSeries(low); if(!as_series_low) ArraySetAsSeries(low,true); bool as_series_close=ArrayGetAsSeries(close); if(!as_series_close) ArraySetAsSeries(close,true); bool as_series_tick_volume=ArrayGetAsSeries(tick_volume); if(!as_series_tick_volume) ArraySetAsSeries(tick_volume,true); bool as_series_volume=ArrayGetAsSeries(volume); if(!as_series_volume) ArraySetAsSeries(volume,true); bool as_series_spread=ArrayGetAsSeries(spread); if(!as_series_spread) ArraySetAsSeries(spread,true); //--- Copy the arrays' zero bar to the OnCalculate() SDataCalculate data structure rates_data.rates_total=rates_total; rates_data.prev_calculated=prev_calculated; rates_data.rates.time=time[0]; rates_data.rates.open=open[0]; rates_data.rates.high=high[0]; rates_data.rates.low=low[0]; rates_data.rates.close=close[0]; rates_data.rates.tick_volume=tick_volume[0]; rates_data.rates.real_volume=(#ifdef __MQL5__ volume[0] #else 0 #endif); rates_data.rates.spread=(#ifdef __MQL5__ spread[0] #else 0 #endif); //--- Return the arrays' initial indexing direction if(!as_series_time) ArraySetAsSeries(time,false); if(!as_series_open) ArraySetAsSeries(open,false); if(!as_series_high) ArraySetAsSeries(high,false); if(!as_series_low) ArraySetAsSeries(low,false); if(!as_series_close) ArraySetAsSeries(close,false); if(!as_series_tick_volume) ArraySetAsSeries(tick_volume,false); if(!as_series_volume) ArraySetAsSeries(volume,false); if(!as_series_spread) ArraySetAsSeries(spread,false); } //+------------------------------------------------------------------+
Como resultado, hemos limpiado el código del indicador para poder realizar la comprobación actual y usar el código posteriormente: las dos funciones trasladadas son necesarias para trabajar con los indicadores dentro de la biblioteca, y el lugar más propicio para ellas es el archivo de funciones de servicio de la misma.
El "encabezado" del indicador será así:
//+------------------------------------------------------------------+ //| TestDoEasyPart42.mq5 | //| Copyright 2020, MetaQuotes Software Corp. | //| https://mql5.com/es/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2020, MetaQuotes Software Corp." #property link "https://mql5.com/es/users/artmedia70" #property version "1.00" //--- includes #include <DoEasy\Engine.mqh> #include <DoEasy\Objects\Indicators\Buffer.mqh> //--- properties #property indicator_chart_window #property indicator_buffers 4 #property indicator_plots 2 //--- classes //--- enums //--- defines //--- structures //--- input variables /*sinput*/ ENUM_SYMBOLS_MODE InpModeUsedSymbols= SYMBOLS_MODE_DEFINES; // Mode of used symbols list sinput string InpUsedSymbols = "EURUSD,AUDUSD,EURAUD,EURGBP,EURCAD,EURJPY,EURUSD,GBPUSD,NZDUSD,USDCAD,USDJPY"; // List of used symbols (comma - separator) sinput ENUM_TIMEFRAMES_MODE InpModeUsedTFs = TIMEFRAMES_MODE_LIST; // Mode of used timeframes list sinput string InpUsedTFs = "M1,M5,M15,M30,H1,H4,D1,W1,MN1"; // List of used timeframes (comma - separator) sinput bool InpUseSounds = true; // Use sounds //--- indicator buffers CArrayObj list_buffers; // Temporary list for storing two buffer objects //--- global variables CEngine engine; // CEngine library main object string prefix; // Prefix of graphical object names int min_bars; // The minimum number of bars for the indicator calculation int used_symbols_mode; // Mode of working with symbols string array_used_symbols[]; // The array for passing used symbols to the library string array_used_periods[]; // The array for passing used timeframes to the library //+------------------------------------------------------------------+
Aquí, pedimos al compilador que cree un indicador en una ventana aparte y establezca para él cuatro búferes (dos de dibujado y dos de color).
Los demás parámetros de los búferes se establecerán mientras se crean los objetos de búfer de indicador y después del proceso.
Como búfer de indicador, añadiremos la matriz dinámica de punteros CArrayObj, en ella iremos colocando los búferes creados.
Al trabajar con los objetos de búfer, no necesitamos actualizar las matrices double para asignarlos como búferes de indicador: todo se encuentra dentro de los objetos de búfer creados, y se asigna durante su creación en el manejador OnInit() del indicador:
//+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- Initialize DoEasy library OnInitDoEasy(); //--- Set indicator global variables prefix=engine.Name()+"_"; //--- Get the index of the maximum used timeframe in the array, //--- calculate the number of bars of the current period fitting in the maximum used period //--- Use the obtained value if it exceeds 2, otherwise use 2 int index=ArrayMaximum(ArrayUsedTimeframes); int num_bars=NumberBarsInTimeframe(ArrayUsedTimeframes[index]); min_bars=(index>WRONG_VALUE ? (num_bars>2 ? num_bars : 2) : 2); //--- Check and remove remaining indicator graphical objects if(IsPresentObectByPrefix(prefix)) ObjectsDeleteAll(0,prefix); //--- Create the button panel //--- Check playing a standard sound using macro substitutions engine.PlaySoundByDescription(SND_OK); //--- Wait for 600 milliseconds engine.Pause(600); engine.PlaySoundByDescription(SND_NEWS); //--- indicator buffers mapping //--- Create two buffer objects CBuffer *buffer0=new CBuffer(BUFFER_STATUS_ARROW,BUFFER_TYPE_DATA, 0, 0); CBuffer *buffer1=new CBuffer(BUFFER_STATUS_LINE,BUFFER_TYPE_DATA, 1, buffer0.IndexNextBuffer()); //--- Set non-default values for the second buffer's "empty" value and color buffer1.SetEmptyValue(0); buffer1.SetColor(clrBlue); //--- Add both buffers to the list of indicator buffers list_buffers.Add(buffer0); list_buffers.Add(buffer1); //--- Print data of the created buffers buffer0.Print(); buffer1.Print(); //--- return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+
Hemos creado dos objetos de búferes de indicador abstractos.
El primero de ellos tiene el estado "Dibujado con flechas"; como índice del búfer de dibujado, designamos 0 y como índice de la matriz básica del búfer, también designamos 0: se trata del primer búfer, y aquí debemos establecer todos los índices como iniciales.
Vamos a eliminar el procedimiento de indicación de matrices al crear los objetos de búfer, y también al crear la colección de búferes de indicador: ahí, todos los índices se asignarán automáticamente, sin participación del usuario.
El segundo objeto tiene el estado "Línea"; como índice del búfer de dibujado, indicamos el valor 1 (el que sigue al cero), mientras que como índice de la matriz básica, indicamos el valor retornado desde el objeto del primer búfer, que indica el índice de la siguiente matriz libre para a designar como matriz básica para el próximo búfer.
A continuación, asignamos al segundo búfer como "vacío" el valor 0 (cero), y como color de dibujado de línea, el valor "Azul" (para comprobar cómo se establecen los valores en las propiedades del objeto de búfer).
Luego añadimos ambos búferes a la lista list_buffers declarada anteriormente, y, finalmente, imprimimos en el diario todas las propiedades de los búferes que acabamos de crear.
Bueno... aquí no podemos comprobar de ninguna forma si la creación de los objetos de búfer ha tenido éxito, ni tampoco si han sido añadidos a la lista con éxito. Pero solo se trata de un indicador de prueba, y para comprobar rápidamente el funcionamiento de los objetos de búfer, podemos no controlar si los objetos han sido creados y añadidos a la lista con éxito.
También hemos "limpiado" el manejador OnCalculate(), tomado del anterior indicador de prueba, dejando solo lo imprescindible para la simulación:
y lo único que tenemos que comprobar es si se han creado con éxito los dos objetos de búfer y si se han designado con éxito estos como búferes de indicador.
¿Cómo podemos hacerlo?
Comprobaremos la creación de los búferes en OnInit(), al imprimir en el diario todas las propiedades de cada búfer creado. Por otra parte, solo prodremos comprobar si ha tenido éxito la designación de estos objetos como búferes de indicador en OnCalculate(). Para ello, bastará con comparar el tamaño de las matrices utilizadas en los objetos como búferes de indicador con el número de barras en el símbolo.
En cuanto designemos alguna matriz como búfer de indicador, el subsistema ejecutado en el terminal tomará esta matriz bajo su mando, distribuyendo él mismo la memoria para ella y gestionando el tamaño de dicha matriz. Por eso, nos bastará con obtener de la lista list_buffers cada uno de los objetos y comparar el tamaño de su matriz designada como búfer con la magnitud rates_total en OnCalculate(). Si dichos valores son iguales, esto nos indicará que el subsistema del terminal ha tomado bajo su control las matrices de los objetos de búfer.
Y para no tener que mostrar una entrada en el diario con cada tick, realizaremos la comprobación de la designación de las matrices de los objetos de búfer como búferes de indicador al efectuar el primer cálculo del indicador, cuando el valor limit calculado sea superior a la unidad:
//+------------------------------------------------------------------+ //| Custom indicator iteration function | //+------------------------------------------------------------------+ int OnCalculate(const int rates_total, const int prev_calculated, const datetime &time[], const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], const int &spread[]) { //+------------------------------------------------------------------+ //| OnCalculate code block for working with the library: | //+------------------------------------------------------------------+ //--- Pass the current symbol data from OnCalculate() to the price structure CopyData(rates_total,prev_calculated,time,open,high,low,close,tick_volume,volume,spread); //--- Check for the minimum number of bars for calculation if(rates_total<min_bars || Point()==0) return 0; //--- Handle the Calculate event in the library //--- If the OnCalculate() method of the library returns zero, not all timeseries are ready - leave till the next tick if(engine.0) return 0; //--- If working in the tester if(MQLInfoInteger(MQL_TESTER)) { engine.OnTimer(rates_data); // Working in the library timer EventsHandling(); // Working with library events } //+------------------------------------------------------------------+ //| OnCalculate code block for working with the indicator: | //+------------------------------------------------------------------+ //--- Set OnCalculate arrays as timeseries ArraySetAsSeries(open,true); ArraySetAsSeries(high,true); ArraySetAsSeries(low,true); ArraySetAsSeries(close,true); ArraySetAsSeries(time,true); ArraySetAsSeries(tick_volume,true); ArraySetAsSeries(volume,true); ArraySetAsSeries(spread,true); //--- Check and calculate the number of calculated bars //--- If limit = 0, there are no new bars - calculate the current one //--- If limit = 1, a new bar has appeared - calculate the first and the current ones //--- limit > 1 means the first launch or changes in history - the full recalculation of all data int limit=rates_total-prev_calculated; //--- Recalculate the entire history if(limit>1) { //--- In a loop by the number of buffers in the list for(int i=0;i<list_buffers.Total();i++) { //--- get the next buffer and display the type of its graphical construction to the journal //--- together with the double array assigned to the buffer (if all is correct, the size is equal to rates_total) CBuffer *buff=list_buffers.At(i); Print(buff.Label()," type = ",EnumToString(buff.DrawType()),", data total = ",buff.GetDataTotal(),", rates_total=",rates_total); } limit=rates_total-1; } //--- Prepare data //--- Calculate the indicator for(int i=limit; i>WRONG_VALUE && !IsStopped(); i--) { CalculateSeries(i,time[i]); } //--- return value of prev_calculated for next call return(rates_total); } //+------------------------------------------------------------------+
En los archivos adjuntos al final del artículo, el lector podrá ver el código completo del indicador.
Compilamos el indicador y lo iniciamos en el gráfico, estableciendo previamente los siguientes parámetros.
En el diario se mostrarán las entradas:
Account 8550475: Artyom Trishkin (MetaQuotes Software Corp.) 10425.23 USD, 1:100, Hedge, MetaTrader 5 demo --- Initializing "DoEasy" library --- Working with the current symbol only. The number of used symbols: 1 "EURUSD" Working with the specified timeframe list: "M5" "M15" "M30" "H1" EURUSD symbol timeseries: - Timeseries "EURUSD" M5: Requested: 1000, Actual: 1000, Created: 1000, On the server: 3684 - Timeseries "EURUSD" M15: Requested: 1000, Actual: 1000, Created: 1000, On the server: 3042 - Timeseries "EURUSD" M30: Requested: 1000, Actual: 0, Created: 0, On the server: 0 - Timeseries "EURUSD" H1: Requested: 1000, Actual: 1000, Created: 1000, On the server: 6240 Library initialization time: 00:00:00.156 ============= Parameter list start: Colored data buffer[0] "Drawing with arrows" ================== Plotted buffer serial number: 0 Buffer status: Indicator buffer with graphical construction type "Drawing with arrows" Buffer type: Colored data buffer Buffer data period (timeframe): Current chart period (M30) Active: No Arrow code: 251 The vertical shift of the arrows: 0 The number of initial bars that are not drawn and values in DataWindow: 0 Display construction values in DataWindow: Yes Graphical construction type: Drawing with arrows Indicator graphical construction shift by time axis in bars: 0 Line style: Solid line Line width: 1 Number of colors: 1 Drawing color: clrRed Number of data buffers: 1 Base data buffer index: 0 Color buffer index: 1 Index of the array to be assigned as the next indicator buffer: 2 ------ Empty value for plotting where nothing will be drawn: EMPTY_VALUE ------ Buffer symbol: EURUSD Name of the graphical indicator series displayed in DataWindow: Buffer 0 ================== Parameter list end: Colored data buffer[0] "Drawing with arrows" ================== ============= Parameter list start: Colored data buffer[1] "Line" ================== Plotted buffer serial number: 1 Buffer status: Indicator buffer with graphical construction type "Line" Buffer type: Colored data buffer Buffer data period (timeframe): Current chart period (M30) Active: No Arrow code: 251 The vertical shift of the arrows: 0 The number of initial bars that are not drawn and values in DataWindow: 0 Display construction values in DataWindow: Yes Graphical construction type: Line Indicator graphical construction shift by time axis in bars: 0 Line style: Solid line Line width: 1 Number of colors: 1 Drawing color: clrBlue Number of data buffers: 1 Base data buffer index: 2 Color buffer index: 3 Index of the array to be assigned as the next indicator buffer: 4 ------ Empty value for plotting where nothing will be drawn: 0.0 ------ Buffer symbol: EURUSD Name of the graphical indicator series displayed in DataWindow: Buffer 1 ================== Parameter list end: Colored data buffer[1] "Line" ================== "EURUSD" M30 timeseries created successfully: - Timeseries "EURUSD" M30: Requested: 1000, Actual: 1000, Created: 1000, On the server: 5111 Buffer 0 type = DRAW_COLOR_ARROW, data total = 5111, rates_total=5111 Buffer 1 type = DRAW_COLOR_LINE, data total = 5111, rates_total=5111
Después de los mensajes de la biblioteca sobre la creación de las series temporales, vemos que desde OnInit() se ha imprimido un bloque en el que se muestran todas las propiedades de cada uno de los objetos de búfer creados. A continuación, desde OnCalculate() se han mostrado dos mensajes sobre el tipo de dibujado de cada uno de los búferes creados, y también se han imprimido los tamaños de las matrices de los objetos de búfer designados como búferes de indicador. Asimismo, se ha indicado el tamaño de rates_total en el momento en que se ha iniciado el indicador.
Como podemos ver, el tamaño de las matrices y el de rates_total coinciden. Esto significa que las matrices de los objetos de búfer creados han sido tomadas bajo control por el terminal, y son búferes de indicador.
Para asegurarnos una vez más, basta con abrir las propiedades del indicador (Ctrl+I) y mirar en la pestaña "Colores":
A ambos búferes de indicador se les han asignado los nombres y el color. Y nosotros no hemos indicado en ningún sitio ni los nombres, ni el color, salvo en los objetos de búfer por defecto creados en el constructor de la clase; para el segundo búfer, a su vez, designamos el color como azul después de crearlo en OnInit().
Todo funciona como esperábamos. Pero esto es solo el comienzo. Para crear diferentes tipos de búferes de indicador, deberemos crear clases herederas para cada uno de los tipos de construcción gráfica, y trabajar ya luego con ellas desde la colección de búferes de indicador.
¿Qué es lo próximo?
En el siguiente artículo, crearemos los objetos herederos de la clase de búfer abstracto. Precisamente estos objetos serán usados por la biblioteca para crear y utilizar los búferes de indicador en los programas-indicadores que usan para funcionar la biblitoca DoEasy.
Más abajo se adjuntan todos los archivos de la versión actual de la biblioteca y los archivos del asesor de prueba. Puede descargarlo todo y ponerlo a prueba por sí mismo.
Si tiene preguntas, observaciones o sugerencias, podrá concretarlas en los comentarios al artículo.
Querríamos recordar al lector que en este artículo hemos creado un indicador de prueba en MQL5 para MetaTrader 5.
Los archivos adjuntos han sido diseñados solo para MetaTrader 5, y en MetaTrader 4, la biblioteca en su versión actual no ha sido puesta a prueba.
Después de crear todas las clases de los búferes de los indicadores y sus colecciones, trataremos de implementar algunas cosas de MQL5 en MetaTrader 4.
Artículos de esta serie:
Trabajando con las series temporales en la biblioteca DoEasy (Parte 35): El objeto "Barra" y la lista de serie temporal del símboloTrabajando con las series temporales en la biblioteca DoEasy (Parte 36): El objeto de series temporales de todos los periodos utilizados del símbolo
Trabajando con las series temporales en la biblioteca DoEasy (Parte 37): Colección de series temporales - Base de datos de series temporales según el símbolo y el periodo
Trabajando con las series temporales en la biblioteca DoEasy (Parte 38): Colección de series temporales - Actualización en tiempo real y acceso a los datos desde el programa
Trabajando con las series temporales en la biblioteca DoEasy (Parte 39): Indicadores basados en la biblioteca - Preparación de datos y eventos de la series temporales
Trabajando con las series temporales en la biblioteca DoEasy (Parte 40): Indicadores basados en la biblioteca - actualización de datos en tiempo real
Trabajando con las series temporales en la biblioteca DoEasy (Parte 41): Ejemplo de indicador de símbolo y periodo múltiples
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/7821
![Monitoreo multidivisas de las señales comerciales (Parte 5): Señales compuestas](https://c.mql5.com/2/39/Article_Logo.png)
![Trabajando con las series temporales en la biblioteca DoEasy (Parte 41): Ejemplo de indicador de símbolo y periodo múltiples](https://c.mql5.com/2/38/MQL5-avatar-doeasy-library__6.png)
![Trabajando con las series temporales en la biblioteca DoEasy (Parte 43): Las clases de los objetos de búferes de indicador](https://c.mql5.com/2/38/MQL5-avatar-doeasy-library__8.png)
![Sobre los métodos de búsqueda de las zonas de sobrecompra/sobreventa. Parte I](https://c.mql5.com/2/39/logo_200x200.png)
![MQL5 - Lenguaje de estrategias comerciales para el terminal de cliente MetaTrader 5](https://c.mql5.com/i/registerlandings/logo-2.png)
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso