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

Introdução

No artigo anterior Do básico ao intermediário: Sub Janelas (I), começamos a falar sobre sub janelas. Apesar daquele conteúdo ter sido apenas e tão somente uma breve introdução sobre o assunto. O que foi visto naquele artigo é algo muito importante para se compreender o que iremos ver daqui para frente. No entanto, apesar de toda a simplicidade envolvida nesta parte mais básica sobre este assunto. Você não deve imaginar que já sabe trabalhar com sub janelas, apenas por conseguir fazer algumas coisas simples com elas. Sub janelas, são coisas muito interessantes e se forem bem pensadas para ser devidamente utilizadas por seus códigos. Você conseguirá implementar coisas que de outra maneira não seria possível, ou talvez nem tão simples de serem feitas.

Ok, como não quero me alongar em demasia antes de realmente começarmos a ver o que será o tema principal aqui. Vamos ao nosso ritual. Então é hora de se afastar das distrações e começar a focar no que será explicado aqui. Dado este recado, vamos ao que interessa.

Sub Janelas (II)

Uma das coisas das quais muitos programadores iniciantes tentam fazer, é o de criar um Expert Advisor, para poderem operar no mercado. Mas ao tentarem fazer isto, muitos destes programadores iniciantes, tendem a tentar criar um monte de controles para controlar seu Expert Advisor. Porém, ao fazerem isto, acabam tornando o gráfico muito poluído e cheio de objetos que poderiam estar em outro local. No caso em uma sub janela. Deixando assim o gráfico totalmente limpo, para de fato podermos analisar o que estará ocorrendo em cada barra presente ali.

Ok, a ideia de colocar os controles em uma sub janela, é de fato muito boa. Porém, toda via e, entretanto, sub janelas

NÃO PODEM SER CRIADA SEM QUE SEJA POR MEIO DE UM INDICADOR.

Este é um ponto onde a coisa toda começa a ficar bem confusa e difícil de administrar. Isto quando nos falta experiência, para que consigamos fazer com que este tipo de implementação venha a funcionar. Em algum momento no futuro, irei explicar de maneira bem clara e simples, como isto pode ser implementado. Porém, peço a você, meu amigo leitor, para que tenha paciência. Pois ainda estamos bem no início do que precisa ser explicado sobre sub janelas. Somente queria dar um exemplo, para que estes artigos sejam devidamente observados e estudados por você. Pois muitos podem vir a achar que isto daqui é pura perda de tempo. Quando na verdade, cada ponto que iremos ver será importante para que você tenha um perfeito entendimento sobre futuros artigos.

Então vamos começar nos profundando um pouco mais, a respeito de uma questão que começamos a ver no artigo anterior. A questão se refere a forma como seu indicador estará calculando a curva a ser plotada no que se refere a sub janela. Cara, este assunto de novo? Acho que já entendi como devo proceder para que meu indicador seja calculado corretamente. Hum, será mesmo meu caro leitor? Será que você de fato já sabe como fazer isto?

Bem, acredito que poucos realmente saibam como fazer isto. Não por eu me achar um gênio. Mas por conta do tipo de coisa que já vi sendo feita por outros programadores. E para demonstrar as coisas de uma forma ainda mais simples. Vamos utilizar um dos códigos vistos no artigo anterior. Porém, aqui vamos resumir ainda mais as coisas, a um cálculo ainda mais simples. Já que quanto mais coisas existirem no código, mais complexo o mesmo se torna em termos de explicação e entendimento. Sendo assim o código que iremos utilizar é visto 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.     {20, MODE_SMA, clrBlack}
14. };
15. //+----------------+
16. #property indicator_chart_window
17. #property indicator_applied_price   PRICE_CLOSE
18. #property indicator_buffers         Averange.Size();
19. #property indicator_plots           Averange.Size();
20. //+------------------------------------------------------------------+
21. struct stInfos
22. {
23.     double  Buff[];
24. }Infos[Averange.Size()];
25. //+------------------------------------------------------------------+
26. int OnInit(void)
27. {
28.     for (uint c = 0; c < Averange.Size(); c++)
29.     {
30.         SetIndexBuffer(c, Infos[c].Buff, INDICATOR_DATA);
31.         PlotIndexSetInteger(c, PLOT_DRAW_TYPE, DRAW_LINE);
32.         PlotIndexSetInteger(c, PLOT_LINE_STYLE, STYLE_SOLID);
33.         PlotIndexSetInteger(c, PLOT_LINE_WIDTH, 2);
34.         PlotIndexSetInteger(c, PLOT_LINE_COLOR, Averange[c].cor);
35.         PlotIndexSetString(c, PLOT_LABEL, StringFormat("Arithmetic of %d", Averange[c].nPeriods));
36.     }
37. 
38.        return INIT_SUCCEEDED;
39. };
40. //+------------------------------------------------------------------+
41. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
42. {
43. 
44.     for (uint c = 0; c < Averange.Size(); c++)
45.     {
46.         if (prev_calculated == 0)
47.         {
48.             double loc = 0;
49.             for (int c1 = 0; c1 < Averange[c].nPeriods; c1++) loc += price[Averange[c].nPeriods - c1];
50.                 Infos[c].Buff[Averange[c].nPeriods] = loc / Averange[c].nPeriods;
51.         }
52.         switch (Averange[c].Method)
53.         {
54.             case MODE_SMA:
55.                 for (int i = (prev_calculated > 0 ? prev_calculated - 1 : Averange[c].nPeriods + 1); i < rates_total; i++)
56.                     Infos[c].Buff[i] = ((Infos[c].Buff[i - 1] * Averange[c].nPeriods) - price[i - Averange[c].nPeriods] + price[i]) / Averange[c].nPeriods;
57.                 break;
58.         }
59.     }
60. 
61.     return rates_total;
62. };
63. //+------------------------------------------------------------------+

Código 01

Este código 01, consegue perfeitamente calcular a média aritmética que estamos pedindo para ser plotada, devido a linha 13, que pode ser vista no código. Porém você sabe me dizer em que sentido este cálculo está sendo feito? Bem, tanto a média calculada como também o sentido pode ser visualizado na imagem logo abaixo.

Imagem 01

A seta vista nesta imagem 01, mostra o sentido que o cálculo está sendo processado. Já a linha em preto, mostra a média calculada. Mas por que saber disto é importante? Acho que isto não faz nenhuma diferença na prática. De certa forma, meu caro leitor, na maior parte das vezes, não faz diferença você calcular as coisas em um sentido ou em outro. No entanto, aqui não estamos lidando com senso comum. Programação, ou melhor dizendo, programadores, não seguem o senso comum. Eles apenas fazem a implementação daquilo que lhes foi pedido. Pouco importa o que o senso comum diz. Programadores tem que conseguir fazer com que o seu código gere aquilo que é esperado dele. A forma de fazer isto, pouco importa.

Porém, quando o assunto é programação 2 + 3 pode ser diferente de 3 + 2. Hã? Mas como assim? Durante os artigos onde expliquei sobrecarga de operadores, mostrei que nem sempre, podemos pensar nas coisas como muitos podem estar imaginando que elas funcionam. Por este motivo, dependendo do tipo de coisa que você esteja tentando fazer, pode ser que calcular as coisas em uma direção fará com que você tenha um resultado. Enquanto se você tentar calcular elas em outra direção, fará com que o código venha a falhar. E este código 01 é um bom exemplo para demonstrar isto.

Para tal, vamos fazer agora o seguinte: Iremos adicionar um indicador de volume, conforme pode ser visto logo abaixo.

Imagem 02

Agora vamos adicionar este código 01 ao indicador de volume. Assim poderemos observar a média de volume nos últimos 20 períodos. Faremos isto com base na animação logo abaixo.

Animação 01

Como esperado. Funcionou. Mas isto não indica que este código 01, pode vir a ser utilizado a qualquer momento. Pois agora vamos ver um exemplo onde este código 01, não irá de fato gerar o que desejamos. Para fazer isto, iremos remover o indicador de volume e adicionar um outro tipo de indicador. Mas antes, quero lhe mostrar uma coisa, meu caro leitor. Isto pode ser visto na imagem logo abaixo.

Imagem 03

Note que nesta imagem 03, temos dois indicadores fazendo uso do código 01. Preste atenção a isto, pois este tipo de informação será muito útil depois. Agora vamos adicionar um outro indicador, como mostrado na animação logo na sequência.

Animação 02

Aqui não nos interessa por que estou utilizando este indicador. Apenas escolhi ele, entre os demais por um acaso. Você pode experimentar outro depois, se assim desejar. A ideia aqui agora é a seguinte: Queremos que este indicador presente na sub janela tenha sua média de valores calculadas de forma a suavizar esta média em verde, que está sendo plotada. Para isto, queremos utilizar nosso indicador que pode ser visto no código 01. Basicamente você deverá adicionar o indicador visto no código 01, da mesma forma que já sabemos como fazer. Assim quando o indicador for plotado, teremos uma segunda média sendo mostra. Mas esta irá se referir a média aritmética dos últimos vinte valores previamente calculados pelo indicador presente na sub janela.

Assim fazemos o que é visto na animação logo abaixo.

Animação 03

Mas o que aconteceu? Onde está o indicador? Será que ele falhou de forma catastrófica, sendo removido do gráfico? Hum. Não entendi. Bem, meu caro leitor, agora você está começando a perceber, que as coisas não são tão simples como você imaginava anteriormente, não é mesmo? Vamos então ver o que aconteceu. Primeiro, vamos ver se existe alguma mensagem no terminal, informando alguma possível falha.

Imagem 04

Como pode ser visto na imagem 04, nenhuma falha foi reportada. Próxima tentativa de entender o que aconteceu aqui. Vamos então olhar a lista de indicadores. Ao fazermos isto, podemos ver o que é mostrado na imagem logo abaixo.

Imagem 05

Cara que coisa mais estranha. Nesta imagem 05, podemos ver que de fato o indicador está ali, onde deveria. Mas no entanto, não está aparecendo no gráfico. Ok desisto. Acho que vou procurar outra coisa para fazer da vida. Esta coisa de programação definitivamente não é para mim. Calma meu caro leitor. Lembre-se de que estes artigos, tem como objetivo lhe ensinar como você pode conseguir atingir seus objetivos. E para isto, você precisa entender como seu código estará lhe reportando falhas e erros. Se você observar com atenção a animação 03, irá notar algo no gráfico. Para tornar isto mais evidente, vamos parar a animação em um determinado quadro e olhar com mais calma o que está sendo mostrado ali.

Imagem 06

Observe que estou destacando um ponto específico nesta imagem. Este valor que está sendo destacado, deveria ser outro e não este que está sendo mostrado. Mas então, será que não podemos utilizar, ou melhor, criar uma média de valores, usando para isto um indicador como o mostrado nesta imagem 06? Bem, vamos responder isto, fazendo um outro teste. Lembre-se de que no código 01, estamos utilizando uma média aritmética de vinte períodos. Sendo assim, vamos usar um outro indicador, que vem por padrão no MetaTrader 5. Isto para verificar que a falhar está no nosso indicador, ou se existe outro motivo para que ele não venha ser plotado no gráfico. Na animação logo abaixo, fazemos o tal teste.

Animação 04

Mas que coisa mais doida. Não é que de fato funciona. Então o erro está no nosso código. Sim meu caro leitor, o erro está no código. Ok, agora não sei como corrigir isto. Já que diferente do que foi visto no artigo anterior, onde estamos pedindo para o que o cálculo fosse executado pelo MetaTrader 5. Agora estamos fazendo nos mesmos os cálculos. E mesmo assim o indicador falhou. Por que?

O motivo é que existe a questão da direção em que o cálculo está sendo feito. Como foi visto na imagem 01. O nosso código 01, está fazendo o cálculo na direção dos dados mais antigos para os dados mais recentes. E possivelmente em algum momento ele não sabe como trabalhar com isto. Fazendo com que o indicador falhe e a média não venha a ser plotada.Justamente por conta que o indicador está com dados inválidos. Por isto que na imagem 06, podemos ver aquela informação sendo mostrada.

