Trabalhando com séries temporais na biblioteca DoEasy (Parte 51): indicadores padrão multiperíodos multissímbolos compostos
441
0
Sumário
Ideia
Hoje estaremos concluindo a criação de objetos para indicadores padrão multissímbolos multiperíodos. Acontece que, no final das contas, deixamos um exemplo muito bom para mostrar a criação do indicador Ichimoku Kinko Hyo. Para desenhá-lo, precisamos não apenas criar todos os buffers significativos que são exibidos na janela de dados do terminal, mas também adicionar dois buffers adicionais para preencher o espaço entre as linhas 'Senkou Span A' e 'Senkou Span B' com ajuda de dois histogramas desenhados entre dois valores. Além disso, cada um dos histogramas deve repetir o estilo e a cor da linha a que pertence.
A criação de tal indicador será um bom exemplo de como podemos criar nossos indicadores personalizados complexos usando esta biblioteca.
Finalmente, criaremos o último objeto do indicador multissímbolo multiperíodo a partir de todo o conjunto de indicadores padrão do terminal MetaTrader5, indicador de Bill Williams Gator Oscillator baseado em seu próprio indicador Alligator, que consideramos no último artigo.
Visto que podemos criar indicadores de qualquer complexidade possuindo diferentes tipos de linhas com seus objetos-buffer, embora todos eles pertençam a um objeto do indicador, precisamos introduzir mais uma propriedade, nomeadamente o número da linha indicadora adicional (um buffer auxiliar para desenhar linhas do indicador adicionais). Assim, pelo número desta linha, determinaremos com precisão a linha auxiliar necessária (objeto-buffer) de qualquer objeto-indicador.
Por exemplo, se quisermos que o indicador que desenha uma média móvel exiba alguns estados de sua linha principal, como o preço cruzando a linha, a interação da linha com outros indicadores, etc., podemos adicionar um ou mais objetos-buffers ao nosso indicador personalizado e exibir no gráfico através deste buffer os dados necessários nos momentos certos, como colocar setas, pintar áreas, etc.
Modificando classes e métodos de biblioteca
Em primeiro lugar, vamos adicionar uma nova mensagem de texto da biblioteca no arquivo \MQL5\Include\DoEasy\Data.mqh.
Escrevemos o índice da nova mensagem:
//--- 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_BASE, // Index of the array to be assigned as the next indicator buffer MSG_LIB_TEXT_BUFFER_TEXT_INDEX_NEXT_PLOT, // Index of the next drawn buffer MSG_LIB_TEXT_BUFFER_TEXT_ID, // Indicator buffer ID MSG_LIB_TEXT_BUFFER_TEXT_IND_LINE_MODE, // Indicator line MSG_LIB_TEXT_BUFFER_TEXT_IND_HANDLE, // Handle of an indicator using a buffer MSG_LIB_TEXT_BUFFER_TEXT_IND_TYPE, // Type of an indicator using a buffer MSG_LIB_TEXT_BUFFER_TEXT_IND_LINE_ADDITIONAL_NUM, // Number of additional line MSG_LIB_TEXT_BUFFER_TEXT_TIMEFRAME, // Buffer (timeframe) data period
e o texto correspondente ao índice recém-adicionado:
{"Индекс базового буфера данных","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"},
{"Индекс следующего по счёту рисуемого буфера","Index of the next drawable buffer"},
{"Идентификатор буферов индикатора","Indicator Buffer Id"},
{"Линия индикатора","Indicator line"},
{"Хэндл индикатора, использующего буфер","Indicator handle that uses the buffer"},
{"Тип индикатора, использующего буфер","Indicator type that uses the buffer"},
{"Номер дополнительной линии","Additional line number"},
{"Период данных буфера (таймфрейм)","Buffer data Period (Timeframe)"},
À enumeração de tipos de linhas dos indicadores localizada no arquivo \MQL5\Include\DoEasy\Defines.mqh adicionamos novas linhas para o indicador Ichimoku Kinko Hyo e mais uma linha como auxiliar para gerar indicadores próprios:
//+------------------------------------------------------------------+ //| Values of indicator lines in enumeration | //+------------------------------------------------------------------+ enum ENUM_INDICATOR_LINE_MODE { INDICATOR_LINE_MODE_MAIN = 0, // Main line INDICATOR_LINE_MODE_SIGNAL = 1, // Signal line INDICATOR_LINE_MODE_UPPER = 0, // Upper line INDICATOR_LINE_MODE_LOWER = 1, // Lower line INDICATOR_LINE_MODE_MIDDLE = 2, // Middle line INDICATOR_LINE_MODE_JAWS = 0, // Jaws line INDICATOR_LINE_MODE_TEETH = 1, // Teeth line INDICATOR_LINE_MODE_LIPS = 2, // Lips line INDICATOR_LINE_MODE_DI_PLUS = 1, // +DI line INDICATOR_LINE_MODE_DI_MINUS = 2, // -DI line INDICATOR_LINE_MODE_TENKAN_SEN = 0, // Tenkan-sen line INDICATOR_LINE_MODE_KIJUN_SEN = 1, // Kijun-sen line INDICATOR_LINE_MODE_SENKOU_SPANA = 2, // Senkou Span A line INDICATOR_LINE_MODE_SENKOU_SPANB = 3, // Senkou Span B line INDICATOR_LINE_MODE_CHIKOU_SPAN = 4, // Chikou Span line INDICATOR_LINE_MODE_ADDITIONAL = 5, // Additional line }; //+------------------------------------------------------------------+
Visto que no último artigo definimos os mesmos valores para linhas indicadoras idênticas nesta enumeração e combinamos os manipuladores de diferentes objetos de indicadores padrão num, agora, ao exibir a descrição do tipo de linha do objeto-buffer, exibimos as descrições de linha correspondentes aos primeiros valores encontrados para esta enumeração. Por exemplo, se exibirmos a descrição da linha Jaws do indicador Alligator padrão e o valor da constante INDICATOR_LINE_MODE_JAWS nesta enumeração for igual a zero, veremos a descrição da primeira constante desta enumeração cujo valor também será igual a zero, isto é, da constante INDICATOR_LINE_MODE_MAIN.
Isso não é um erro, é mais um mal-entendido. Para evitar isso, precisamos ter um valor exclusivo para cada constante de enumeração. Porém, nesse caso, teremos que separar os manipuladores novamente, o que será muito pior. Portanto, faremos o seguinte: adicionaremos mais uma enumeração e exibiremos a descrição da linha do objeto-buffer, verificando qual linha de qual indicador em particular o buffer exibirá, e geraremos o valor da nova enumeração correspondente ao objeto-buffer.
Vamos adicionar esta enumeração:
//+------------------------------------------------------------------+ //| Enumeration of indicator lines | //+------------------------------------------------------------------+ enum ENUM_INDICATOR_LINE { INDICATOR_LINE_MAIN, // Main line INDICATOR_LINE_SIGNAL, // Signal line INDICATOR_LINE_UPPER, // Upper line INDICATOR_LINE_LOWER, // Lower line INDICATOR_LINE_MIDDLE, // Middle line INDICATOR_LINE_JAWS, // Jaws line INDICATOR_LINE_TEETH, // Teeth line INDICATOR_LINE_LIPS, // Lips line INDICATOR_LINE_DI_PLUS, // +DI line INDICATOR_LINE_DI_MINUS, // -DI line INDICATOR_LINE_TENKAN_SEN, // Tenkan-sen line INDICATOR_LINE_KIJUN_SEN, // Kijun-sen line INDICATOR_LINE_SENKOU_SPANA, // Senkou Span A line INDICATOR_LINE_SENKOU_SPANB, // Senkou Span B line INDICATOR_LINE_CHIKOU_SPAN, // Chikou Span line INDICATOR_LINE_ADDITIONAL, // Additional line }; //+------------------------------------------------------------------+
Nessa enumeração, cada constante tem seu próprio valor exclusivo de 0 a 15. Agora podemos exibir facilmente os valores de que precisamos para cada linha específica de um indicador em particular. Faremos isso a seguir.
No mesmo arquivo adicionamos mais uma propriedade inteira do objeto-buffer e, ao mesmo tempo, aumentamos o número de propriedades inteiras do objeto de 24 para 25:
//+------------------------------------------------------------------+ //| 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_DRAW_TYPE, // Graphical construction type (from the ENUM_DRAW_TYPE enumeration) 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_LINE_STYLE, // Line style BUFFER_PROP_LINE_WIDTH, // Line width 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_SHIFT, // Indicator graphical construction shift by time axis in bars BUFFER_PROP_COLOR_INDEXES, // Number of colors BUFFER_PROP_COLOR, // Drawing color BUFFER_PROP_INDEX_BASE, // Base data buffer index BUFFER_PROP_INDEX_NEXT_BASE, // Index of the array to be assigned as the next indicator buffer BUFFER_PROP_INDEX_NEXT_PLOT, // Index of the next drawn buffer BUFFER_PROP_ID, // ID of multiple buffers of a single indicator BUFFER_PROP_IND_LINE_MODE, // Indicator line BUFFER_PROP_IND_HANDLE, // Handle of an indicator using a buffer BUFFER_PROP_IND_TYPE, // Type of an indicator using a buffer BUFFER_PROP_IND_LINE_ADDITIONAL_NUM, // Number of indicator additional line BUFFER_PROP_NUM_DATAS, // Number of data buffers BUFFER_PROP_INDEX_COLOR, // Color buffer index }; #define BUFFER_PROP_INTEGER_TOTAL (25) // Total number of integer bar properties #define BUFFER_PROP_INTEGER_SKIP (2) // Number of buffer properties not used in sorting //+------------------------------------------------------------------+
Para poder pesquisar e classificar objetos-buffers por nova propriedade, adicionamos esta propriedade à lista de possíveis critérios de classificação:
//+------------------------------------------------------------------+ //| 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_DRAW_TYPE, // Sort by graphical construction type (from the ENUM_DRAW_TYPE enumeration) 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_LINE_STYLE, // Sort by the line style SORT_BY_BUFFER_LINE_WIDTH, // Sort by the line width 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_SHIFT, // Sort by the indicator graphical construction shift by time axis in bars SORT_BY_BUFFER_COLOR_INDEXES, // Sort by a number of attempts SORT_BY_BUFFER_COLOR, // Sort by the drawing color SORT_BY_BUFFER_INDEX_BASE, // Sort by the basic data buffer index SORT_BY_BUFFER_INDEX_NEXT_BASE, // Sort by the index of the array to be assigned as the next indicator buffer SORT_BY_BUFFER_INDEX_NEXT_PLOT, // Sort by the index of the next drawn buffer SORT_BY_BUFFER_ID, // Sort by ID of multiple buffers of a single indicator SORT_BY_BUFFER_IND_LINE_MODE, // Sort by the indicator line SORT_BY_BUFFER_IND_HANDLE, // Sort by handle of an indicator using a buffer SORT_BY_BUFFER_IND_TYPE, // Sort by type of an indicator using a buffer SORT_BY_BUFFER_IND_LINE_ADDITIONAL_NUM, // Sort by number of additional indicator line //--- 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 SORT_BY_BUFFER_IND_NAME, // Sort by name of an indicator using a buffer SORT_BY_BUFFER_IND_NAME_SHORT, // Sort by a short name of an indicator using a buffer }; //+------------------------------------------------------------------+
Agora precisamos modificar ligeiramente a classe do objeto de buffer abstrato no arquivo \MQL5\Include\DoEasy\Objects\Indicators\Buffer.mqh.
Na seção pública da classe, escrevemos os métodos para definir e retornar o número da linha adicional:
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) {;} //--- Set (1) the arrow code, (2) vertical shift of arrows, (3) symbol, (4) timeframe, (5) buffer activity flag //--- (6) drawing type, (7) number of initial bars without drawing, (8) flag of displaying construction values in DataWindow, //--- (9) shift of the indicator graphical construction along the time axis, (10) line style, (11) line width, //--- (12) total number of colors, (13) one drawing color, (14) color of drawing in the specified color index, //--- (15) drawing colors from the color array, (16) empty value, (17) name of the graphical series 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 SetDrawType(const ENUM_DRAW_TYPE draw_type); 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 SetColor(const color colour,const uchar index); void SetColors(const color &array_colors[]); void SetEmptyValue(const double value); virtual void SetLabel(const string label); void SetID(const int id) { this.SetProperty(BUFFER_PROP_ID,id); } void SetIndicatorHandle(const int handle) { this.SetProperty(BUFFER_PROP_IND_HANDLE,handle); } void SetIndicatorType(const ENUM_INDICATOR type) { this.SetProperty(BUFFER_PROP_IND_TYPE,type); } void SetIndicatorName(const string name) { this.SetProperty(BUFFER_PROP_IND_NAME,name); } void SetIndicatorShortName(const string name) { this.SetProperty(BUFFER_PROP_IND_NAME_SHORT,name); } void SetLineMode(const ENUM_INDICATOR_LINE_MODE mode){ this.SetProperty(BUFFER_PROP_IND_LINE_MODE,mode); } void SetIndicatorLineAdditionalNumber(const int number){this.SetProperty(BUFFER_PROP_IND_LINE_ADDITIONAL_NUM,number); } //--- 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) index of the next drawn buffer, (6) buffer data period, (7) buffer status, //--- (8) buffer type, (9) buffer usage flag, (10) arrow code, (11) arrow shift for DRAW_ARROW style, //--- (12) number of initial bars that are not drawn and values in DataWindow, (13) graphical construction type, //--- (14) flag of displaying construction values in DataWindow, (15) indicator graphical construction shift along the time axis, //--- (16) drawing line style, (17) drawing line width, (18) number of colors, (19) drawing color, (20) number of buffers for construction //--- (21) set empty value, (22) buffer symbol and (23) name of the indicator graphical series displayed in DataWindow //--- (24) buffer ID, (25) indicator handle, (26) standard indicator type, (27) standard indicator name, //--- (28) number of standard indicator calculated bars, (29) number of additional indicator line, (30) line type (main, signal, etc.) 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 IndexNextBaseBuffer(void) const { return (int)this.GetProperty(BUFFER_PROP_INDEX_NEXT_BASE); } int IndexNextPlotBuffer(void) const { return (int)this.GetProperty(BUFFER_PROP_INDEX_NEXT_PLOT); } 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 ColorsTotal(void) const { return (int)this.GetProperty(BUFFER_PROP_COLOR_INDEXES); } color Color(void) const { return (color)this.GetProperty(BUFFER_PROP_COLOR); } int BuffersTotal(void) const { return (int)this.GetProperty(BUFFER_PROP_NUM_DATAS); } 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); } int ID(void) const { return (int)this.GetProperty(BUFFER_PROP_ID); } int IndicatorHandle(void) const { return (int)this.GetProperty(BUFFER_PROP_IND_HANDLE); } ENUM_INDICATOR IndicatorType(void) const { return (ENUM_INDICATOR)this.GetProperty(BUFFER_PROP_IND_TYPE); } string IndicatorName(void) const { return this.GetProperty(BUFFER_PROP_IND_NAME); } string IndicatorShortName(void) const { return this.GetProperty(BUFFER_PROP_IND_NAME_SHORT); } int IndicatorBarsCalculated(void) const { return ::BarsCalculated((int)this.GetProperty(BUFFER_PROP_IND_HANDLE));} int IndicatorLineAdditionalNumber(void) const { return (int)this.GetProperty(BUFFER_PROP_IND_LINE_ADDITIONAL_NUM); } int IndicatorLineMode(void) const { return (int)this.GetProperty(BUFFER_PROP_IND_LINE_MODE); }
Visto que iremos agora exibir a descrição da linha do indicador desde outra enumeração (que escrevemos acima), o método IndicatorLineMode() agora retornará um valor inteiro em vez do valor de enumeração ENUM_INDICATOR_LINE_MODE.
No mesmo local, na seção pública da classe, declaramos um método que retorna uma descrição da linha do indicador:
//--- 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 and (9) specified colors 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; string GetColorsDescription(void) const; string GetIndicatorLineModeDescription(void) const;
e escrever sua implementação fora do corpo da classe:
//+------------------------------------------------------------------+ //| Return description of indicator buffer line | //+------------------------------------------------------------------+ string CBuffer::GetIndicatorLineModeDescription(void) const { uchar shift=0; switch(this.IndicatorType()) { case IND_ENVELOPES : case IND_FRACTALS : case IND_GATOR : case IND_BANDS : shift=2; break; case IND_ALLIGATOR : shift=5; break; case IND_ADX : case IND_ADXW : shift=8; break; case IND_ICHIMOKU : shift=10;break; default : shift=0; break; } return ::StringSubstr(::EnumToString(ENUM_INDICATOR_LINE(this.GetProperty(BUFFER_PROP_IND_LINE_MODE)+shift)),10); } //+------------------------------------------------------------------+
Aqui: declaramos uma variável que armazena o valor de deslocamento necessário para aumentar os valores da constante de enumeração ENUM_INDICATOR_LINE_MODE a fim de chegar ao início da declaração das constantes de linha do indicador correspondente na enumeração ENUM_INDICATOR_LINE.
Por exemplo, se precisarmos exibir a descrição da linha Teeth do indicador Allegator, o valor de deslocamento será 5, o que aponta para a constante INDICATOR_LINE_JAWS da enumeração ENUM_INDICATOR_LINE:
//+------------------------------------------------------------------+ //| Enumeration of indicator lines | //+------------------------------------------------------------------+ enum ENUM_INDICATOR_LINE { INDICATOR_LINE_MAIN, // Main line INDICATOR_LINE_SIGNAL, // Signal line INDICATOR_LINE_UPPER, // Upper line INDICATOR_LINE_LOWER, // Lower line INDICATOR_LINE_MIDDLE, // Middle line INDICATOR_LINE_JAWS, // Jaws line INDICATOR_LINE_TEETH, // Teeth line INDICATOR_LINE_LIPS, // Lips line INDICATOR_LINE_DI_PLUS, // +DI line INDICATOR_LINE_DI_MINUS, // -DI line INDICATOR_LINE_TENKAN_SEN, // Tenkan-sen line INDICATOR_LINE_KIJUN_SEN, // Kijun-sen line INDICATOR_LINE_SENKOU_SPANA, // Senkou Span A line INDICATOR_LINE_SENKOU_SPANB, // Senkou Span B line INDICATOR_LINE_CHIKOU_SPAN, // Chikou Span line INDICATOR_LINE_ADDITIONAL, // Additional line }; //+------------------------------------------------------------------+
Visto que nosso buffer retorna o valor da linha Teeth desde o método GetProperty (BUFFER_PROP_IND_LINE_MODE) e este valor é igual a um, adicionaremos o valor 5 a um, resultando num índice de constante igual a 6, o que aponta para a constante INDICATOR_LINE_TEETH.
Como resultado, o método retorna uma descrição de string da constante recebida, truncada para o valor "LINE_TEETH".
No construtor privado da classe definimos para a nova propriedade do objeto-buffer o valor padrão -1, o que não significará uma linha indicadora adicional:
//+------------------------------------------------------------------+ //| Closed parametric constructor | //+------------------------------------------------------------------+ CBuffer::CBuffer(ENUM_BUFFER_STATUS buffer_status, ENUM_BUFFER_TYPE buffer_type, const uint index_plot, const uint index_base_array, const int num_datas, const uchar total_arrays, const int width, const string label) { this.m_type=COLLECTION_BUFFERS_ID; this.m_act_state_trigger=true; this.m_total_arrays=total_arrays; //--- Save integer properties this.m_long_prop[BUFFER_PROP_STATUS] = buffer_status; this.m_long_prop[BUFFER_PROP_TYPE] = buffer_type; this.m_long_prop[BUFFER_PROP_ID] = WRONG_VALUE; this.m_long_prop[BUFFER_PROP_IND_LINE_MODE] = INDICATOR_LINE_MODE_MAIN; this.m_long_prop[BUFFER_PROP_IND_HANDLE] = INVALID_HANDLE; this.m_long_prop[BUFFER_PROP_IND_TYPE] = WRONG_VALUE; this.m_long_prop[BUFFER_PROP_IND_LINE_ADDITIONAL_NUM] = WRONG_VALUE; ENUM_DRAW_TYPE type= (
No método que retorna uma descrição da propriedade inteira do objeto-buffer, escrevemos um bloco de código para retornar uma descrição de uma nova propriedade, e corrijimos o bloco de código que exibe a descrição da linha do indicador (agora exibiremos a descrição pelo método recém-escrito para isso):
//+------------------------------------------------------------------+ //| 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_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_TIMEFRAME ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_TIMEFRAME)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.GetTimeframeDescription() ) : 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_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_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_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 ? (this.Status()==BUFFER_STATUS_ARROW ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_ARROW_SIZE) : 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_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_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_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_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_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_INDEX_NEXT_BASE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_INDEX_NEXT_BASE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_INDEX_NEXT_PLOT ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_INDEX_NEXT_PLOT)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_ID ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_ID)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_IND_LINE_MODE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_IND_LINE_MODE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.GetIndicatorLineModeDescription() ) : property==BUFFER_PROP_IND_HANDLE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_IND_HANDLE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(string)this.GetProperty(property) ) : property==BUFFER_PROP_IND_TYPE ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_IND_TYPE)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+::StringSubstr(::EnumToString((ENUM_INDICATOR)this.GetProperty(property)),4) ) : property==BUFFER_PROP_IND_LINE_ADDITIONAL_NUM ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_IND_LINE_ADDITIONAL_NUM)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+(this.GetProperty(property)==WRONG_VALUE ? CMessage::Text(MSG_LIB_PROP_NOT_SET) : (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_COLOR ? CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_COLOR)+ (!this.SupportProperty(property) ? ": "+CMessage::Text(MSG_LIB_PROP_NOT_SUPPORTED) : ": "+this.GetColorsDescription() ) : "" ); } //+------------------------------------------------------------------+
Visto que adicionamos uma nova propriedade inteira, em todas as classes de objetos que herdam objetos-buffers abstratos precisamos modificar o método virtual que retorna um sinalizador de que o objeto suporta esta nova propriedade (com ajuda do exemplo do método de classe CBufferArrow):
//+------------------------------------------------------------------+ //| Return 'true' if a buffer supports a passed | //| integer property, otherwise return 'false' | //+------------------------------------------------------------------+ bool CBufferArrow::SupportProperty(ENUM_BUFFER_PROP_INTEGER property) { if(property==BUFFER_PROP_LINE_STYLE || ( this.TypeBuffer()==BUFFER_TYPE_CALCULATE && property!=BUFFER_PROP_TYPE && property!=BUFFER_PROP_INDEX_NEXT_BASE && property!=BUFFER_PROP_IND_LINE_MODE && property!=BUFFER_PROP_IND_HANDLE && property!=BUFFER_PROP_IND_TYPE && property!=BUFFER_PROP_IND_LINE_ADDITIONAL_NUM && property!=BUFFER_PROP_ID ) ) return false; return true; } //+------------------------------------------------------------------+
Exatamente as mesmas alterações foram feitas em todos os arquivos de todos os objetos-buffers, como BufferArrow.mqh, BufferBars.mqh, BufferCandles.mqh, BufferFilling.mqh, BufferHistogram.mqh, BufferHistogram2.mqh, BufferLine.mqh, BufferSection.mqh e BufferZigZag.mqh.
Todos os métodos para criar objetos indicadores padrão estão localizados na classe-coleção de objetos-buffers
no arquivo \MQL5\Include\DoEasy\Collections\BuffersCollection.mqh. Antes de adicionarmos dois métodos para criar objetos dos indicadores padrão Ichimoku Kinko Hyo e Gator Oscillator, vamos modificar ligeiramente o método de preparação dos dados do indicador padrão especificado para definir valores no gráfico de símbolo atual. Visto que o indicador Ichimoku Kinko Hyo tem cinco buffers desenhados e nosso método recebe apenas três ponteiros para objetos-buffers de indicadores padrão e, consequentemente, seis variáveis por referência (duas para cada um dos buffers) para escrever os valores das linhas do indicador, precisaremos acrescentar ao método a transferência de quatro ponteiros adicionais para objetos-buffers (dois desenhados e calculados) e passar mais quatro variáveis por referência.
No corpo da classe, adicionamos os valores necessários à declaração do método:
//--- Set the values for the current chart to the buffers of the specified standard indicator by the timeseries index according to the buffer object period/symbol bool SetDataBufferStdInd(const ENUM_INDICATOR std_ind,const int id,const int series_index,const datetime series_time,const char color_index=WRONG_VALUE); private: //--- Prepare data of the specified standard indicator for setting values on the current symbol chart int PreparingSetDataStdInd(CBuffer *buffer_data0,CBuffer *buffer_data1,CBuffer *buffer_data2,CBuffer *buffer_data3,CBuffer *buffer_data4, CBuffer *buffer_calc0,CBuffer *buffer_calc1,CBuffer *buffer_calc2,CBuffer *buffer_calc3,CBuffer *buffer_calc4, const ENUM_INDICATOR ind_type, const int series_index, const datetime series_time, int &index_period, int &num_bars, double &value00, double &value01, double &value10, double &value11, double &value20, double &value21, double &value30, double &value31, double &value40, double &value41); public: //--- Return the buffer (1) by the graphical series name, (2) by timeframe,
Na implementação do método escrito fora do corpo da classe adicionamos as mudanças necessárias:
//+------------------------------------------------------------------+ //| Prepare data of the specified standard indicator | //| for setting values on the current symbol chart | //+------------------------------------------------------------------+ int CBuffersCollection::PreparingSetDataStdInd(CBuffer *buffer_data0,CBuffer *buffer_data1,CBuffer *buffer_data2,CBuffer *buffer_data3,CBuffer *buffer_data4, CBuffer *buffer_calc0,CBuffer *buffer_calc1,CBuffer *buffer_calc2,CBuffer *buffer_calc3,CBuffer *buffer_calc4, const ENUM_INDICATOR ind_type, const int series_index, const datetime series_time, int &index_period, int &num_bars, double &value00, double &value01, double &value10, double &value11, double &value20, double &value21, double &value30, double &value31, double &value40, double &value41) { //--- Find the bar index corresponding to the current bar start time index_period=::iBarShift(buffer_calc0.Symbol(),buffer_calc0.Timeframe(),series_time,true); if(index_period==WRONG_VALUE || index_period>buffer_calc0.GetDataTotal()-1) return WRONG_VALUE; //--- Get the value by the index from the indicator buffer if(buffer_calc0!=NULL) value00=buffer_calc0.GetDataBufferValue(0,index_period); if(buffer_calc1!=NULL) value10=buffer_calc1.GetDataBufferValue(0,index_period); if(buffer_calc2!=NULL) value20=buffer_calc2.GetDataBufferValue(0,index_period); if(buffer_calc3!=NULL) value30=buffer_calc3.GetDataBufferValue(0,index_period); if(buffer_calc4!=NULL) value40=buffer_calc4.GetDataBufferValue(0,index_period); int series_index_start=series_index; //--- The current chart requires no calculation of the number of handled bars since there is only one bar if(buffer_calc0.Symbol()==::Symbol() && buffer_calc0.Timeframe()==::Period()) { series_index_start=series_index; num_bars=1; } else { //--- Get the bar time the bar with the index_period index falls into on the calculated buffer period and symbol datetime time_period=::iTime(buffer_calc0.Symbol(),buffer_calc0.Timeframe(),index_period); if(time_period==0) return false; //--- Get the appropriate current chart bar series_index_start=::iBarShift(::Symbol(),::Period(),time_period,true); if(series_index_start==WRONG_VALUE) return WRONG_VALUE; //--- Calculate the number of bars on the current chart which should be filled with calculated buffer data num_bars=::PeriodSeconds(buffer_calc0.Timeframe())/::PeriodSeconds(PERIOD_CURRENT); if(num_bars==0) num_bars=1; } //--- Set values to calculate colors if(buffer_calc0!=NULL) value01=(series_index_start+num_bars>buffer_data0.GetDataTotal()-1 ? value00 : buffer_data0.GetDataBufferValue(0,series_index_start+num_bars)); if(buffer_calc1!=NULL) value11=(series_index_start+num_bars>buffer_data1.GetDataTotal()-1 ? value10 : buffer_data1.GetDataBufferValue(0,series_index_start+num_bars)); if(buffer_calc2!=NULL) value21=(series_index_start+num_bars>buffer_data2.GetDataTotal()-1 ? value20 : buffer_data2.GetDataBufferValue(0,series_index_start+num_bars)); if(buffer_calc3!=NULL) value31=(series_index_start+num_bars>buffer_data3.GetDataTotal()-1 ? value30 : buffer_data3.GetDataBufferValue(0,series_index_start+num_bars)); if(buffer_calc4!=NULL) value41=(series_index_start+num_bars>buffer_data4.GetDataTotal()-1 ? value40 : buffer_data4.GetDataBufferValue(0,series_index_start+num_bars)); return series_index_start; } //+------------------------------------------------------------------+
Em geral, acabamos de adicionar exatamente o mesmo processamento - que para os objetos-buffers já existentes no método - a dois novos objetos-buffers, cujos ponteiros são passados para o método, e o registro de valores para as variáveis correspondentes aos buffers, passados para o método por referência.
Como no indicador Ichimoku Kinko Hyo padrão, entre suas duas linhas é desenhada uma hachura, sendo que para cada uma delas tem seu próprio tipo de hachura e cor:
... precisamos de um método que retorne um ponteiro para o objeto-buffer do indicador padrão com base no tipo de indicador, seu identificador e linha para que possamos tirar dele todos os parâmetros definidos para desenhar suas linhas e defini-las para o objeto-buffer auxiliar usado para criar a aparência de nosso indicador personalizado.
Na seção pública da classe vamos declarar este método
public: //--- Return the buffer (1) by the graphical series name, (2) by timeframe, //--- (3) by Plot index, (4) by object index in the collection list, (5) the last created one, //--- (6) standard indicator buffer by indicator type, its ID and line CBuffer *GetBufferByLabel(const string plot_label); CBuffer *GetBufferByTimeframe(const ENUM_TIMEFRAMES timeframe); CBuffer *GetBufferByPlot(const int plot_index); CBuffer *GetBufferByListIndex(const int index_list); CBuffer *GetLastCreateBuffer(void); CBuffer *GetBufferStdInd(const ENUM_INDICATOR indicator_type,const int id,const ENUM_INDICATOR_LINE_MODE line_mode,const char additional_id=WRONG_VALUE); //--- Return buffer list (1) by ID, (2) standard indicator type, (3) type and ID
e escrever sua implementação fora do corpo da classe:
//+------------------------------------------------------------------+ //| Return standard indicator buffer | //| by indicator type, its ID and line | //+------------------------------------------------------------------+ CBuffer *CBuffersCollection::GetBufferStdInd(const ENUM_INDICATOR indicator_type,const int id,const ENUM_INDICATOR_LINE_MODE line_mode,const char additional_id=WRONG_VALUE) { CArrayObj *list=this.GetListBufferByTypeID(indicator_type,id); list=CSelect::ByBufferProperty(list,BUFFER_PROP_IND_LINE_MODE,line_mode,EQUAL); list=CSelect::ByBufferProperty(list,BUFFER_PROP_IND_LINE_ADDITIONAL_NUM,additional_id,EQUAL); if(list==NULL) return NULL; return list.At(0); } //+------------------------------------------------------------------+
Aqui tudo é simples: primeiro, obtemos uma lista de objetos-buffers pelo tipo de indicador padrão e seu identificador, em seguida, filtramos a lista resultante pelo tipo de linha do indicador padrão e, finalmente, dos objetos restantes na lista deixamos apenas aqueles que têm um identificador de buffer auxiliar (por padrão, todos os buffers são definidos como -1, o que significa que não existe tal identificador).
Do método retornamos o primeiro objeto da lista filtrada.
Vamos complementar o método que prepara os dados do buffer calculado do indicador padrão especificado para processar os indicadores Ichimoku Kinko Hyo e Gator Oscillator.
Basicamente, só precisamos adicionar o processamento correspondente ao tipo de indicador, processamento esse que é idêntico para todos os indicadores e que já está escrito no método. Mas há uma ligeira diferença para o indicador Gator Oscillator padrão - seu segundo buffer está no índice 2, e não no 1 como o resto dos indicadores de dois buffers porque o buffer de índice 1 pertence ao buffer de cores do buffer de dados de índice 0. Não usaremos os buffers de cor do indicador padrão, uma vez que, além de podermos definir a cor desejada para cada barra nós mesmos, já criamos o processamento e a configuração da cor para as linhas do indicador, portanto, por padrão, a cor das colunas do indicador Gator Oscillator será calculada automaticamente pela biblioteca. Este cálculo já foi feito, e se desejar, o próprio usuário pode transferir a cor desejada para cada barra para os métodos de desenho desses indicadores padrão a fim de criar sua própria cor do indicador.
Para o indicador Ichimoku Kinko Hyo, a preparação de dados é idêntica à preparação de dados de outros indicadores padrão - apenas mais dois buffers.
//+------------------------------------------------------------------+ //| Prepare the calculated buffer data | //| of the specified standard indicator | //+------------------------------------------------------------------+ int CBuffersCollection::PreparingDataBufferStdInd(const ENUM_INDICATOR std_ind,const int id,const int total_copy) { CArrayObj *list_ind=this.GetListBufferByTypeID(std_ind,id); CArrayObj *list; list_ind=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_TYPE,BUFFER_TYPE_CALCULATE,EQUAL); if(list_ind==NULL || list_ind.Total()==0) { ::Print(DFUN_ERR_LINE,CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_NO_BUFFER_OBJ)); return 0; } CBufferCalculate *buffer=NULL; int copied=WRONG_VALUE; int idx0=0,idx1=1,idx2=2; switch((int)std_ind) { //--- Single-buffer standard indicators case IND_AC : case IND_AD : case IND_AMA : case IND_AO : case IND_ATR : case IND_BEARS : case IND_BULLS : case IND_BWMFI : case IND_CCI : case IND_CHAIKIN : case IND_DEMA : case IND_DEMARKER : case IND_FORCE : case IND_FRAMA : case IND_MA : case IND_MFI : case IND_MOMENTUM : case IND_OBV : case IND_OSMA : case IND_RSI : case IND_SAR : case IND_STDDEV : case IND_TEMA : case IND_TRIX : case IND_VIDYA : case IND_VOLUMES : case IND_WPR : buffer=list_ind.At(0); if(buffer==NULL) return 0; copied=buffer.FillAsSeries(buffer.IndicatorHandle(),0,buffer.Shift(),total_copy); return copied; //--- Multi-buffer standard indicators case IND_ENVELOPES : case IND_FRACTALS : case IND_MACD : case IND_RVI : case IND_STOCHASTIC : case IND_GATOR : if(std_ind==IND_GATOR) { idx0=0; idx1=2; } else { idx0=0; idx1=1; } list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,0,EQUAL); buffer=list.At(0); if(buffer==NULL) return 0; copied=buffer.FillAsSeries(buffer.IndicatorHandle(),idx0,buffer.Shift(),total_copy); if(copied<total_copy) return 0; list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,1,EQUAL); buffer=list.At(0); if(buffer==NULL) return 0; copied=buffer.FillAsSeries(buffer.IndicatorHandle(),idx1,buffer.Shift(),total_copy); if(copied<total_copy) return 0; return copied; case IND_ALLIGATOR : case IND_ADX : case IND_ADXW : case IND_BANDS : if(std_ind==IND_BANDS) { idx0=1; idx1=2; idx2=0; } else { idx0=0; idx1=1; idx2=2; } list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,0,EQUAL); buffer=list.At(0); if(buffer==NULL) return 0; copied=buffer.FillAsSeries(buffer.IndicatorHandle(),idx0,buffer.Shift(),total_copy); if(copied<total_copy) return 0; list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,1,EQUAL); buffer=list.At(0); if(buffer==NULL) return 0; copied=buffer.FillAsSeries(buffer.IndicatorHandle(),idx1,buffer.Shift(),total_copy); if(copied<total_copy) return 0; list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,2,EQUAL); buffer=list.At(0); if(buffer==NULL) return 0; copied=buffer.FillAsSeries(buffer.IndicatorHandle(),idx2,buffer.Shift(),total_copy); if(copied<total_copy) return 0; return copied; case IND_ICHIMOKU : list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_TENKAN_SEN,EQUAL); buffer=list.At(0); if(buffer==NULL) return 0; copied=buffer.FillAsSeries(buffer.IndicatorHandle(),TENKANSEN_LINE,buffer.Shift(),total_copy); if(copied<total_copy) return 0; list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_KIJUN_SEN,EQUAL); buffer=list.At(0); if(buffer==NULL) return 0; copied=buffer.FillAsSeries(buffer.IndicatorHandle(),KIJUNSEN_LINE,buffer.Shift(),total_copy); if(copied<total_copy) return 0; list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_SENKOU_SPANA,EQUAL); buffer=list.At(0); if(buffer==NULL) return 0; copied=buffer.FillAsSeries(buffer.IndicatorHandle(),SENKOUSPANA_LINE,buffer.Shift(),total_copy); if(copied<total_copy) return 0; list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_SENKOU_SPANB,EQUAL); buffer=list.At(0); if(buffer==NULL) return 0; copied=buffer.FillAsSeries(buffer.IndicatorHandle(),SENKOUSPANB_LINE,buffer.Shift(),total_copy); if(copied<total_copy) return 0; list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_CHIKOU_SPAN,EQUAL); buffer=list.At(0); if(buffer==NULL) return 0; copied=buffer.FillAsSeries(buffer.IndicatorHandle(),CHIKOUSPAN_LINE,buffer.Shift(),total_copy); if(copied<total_copy) return 0; return copied; default: break; } return 0; } //+------------------------------------------------------------------+
Ao método para limpar os dados do buffer do indicador padrão especificado pelo índice da série temporal
adicionamos o processamento para os buffers do indicador Ichimoku Kinko Hyo:
//+------------------------------------------------------------------+ //| Clear buffer data of the specified standard indicator | //| by the timeseries index | //+------------------------------------------------------------------+ void CBuffersCollection::ClearDataBufferStdInd(const ENUM_INDICATOR std_ind,const int id,const int series_index) { //--- Get the list of buffer objects by type and ID CArrayObj *list_ind=this.GetListBufferByTypeID(std_ind,id); CArrayObj *list=NULL; if(list_ind==NULL || list_ind.Total()==0) return; list_ind=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_TYPE,BUFFER_TYPE_DATA,EQUAL); if(list_ind.Total()==0) return; CBuffer *buffer=NULL; switch((int)std_ind) { //--- Single-buffer standard indicators case IND_AC : case IND_AD : case IND_AMA : case IND_AO : case IND_ATR : case IND_BEARS : case IND_BULLS : case IND_BWMFI : case IND_CCI : case IND_CHAIKIN : case IND_DEMA : case IND_DEMARKER : case IND_FORCE : case IND_FRAMA : case IND_MA : case IND_MFI : case IND_MOMENTUM : case IND_OBV : case IND_OSMA : case IND_RSI : case IND_SAR : case IND_STDDEV : case IND_TEMA : case IND_TRIX : case IND_VIDYA : case IND_VOLUMES : case IND_WPR : buffer=list_ind.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); break; //--- Multi-buffer standard indicators case IND_ENVELOPES : case IND_FRACTALS : case IND_MACD : case IND_RVI : case IND_STOCHASTIC : case IND_GATOR : list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,0,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,1,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); break; case IND_ALLIGATOR : case IND_ADX : case IND_ADXW : case IND_BANDS : list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,0,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,1,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,2,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); break; case IND_ICHIMOKU : list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_TENKAN_SEN,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_KIJUN_SEN,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_SENKOU_SPANA,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_SENKOU_SPANB,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_CHIKOU_SPAN,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_ADDITIONAL,EQUAL); list=CSelect::ByBufferProperty(list,BUFFER_PROP_IND_LINE_ADDITIONAL_NUM,0,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); list=CSelect::ByBufferProperty(list_ind,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_ADDITIONAL,EQUAL); list=CSelect::ByBufferProperty(list,BUFFER_PROP_IND_LINE_ADDITIONAL_NUM,1,EQUAL); buffer=list.At(0); if(buffer==NULL) return; buffer.SetBufferValue(0,series_index,buffer.EmptyValue()); break; default: break; } } //+------------------------------------------------------------------+
Como, posteriormente, iremos criar um objeto do indicador Ichimoku Kinko Hyo padrão que terá dois buffers-histogramas adicionais para gerar a aparência do indicador, blocos de código já foram adicionados ao método para limpar os dados desses dois buffers auxiliares.
Todo o resto é idêntico, é limpar dados de buffers de outros indicadores padrão escritos por nós em artigos anteriores.
Vamos melhorar o método que define os valores do gráfico atual para os buffers do indicador padrão especificado pelo índice da série temporal de acordo com o símbolo/período do objeto-buffer.
Agora o método terá mais objetos-buffers, uma vez que o indicador Ichimoku Kinko Hyo tem cinco, mais dois buffers-histogramas auxiliares para gerar a aparência do indicador. Assim, o número de variáveis para armazenar os valores de todas as linhas de objetos-buffers aumenta:
//+------------------------------------------------------------------+ //| Set values for the current chart to the buffers of the specified | //| standard indicator by the timeseries index according to | //| the buffer object symbol/period | //+------------------------------------------------------------------+ bool CBuffersCollection::SetDataBufferStdInd(const ENUM_INDICATOR ind_type,const int id,const int series_index,const datetime series_time,const char color_index=WRONG_VALUE) { //--- Get the list of buffer objects by type and ID CArrayObj *list=this.GetListBufferByTypeID(ind_type,id); if(list==NULL || list.Total()==0) { ::Print(DFUN,CMessage::Text(MSG_LIB_TEXT_BUFFER_TEXT_NO_BUFFER_OBJ)); return false; } //--- Get the list of drawn objects with ID CArrayObj *list_data=CSelect::ByBufferProperty(list,BUFFER_PROP_TYPE,BUFFER_TYPE_DATA,EQUAL); list_data=CSelect::ByBufferProperty(list_data,BUFFER_PROP_IND_TYPE,ind_type,EQUAL); //--- Get the list of calculated buffers with ID CArrayObj *list_calc=CSelect::ByBufferProperty(list,BUFFER_PROP_TYPE,BUFFER_TYPE_CALCULATE,EQUAL); list_calc=CSelect::ByBufferProperty(list_calc,BUFFER_PROP_IND_TYPE,ind_type,EQUAL); //--- Exit if any of the lists is empty if(list_data.Total()==0 || list_calc.Total()==0) return false; //--- Declare the necessary objects and variables CBuffer *buffer_data0=NULL,*buffer_data1=NULL,*buffer_data2=NULL,*buffer_data3=NULL,*buffer_data4=NULL,*buffer_tmp0=NULL,*buffer_tmp1=NULL; CBuffer *buffer_calc0=NULL,*buffer_calc1=NULL,*buffer_calc2=NULL,*buffer_calc3=NULL,*buffer_calc4=NULL; double value00=EMPTY_VALUE, value01=EMPTY_VALUE; double value10=EMPTY_VALUE, value11=EMPTY_VALUE; double value20=EMPTY_VALUE, value21=EMPTY_VALUE; double value30=EMPTY_VALUE, value31=EMPTY_VALUE; double value40=EMPTY_VALUE, value41=EMPTY_VALUE; double value_tmp0=EMPTY_VALUE,value_tmp1=EMPTY_VALUE; long vol0=0,vol1=0; int series_index_start=series_index,index_period=0, index=0,num_bars=1; uchar clr=0; //--- Depending on the standard indicator type
Em cada bloco de código que processa seu próprio conjunto de indicadores padrão, ao método de preparação de dados do buffer PreparingSetDataStdInd() transferimos agora mais valores:
series_index_start=PreparingSetDataStdInd(buffer_data0,buffer_data1,buffer_data2,buffer_data3,buffer_data4, buffer_calc0,buffer_calc1,buffer_calc2,buffer_calc3,buffer_calc4, ind_type,series_index,series_time,index_period,num_bars, value00,value01,value10,value11,value20,value21,value30,value31,value40,value41);
No final do método, adicionamos manipuladores de indicadores padrão Ichimoku Kinko Hyo e Gator Oscillator:
case IND_ICHIMOKU : list=CSelect::ByBufferProperty(list_data,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_TENKAN_SEN,EQUAL); buffer_data0=list.At(0); list=CSelect::ByBufferProperty(list_data,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_KIJUN_SEN,EQUAL); buffer_data1=list.At(0); list=CSelect::ByBufferProperty(list_data,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_SENKOU_SPANA,EQUAL); buffer_data2=list.At(0); list=CSelect::ByBufferProperty(list_data,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_SENKOU_SPANB,EQUAL); buffer_data3=list.At(0); list=CSelect::ByBufferProperty(list_data,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_CHIKOU_SPAN,EQUAL); buffer_data4=list.At(0); //--- Get the list of buffer objects which have ID of auxiliary line, and from it - buffer object with line number as 0 list=CSelect::ByBufferProperty(list_data,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_ADDITIONAL,EQUAL); list=CSelect::ByBufferProperty(list,BUFFER_PROP_IND_LINE_ADDITIONAL_NUM,0,EQUAL); buffer_tmp0=list.At(0); //--- Get the list of buffer objects which have ID of auxiliary line, and from it - buffer object with line number as 1 list=CSelect::ByBufferProperty(list_data,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_ADDITIONAL,EQUAL); list=CSelect::ByBufferProperty(list,BUFFER_PROP_IND_LINE_ADDITIONAL_NUM,1,EQUAL); buffer_tmp1=list.At(0); list=CSelect::ByBufferProperty(list_calc,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_TENKAN_SEN,EQUAL); buffer_calc0=list.At(0); list=CSelect::ByBufferProperty(list_calc,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_KIJUN_SEN,EQUAL); buffer_calc1=list.At(0); list=CSelect::ByBufferProperty(list_calc,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_SENKOU_SPANA,EQUAL); buffer_calc2=list.At(0); list=CSelect::ByBufferProperty(list_calc,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_SENKOU_SPANB,EQUAL); buffer_calc3=list.At(0); list=CSelect::ByBufferProperty(list_calc,BUFFER_PROP_IND_LINE_MODE,INDICATOR_LINE_MODE_CHIKOU_SPAN,EQUAL); buffer_calc4=list.At(0); if(buffer_calc0==NULL || buffer_data0==NULL || buffer_calc0.GetDataTotal(0)==0) return false; if(buffer_calc1==NULL || buffer_data1==NULL || buffer_calc1.GetDataTotal(0)==0) return false; if(buffer_calc2==NULL || buffer_data2==NULL || buffer_calc2.GetDataTotal(0)==0) return false; if(buffer_calc3==NULL || buffer_data3==NULL || buffer_calc3.GetDataTotal(0)==0) return false; if(buffer_calc4==NULL || buffer_data4==NULL || buffer_calc4.GetDataTotal(0)==0) return false; series_index_start=PreparingSetDataStdInd(buffer_data0,buffer_data1,buffer_data2,buffer_data3,buffer_data4, buffer_calc0,buffer_calc1,buffer_calc2,buffer_calc3,buffer_calc4, ind_type,series_index,series_time,index_period,num_bars, value00,value01,value10,value11,value20,value21,value30,value31,value40,value41); if(series_index_start==WRONG_VALUE) return false; //--- In the loop by the number of bars in num_bars, fill in the drawn buffer with the calculated buffer value taken by the index_period index //--- and set the color of the drawn buffer depending on the value00 and value01 values ratio for(int i=0;i<num_bars;i++) { index=series_index_start-i; buffer_data0.SetBufferValue(0,index,value00); buffer_data1.SetBufferValue(0,index,value10); buffer_data2.SetBufferValue(0,index,value20); buffer_data3.SetBufferValue(0,index,value30); buffer_data4.SetBufferValue(0,index,value40); buffer_data0.SetBufferColorIndex(index,color_index==WRONG_VALUE ? uchar(value00>value01 ? 0 : value00<value01 ? 1 : 2) : color_index); buffer_data1.SetBufferColorIndex(index,color_index==WRONG_VALUE ? uchar(value10>value11 ? 0 : value10<value11 ? 1 : 2) : color_index); buffer_data2.SetBufferColorIndex(index,color_index==WRONG_VALUE ? uchar(value20>value21 ? 0 : value20<value21 ? 1 : 2) : color_index); buffer_data3.SetBufferColorIndex(index,color_index==WRONG_VALUE ? uchar(value30>value31 ? 0 : value30<value31 ? 1 : 2) : color_index); buffer_data4.SetBufferColorIndex(index,color_index==WRONG_VALUE ? uchar(value40>value41 ? 0 : value40<value41 ? 1 : 2) : color_index); //--- Set values for indicator auxiliary lines depending on mutual position of Senkou Span A and Senkou Span B lines value_tmp0=buffer_data2.GetDataBufferValue(0,index); value_tmp1=buffer_data3.GetDataBufferValue(0,index); if(value_tmp0<value_tmp1) { buffer_tmp0.SetBufferValue(0,index,buffer_tmp0.EmptyValue()); buffer_tmp0.SetBufferValue(1,index,buffer_tmp0.EmptyValue()); buffer_tmp1.SetBufferValue(0,index,value_tmp0); buffer_tmp1.SetBufferValue(1,index,value_tmp1); } else { buffer_tmp0.SetBufferValue(0,index,value_tmp0); buffer_tmp0.SetBufferValue(1,index,value_tmp1); buffer_tmp1.SetBufferValue(0,index,buffer_tmp1.EmptyValue()); buffer_tmp1.SetBufferValue(1,index,buffer_tmp1.EmptyValue()); } } return true; case IND_GATOR : list=CSelect::ByBufferProperty(list_data,BUFFER_PROP_IND_LINE_MODE,0,EQUAL); buffer_data0=list.At(0); list=CSelect::ByBufferProperty(list_data,BUFFER_PROP_IND_LINE_MODE,1,EQUAL); buffer_data1=list.At(0); list=CSelect::ByBufferProperty(list_calc,BUFFER_PROP_IND_LINE_MODE,0,EQUAL); buffer_calc0=list.At(0); list=CSelect::ByBufferProperty(list_calc,BUFFER_PROP_IND_LINE_MODE,1,EQUAL); buffer_calc1=list.At(0); if(buffer_calc0==NULL || buffer_data0==NULL || buffer_calc0.GetDataTotal(0)==0) return false; if(buffer_calc1==NULL || buffer_data1==NULL || buffer_calc1.GetDataTotal(0)==0) return false; series_index_start=PreparingSetDataStdInd(buffer_data0,buffer_data1,buffer_data2,buffer_data3,buffer_data4, buffer_calc0,buffer_calc1,buffer_calc2,buffer_calc3,buffer_calc4, ind_type,series_index,series_time,index_period,num_bars, value00,value01,value10,value11,value20,value21,value30,value31,value40,value41); if(series_index_start==WRONG_VALUE) return false; //--- In the loop by the number of bars in num_bars, fill in the drawn buffer with the calculated buffer value taken by the index_period index //--- and set the color of the drawn buffer depending on the value00 and value01 values ratio for(int i=0;i<num_bars;i++) { index=series_index_start-i; buffer_data0.SetBufferValue(0,index,value00); buffer_data1.SetBufferValue(1,index,value10); buffer_data0.SetBufferColorIndex(index,color_index==WRONG_VALUE ? uchar(value00>value01 ? 0 : value00<value01 ? 1 : 2) : color_index); buffer_data1.SetBufferColorIndex(index,color_index==WRONG_VALUE ? uchar(value10<value11 ? 0 : value10>value11 ? 1 : 2) : color_index); } return true; default: break;
O código comenta as ações que diferem exatamente dos mesmos blocos de código para processamento de outros indicadores padrão que consideramos em artigos anteriores. Isso afetou apenas o recebimento e processamento de dados para o design externo do indicador Ichimoku Kinko Hyo. Para o indicador Gator Oscillator, toda a lógica permanece a mesma que para outros indicadores padrão.
Agora vamos escrever métodos para criar objetos dos indicadores padrão Ichimoku Kinko Hyo e Gator Oscillator.
Método para criar Gator Oscillator:
//+------------------------------------------------------------------+ //| Create multi-symbol multi-period Gator | //+------------------------------------------------------------------+ int CBuffersCollection::CreateGator(const string symbol,const ENUM_TIMEFRAMES timeframe, const int jaw_period, const int jaw_shift, const int teeth_period, const int teeth_shift, const int lips_period, const int lips_shift, const ENUM_MA_METHOD ma_method, const ENUM_APPLIED_PRICE applied_price, const int id=WRONG_VALUE) { //--- Create the indicator handle and set the default ID int num_bars=::PeriodSeconds(timeframe)/::PeriodSeconds(PERIOD_CURRENT); int shift=::fmin(jaw_shift,teeth_shift); int handle=::iGator(symbol,timeframe,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price); int identifier=(id==WRONG_VALUE ? IND_GATOR : id); color array_colors[3]={clrGreen,clrRed,clrGreen}; CBuffer *buff=NULL; if(handle!=INVALID_HANDLE) { //--- Create the histogram buffer from the zero line this.CreateHistogram(); //--- Get the last created buffer object (drawn) and set to it all the necessary parameters of Up buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetShift(shift*num_bars); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_GATOR); buff.SetShowData(true); buff.SetLineMode(INDICATOR_LINE_MODE_UPPER); buff.SetIndicatorName("Gator Oscillator"); buff.SetIndicatorShortName("Gator("+symbol+","+TimeframeDescription(timeframe)+": "+(string)jaw_period+","+(string)teeth_period+","+(string)lips_period+")"); buff.SetLabel("Gator("+symbol+","+TimeframeDescription(timeframe)+": "+(string)jaw_period+","+(string)teeth_period+","+(string)lips_period+","+") Up"); buff.SetColors(array_colors); //--- Create the histogram buffer from the zero line this.CreateHistogram(); //--- Get the last created buffer object (drawn) and set to it all the necessary parameters of Down buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetShift(shift*num_bars); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_GATOR); buff.SetShowData(true); buff.SetLineMode(INDICATOR_LINE_MODE_LOWER); buff.SetIndicatorName("Gator Oscillator"); buff.SetIndicatorShortName("Gator("+symbol+","+TimeframeDescription(timeframe)+": "+(string)jaw_period+","+(string)teeth_period+","+(string)lips_period+")"); buff.SetLabel("Gator("+symbol+","+TimeframeDescription(timeframe)+": "+(string)jaw_period+","+(string)teeth_period+","+(string)lips_period+","+") Down"); buff.SetColors(array_colors); //--- Create a calculated Up line buffer storing standard indicator data this.CreateCalculate(); //--- Get the last created buffer object (calculated) and set to it all the necessary parameters of Up buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetShift(shift); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_GATOR); buff.SetEmptyValue(EMPTY_VALUE); buff.SetLineMode(INDICATOR_LINE_MODE_UPPER); buff.SetIndicatorName("Gator Oscillator"); buff.SetLabel("Gator("+symbol+","+TimeframeDescription(timeframe)+": "+(string)jaw_period+","+(string)teeth_period+","+(string)lips_period+","+") Up"); //--- Create a calculated Teeth line buffer storing standard indicator data this.CreateCalculate(); //--- Get the last created (calculated) buffer object and set all the necessary Teeth line parameters to it buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetShift(shift); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_GATOR); buff.SetEmptyValue(EMPTY_VALUE); buff.SetLineMode(INDICATOR_LINE_MODE_LOWER); buff.SetIndicatorName("Gator Oscillator"); buff.SetLabel("Gator("+symbol+","+TimeframeDescription(timeframe)+": "+(string)jaw_period+","+(string)teeth_period+","+(string)lips_period+","+") Down"); } return handle; } //+------------------------------------------------------------------+
Ao criar o identificador do indicador transferimos a ele os dados sobre o deslocamento das linhas do indicador Alligator cujos dados são usados para calcular o Gator, pois eles estão nos parâmetros de entrada, independentemente do fato de que o indicador pode ser desenhado num timeframe não nativo - todos esses dados são necessários para o cálculo interno do indicador. O deslocamento visual das linhas do indicador Gator padrão é calculado como o valor mínimo dos valores do deslocamento das linhas Jaw e Teeth do indicador Alligator, valor esse para o cálculo do Gator. Precisamos multiplicar este deslocamento visual pelo número de barras que precisam ser exibidas no timeframe atual, o que fazemos definindo o tamanho do deslocamento para os objetos-buffers do indicador desenhado. Definimos o deslocamento para os objetos-buffers calculados sem multiplicar pelo número de barras...
Método para criar o Ichimoku Kinko Hyo:
//+------------------------------------------------------------------+ //| Create multi-symbol multi-period Ichimoku | //+------------------------------------------------------------------+ int CBuffersCollection::CreateIchimoku(const string symbol,const ENUM_TIMEFRAMES timeframe, const int tenkan_sen, const int kijun_sen, const int senkou_span_b, const int id=WRONG_VALUE) { //--- Create the indicator handle and set the default ID int num_bars=::PeriodSeconds(timeframe)/::PeriodSeconds(PERIOD_CURRENT); int handle=::iIchimoku(symbol,timeframe,tenkan_sen,kijun_sen,senkou_span_b); int identifier=(id==WRONG_VALUE ? IND_ICHIMOKU : id); color array_colors[1]={clrRed}; CBuffer *buff=NULL; if(handle!=INVALID_HANDLE) { //--- Create the line buffer this.CreateLine(); //--- Get the last created buffer object (drawn) and set to it all the necessary parameters of Tenkan-Sen buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_TENKAN_SEN); buff.SetShowData(true); buff.SetLabel("Tenkan-Sen("+symbol+","+TimeframeDescription(timeframe)+": "+(string)tenkan_sen+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); buff.SetColors(array_colors); //--- Create the line buffer this.CreateLine(); //--- Get the last created buffer object (drawn) and set to it all the necessary parameters of Kijun-Sen buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_KIJUN_SEN); buff.SetShowData(true); buff.SetLabel("Kijun-Sen("+symbol+","+TimeframeDescription(timeframe)+": "+(string)kijun_sen+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); array_colors[0]=clrBlue; buff.SetColors(array_colors); //--- Create the line buffer this.CreateLine(); //--- Get the last created buffer object (drawn) and set to it all the necessary parameters of Senkou Span A buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetShift(kijun_sen*num_bars); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_SENKOU_SPANA); buff.SetShowData(true); buff.SetLabel("Senkou Span A("+symbol+","+TimeframeDescription(timeframe)+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); array_colors[0]=clrSandyBrown; buff.SetColors(array_colors); buff.SetStyle(STYLE_DOT); //--- Create the line buffer this.CreateLine(); //--- Get the last created buffer object (drawn) and set to it all the necessary parameters of Senkou Span B buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetShift(kijun_sen*num_bars); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_SENKOU_SPANB); buff.SetShowData(true); buff.SetLabel("Senkou Span B("+symbol+","+TimeframeDescription(timeframe)+": "+(string)senkou_span_b+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); array_colors[0]=clrThistle; buff.SetColors(array_colors); buff.SetStyle(STYLE_DOT); //--- Create the line buffer this.CreateLine(); //--- Get the last created buffer object (drawn) and set to it all the necessary parameters of Chikou Span buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_CHIKOU_SPAN); buff.SetShowData(true); buff.SetLabel("Chikou Span("+symbol+","+TimeframeDescription(timeframe)+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); array_colors[0]=clrLime; buff.SetColors(array_colors); //--- Create histogram buffer on two lines for displaying the histogram of Senkou Span A this.CreateHistogram2(); //--- Get the last created (drawn) buffer object and set all the necessary parameters to it buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetShift(kijun_sen*num_bars); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_ADDITIONAL); buff.SetShowData(false); buff.SetLabel("Senkou Span A("+symbol+","+TimeframeDescription(timeframe)+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); buff.SetIndicatorLineAdditionalNumber(0); //--- Get buffer data of Senkou Span A and set values of line color, width and style to the histogram CBuffer *tmp=GetBufferStdInd(IND_ICHIMOKU,identifier,INDICATOR_LINE_MODE_SENKOU_SPANA); array_colors[0]=(tmp!=NULL ? tmp.Color() : clrSandyBrown); buff.SetColors(array_colors); buff.SetWidth(tmp!=NULL ? tmp.LineWidth() : 1); buff.SetStyle(tmp!=NULL ? tmp.LineStyle() : STYLE_DOT); //--- Create histogram buffer on two lines for displaying the histogram of Senkou Span B this.CreateHistogram2(); //--- Get the last created (drawn) buffer object and set all the necessary parameters to it buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetShift(kijun_sen*num_bars); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_ADDITIONAL); buff.SetShowData(false); buff.SetLabel("Senkou Span B("+symbol+","+TimeframeDescription(timeframe)+": "+(string)senkou_span_b+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); buff.SetIndicatorLineAdditionalNumber(1); //--- Get buffer data of Senkou Span B and set values of line color, width and style to the histogram tmp=GetBufferStdInd(IND_ICHIMOKU,identifier,INDICATOR_LINE_MODE_SENKOU_SPANB); array_colors[0]=(tmp!=NULL ? tmp.Color() : clrThistle); buff.SetColors(array_colors); buff.SetWidth(tmp!=NULL ? tmp.LineWidth() : 1); buff.SetStyle(tmp!=NULL ? tmp.LineStyle() : STYLE_DOT); //--- Create calculated buffer in which data of Tenkan-Sen line will be stored this.CreateCalculate(); //--- Get the last created (calculated) buffer object and set all the necessary parameters to it buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_TENKAN_SEN); buff.SetEmptyValue(EMPTY_VALUE); buff.SetLabel("Tenkan-Sen("+symbol+","+TimeframeDescription(timeframe)+": "+(string)tenkan_sen+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); //--- Create calculated buffer in which data of Kijun-Sen line will be stored this.CreateCalculate(); //--- Get the last created (calculated) buffer object and set all the necessary parameters to it buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_KIJUN_SEN); buff.SetEmptyValue(EMPTY_VALUE); buff.SetLabel("Kijun-Sen("+symbol+","+TimeframeDescription(timeframe)+": "+(string)kijun_sen+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); //--- Create calculated buffer in which data of Senkou Span A line will be stored this.CreateCalculate(); //--- Get the last created (calculated) buffer object and set all the necessary parameters to it buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetShift(kijun_sen); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_SENKOU_SPANA); buff.SetEmptyValue(EMPTY_VALUE); buff.SetLabel("Senkou Span A("+symbol+","+TimeframeDescription(timeframe)+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); //--- Create calculated buffer in which data of Senkou Span B line will be stored this.CreateCalculate(); //--- Get the last created (calculated) buffer object and set all the necessary parameters to it buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetShift(kijun_sen); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_SENKOU_SPANB); buff.SetEmptyValue(EMPTY_VALUE); buff.SetLabel("Senkou Span B("+symbol+","+TimeframeDescription(timeframe)+": "+(string)senkou_span_b+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); //--- Create calculated buffer in which data of Chikou Span line will be stored this.CreateCalculate(); //--- Get the last created (calculated) buffer object and set all the necessary parameters to it buff=this.GetLastCreateBuffer(); if(buff==NULL) return INVALID_HANDLE; buff.SetSymbol(symbol); buff.SetTimeframe(timeframe); buff.SetID(identifier); buff.SetIndicatorHandle(handle); buff.SetIndicatorType(IND_ICHIMOKU); buff.SetLineMode(INDICATOR_LINE_MODE_CHIKOU_SPAN); buff.SetEmptyValue(EMPTY_VALUE); buff.SetLabel("Chikou Span("+symbol+","+TimeframeDescription(timeframe)+")"); buff.SetIndicatorName("Ichimoku Kinko Hyo"); buff.SetIndicatorShortName("Ichimoku("+symbol+","+TimeframeDescription(timeframe)+")"); } return handle; } //+------------------------------------------------------------------+
Aqui fazemos exatamente o mesmo que com a criação de um objeto do indicador Gator padrão, durante a criação do identificador transferimos a ele os parâmetros de entrada sem alterações, já durante a criação dos objetos-buffers para exibir as linhas Senkou Span A e Senkou Span B e buffers adicionais para criar o espaço entre estas duas linhas como um histograma, multiplicamos o deslocamento pelo número necessário de barras a ser exibido no gráfico atual. Ao criar objetos de buffers calculados, definimos o deslocamento sem multiplicar pelo número de barras no gráfico atual.
O deslocamento para as linhas Senkou Span A e Senkou Span B é o período de cálculo para a linha Kijun-Sen.
Ao criar buffers-histogramas adicionais, primeiro, devemos definir para eles os parâmetros padrão do indicador, em seguida, obtemos o objeto-buffer da linha que corresponde ao histograma e definimos os parâmetros de desenho para o histograma exatamente da mesma forma que para a linha do indicador, recebendo valores do buffer de linha obtido.
Para objetos-buffers de histogramas, definimos a propriedade não exibir sua linha na janela de dados, ja que esses buffers são necessários apenas para o registro, e seus valores correspondem totalmente às linhas do indicador de onde recebem seus dados.
Assim concluímos o refinamento das classes e métodos da biblioteca para a criação de indicadores padrão multissímbolos e multiperíodos. Agora temos um conjunto completo de métodos para a criação de qualquer multi-indicadores padrão e personalizados em nossos programas. Claro, ainda existem algumas desvantagens, que iremos corrigir gradualmente no futuro desenvolvimento da funcionalidade da biblioteca.
Teste
Para teste, vamos pegar um indicador do artigo anterior e criamos dois novos indicadores na nova pasta \MQL5\Indicators\TestDoEasy\Part51\
usando os nomes TestDoEasyPart51_1.mq5 e TestDoEasyPart51_2.mq5.
A única diferença entre eles estará apenas no parâmetro #property indicator_chart_window ou #property indicator_separate_window, já que um deles será desenhado no gráfico principal e o segundo, na subjanela. Bem, num caso, criaremos o indicador Ichimoku Kinko Hyo e, no outro caso, o Gator Oscillator.
Remover dos parâmetros de entrada as linhas para especificar o tipo de indicadores e seu deslocamento de linhas:
sinput ENUM_INDICATOR InpIndType = IND_AC; // Type standard indicator
sinput int InpShift = 0; // Indicator line shift
No manipulador OnInit() do arquivo TestDoEasyPart51_1.mq5 criamos um objeto do indicador Ichimoku Kinko Hyo:
//+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- Write the name of the working timeframe selected in the settings to the InpUsedTFs variable InpUsedTFs=TimeframeDescription(InpPeriod); //--- Initialize DoEasy library OnInitDoEasy(); //--- Set indicator global variables prefix=engine.Name()+"_"; //--- 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 num_bars=NumberBarsInTimeframe(InpPeriod); min_bars=(num_bars>2 ? num_bars : 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 all the necessary buffer objects for constructing a selected standard indicator if(!engine.BufferCreateIchimoku(InpUsedSymbols,InpPeriod,9,26,52,1)) { Print(TextByLanguage("Ошибка. Индикатор не создан","Error. Indicator not created")); return INIT_FAILED; } //--- Check the number of buffers specified in the 'properties' block if(engine.BuffersPropertyPlotsTotal()!=indicator_plots) Alert(TextByLanguage("Внимание! Значение \"indicator_plots\" должно быть ","Attention! Value of \"indicator_plots\" should be "),engine.BuffersPropertyPlotsTotal()); if(engine.BuffersPropertyBuffersTotal()!=indicator_buffers) Alert(TextByLanguage("Внимание! Значение \"indicator_buffers\" должно быть ","Attention! Value of \"indicator_buffers\" should be "),engine.BuffersPropertyBuffersTotal()); //--- Create the color array and set non-default colors to all buffers within the collection //--- (commented out since the colors have already been set in the methods of creating default standard indicators) //--- (we can always set necessary colors either for all indicators, like here, or for each of them individually) //color array_colors[]={clrGreen,clrRed,clrGray}; //engine.BuffersSetColors(array_colors); //--- Display short descriptions of created indicator buffers engine.BuffersPrintShort(); //--- Set the indicator short name, digital capacity and levels string label=engine.BufferGetIndicatorShortNameByTypeID(IND_ICHIMOKU,1); IndicatorSetString(INDICATOR_SHORTNAME,label); SetIndicatorLevels(InpUsedSymbols,IND_ICHIMOKU); //--- Successful return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+
Já no manipulador OnCalculate() vamos processar apenas um indicador criado:
//+------------------------------------------------------------------+ //| 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 and set the "as timeseries" flag to the arrays CopyDataAsSeries(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.OnCalculate(rates_data)==0) return 0; //--- If working in the tester if(MQLInfoInteger(MQL_TESTER)) { engine.OnTimer(rates_data); // Working in the library timer engine.EventsHandling(); // Working with library events } //+------------------------------------------------------------------+ //| OnCalculate code block for working with the indicator: | //+------------------------------------------------------------------+ //--- 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) { limit=rates_total-1; engine.BuffersInitPlots(); engine.BuffersInitCalculates(); } //--- Prepare data //--- Fill in calculated buffers of all created standard indicators with data int bars_total=engine.SeriesGetBarsTotal(InpUsedSymbols,InpPeriod); int total_copy=(limit<min_bars ? min_bars : fmin(limit,bars_total)); if(!engine.BufferPreparingDataAllBuffersStdInd()) return 0; //--- Calculate the indicator //--- Main calculation loop of the indicator for(int i=limit; i>WRONG_VALUE && !IsStopped(); i--) { engine.GetBuffersCollection().SetDataBufferStdInd(IND_ICHIMOKU,1,i,time[i]); } //--- return value of prev_calculated for next call return(rates_total); } //+------------------------------------------------------------------+
No arquivo TestDoEasyPart51_2.mq5 faremos exatamente as mesmas alterações, mas em vez de criar e processar o indicador Ichimoku Kinko Hyo, criaremos e processaremos o indicador Gator Oscillator. Instruiremos o pré-processador a criar um indicador que funcione numa subjanela:
//+------------------------------------------------------------------+ //| TestDoEasyPart51_2.mq5 | //| Copyright 2020, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2020, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //--- includes #include <DoEasy\Engine.mqh> //--- properties #property indicator_separate_window #property indicator_buffers 6 #property indicator_plots 2
Vamos iniciar ambos os indicadores no gráfico EURUSD H1, especificando nas configurações do indicador o uso dos dados EURUSD H4 para o cálculo, e comparando-os com os indicadores padrão:
Como podemos ver, os dados de ambos os indicadores coincidem com os dados dos indicadores padrão.
Os códigos completos de ambos os indicadores podem ser encontrados nos arquivos anexados ao artigo.
O que vem agora?
No próximo artigo, começaremos a trabalhar com a compatibilidade de classes de objetos de indicadores padrão com MQL4.
Todos os arquivos da versão atual da biblioteca e arquivos dos indicadores de teste estão anexados abaixo. Você pode baixá-los e testar tudo sozinho.
Se você tiver dúvidas, comentários e sugestões, pode expressá-los nos comentários do artigo.
Gostaria de chamar sua atenção para o fato de que neste artigo fizemos indicadores de teste em MQL5 para o MetaTrader 5.
Os arquivos anexados estão destinados apenas ao MetaTrader 5 e a versão atual da biblioteca ainda não foi testada no MetaTrader 4.
Artigos desta série:
Trabalhando com séries temporais na biblioteca DoEasy (Parte 35): Objeto "Barra" e lista-série temporal do símbolo
Trabalhando com séries temporais na biblioteca DoEasy (Parte 36): objeto das séries temporais de todos os períodos usados do símbolo
Trabalhando com séries temporais na biblioteca DoEasy (Parte 37): coleção de séries temporais - banco de dados de séries temporais para símbolos e períodos
Trabalhando com séries temporais na biblioteca DoEasy (Parte 38): coleção de séries temporais - atualização em tempo real e acesso aos dados do programa
Trabalhando com séries temporais na biblioteca DoEasy (Parte 39): indicadores com base na biblioteca - preparação de dados e eventos das séries temporais
Trabalhando com séries temporais na biblioteca DoEasy (Parte 40): indicadores com base na biblioteca - atualização de dados em tempo real
Trabalhando com séries temporais na biblioteca DoEasy (Parte 41): exemplo de indicador multissímbolo multiperíodo
Trabalhando com séries temporais na biblioteca DoEasy (Parte 42): classe de um objeto de buffer abstrato de indicador
Trabalhando com séries temporais na biblioteca DoEasy (Parte 43): classes de objetos de buffers de indicador
Trabalhando com séries temporais na biblioteca DoEasy (Parte 44): classe-coleção de objetos de buffers de indicador
Trabalhando com séries temporais na biblioteca DoEasy (Parte 45): buffers de indicador multiperíodo
Trabalhando com séries temporais na biblioteca DoEasy (Parte 46): buffers de indicador multiperíodos multissímbolos
Trabalhando com séries temporais na biblioteca DoEasy (Parte 47): indicadores padrão multiperíodos multissímbolos
Trabalhando com séries temporais na biblioteca DoEasy (Parte 48): indicadores multissímbolos multiperíodos num buffer de uma subjanela
Trabalhando com séries temporais na biblioteca DoEasy (Parte 49): indicadores padrão multiperíodos multissímbolos multibuffer
Trabalhando com séries temporais na biblioteca DoEasy (Parte 50): indicadores padrão multiperíodos multissímbolos com deslocamento
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/8354
Trabalhando com séries temporais na biblioteca DoEasy (Parte 52): natureza multiplataforma de indicadores padrão multiperíodos multissímbolos de buffer único
Trabalhando com séries temporais na biblioteca DoEasy (Parte 50): indicadores padrão multiperíodos multissímbolos com deslocamento
Símbolos personalizados: Fundamentos práticos
Trabalhando com séries temporais na biblioteca DoEasy (Parte 49): indicadores padrão multiperíodos multissímbolos multibuffer
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso