Do básico ao intermediário: Sub Janelas (I)

Introdução

No artigo anterior Do básico ao intermediário: Indicadores técnico (II), foi demonstrado como poderíamos adicionar diversas médias móveis de maneira muito simples e prática em um mesmo indicador. E isto sem necessitar efetuar diversas mudanças no código fonte. O que torna aquele tipo de modelagem de código algo extremamente útil para quem quer agilidade sem ter grandes dores de cabeça ao precisar modificar um código fonte qualquer para obter um certo tipo de comportamento do mesmo.

Porém, apesar daquela metodologia ser algo bastante útil e interessante. Aquilo que foi visto ali, é apenas parte de um conjunto bem maior de coisas que podemos fazer. Isto quando o assunto está diretamente relacionado a questão de indicadores a serem colocados em um gráfico qualquer.

Existem alguns tipos de situação em que precisamos adotar uma abordagem ainda mais intensiva. Usando de maneira adequada tudo que o MQL5 tem a nos oferecer. E quando isto não for o bastante, precisamos ter um bom entendimento de como o MetaTrader 5 funciona. Já que o objetivo primário do MQL5, é o de promover uma forma de controlarmos o comportamento do MetaTrader 5. O fazendo trabalhar de tal maneira que ele gere o tipo de resultado que estamos desejando obter. Muitos imaginam que o MQL5, tem um propósito geral, como seria o caso de uma linguagem como C ou C++. No entanto, isto não se aplica. E justamente por conta disto, é que precisamos entender e compreender até onde podemos ir dentro do MQL5, antes de pensarmos em adotar soluções ainda mais agressivas.

Pois bem, em meus primeiros artigos, publicados aqui na comunidade, abordei um tipo de construção, que é possível ser feita no MetaTrader 5. Apesar de que na época, acabei cometendo um erro de imaginar que a comunidade, era constituída de programadores já com um bom grau de experiência. Por conta deste meu equívoco na época, acabei não dando as devidas explicações sobre o porquê daquele tipo de construção funcionar. E como ela deveria ser pensada, antes mesmo de você a colocar em um gráfico qualquer. Devido a isto, muitos que talvez tenham achado aquele tipo de implementação interessante, não conseguiram de fato a utilizar. Justamente por conta que tais pessoas não teriam o nível adequado de conhecimento a fim de atingir tal objetivo.

E por favor, não me entenda mal, ao dizer que você, muito provavelmente, ainda não está preparado para entender como tais aplicações funcionam. Muito pelo contrário, se sinta motivado e aberto para que novos conhecimentos sejam adquiridos. Pois a cura da falta de saber, não é o orgulho, mas sim a humildade, em admitir que ainda temos muito a aprender uns com os outros.

Ok, para quem não sabe do que estive falando nesta introdução, você pode ver em Indicadores múltiplos em um gráfico (Parte 03): Desenvolvendo definições para usuários do que se trata. Mas então chegou a hora de se afastar das distrações e focar no que será visto neste artigo de agora.

Usando sub janelas (I)

Existem diversas situações em que precisamos, ou melhor dizendo, é bem mais conveniente termos um indicador sendo utilizado e mostrado no que seria uma sub janela. Talvez o termo sub janela não seja de fato o mais adequado. Mas como disse um amigo uma vez:

Programadores são péssimos para nomear as coisas.

De qualquer forma, o termo adotado é este e assim o faremos. Porém diferente do que muitos podem pensar. Criar um indicador a fim de que ele venha a ser utilizado em uma sub janela, não é algo assim tão complicado. Isto tomando como base, o que na maior parte das vezes, precisaremos fazer. Porém, existem situações em que este tipo de abordagem pode vir a ficar um tanto quanto confusa, se você não estiver utilizando os conceitos adequados. Já que em muitos dos casos, você espera que as coisas funcionem de uma maneira quando na verdade, elas estarão funcionando de uma forma completamente diferente. Nos meus primeiros artigos, isto acontecia bastante, gerando muito mais dúvidas nas pessoas, do que qualquer outro tipo de coisa. E como eu disse, foi um equívoco da minha parte.

Já imaginei que os artigos eram sempre voltados a pessoas que já tinham uma certa experiência. O que não era de fato verdadeiro. Por conta disto, decidi criar um novo perfil, voltado única e exclusivamente a explicar os pequenos detalhes envolvidos nas tomadas de decisão durante uma implementação real. Assim como também o de explicar, para iniciantes e entusiastas, como você deve pensar ao construir um código. Daí o fato destes artigos de agora terem surgido.

Aqui já foi abordado diversos temas, que vão deste o básico, como a sintaxe de comandos essenciais até coisas um pouco mais complexas, como a sobrecarga de operadores. E de fato, falta apenas alguns pequenos detalhes sobre a parte básica de programação para serem explicados. No entanto, tais partes faltantes, não nos impede de já conseguir fazer diversas coisas legais e divertidas. E como quero lhe dar um tempo, para que você consiga assimilar adequadamente o assunto sobrecarga de operadores, já que de tudo que foi mostrado até aqui. Aquele com toda a certeza é o assunto mais complexo.

Vamos durante alguns artigos, trabalhar com algum tipo de assunto, que seja mais suave e simples de compreender. Porém sempre subindo a régua, de forma lenta e gradual. Assim todos irão conseguir acompanhar os artigos sem se cansar. Já que não existe uma sequência lógica para que você os leia. Você deve pensar nestes artigos como uma extensão da própria documentação do MQL5, que sempre deve ser lida em caso de dúvidas.

Ok, então o que iremos ver neste artigo? Bem, meu caro leitor, aqui iremos ver os primeiros passos para se fazer o uso de uma sub janela. Vamos entender basicamente como a sub janela pode vir a ser utilizada pelo nosso código, mesmo quando não implementamos o código para que ele a utilize. Entender isto, é de suma importância para entender outras coisas, ainda mais complicadas, que serão vistas futuramente.

Muito bem. Como não pretendo ficar criando códigos do zero, para não perder tempo explicando como ele funciona. Vamos pegar o código visto no artigo anterior, para entender estes primeiros passos de utilização de sub janelas.

Assim sendo o código original é visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property description "DEMO Indicator"
05. //+------------------------------------------------------------------+
06. const struct stAverange
07. {
08.    uint           nPeriods;
09.    ENUM_MA_METHOD Method;
10.    color          cor;
11. }Averange[] = 
12. {
13.    {9, MODE_EMA, clrRed},
14.    {20, MODE_SMA, clrGreen},
15.    {50, MODE_SMA, clrBlue},
16.    {200, MODE_SMA, clrBlack}
17. };
18. //+----------------+
19. #property indicator_chart_window
20. #property indicator_applied_price   PRICE_CLOSE
21. #property indicator_buffers         Averange.Size();
22. #property indicator_plots           Averange.Size();
23. //+------------------------------------------------------------------+
24. struct stInfos
25. {
26.    double   Buff_iMA[];
27.    int      Handle;
28. }Infos[Averange.Size()];
29. //+------------------------------------------------------------------+
30. int OnInit(void)
31. {
32.    for (uint c = 0; c < Averange.Size(); c++)
33.    {
34.       SetIndexBuffer(c, Infos[c].Buff_iMA, INDICATOR_DATA);
35.       PlotIndexSetInteger(c, PLOT_DRAW_TYPE, DRAW_LINE);
36.       PlotIndexSetInteger(c, PLOT_LINE_STYLE, STYLE_SOLID);
37.       PlotIndexSetInteger(c, PLOT_LINE_WIDTH, 2);
38.       PlotIndexSetInteger(c, PLOT_LINE_COLOR, Averange[c].cor);
39.       PlotIndexSetString(c, PLOT_LABEL, StringFormat("%s of %d", (Averange[c].Method == MODE_EMA ? "Exponential" : "Arithmetica"), Averange[c].nPeriods));
40.       if ((Infos[c].Handle = iMA(NULL, NULL, Averange[c].nPeriods, 0, Averange[c].Method, _AppliedTo)) == INVALID_HANDLE)
41.       {
42.          Print("Could not start the indicator...");
43.          return INIT_FAILED;
44.       };
45.    }
46. 
47.    return INIT_SUCCEEDED;
48. };
49. //+------------------------------------------------------------------+
50. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
51. {
52.    for (uint c = 0; c < Averange.Size(); c++)
53.    {
54.        ArrayInitialize(Infos[c].Buff_iMA, EMPTY_VALUE);
55.       CopyBuffer(Infos[c].Handle, 0, 0, Averange[c].nPeriods, Infos[c].Buff_iMA);
56.    }
57. 
58.    return rates_total;
59. };
60. //+------------------------------------------------------------------+
61. void OnDeinit(const int reason)
62. {
63.    for (uint c = 0; c < Averange.Size(); c++)
64.       IndicatorRelease(Infos[c].Handle);
65. };
66. //+------------------------------------------------------------------+

Código 01

Aqui neste código 01, temos uma coisa interessante sendo informada ao compilador. Tal coisa se trata da linha 19. O que esta linha 19 está dizendo ao compilador, é que este indicador, visto no código 01, irá utilizar a janela na qual ele será aplicado. Há, mas isto é obvio. Bem, meu caro leitor, apesar se ser obvio, talvez você não tenha entendido de fato o que foi dito. Eu NÃO DISSE que o indicador irá utilizar a janela onde as barras estão sendo plotadas. Eu disse que ele irá usar a janela onde ele for colocado. E muita gente, mas muita gente mesmo não entende isto. E por conta deste fato, acaba fazendo uma grande bobagem, e dizendo que o MetaTrader 5 é uma plataforma horrível de ser utilizada.

Ok, para tornar as coisas mais simples de entender. Vamos modificar o código 01, de forma que ele faça uso do seguinte fragmento mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property description "DEMO Indicator"
05. //+------------------------------------------------------------------+
06. const struct stAverange
07. {
08.    uint           nPeriods;
09.    ENUM_MA_METHOD Method;
10.    color          cor;
11. }Averange[] = 
12. {
13.    // {9, MODE_EMA, clrRed},
14.    {20, MODE_SMA, clrGreen},
15.    // {50, MODE_SMA, clrBlue},
16.    // {200, MODE_SMA, clrBlack}
17. };
18. //+----------------+
                   .
                   .
                   .

Fragmento 01

Muito bem, agora apenas e somente uma das médias será plotada. Se você não sabe, ou não entende o que acabamos de fazer, veja os artigos anteriores para entender melhor isto que foi feito. Já que não irei entrar em detalhes aqui. Por conta de que isto já foi explicado antes. Certo, quando adicionarmos este indicador ao gráfico ele irá se mostrar como visto na imagem abaixo.

Imagem 01

Agora vamos estender está média móvel para englobar mais barras. Para isto bastará modificar o código como mostrado no fragmento logo abaixo.

                   .
                   .
                   .
49. //+------------------------------------------------------------------+
50. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
51. {
52.    for (uint c = 0; c < Averange.Size(); c++)
53.    {
54.        ArrayInitialize(Infos[c].Buff_iMA, EMPTY_VALUE);
55.       CopyBuffer(Infos[c].Handle, 0, 0, Bars(NULL, NULL), Infos[c].Buff_iMA);
56.    }
57. 
58.    return rates_total;
59. };
60. //+------------------------------------------------------------------+
                   .
                   .
                   .

Fragmento 02

Agora o resultado é este visto logo abaixo.

Imagem 02

Tudo isto já foi explicado anteriormente. Então agora chegamos onde era o objetivo primário para realmente começar a explicar uma outra coisa.

Antes de vermos sobre como implementar um código que venha a usar uma sub janela. Precisamos entender como o MetaTrader 5, trabalha com sub janelas. E sim, por mais simples que isto possa parecer para você, meu caro leitor. Muitos programadores e operadores, NÃO SABEM COMO O METATRADER 5 TRABALHA COM SUB JANELAS. E ainda assim, muitos destes, afirmam solenemente serem pessoas com vasta experiência no uso do MetaTrader 5. Fala sério, isto é no mínimo, trágico.

Dentro dos indicadores disponíveis no MetaTrader 5, que já vem previamente compilados, temos diversos que fazem uso de uma sub janela. No entanto para o proposito aqui, vamos utilizar um bem clássico. Que seria justamente o que indica o volume negociado. Assim quando o aplicamos no gráfico, o que seria a imagem 02, passará a ser a imagem vista logo abaixo.

Imagem 03

Isto que você pode observar na parte inferior do gráfico, é o que aqui chamamos de sub janela. Agora preste atenção. Uma sub janela está de alguma forma ligada ao que seria a janela principal. Porém ela tem seus próprios mecanismos e configurações. Podendo inclusive ser modificada de forma a se tornar o que poderia ser considerada como sendo uma janela principal. Calma lá, pois agora fiquei confuso, com isto que você disse. Você está me dizendo que esta janela na parte inferior do gráfico, pode vir a ser utilizada como se fosse a janela principal? Sim meu caro leitor. É isto mesmo. Porém, ao fazer isto, você precisará estar ciente de diversas consequências que isto irá lhe trazer.

Mas como este daqui é apenas o primeiro artigo no qual iremos falar sobre isto. Não irei me aprofundar muito a este respeito, neste exato momento. Conforme novos artigos forem sendo postados, você irá entender melhor isto que foi dito.

Porém vamos voltar a nossa questão principal. Você se lembra da linha 19 no nosso código? Pois bem, agora queremos fazer o seguinte: Normalmente, e até onde sei muita gente faz uso disto. Os operadores não olham diretamente o volume que está sendo mostrado nesta sub janela. O que eles fazem é adicionar uma média e passam a olhar justamente esta média. Mas espere um pouco. Como vamos adicionar uma média móvel a este volume?

Bem, esta é justamente uma das coisas dais quais muitos não sabem como fazer. E quando fazem costumam fazer de maneira errada. O que acaba prejudicando enormemente a análise que eles gostariam de fazer.

Para tornar o problema evidente, veja a animação logo abaixo.

Animação 01

De certa forma, está animação 01, é a forma correta de adicionar um indicador ao que seria uma sub janela. Porém note o desenho que a média móvel está criando. Para que isto fique mais evidente, a imagem logo abaixo, mostra isto mais claramente.

Imagem 04

Aqui podemos ver de maneira bastante nítida que a curva da média móvel, NÃO ESTÁ REFLETINDO A CURVA DE VOLUME. Mas sim está média móvel presente na sub janela está refletindo a curva de cotações vista na janela principal. E não é isto que o operador de fato estava pretendendo fazer. Então ele, já com alguma experiência no MetaTrader 5, vai e faz o que é mostrado na animação abaixo.

Animação 02

Mas o que aconteceu aqui? Onde está a média móvel do volume? Bem, de fato algo aconteceu aqui. Então procurando saber o que pode ter sido, o tal operador abre o terminal e encontra a seguinte mensagem no mesmo.

Imagem 05

Ok, agora temos de fato um problema. Há já sei, a culpa é da plataforma. Calma lá meu caro leitor. O culpado aqui não é a plataforma, mas sim você, ou melhor dizendo o programador que implementou o código do indicador. Espera aí, fomos nós que implementamos isto? Você está me dizendo que somos incompetentes? Não é isto, meu caro leitor. Como eu disse no início do artigo, tenha humildade de aceitar o fato de que não sabemos tudo. E de que sempre existe algo que podemos aprender uns com os outros.

O problema, é de fato no código do indicador. Lembra que nos artigos anteriores, menciono e explicou como um indicador técnico funciona. E por que ele funciona? Pois bem, apesar dos cálculos feitos pelos indicadores técnicos funcionarem muito bem, como pode ser visto nas figuras, onde a curva da média no gráfico principal ser adequadamente apresentada. Eles NÃO SÃO adequados para serem usados a fim de calcular outras coisas, das quais o MetaTrader 5, não tem consciência dos dados. E quando pedimos para o indicador, mudar a base de cálculo, para utilizar os dados de um outro indicador, que no caso é o indicador de volume. O indicador técnico que estamos utilizando, que no caso é o iMA, não será de fato calculado. Isto por que, o MetaTrader 5, não sabe quais os valores estão presentes no indicador utilizado. Que no caso é justamente o indicador de volume. Por isto que o código acaba falhando, gerando isto que é visto na imagem 05. Então aceite o fato, de que nem sempre sabemos o que estamos fazendo. Muitas das vezes, ter a humildade de admitir isto, irá nos fazer entender as coisas da maneira correta.

Hum, então está certo. Mas sendo assim, lhe pergunto: Como poderemos resolver esta situação? Já que deve haver algum tipo de solução para isto? Ou estou errado? Existe sim, uma solução para este tipo de situação meu caro leitor. E é neste ponto que as coisas, começam a ficar um pouco mais interessantes. Apesar de também ficarem um pouco mais complicadas. A solução, é que precisaremos implementar o cálculo da média móvel por nós mesmos. Não podendo assim depender da ajuda o MetaTrader 5, ou melhor dizendo, não poderemos usar os indicadores técnicos que já estão disponíveis. E é aqui onde entra a parte complicada. Já que em muitos casos, ao implementar estes cálculos, muitos comentem uma série de erros. Seja no próprio cálculo em si, seja na forma desastrosa de criar o código, fazendo com que ele gaste muito mais recursos do que seria de fato necessário.

Então somente faça o que será feito aqui, em último caso. Ou se tiver certeza absoluta do que você estará fazendo. Pois qualquer bobagem feita aqui, será de sua responsabilidade. Uma vez tendo entendido isto, podemos partir para a fase de criar o código em si.

Para começar, vamos dar uma leve resumida no código 01. Desta forma ele irá ficar como mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property description "DEMO Indicator"
05. //+------------------------------------------------------------------+
06. const struct stAverange
07. {
08.     int            nPeriods;
09.     ENUM_MA_METHOD Method;
10.     color          cor;
11. }Averange[] = 
12. {
13.     {9, MODE_EMA, clrRed},
14.     {20, MODE_SMA, clrGreen},
15. };
16. //+----------------+
17. #property indicator_chart_window
18. #property indicator_applied_price   PRICE_CLOSE
19. #property indicator_buffers         Averange.Size();
20. #property indicator_plots           Averange.Size();
21. //+------------------------------------------------------------------+
22. struct stInfos
23. {
24.     double   Buff_iMA[];
25. }Infos[Averange.Size()];
26. //+------------------------------------------------------------------+
27. int OnInit(void)
28. {
29.     for (uint c = 0; c < Averange.Size(); c++)
30.     {
31.         SetIndexBuffer(c, Infos[c].Buff_iMA, INDICATOR_DATA);
32.         PlotIndexSetInteger(c, PLOT_DRAW_TYPE, DRAW_LINE);
33.         PlotIndexSetInteger(c, PLOT_LINE_STYLE, STYLE_SOLID);
34.         PlotIndexSetInteger(c, PLOT_LINE_WIDTH, 2);
35.         PlotIndexSetInteger(c, PLOT_LINE_COLOR, Averange[c].cor);
36.         PlotIndexSetString(c, PLOT_LABEL, StringFormat("%s of %d", (Averange[c].Method == MODE_EMA ? "Exponential" : "Arithmetica"), Averange[c].nPeriods));
37.     }
38. 
39.        return INIT_SUCCEEDED;
40. };
41. //+------------------------------------------------------------------+
42. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
43. {
44.     for (uint c = 0; c < Averange.Size(); c++)
45.     {
46.     }
47. 
48.     return rates_total;
49. };
50. //+------------------------------------------------------------------+

Código 02

Este é o nosso novo código inicial. Note que removi diversas coisas de entro dele. Mas principalmente a parte referente ao que nos daria acesso ao que seria o indicador técnico iMA. Agora vamos adicionar algumas coisas para nos auxiliar, na parte dos cálculos que será feita em breve. Para fazer isto, iremos modificar este código 02, como mostrado no fragmento logo abaixo.

                   .
                   .
                   .
21. //+------------------------------------------------------------------+
22. struct stInfos
23. {
24.     double  Buff_iMA[],
25.             f_Expo;
26. }Infos[Averange.Size()];
27. //+------------------------------------------------------------------+
28. int OnInit(void)
29. {
30.     for (uint c = 0; c < Averange.Size(); c++)
31.     {
32.         SetIndexBuffer(c, Infos[c].Buff_iMA, INDICATOR_DATA);
33.         Infos[c].f_Expo = (double) (2.0 / (1.0 + Averange[c].nPeriods));
34.         PlotIndexSetInteger(c, PLOT_DRAW_TYPE, DRAW_LINE);
35.         PlotIndexSetInteger(c, PLOT_LINE_STYLE, STYLE_SOLID);
36.         PlotIndexSetInteger(c, PLOT_LINE_WIDTH, 2);
37.         PlotIndexSetInteger(c, PLOT_LINE_COLOR, Averange[c].cor);
38.         PlotIndexSetString(c, PLOT_LABEL, StringFormat("%s of %d", (Averange[c].Method == MODE_EMA ? "Exponential" : "Arithmetica"), Averange[c].nPeriods));
39.     }
40. 
41.        return INIT_SUCCEEDED;
42. };
43. //+------------------------------------------------------------------+
                   .
                   .
                   .

Fragmento 03

Agora podemos focar no cálculo em si. Já que a base necessária já foi devidamente criada. Para efetuar os cálculos, vamos utilizar o que é visto no fragmento logo abaixo.

                   .
                   .
                   .
43. //+------------------------------------------------------------------+
44. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
45. {
46.     int c0 = 0;
47. 
48.     for (uint c = 0; c < Averange.Size(); c++)
49.     {
50.         if (prev_calculated == 0)
51.         {
52.             double loc = 0;
53.             for (int c1 = 0; c1 < Averange[c].nPeriods; c1++) loc += price[Averange[c].nPeriods - c1];
54.             Infos[c].Buff_iMA[Averange[c].nPeriods] = loc / Averange[c].nPeriods;
55.         }
56.         switch (Averange[c].Method)
57.         {
58.             case MODE_EMA:
59.                 for (c0 = (prev_calculated > 0 ? prev_calculated - 1 : 0); c0 < rates_total; c0++)
60.                     Infos[c].Buff_iMA[c0] = (c0 > 0 ? (((price[c0] - Infos[c].Buff_iMA[c0 - 1])) * Infos[c].f_Expo) + Infos[c].Buff_iMA[c0 - 1] : Infos[c].Buff_iMA[c0]);
61.                 break;
62.             case MODE_SMA:
63.                 for (c0 = (prev_calculated > 0 ? prev_calculated - 1 : Averange[c].nPeriods + 1); c0 < rates_total; c0++)
64.                     Infos[c].Buff_iMA[c0] = ((Infos[c].Buff_iMA[c0 - 1] * Averange[c].nPeriods) - price[c0 - Averange[c].nPeriods] + price[c0]) / Averange[c].nPeriods;
65.                 break;
66.         }
67.     }
68. 
69.     return rates_total;
70. };
71. //+------------------------------------------------------------------+

Fragmento 04

Não irei entrar em detalhes sobre como estes cálculos aqui funcionam. Isto para não tomar muito tempo. Mas tenho certeza de que nesta altura do campeonato, todos aqui irão conseguir entender o que estes cálculos estão fazendo. Lembrando que isto daqui visa apenas e somente a didática. Não sendo assim a forma mais eficiente de se fazer tais cálculos. Temos forma bem mais rápidas de fazer estes cálculos mostrados aqui. E isto usando o próprio MQL5.

De qualquer modo, uma vez compilado o código 02 com estas mudanças mostradas em ambos os fragmentos. Poderemos ver as coisas funcionando da seguinte maneira. Primeiro colocando o indicador diretamente no gráfico principal. Isto é mostrado na animação logo abaixo.

Animação 03

Note que funcionou. Para atestar se de fato as médias estão corretamente calculadas, faça uso do mesmo princípio mostrado nos artigos anteriores. Pois é sempre bom, ter certeza de que não estamos calculando as coisas de maneira equivocada. Uma vez atestado os cálculos das médias, podemos partir para o que seria o próximo passo. Ou seja, adicionar o indicador na sub janela onde se encontra o volume. E para isto fazemos como foi feito antes. E isto é mostrado na animação logo abaixo.

Animação 04

Note que o desenho da média continua sendo igual o que podemos ver na região onde estão sendo plotados as barras de cotação. Isto significa que de fato o que está sendo mostrado aqui é a média de preços e não a média de volume, como seria o esperado. Para que isto fique bem claro, veja a imagem logo abaixo.

Imagem 06

Ok, então o próximo passo é mudar as coisas como podemos ver na animação logo abaixo.

Animação 05

E finalmente funcionou. Mas como na animação pode ter ficado muito rápido, para ser de fato notado. Vamos tornar as coisas mais fáceis de serem analisadas. E para isto iremos fazer uso da imagem mostrada logo a seguir. Na qual estamos capturando os últimos frames da animação 05 logo acima.

Imagem 07

De fato, agora temos um tipo de indicador perfeitamente funcional e bem mais adequado para uma gama bem maior de situações. Podendo inclusive ser aplicado a sub janelas. Mas espere um pouco, antes de você finalizar este artigo, poderia por gentiliza me explicar algumas coisas a respeito do que foi visto aqui? Pois não meu caro leitor. Pode mandar as dúvidas.

Bem, a primeira de minhas dúvidas é a seguinte: Notei que tanto no código 01, quanto também no código 02, temos o uso da propriedade indicator_chart_window. Até onde consegui observar, e pude entender. Na documentação está sendo informado, que ao usarmos esta propriedade, o indicador será apresentado na janela do gráfico, e não será colocado em uma outra janela. Pois bem, aqui você disse que alguns indicadores criam uma nova janela, ou sub janela. Então fiquei com uma dúvida. No caso do indicador de volume, como foi visto nas animações, estamos criando uma sub janela. Mas o indicador, está aparecendo nela. Por que? Não era para ele continuar atrelado ao que seria a janela principal, ou a janela onde as barras estão sendo plotadas? Excelente pergunta meu caro leitor. E antes de você mandar uma próxima dúvida. Vamos entender por que o indicador está aparecendo na sub janela. Apesar de que a propriedade indicator_chart_window está sendo utilizada aqui.

O grande detalhe, e talvez o que dificulta muitos iniciantes em conseguir implementar algumas coisas. É justamente esta ligeira confusão que eles acabam criando. Para não deixar de responder a sua dúvida, e ao mesmo tempo não tornar a explicação demasiadamente confusa. Vamos rever as animações. Principalmente as animações 02 e 04. Que são exatamente as que utilizamos para adicionar o indicador ao gráfico.

Note que em ambas animações, estamos carregando e soltando o indicador em um ponto específico. No caso dentro da sub janela que foi criada pelo indicador de volume. É muito importante que você se atende a este detalhe. Pois isto faz toda a diferença aqui. Quando fazemos isto, o MetaTrader 5 irá interpretar este fato como algo importante. Assim quando ele for lançar o indicador que está fazendo uso da propriedade indicator_chart_window, ele entenderá, e fará com que o indicador entenda, que aquela janela, que na verdade é uma sub janela. Deverá ser entendida como sendo a janela principal. No entanto, e esta é a parte onde muitos geram uma tremenda confusão, o MetaTrader 5, NÃO IRÁ ATUALIZAR O INDICADOR a fim de utilizar dados daquela sub janela específica. É preciso que você, como operador, mude isto de maneira manual. Como foi mostrado nas animações.

E como a maior parte das pessoas, muitas das vezes, estão vindo de uma outra plataforma, onde está troca é feita de maneira automática, como é o caso o PROFIT muito usado nas negociações por operadores no BRASIL. As pessoas acabam vendo que a média não se ajustou como elas esperavam. Assim, acabam tendo uma má experiência junto ao MetaTrader 5.

Ok, acho que entendi está questão. Mas agora tenho uma outra dúvida. Vejo que em todos os casos, que podemos observar nas animações 02 e 05, que você ao mudar o parâmetro de cálculo, utiliza o parâmetro FIRST INDICATOR'S DATA. Apesar de termos também a possibilidade de utilizar como parâmetro PREVIOUS INDICATOR'S DATA. Por que esta preferência em usar um e não o outro? Caramba, temos aqui um leitor, bastante observador. Gostei da pergunta. Mas acho que é um pouco cedo para tentar explicar ela assim de maneira realmente adequada. Mas mesmo assim vou tentar lhe mostrar o motivo, Mesmo sem de fato entrar em todos os detalhes aqui. Isto será feito depois.