Percebe agora como todas as coisas começam a fazer sentido? E de que todas estão de alguma forma correlacionadas umas com as outras. Se eu simplesmente mostrasse um código totalmente funcional e perfeitamente correto. Você, que está tentando aprender, jamais iria conseguir descobrir onde estaria o erro. Já que ele à primeira vista não faz nenhum sentido.

Mas então como podemos corrigir este código 01, para que a média possa vir a ser plotada no gráfico da sub janela? Bem, para fazer isto, meu caro leitor, precisamos fazer com que o cálculo que está sendo efetuado dentro do procedimento OnCalculate seja invertido. Isto é, precisamos que ele comece calculando dos valores mais recentes para os valores mais antigo. Claro que para fazer isto precisamos mudar a forma como o cálculo está sendo feito. E isto é conseguido, quando mudamos o código 01, para este que pode ser visto 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.     {20, MODE_SMA, clrYellow}
14. };
15. //+----------------+
16. #property indicator_chart_window
17. #property indicator_applied_price   PRICE_CLOSE
18. #property indicator_buffers         Averange.Size();
19. #property indicator_plots           Averange.Size();
20. //+------------------------------------------------------------------+
21. struct stInfos
22. {
23.     double  Buff_iMA[],
24.             f_Expo;
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.         Infos[c].f_Expo = (double) (2.0 / (1.0 + Averange[c].nPeriods));
33.         PlotIndexSetInteger(c, PLOT_DRAW_TYPE, DRAW_LINE);
34.         PlotIndexSetInteger(c, PLOT_LINE_STYLE, STYLE_SOLID);
35.         PlotIndexSetInteger(c, PLOT_LINE_WIDTH, 1);
36.         PlotIndexSetInteger(c, PLOT_LINE_COLOR, Averange[c].cor);
37.         PlotIndexSetString(c, PLOT_LABEL, StringFormat("%s of %d", (Averange[c].Method == MODE_EMA ? "Exponential" : "Arithmetica"), Averange[c].nPeriods));
38.     }
39. 
40.        return INIT_SUCCEEDED;
41. };
42. //+------------------------------------------------------------------+
43. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
44. {
45.     int c0 = 0;
46.     double value;
47. 
48.     for (uint c = 0; c < Averange.Size(); c++) switch (Averange[c].Method)
49.     {
50.         case MODE_SMA:
51.             for (int i = rates_total - 1; i > prev_calculated; i--)
52.             {
53.                 value = 0;
54.                 for (int j = 0; (i - j) > 0 && j < Averange[c].nPeriods; j++)
55.                     value += price[i - j];
56.                 Infos[c].Buff_iMA[i] = value / Averange[c].nPeriods;
57.             }
58.             break;
59.     }
60. 
61.     return rates_total;
62. };
63. //+------------------------------------------------------------------+

Código 02

Agora preste atenção meu caro leitor. Este código 02, está invertendo o sentido do cálculo. Dependendo da forma como iremos fazer isto, precisamos adaptar o código de uma maneira ou de outra. No entanto, como aqui o objetivo é a didática, estou usando a média aritmética, por nos permitir criar um código consideravelmente mais simples. Sendo assim, tudo que foi visto até aqui, cabe a este código 02. Porém, existe uma diferença, e esta está justamente no fato, de que quando aplicamos, ou melhor dizendo, incorporamos este código 02, ao indicador colocado no gráfico, pela animação 02. Teremos um resultado totalmente diferente do que foi visto na animação 03. Este resultado pode ser observado na animação logo na sequência.

Animação 05

Note que mudei a cor e a espessura do indicador. Isto diretamente no código 02. Desta forma, quando ele é colocado, podemos claramente perceber que ele está se encaixando perfeitamente no que seria o indicador que foi colocado na animação 04. Mostrando desta maneira que de fato temos um indicador agora perfeitamente funcional, no que diz respeito a utilização básica do mesmo. Isto é ao não é algo lindo de ser visto e aprendido, meu caro leitor? Sem este conhecimento que você acabou de adquirir, você jamais conseguiria encontrar onde estaria o erro. Justamente por conta de que praticamente ninguém fala ou mesmo explica que este tipo de coisa deve ser levado em consideração, durante o procedimento de codificação.

