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

Introdução

No artigo anterior Do básico ao intermediário: Sub Janelas (II), foi demonstrando algumas falhas e problemas que podemos vir a ter quando tentarmos utilizar um indicador em uma sub janela. E mais do que isto, vimos também como o MetaTrader 5, de maneira bastante sagas, foi implementado de forma a conseguir gerir os indicadores. Isto com a finalidade de evitar possíveis conflitos entre informações que tais indicadores estarão nos fornecendo durante o seu uso.

Como foi demonstrando no artigo anterior, podemos, desde que tenhamos o devido conhecimento, fazer diversas coisas dentro do MetaTrader 5. E isto utilizando o MQL5 puro e simples. Sem nenhum tipo de frescura, ou coisas sem pé e sem cabeça. Como grande parte já deve ter notado, não gosto muito de seguir uma lógica rígida. Gosto de ir e olhar o que muitos se quer imaginam que pode vir a ser feito, ou a acontecer. Devido a isto, sei que muitos de vocês, já devem estar ansiosos para começar a implementar coisas mais complexas. Mas como diria um sábio, vamos com calma.

Então vamos focar no que será explicado neste artigo, afastando toda e qualquer coisa que possa nos distrair durante a leitura. Pois aqui iremos ver que nem tudo é como muitos imaginam ser.

Sub Janelas (III)

Sub janelas são coisas bastante uteis, principalmente quando bem utilizadas. Já que elas nos permitem organizar uma série de coisas de maneira muito simples, fácil e prática. No entanto, por simplicidade, dentro do MetaTrader 5, somos limitados a somente um único modo de apresentação de sub janelas. Apesar de isto ser um tanto quanto limitante no que diz respeito ao tipo de coisa na qual podemos chegar a construir. Nas mãos certas, esta limitação é apenas um pequeno detalhe. Já que podemos trabalhar dentro dela, fazendo com que ela seja apenas um mero detalhe. Não sendo de fato um limitante, mas sim um desafio a ser vencido.

Ok, parece que o real limitante, é a nossa imaginação e o nosso grau de conhecimento do que realmente podemos fazer dentro do MQL5. Isto a fim de conseguir controlar o MetaTrader 5 de uma determinada maneira. Sendo assim, vamos começar pelo mais simples dos cenários, que é justamente quando dizemos ao compilador do MQL5, que desejamos fazer uso de uma sub janela.

Tal coisa foi vista no final do artigo anterior. Porém ali apenas foi demonstrando uma pequena parte do que realmente podemos fazer. Para que as coisas fiquem bem claras, precisamos voltar a um ponto bem mais simples do que aquele visto anteriormente. Desta maneira, a forma mais básica de informarmos ao MetaTrader 5 que desejamos fazer uso de uma sub janela, ou até mesmo criar uma, é simplesmente fazermos uso do código visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property description "DEMO Indicator"
05. //+------------------------------------------------------------------+
06. #property indicator_separate_window
07. //+------------------------------------------------------------------+
08. int OnInit(void)
09. {
10.     return INIT_SUCCEEDED;
11. };
12. //+------------------------------------------------------------------+
13. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
14. {
15.     return rates_total;
16. };
17. //+------------------------------------------------------------------+

Código 01

Este código 01, tem como único e real objetivo promover a criação de uma sub janela em um gráfico qualquer. E para fazermos isto, é utilizado a linha seis, onde modificamos a propriedade do próprio indicador, para que ele venha a ser colocado em um sub janela qualquer. Apesar desta ser a maneira mais simples de se fazer isto, ela não é a única, como será demonstrado em breve.

Porém antes de vermos isto, preciso explicar uma outra coisa que é muito importante. E você pode e deve experimentar, isto fazendo o uso deste código 01, mostrado acima. A tal questão é justamente o fato de que cada vez que você adicionar uma instância deste código 01 ao gráfico, será criada uma nova sub janela no gráfico. E dependendo do tipo de tarefa que este indicador precisar e vier a fazer. Estas instâncias extras, podem acabar gerando muito mais problemas, do que realmente vir a nos ajudar na solução de um dado problema específico.

E como na maior parte das vezes, podemos estar, ou desejamos vir a disponibilizar estes códigos, a outros operadores que de fato não tem o conhecimento sobre como ele de fato deverá ser utilizado. Não é raro que estes outros operadores venham a colocar o indicador mais se uma vez no mesmo gráfico. Acabando assim gerando muito mais problemas do que seria previsto, por você, que implementou o código.

Quando, nosso código é colocado em uma janela principal. O MetaTrader 5, muitas das vezes, utiliza de maneira bastante sagas, dados de configuração que serão utilizados no nosso código como forma de verificar se estamos tentando adicionar uma instância que já esteja presente no gráfico. Caso isto seja verdadeiro, a nova instância que estamos tentando criar será descartada. No entanto, sendo detectado pelo MetaTrader 5, de que de fato estamos criando uma instância, completamente nova e diferente. O MetaTrader 5, permitirá que venha a surgir uma nova instância de seu código no gráfico.

Bem, basicamente é isto que acontece. Porém quando fazemos uso de um código, que venha a criar ou gerar uma nova sub janela no gráfico. Este mecanismo usado pelo MetaTrader 5, não irá entrar em ação. Daí, o fato de que você poderá colocar diversas instâncias, do código 01, no mesmo gráfico. Gerando assim uma cascata de sub janelas presentes no gráfico do ativo atual.

Ok, mas e se não desejarmos que isto venha a acontecer. Como podemos evitar que novas sub janelas sejam criadas, pelo código que já esteja sendo executado no ativo atual? Para isto, precisaremos recorrer ao MQL5, a fim de analisar que tipo de situação estará presente no gráfico atual. Lembrando que o que iremos ver aqui, é apenas o básico do básico, para algo ainda mais abrangente.

Para começar, precisamos ter uma forma de checar se o nosso código está ou não presente no gráfico. E para isto, precisamos adicionar algo bem específico no nosso código. Tal coisa pode ser vista no código logo abaixo, que seria um tipo de atualização do código 01, visto a pouco.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property description "DEMO Indicator"
05. //+------------------------------------------------------------------+
06. #property indicator_separate_window
07. //+------------------------------------------------------------------+
08. int OnInit(void)
09. {
10.     IndicatorSetString(INDICATOR_SHORTNAME, "Test 123.");
11.     
12.     return INIT_SUCCEEDED;
13. };
14. //+------------------------------------------------------------------+
15. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
16. {
17.     return rates_total;
18. };
19. //+------------------------------------------------------------------+

Código 02

Agora veja o seguinte meu caro leitor. Neste código 02, adicionamos esta chamada que é vista na linha dez. Esta chamada tem um objetivo muito especial. Ela irá fazer com que nosso código venha a ter um nome dentro do gráfico. O nome em questão é este que vemos entre aspas duplas. Naturalmente você deve tentar fazer com que este nome venha a ser único. Já que este nome é o que iremos testar depois, isto para verificar se o nosso código está ou não presente no gráfico.

Mas espere um pouco. Não seria mais fácil utilizar o nome do executável a fim de verificar se temos ou não uma instância de nosso código no gráfico? Bem, em tese sim, seria mais simples. Porém existe um problema. Quando compilamos o código ele pode vir a ter um certo nome, como sendo o nome do executável. No entanto, pode ser que este nome venha a entrar em conflito com o nome de outros arquivos. Já que, pode ser que você venha a distribuir seu código a outras pessoas. E neste momento, o nome do executável poderá ser modificado, acabando por assim dizer, qualquer tentativa de analisar se o nosso código já está ou não presente no gráfico atual.