Então para que você possa, pelo menos ter uma noção do motivo de eu selecionar um e não o outro parâmetro nas animações mencionadas. Vamos modificar o código 02 para algo visto logo abaixo. É algo bem simples mais vai lhe ajudar a entender melhor isto.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property description "DEMO Indicator"
05. //+------------------------------------------------------------------+
06. const struct stAverange
07. {
08.     int            nPeriods;
09.     ENUM_MA_METHOD Method;
10.     color          cor;
11. }Averange[] = 
12. {
13.     {3, MODE_SMA, clrBlack}
14. };
15. //+----------------+
                   .
                   .
                   .

Fragmento 05

Ok, veja que mudamos o código para que tivéssemos um tipo de média de período bem curto e do tipo aritmética. Isto irá garantir com que possamos ver algo acontecendo. Apesar de não ser a melhor das explicações vai ajudar pelo menos a sanar um pouco da sua curiosidade.

Uma vez criado e compilado, podemos incluir este indicador, no gráfico. Ao fazermos isto será visto o que é mostrado na imagem logo abaixo.

Imagem 08

Agora ajustamos este indicador, de forma que ele utilize o que é visto na imagem logo abaixo.

Imagem 09

Ao fazermos isto o resultado será o que é visto logo abaixo.

Imagem 10

Note que trocamos a cor, e também mudei a espessura da linha. Isto para ajudar a ver o que irá acontece logo mais. Agora vamos adicionar novamente o mesmo indicador. E ao fazermos isto será gerado o que podemos ver logo a seguir.

Imagem 11

Agora preste atenção, apesar de que irei explicar isto em mais detalhes em breve. Já que temos duas médias sendo mostradas aqui, vamos fazer com que esta que está em preto, utilize o que é visto logo abaixo.

Imagem 12

Veja que estamos pedindo para utilizar um parâmetro diferente aqui. Porém o resultado é o que você verá logo abaixo.

Imagem 13

Mas que coisa estranha. Achei que o resultado seria o mesmo. Bem agora fiquei um tanto quanto confuso. Pois nunca me preocupei de fato, em pensar se deveria selecionar um ou outro destes parâmetros. Para mim ambos eram a mesma coisa. De fato meu caro leitor, existem muitas coisas que achamos que trabalham de uma forma, mas quando vamos ver, trabalham de uma maneira totalmente diferente. E apesar de parecer estranho isto que você está vendo na imagem 13, este fato tem uma explicação e em alguns casos pode até vir a ser util. Apesar de ser um tanto quanto questionável o verdadeiro grau de utilidade disto. Mas conheço alguns operadores que de fato fazem uso disto.

Considerações finais

Aqui foi demonstrado o que seria os princípios básicos referentes a utilização do que é conhecido como sendo uma sub janela. Apesar de algumas coisas, como por exemplo uma melhor explicação do por que usar um ou outro tipo de entrada no cálculo do indicador, não ter sido feita de forma totalmente adequada. Já que isto será visto nos próximos artigos. Acredito que este artigo tenha conseguido ser suficientemente adequado para que você consiga dentro do que foi possível mostrar aqui. Entender que para uma correta utilização do MetaTrader 5, precisamos ficar atentos a alguns detalhes. Tanto na questão da programação, quando na própria questão de utilização dos indicadores. Que por ventura você venha a colocar em um gráfico específico.

No próximo artigo iremos ver alguns detalhes mais específicos, com relação a utilização de sub janelas. Já que este é um recurso, que de fato, pode vir a ser explorado de diversas maneiras diferentes. Podendo inclusive servir como base de apoio a um possível sistema de interação mais avançada com o usuário. Mas para conseguir efetivar isto, você precisa compreender um pouco mais a fundo, como trabalhar com sub janelas.

Arquivo MQ5	Descrição
Indicators\Code 01	Demonstração básica
Indicators\Code 02	Demonstração básica
Indicators\Code 03	Demonstração básica