Talvez, por que muitos não venha a de fato tentar fazer isto que estou lhe mostrando aqui. Devido a isto, a pessoa simplesmente não sabe destes pormenores e assim não tem como lhe explicar o motivo de tais falhas no código. E quando ninguém fala ou explica, você acaba desistindo, e colocando a culpa no lugar errado. Como muitos fazem ao culpar a plataforma ou mesmo a linguagem MQL5. Sendo que no entanto, tais pessoas simplesmente desconhecem tais fatos mostrados aqui.

Ok, isto foi legal e bastante divertido. Mas vamos agora utilizar este código 02, para explicar algo que foi apenas pincelado no artigo anterior. Que é justamente entender como e por que escolher o FIRST INDICATOR'S DATA ou o PREVIOUS INDICATOR'S DATA. Isto pode ser visto na imagem logo abaixo.

Imagem 07

Para que isto fique bem fácil de ser entendido, precisamos recorrer a uma outra informação. Esta é vista na imagem logo abaixo.

Imagem 08

Quando você vai adicionar um indicador qualquer em uma sub janela. Onde este indicador deverá usar em seus cálculos internos, valores previamente calculados e já presentes na sub janela. Você precisará ver e entender isto que é mostrado na imagem 08.

A seta presente nesta imagem 08, mostra a ordem em que os indicadores foram colocados. Detalhe: Às vezes isto não é de todo verdade, já que existem casos especiais aqui. Mas em quase 100% das vezes isto será verdadeiro. De qualquer maneira, o indicador mais próximo no topo da lista, é considerando como sendo o primeiro indicador. Todos os demais são colocados um após o outro. Agora para entender o que seria o FIRST INDICATOR'S DATA e o que seria o PREVIOUS INDICATOR'S DATA, você precisa pensar que estes indicadores vistos nesta imagem 08, estão em uma fila de valores. Onde você pode apenas ver o primeiro e o último.

Se você não sabe o que seria uma fila de valores, veja este artigo Do básico ao intermediário: Filas, Listas e Árvores (II), para ter alguma noção do que estamos falando aqui. Perceba, que o conhecimento vai acumulando com o tempo. Por isto parece que não estamos andando. Quando na verdade estamos mesmo é voando.

Uma vez entendido esta questão, de que estamos lidando com uma fila aqui. Fica muito fácil saber qual método escolher. Pois se estamos escolhendo o método FIRST INDICATOR'S DATA, estaremos dizendo ao MetaTrader 5, para usar os dados que se encontram no primeiro indicador desta fila mostrada na imagem 08. Agora se usarmos o método PREVIOUS INDICATOR'S DATA, estamos dizendo para o MetaTrader 5, utilizar o último indicador desta fila mostrada na imagem 08.

Hum, isto sim foi bem bolado. Mas será que temos como burlar este sistema? Escolhendo assim qual indicador queremos utilizar? Sim, meu caro leitor. Existem meios de fazermos isto. No entanto, não se preocupe com isto agora. Isto por que, ainda estamos bem no início das coisas que podemos fazer dentro do que seria as sub janelas. Porém, é preciso lembra que mesmo dentro do gráfico principal, ou janela primária. Temos sim meios de adicionar este tipo de regra. Se bem que neste caso ficaremos limitados a poder utilizar apenas o tipo PREVIOUS INDICATOR'S DATA. Mas os resultados ainda assim podem vir a ser bem interessantes. Como você pode observar na animação logo abaixo.

Animação 06

Note que de fato é algo bem interessante. Podendo inclusive gerar uma série de estudos com diversas finalidades. Mas vamos voltar a nossa questão aqui. Que é justamente as sub janelas. Como já vimos o que acontece quando adicionando o indicador de código 02, a sub janela. E isto pode ser visto na animação 05. Vamos ver o que acontece, se começarmos a utilizar a escolha PREVIOUS INDICATOR'S DATA. Isto para entender como a fila irá ser construída a cada novo indicador colocado. Bem, lembre-se de que a fila inicial é a que podemos ver na imagem 08. Assim quando adicionarmos o primeiro novo indicador, iremos ter como resultado o que é mostrado na animação logo abaixo.