No entanto, usando esta chamada vista na linha dez deste código 02, evitamos este tipo de problema. Já que uma vez compilado, dificilmente algum usuário, irá conseguir mudar esta string que estamos definindo aqui. Lembrando que podendo assumir qualquer valor aqui. De preferência um que você considere ser único. E esta é a parte importante. Que esta string seja única.

Ok, mas como esta string irá nos ajudar a saber se temos ou não uma instância já aberta no gráfico atual? Bem agora vem a parte divertida.

Considerando o fato de que está string, informa quando nosso código está ou não presente no gráfico. Iremos adicionar um código para testar isto. Mas antes de fazermos isto. Preciso que você entenda uma outra coisa primeiro. Isto é feito usando o código logo abaixo.

1. //+------------------------------------------------------------------+
2. #property copyright "Daniel Jose"
3. //+------------------------------------------------------------------+
4. void OnStart(void)
5. {
6.     Print(ChartGetInteger(0, CHART_WINDOWS_TOTAL));  
7. }
8. //+------------------------------------------------------------------+

Código 03

Este código irá simplesmente dizer quantas janelas existem atualmente no gráfico em que ele for executado. Preste atenção nisto meu caro leitor. Pois preciso que você entenda muito bem onde iremos chegar daqui a pouco. Então executando este código 03, termos como resposta algo parecido com o que é visto logo abaixo.

Imagem 01

Agora adicionando algumas sub janelas, teremos o que é visto na imagem logo abaixo.

Imagem 02

Hum, legal. Então podemos usar o MQL5 para saber quantas sub janelas estão presentes em um gráfico. Mas e quanto o fato de saber que tipo de indicador está presente ali? Bem, para isto, modificamos o código 03, para algo parecido como o que é visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     for (int c0 = 0; c0 < (int)(ChartGetInteger(0, CHART_WINDOWS_TOTAL)); c0++)
07.         for (int c1 = (ChartIndicatorsTotal(0, c0) - 1); c1 >= 0; c1--)
08.             PrintFormat("In the sub window [%d] was found this indicator >>%s<<", c0, ChartIndicatorName(0, c0, c1));
09. }
10. //+------------------------------------------------------------------+

Código 04

Agora quando executamos este código 04, o resultado é o que podemos ver logo abaixo.

Imagem 03

Agora repare em uma coisa interessante nesta imagem 03. Nela podemos ver o nome de todos os indicadores presentes o gráfico. Inclusive em qual janela cada um está sendo mostrado. Porém se você for olhar na lista de indicadores irá ver o que é mostrado na imagem logo na sequência.

Imagem 04

Isto que pode ser observado na imagem acima é algo bem interessante. Note que que nesta imagem 04 temos os nomes dos executáveis que estão no gráfico. Porém o nome de cada indicador aparece diferente na imagem 03. Portanto, acredito que esteja ficando claro o fato de que o nome do executável, não necessariamente estará ligado ao nome do indicador. De fato, este tipo de coisa torna bem mais simples fazer certas coisas. Porém você deve sim agradecer a equipe que bolou e colocou este tipo de coisa no MetaTrader 5. Pois isto de fato, torna nos permitirá fazer algumas coisas no futuro. No entanto, meu objetivo aqui é justamente tentar lhe ajudar a entender estes pequenos detalhes, e assim lhe ajudar a criar suas próprias soluções.

Ok, mas e se não tivéssemos utilizado aquela linha dez do código 02. O que aconteceria? Bem, meu caro leitor, para mostrar isto, vamos usar o código 01. Assim adicionando ele ao gráfico. E executando novamente o código 04. O resultado visto seria este mostrado logo abaixo.

Imagem 05

Agora abrindo a lista de indicadores podemos ver o seguinte:

Imagem 06

Hum, não entendi. O que aconteceu aqui? Bem, meu caro leitor. Você pode notar que em ambas as imagens estou destacando uma certa informação. Note agora que o fato de que não termos definido um nome para o nosso indicador, fez com que o nome do executável viesse a ser utilizado, como referência ao procuramos saber que tipo de indicador está presente em cada janela. No entanto, volto a frisar que este tipo de coisa visto nestas imagens acima, devem ser evitadas sempre que possível. Isto quando você deseja, de fato, ter um certo controle sobre o seu código. Já que, como foi dito antes, o usuário pode vir a mudar o nome do executável e ser isto for feito, acabaremos por perder completamente o controle sobre certas coisas relacionadas ao nosso código. Por isto, saber como e quando definir um nome curto, que é justamente o que a linha dez do código 02, está fazendo é algo muito importante.

Existem outros motivos para se utilizar nomes curtos em indicadores. Mas não irei entrar neste momento, nestes outros motivos. Já que para os entender, seria preciso fazer algo que ainda não vejo ser de fato o momento.

Ok, dito tais coisas e tendo sido feita uma demonstração básica sobre algumas coisas relacionadas ao sub janela. Podemos começar a trabalhar em algo um pouco mais elaborado. Isto por que existem situações em que não devemos utilizar as coisas da forma convencional. Precisamos de fato fazer com que elas venham a ser criadas de uma outra maneira.

Cara o que você está prendendo fazer? Bem, meu caro leitor, normalmente quando trabalhamos com indicadores, não queremos, ou melhor dizendo, não precisamos que eles venham a ser duplicados. Raras são as situações quem que precisamos que um indicador qualquer venha a ter uma segunda instância em um mesmo gráfico. Quando este tipo de situação chega a de fato surgir, precisamos saber como burlar o sistema. Isto por que de maneira muito sagas, o MetaTrader 5 evita que tenhamos um indicador sendo duplicado. Você pode atestar isto, se utilizar o código 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, clrDodgerBlue}
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, 2);
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 05

Por mais que você tente, você não irá conseguir colocar duas instâncias deste código 05 em um mesmo gráfico. Isto pelo simples motivo, de que para o MetaTrader 5, a presença de uma segunda instância neste caso seria completamente desnecessária. No entanto, vamos fazer uma pequena modificação, adicionando uma string para que possamos analisar isto com mais calma. A tal string que iremos colocar seria algo parecido com o que é visto na linha dez do código 02. Com isto o nosso código 05, seria modificado como mostrado no fragmento logo abaixo.

                   .
                   .
                   .
26. //+------------------------------------------------------------------+
27. int OnInit(void)
28. {
29.     IndicatorSetString(INDICATOR_SHORTNAME, "Averange 20 SMA.");
30. 
31.     for (uint c = 0; c < Averange.Size(); c++)
                   .
                   .
                   .

Fragmento 01

Agora adicionamos este novo código ao gráfico, e novamente por mais que você tente não conseguirá criar uma segunda instância dele. Mas adicionamos a linha 29 vista no fragmento 01, justamente para que quando executarmos o script visto no código 04, venhamos a ter o que é visto na imagem logo abaixo.

Imagem 07

Mas isto já era previsto, dado o que vimos antes. Sim meu caro leitor. Mas você sabe de fato por que não conseguimos colocar uma segunda instância do código 05 no mesmo gráfico? Mas é claro que sei. Já experimentei fazer isto, e como não temos meios de mudar o tipo de média, e tão pouco a forma como ela está sendo calculada. Acaba que o MetaTrader 5, vê este código 05, como sendo algo imutável. Assim se tentarmos colocar uma segunda instância, sem mudar algo no código, que faça com que o MetaTrader 5, o veja de uma outra maneira, não poderemos ter uma segunda instância sendo criada no mesmo gráfico.

Legal, basicamente você deu uma descrição perfeita. Mas existe um outro motivo. E este está relacionado a linha dezesseis deste código 05. Agora preste atenção. Sua descrição do motivo pelo qual o MetaTrader 5 não nos permite colocar uma segunda instância de um indicador no gráfico está de fato correta. Porém, quando mudamos a propriedade do próprio indicador, isto deixará se ser uma regra e teremos um outro tipo de comportamento. Para experimentar isto, bastará mudar o código 05, para o que é visto 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();
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.     IndicatorSetString(INDICATOR_SHORTNAME, "Averange 20 SMA.");
30. 
31.     for (uint c = 0; c < Averange.Size(); c++)
                   .
                   .
                   .

Fragmento 02

Note que apesar de estar mostrando um trecho maior de código neste fragmento 02. Ainda assim nosso ponto central é justamente a linha dezesseis. E note que na linha vinte e nove, continuamos informando uma string para ser usada como foi visto anteriormente. Uma vez compilado o código 05, com esta modificação vista no fragmento 02. Poderemos executar o mesmo de forma que quando rodamos o código 04, o resultado geral será o que é visto na imagem logo abaixo.

Imagem 08

Mas espere um pouco. Por que desta vez o MetaTrader 5 não impediu de termos uma segunda instância sendo criada? Bem, meu caro leitor, o motivo é justamente o fato de que mudamos a propriedade do código, a fim de que ele criasse uma sub janela. Como normalmente, e isto foi visto no artigo anterior, podemos estar utilizando uma sub janela para um tipo mais sofisticado, de analise fazendo a plotagem de alguma média. Não faz o menor sentido que o MetaTrader 5, venha a restringir a colocação de um novo indicador no gráfico. Isto a ponto de que não possamos vir a poder criar uma segunda instância. Sendo que esta nova instância poderá estar sendo utilizada justamente para se criar o que poderíamos classificar como sendo uma plotagem um pouco mais sofisticada.

Porém, toda via e, entretanto, nem sempre queremos de fato, que um usuário, ou algum operador que esteja fazendo uso de um dos nossos códigos, possa criar uma segunda instância de um dado indicador. E mesmo assim queremos, por motivos de organização, criar, ou melhor dizendo, utilizar uma sub janela em um gráfico. Caso estejamos utilizando, nós mesmos, um indicador que venha a fazer uso de tal modelagem, sabemos que não devemos tentar criar uma segunda instância. Mas outras pessoas podem tentar fazer isto, por um motivo ou por outro. E criar meios de impedir que uma segunda instância, de nosso indicador, venha a ser criada. E isto visando justamente o fato de querer evitar que uma segunda sub janela venha a surgir.

É algo que iremos ver em detalhes em breve. Mas antes, que tão brincarmos um pouco com este código 05, que cria uma segunda sub janela? Isto por que, existem alguns detalhes que podem vir a ser uteis futuramente. E esta é uma ótima oportunidade para mostrar certos controles que podemos ter sobre algumas das propriedades presentes em uma sub janela.

Como por exemplo: Você sabia que podemos informar, em nosso código fonte, qual deverá ser a altura que uma sub janela deverá ter? Isto para que as coisas fiquem devidamente distribuídas logo no início. O que acaba tornando a experiência dos usuários, algo muito mais prazeroso e menos custoso.

Para conseguir fazer isto, precisamos adicionar algo a este código 05. E o que iremos fazer é mostrado no fragmento logo na sequência.

                   .
                   .
                   .
11. }Averange[] = 
12. {
13.     {20, MODE_SMA, clrDodgerBlue}
14. };
15. //+----------------+
16. #property indicator_separate_window
17. #property indicator_height          50
18. #property indicator_applied_price   PRICE_CLOSE
19. #property indicator_buffers         Averange.Size();
20. #property indicator_plots           Averange.Size();
21. //+------------------------------------------------------------------+
22. struct stInfos
23. {
                   .
                   .
                   .

Fragmento 03

Agora quando executarmos o código 05, com as mudanças mostradas neste fragmento 03, o resultado é o que podemos ver logo abaixo.

Imagem 09

Este tipo de coisa é extremamente útil nas mais diversas situações, meu caro leitor. Isto por que, quando usamos o que é visto na linha dezessete deste fragmento 03, iremos definir um valor para a altura da sub janela. Esta altura NÃO PODERÁ SER MODIFICADA pelo operador, ou usuário de nosso indicador. Isto por que o MetaTrader 5 irá impedir que ela seja modificada.

Naturalmente você não irá empregar este tipo de construção, caso esteja criando uma média móvel. Estou fazendo isto aqui, apenas para demonstrar que isto pode ser feito. Porém, o que é de fato comum acontecer é você usar este tipo de construção, quando estiver implementando e adicionando controles ou objetos a uma sub janela. Neste caso, empregar esta linha dezessete faz todo o sentido. Já que não queremos que o usuário ou operador venha a modificar a altura da sub janela. Visto que isto poderá acabar ocultado ou dificultando a utilização de controles ou objetos presentes ali. Este tipo de coisa é muito legal, e algo que você pode explorar bastante.

Existe uma outra propriedade, bastante útil em diversas situações. Que podemos utilizar de maneira bem simples. Esta pode ser demonstrada fazendo uso de um indicador vazio, como o que pode ser observado no código logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property description "DEMO Indicator"
05. //+------------------------------------------------------------------+
06. #property indicator_separate_window
07. #property indicator_height          150
08. #property indicator_maximum         80
09. #property indicator_minimum         15
10. #property indicator_plots           0
11. //+------------------------------------------------------------------+
12. int OnInit(void)
13. {
14.     return INIT_SUCCEEDED;
15. };
16. //+------------------------------------------------------------------+
17. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
18. {
19.     return rates_total;
20. };
21. //+------------------------------------------------------------------+

Código 06

Isto daqui é uma coisa muito legal. Muito legal mesmo meu caro leitor. Muitas vezes você pode perder um belo tempo, tentando fazer certas coisas. Mas usando este simples recurso, que é mostrado neste código 06. Diversas coisas podem ser feitas de maneira muito rápida. Mas antes de falarmos sobre isto. Veja o resultado da execução na imagem logo abaixo.

Imagem 10

O que nos interessa aqui são estes valores vistos no canto direito da sub janela. Agora preste atenção a uma coisa aqui, meu caro leitor. Pois isto pode lhe ajudar bastante. Observe que na linha oito deste código 06 estamos definindo um valor que será indicado como sendo o valor máximo na sub janela. Assim como na linha nove estamos indicando o valor mínimo. Naturalmente o valor mínimo, muitas das vezes não precisa ser definido de fato. Já que por padrão o MetaTrader 5, o indicará como sendo igual a zero. Sendo assim podemos fazer uma coisa bem legal aqui. Para isto, vamos ver este código 06 modificado como mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property description "DEMO Indicator"
05. //+------------------------------------------------------------------+
06. #property indicator_separate_window
07. #property indicator_height          150
08. #property indicator_maximum         indicator_height
09. #property indicator_plots           0
10. //+------------------------------------------------------------------+
11. int OnInit(void)
12. {
13.     return INIT_SUCCEEDED;
14. };
15. //+------------------------------------------------------------------+
16. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
17. {
18.     return rates_total;
19. };
20. //+------------------------------------------------------------------+

Código 07

Cara que coisa maluca é esta que você está pensando em fazer? Calma, meu caro leitor, você logo vai entender. Primeiro vamos executar este código 07. E o resultado é o que podemos ver logo abaixo.

Imagem 11

Agora note que estou fazendo questão de destacar uma coisa nesta imagem 11. E o que isto significa na prática? Pois bem, meu caro leitor, lembra de que mencionei o fato de que em alguns momentos, é desejável que tenhamos um indicador com uma dada altura? Pois é isto que esta imagem 11 está nos dizendo. Note que na linha sete do código 07 estamos dizendo qual a altura em pixel da sub janela. Logo depois na linha oito estamos dizendo para o compilador, utilizar esta mesma altura como limite máximo a ser aplicado e mostrado no indicador.

Mas e daí? No que isto pode nos ajudar na prática? Manja só o que acabamos de fazer, meu caro leitor. Como a sub janela tem uma altura definida na linha sete, quando usamos esta mesma altura como valor máximo do indicador. Cada pixel agora irá corresponder a um determinado valor que podemos visualizar muito facilmente usando este mesmo indicador.

Hum, ainda não consegui entender. Poderia explicar isto um pouco melhor? Bem, não vou explicar, vou lhe mostrar, pois assim será bem mais interessante. Observe a animação logo abaixo.

Animação 01

Observe os valores no canto direito quando estamos dentro da sub janela. Agora pense no seguinte fato, você deseja alinha diversos controles dentro de uma sub janela, de forma que eles fiquem distribuídos da melhor maneira possível. Qual a forma mais simples de fazer isto? Programando? Sim, talvez. Mas será muito mais rápido de implementar uma interface gráfica, usando diversos botões, texto e gráfico. Se você puder ir até a sub janela, e usando o que é mostrado nesta animação 01, pegar os valores vistos no canto direito, e os aplicar nos controles. Concorda comigo? Isto irá lhe permitir distribuir os objetos gráficos de maneira muito rápida. Já que você apenas precisa ver qual o valor que está sendo mostrado, e indicar como posição para o controle.

Existe uma maneira bem mais rápida de se fazer isto. E tal maneira foi abordada em dois de meus artigos bem antigos, aqui na comunidade. Você pode os ver em:

Indicadores múltiplos em um gráfico (Parte 05): Transformando o MetaTrader 5 em um sistema RAD (I)

Indicadores múltiplos em um gráfico (Parte 06): Transformando o MetaTrader 5 em um sistema RAD (II)

É bem verdade que na época em que escrevi tais artigos, eu não tinha consciência do fato de que muitos que os iriam ler, não eram e talvez ainda não sejam programadores. Devido a isto, boa parte daquela explicação ficou muito superficial, não permitindo assim que boa parte de vocês, pudessem de fato tirar proveito daquele conhecimento que está sendo demonstrado ali.

Assim como outros daqueles meus primeiros artigos. Onde ao longo das semanas e meses que sucederam aquelas publicações, diversos de vocês, que hoje acompanham minhas publicações. Me pediram para explicar melhor certos detalhes envolvidos em muitos dos meus códigos. Ficou decidido criar esta sequência de agora. Espero que vocês estejam gostando, e conseguindo aprender com ela.

Considerações finais

Neste artigo, exploramos um pouco algumas das possibilidades que regem e permitem que façamos a escolha de fazer ou não uso de uma sub janela. Isto quando temos como objetivo trabalhar da maneira mais simples, rápida e prática dentro do MQL5. No entanto, e este é que é o cerne da coisa toda, nem sempre poderemos seguir por estes caminhos mais simples e fáceis. Existem muitas situações em que de fato, precisamos adotar um tipo de abordagem um pouco mais profunda. Onde precisaremos ter um conhecimento um pouco maior.

Porém, que irá de fato fazer a diferença entre o tempo gasto para se construir uma determinada aplicação. Não será de fato o nível de conhecimento deste ou daquele programador específico. Mas sim seu nível de criatividade, em conseguir enxergar soluções onde ninguém mais consegue as ver. E isto não consigo passar a você e a ninguém, meu caro leitor. Depende única e exclusivamente de você, procurar aprimorar sua criatividade a ponto de conseguir simplificar tarefas, que para outros, serão muito mais trabalhosas.

No próximo artigo iremos começar a tratar justamente deste tipo de problema, onde a solução mais simples nem sempre será a mais adequada.

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
Indicators\Code 04	Demonstração básica
Indicators\Code 05	Demonstração básica
Indicators\Code 06	Demonstração básica
Scripts\Code 01	Demonstração básica
Scripts\Code 02	Demonstração básica