Animação 07

Por consequência, a nova fila é mostrada na imagem logo a seguir.

Imagem 09

Note que agora Code 02 é o novo valor no fundo da fila. Assim se adicionarmos novamente um novo indicador, o resultado é este visto na animação logo na sequência.

Animação 08

Bem, creio que já deve ter dado para entender, onde isto irá chegar. Note que sempre que adicionamos um indicador, para usar a previa como base de cálculos, acabamos suavizando, ou intensificando o sinal. Isto claro dependendo da forma como os cálculos estiverem sendo feitos pelo nosso indicador. De qualquer forma, podemos fazer muitas coisas apenas nos baseando neste tipo de modelagem bem simples e direta. Sem necessidade de cálculos excêntricos e totalmente exóticos a ponto de criar algum tipo de média móvel mágica, ou algum indicador mágico, que somente um gênio da matemática conseguiria obter. Nada disto. Podemos alcançar resultados bem interessantes, usando basicamente um cálculo muito simples, rápido e direto.

Legal, mas o que acontece se removermos um indicador que tem diversos outros ligados a ele? Por exemplo: No caso da animação 08, temos dois indicadores sendo ligados um ao outro. Ambos sendo Code 02. Assim se removermos o indicador mais ao topo, o que acontecerá com o outro indicador que está mais ao fundo? Ele por um acaso irá tomar o lugar daquele que acabamos de remover? Está de fato é uma questão interessante meu caro leitor. Isto por que a resposta para ela, depende de como o MetaTrader 5, irá tratar este tipo de situação. Aqui, não temos como dizer ao MetaTrader 5, como ele deverá agir, ou pelo menos desconheço uma forma de se fazer isto. Portanto, precisamos entender como ele irá tratar esta situação bem específica. E para demonstrar isto, faremos uso da animação logo abaixo.

Animação 09

Note que a resposta padrão do MetaTrader 5, foi simplesmente remover os indicadores que estão ligados a este que estamos removendo. Isto de fato é algo bem mais prático e simples, do que tentar criar algum método maluco para que os demais indicadores possam a vir a ser mantidos no gráfico. A forma como o MetaTrader 5, lida com este tipo de situação, além de ser limpa, e bastante elegante. Já que não deixa margem para possíveis interpretações do que está sendo calculado em cada um dos indicadores.

Agora vamos ver uma coisa que servirá para fechar este artigo. Com base no código 02, vamos modificar apenas e somente uma única linha neste código. Esta poderá ser vista no fragmento logo abaixo.

                   .
                   .
                   .
11. }Averange[] = 
12. {
13.     {20, MODE_SMA, clrDodgerBlue}
14. };
15. //+----------------+
16. #property indicator_separate_window
17. #property indicator_applied_price   PRICE_CLOSE
18. #property indicator_buffers         Averange.Size();
                   .
                   .
                   .

Fragmento 01

A linha modificada é justamente a linha 16. E não se preocupe meu caro leitor. No anexo, você terá todos estes códigos vistos aqui, na íntegra, para que os possa estudar com calma. Mas esta mudança vista nesta linha 16, irá gerar um código bem interessante. Isto pelo ponto de vista prático. Apesar de que na teoria, este código deveria se comportar de uma maneira totalmente diferente da que você pode vir a presenciar.

Quando você utiliza esta linha 16 em um indicador, espera que ele SEMPRE venha a ser colocado em uma nova sub janela, não é mesmo meu caro leitor? Porém isto nem sempre irá acontecer. Na verdade, somente iremos criar uma sub janela, com base neste tipo de propriedade do indicador. SE E SOMENTE SI, o estivermos definindo da maneira padrão. Ou seja, não poderemos estar tentando utilizar a forma de busca de dados FIRST INDICATOR'S DATA e nem PREVIOUS INDICATOR'S DATA. Se tais forma forem tentadas, o MetaTrader 5 irá ignorar a propriedade definida na linha 16, e irá colocar o indicador na sub janela em que ele está sendo adicionado.

Mas espere um pouco. Isto quer dizer que podemos colocar o indicador, mesmo com esta propriedade sendo indicada no gráfico principal. NÃO meu caro leitor, neste caso não poderemos fazer isto. E o motivo é que o MetaTrader 5, irá bloquear o acesso a seleção PREVIOUS INDICATOR'S DATA neste caso específico. Porém se você tentar usar o indicador em uma sub janela, onde já existe outro indicador, poderá dizer se quer utilizar os modos FIRST ou PREVIOUS INDICATOR'S DATA. E neste caso, nenhuma sub janela será criada.

Para tornar isto mais claro, vamos ver algumas animações, onde demonstro isto acontecendo na prática.

Animação 10

Aqui na animação 10 podemos ver o que acontece quando tentamos adicionar ao gráfico principal um indicador, que tem como propriedade o fato de que deverá ser adicionado em uma nova sub janela. Note que não temos como mudar muita coisa aqui.

Animação 11

Já nesta animação 11, estamos testando o que acontece quando adicionamos um indicador em uma sub janela. Mas este indicador tem como propriedade interna, o fato de dizer que quer ser adicionado em uma nova sub janela. Perceba que diferente do que acontecia na animação 10, agora já temos como fazer algumas seleções, que antes não podíamos.

Mas a parte que realmente interessa aqui, é o fato de que nesta animação 11, a curva que estará sendo plotada é exatamente a mesma que estaria sendo plotada na animação 10. No entanto, apesar do indicador ter como propriedade o fato de que deveria ser sua própria sub janela. O MetaTrader 5, entende que ele já estará sendo colocado em uma sub janela. Sendo assim nenhuma nova sub janela precisará ser criada.

Animação 12

Agora nesta animação 12 estamos fazendo com que o mesmo indicador, visto nas animações 10 e 11, fizesse uso de algum dado previamente calculado, já presente na sub janela. Com isto, temos algo muito similar ao que havia sido visto mais no início deste artigo. Mostrando assim que mesmo um indicador com algumas propriedades sendo definidas de uma certa maneira, irá se comportar de uma forma um pouco diferente. Desde que isto ajude ao MetaTrader 5, efetuar o correto gerenciamento dos indicadores ali presentes.

Animação 13

E para finalizar esta parte da demonstração, temos esta animação 13. Perceba que da mesma forma que aconteceu na animação 12, o MetaTrader 5, viu que a melhor solução neste caso, seria a de manter o indicador presente na mesma sub janela na qual ele estaria sendo arrastado. Novamente, este tipo de decisão feita pelo MetaTrader 5, tem como princípio, facilitar a administração de todos os indicadores presentes em um gráfico. Isto para que no final, ele saiba como os remover dependendo da maneira como eles estiverem sendo correlacionados uns com os outros.

Considerações finais

Neste artigo, que por sinal foi bem divertido e didático. Demostrei diversas características relacionadas ao uso de indicadores dentro do que seria uma sub janela. Lembrando que ainda estamos apenas iniciando os estudos e demonstrações sobre como isto acontece na prática.

Aqui também foi visto, que precisamos tomar alguns cuidados, quando estamos implementando nossos códigos. Já que dependendo da maneira como os estivermos criando, pode ser em algum momento, os mesmos não venham a se comportar da maneira como esperávamos que eles iriam se comportar. Nos dando desta forma resultados completamente errados, ou até mesmo inexistentes. No entanto, como tudo em programação depende de que você experimente e procure estudar cada coisa envolvida neste ou naquele tipo de implementação. Isto a fim de realmente aprender e se tornar um profissional graduado.

Deixo no anexo, os três principais códigos vistos neste artigo. Isto para que você os experimente na prática e veja o que acontece em cada uma das situações. Entender onde um código falha, é muito mais importante e nos ensina muito mais, do que simplesmente ver o código funcionando todo bonito na tela. Então meu caro leitor, aproveite esta oportunidade e estude com calma o que foi visto neste artigo. Pois isto pode lhe ajudar bastante no futuro.

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