Do básico ao intermediário: Eventos (II)

Introdução

No artigo anterior Do básico ao intermediário: Eventos (I), começamos a falar sobre programação baseada em eventos. E sim, meu caro leitor, este tipo de abordagem é conhecida por muitos programadores exatamente por este nome: Programação baseada em eventos. Sendo considerada por muitos algo complicado e difícil. Mas isto se deve justamente ao fato de que tais pessoas não entendem de fato os mecanismos e conceitos envolvidos.

No entanto, a programação baseada em eventos, remove dos nossos ombros diversos problemas e detalhes relacionados ao trabalho com interface gráfica. E sendo o MetaTrader 5, uma interface gráfica. O uso da programação baseada em eventos, facilita bastante o desenvolvimento de aplicações voltadas ao ambiente do MetaTrader 5.

Pois bem, no artigo anterior, foi efetuado aquilo que podemos considerar como sendo os primeiros passos, dentro do riacho, a fim de sentir como as coisas irão fluir, de agora em diante. Vimos como poderíamos contornar alguns pontos para conseguir manter uma contagem de eventos ocorridos e tratados por um indicador bastante simples e singelo. Mas ficou faltando falar e mostrar uma pequena coisa. Sendo deixada como um desafio para aqueles que querem de fato, vislumbrar o quanto estão conseguindo compreender e colocar em prática certos conceitos de programação.

Como o desafio proposto, não era algo assim de fato complicado. Acredito que aqueles com um pouco mais de dedicação, e esforço, devem ter conseguido, bolar uma forma de resolver a questão. Já que, com base em tudo que foi mostrado até aqui, é sim possível resolver a questão de forma relativamente simples.

Pois bem, aqui irei mostrar duas maneiras de se resolver a mesma questão. Irei explicar os prós e contras de cada uma das formas de se resolver o problema. Então chegou a hora de se afastar de possíveis distrações e focar no que será explicado neste artigo. E como de praxe, vamos iniciar um novo tópico, para separar devidamente as coisas.

Possível primeira solução

Para começar a explicar de maneira correta, o que será visto. Vamos iniciar vendo o que era o código do indicador, visto no artigo anterior.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. uint gl_Counter;
05. //+------------------------------------------------------------------+
06. int OnInit()
07. {
08.    gl_Counter = 0;
09. 
10.    Print(__FUNCTION__);
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.    if (!gl_Counter)
18.    {
19.       uint arr[];
20. 
21.       if (FileLoad(_Symbol, arr) > 0)
22.          gl_Counter = arr[0];
23.    }
24.    
25.    Print(__FUNCTION__, " :: ", ++gl_Counter);
26. 
27.    return rates_total;
28. };
29. //+------------------------------------------------------------------+
30. void OnDeinit(const int reason)
31. {
32.    uint arr[1];
33. 
34.    arr[0] = gl_Counter;
35.    FileSave(_Symbol, arr);
36. 
37.    Print(__FUNCTION__);
38. };
39. //+------------------------------------------------------------------+

Código 01

O desafio proposto, consistia em tentar criar uma maneira, de fazer com que a variável declarada na linha quatro deste código 01. Viesse a manter o seu atual valor de contagem, se e somente se, o período gráfico fosse modificado. Em qualquer outro caso, o valor de tal variável deveria ser zerado. Fazendo assim com que a contagem fosse reiniciada.

Pois bem, este desafio, apesar de ser relativamente simples de ser cumprido. Pode lhe dizer, o quanto você está preparado para coisas mais elaboradas. Porém, se você tentou e mesmo assim acabou empacando em algum ponto. Não se preocupe. O importante é que você tentou e procurou pensar em uma maneira de resolver o problema. É isto que conta. Conseguir resolver o problema, sendo um iniciante, seria o equivalente a receber um bônus. Mas não mostraria de fato que você já sabe programar. Apenas que conseguiu encontrar uma solução. Neste caso, meus sinceros parabéns.

Ok, então vamos pensar um pouco. Sempre que trocamos o tempo gráfico, o MetaTrader 5, dispara um evento Deinit. Este por sua vez acaba gerando uma chamada, que irá ser direcionada para um determinado gráfico. Futuramente iremos nos aprofundar ainda mais neste mecanismo a fim de explorar um pouco melhor o mesmo. Por hora, você apenas precisa entender, até onde o MetaTrader 5, fará as coisas para você. E como podemos e devemos lidar com isto. Quando este evento chega na janela gráfica, o mesmo é dirigido a TODAS AS APLICAÇÕES PRESENTES NO GRÁFICO. TODAS. Depende de cada uma capturar e tratar este evento Deinit da melhor maneira possível.

Muito bem, e quem recebe este evento ? Bem meu caro leitor, este evento será capturado apenas e somente pelo procedimento OnDeinit, e é aqui onde as coisas começam a ficar interessantes. Isto porque se você observar na linha 30 do código 01, irá notar que este procedimento recebe um valor. Este valor é preenchido pelo MetaTrader 5, a fim de informar o motivo pelo qual a aplicação está sendo removida do gráfico. Mas espere um pouco aí. Como assim, o indicador está sendo removido do gráfico ? Isto não faz nenhum sentido. Já que estamos apenas pedindo para que o tempo gráfico venha a ser modificado. E não pedindo para remover o indicador do gráfico. De certa maneira você está correto quanto a isto, eu caro leitor. Porém, devido a diversas questão, principalmente de implementação da própria plataforma MetaTrader 5. É muito mais simples, remover todos elementos do gráfico. Mandar o gráfico ser repintado. E somente depois, recolocar os elementos que formam removido, novamente no gráfico. Claro que devido a isto, scripts não são recolocados. Já que eles não conseguem lidar com eventos. Porém indicadores e Expert Advisores, por conseguirem lidar com eventos, são reenviados, de maneira automática novamente para o gráfico. Da mesma maneira que acontece quando você inicializa a plataforma. Caso houvesse algum gráfico aberto, e contendo algum indicador ou Expert Advisor, este seria colocado no gráfico de maneira automática pelo MetaTrader 5. Logo depois de todos estes elementos terem sido colocados no gráfico. O MetaTrader 5, emite um novo evento, para este mesmo gráfico. O evento em questão é o Init, que por sua vez será capturado pela função OnInit. E esta função você pode observar na linha seis do código 01. Este é todo o trabalho que o MetaTrader 5 irá fazer por nós. Daí em diante, depende de nós, implementarmos como nossa aplicação irá lidar com tais eventos.

Isto que acabei de explicar, é muito, mais muito importante que você entenda e assimile muito bem, meu caro leitor. Pois esta é a base da programação baseada em eventos, aqui no MQL5, a fim de produzirmos aplicações para serem executadas no MetaTrader 5. Ok, como nossa aplicação somente conhece o valor de contagem presente em gl_Counter, apenas e somente durante a execução. Não podemos saber qual o valor que havia antes da chegada do evento Init. Isto por que, durante o processo de remover o gráfico da plataforma, e depois o recriar. O MetaTrader 5, limpa toda e qualquer região da memória que estava sendo utilizada por nossa aplicação presente no gráfico. A única coisa, que dependendo da situação pode se manter, são variáveis estáticas. Porém variáveis estáticas em aplicações voltadas a trabalhar como indicadores, são um tanto quanto problemáticas em alguns aspectos. Elas podem até ser utilizadas. Porém isto deve ser feito com algumas ressalvas e cuidados. Futuramente iremos falar mais sobre isto. Por hora esqueçamos variáveis estáticas em códigos cujo objetivo é servirem como indicadores. Para Expert Advisores, a conversa é outra, sendo que existem outros mecanismos que precisamos entender apenas para lidar com Expert Advisores. Então vamos primeiramente focar na questão dos Indicadores, justamente por serem mais simples.

Certo, já sabemos que não podemos lidar com variáveis estáticas neste momento. E que o valor de gl_Counter, somente é válido, enquanto o indicador existe no gráfico. E para terminar, quando pedimos para o MetaTrader 5, modificar o tempo gráfico, um evento será disparado, e capturado pelo procedimento da linha 30. E o mais importante, que o valor do parâmetro reason, na linha 30, nos diz o motivo do evento Deinit. Pronto, agora é só irmos na documentação e ver que valor informa o tipo de evento que precisamos fazer com que gl_Counter, seja gravada. E com isto teremos a nossa solução.

Perfeito, então olhando na documentação, podemos ver que a constante REASON_CHARTCHANGE, atende nosso critério. Que é justamente a mudança no tempo gráfico. Claro que se o ativo também for modificado, teremos a mesma constante sendo repassada. Mas vamos primeiro focar na questão do tempo gráfico. Assim, adicionado um pequeno teste, no procedimento OnDeinit, temos o que podemos ver como sendo nosso novo código logo na sequência.

                   .
                   .
                   .
29. //+------------------------------------------------------------------+
30. void OnDeinit(const int reason)
31. {
32.    uint arr[1];
33. 
34.    arr[0] = (reason == REASON_CHARTCHANGE ? gl_Counter : 0);
35.    FileSave(_Symbol, arr);
36. 
37.    Print(__FUNCTION__);
38. };
39. //+------------------------------------------------------------------+

Código 02

Como todo o restante do código permaneceu idêntico ao que pode ser visto no código 01. Procurei focar apenas no que realmente mudou. E observe que a mudança foi muito simples e fácil de entender. Isto por conta que tudo que foi preciso fazer, foi modificar a linha 34, a fim de verificar se a constante é ou não aquela que queríamos utilizar. Sendo ela, o valor de contagem será salvo. Caso contrário, o valor será jogado para zero. Forçando assim uma reinicialização da contagem, quando viermos a utilizar o indicador novamente no mesmo ativo onde a contagem estava sendo efetuada.

Agora vem as vantagens e desvantagens em se implementar uma solução desta forma. E sim, meu caro leitor, não existe somente vantagens ou desvantagens em se implementar algo. Por isto, entender conceitos e praticar faz parte do aprendizado.

Para não me estender em demasia de maneira desnecessária, irei citar apenas uma vantagem e uma desvantagem. O resto é contigo, meu caro leitor. E o conhecimento irá surgir conforme você for pegando prática e estudar cada cenário específico de utilização, desta ou daquela forma de implementação.

Como vantagem, podemos dizer que o processo é relativamente limpo e fácil de ser controlado em diversos aspectos. Como por exemplo: Você pode querer saber, quantas vezes a plataforma disparou um determinado evento, durante um prazo pré-estipulado.

Como desvantagem, podemos dizer que o fato de estarmos utilizando arquivos para armazenar os valores, nos força a analisar o próprio arquivo. O que em diversos casos é um problema. Como por exemplo, caso venhamos a ter um mesmo ativo aberto na mesma seção do MetaTrader 5, com este mesmo indicador mostrado aqui. Você pode acabar tendo valores inconsistentes, caso venha a ficar mudando o tempo gráfico. Este tipo de coisa é conhecido na programação como condição de corrida. E é bem chato de ser resolvido. Sendo inclusive tema de teses de doutorado e livros inteiros somente falando sobre este tema. Acredite, como iniciante, você não vai querer precisar lidar com uma condição de corrida ocorrendo em seu código.

Pois bem, meu caro leitor, esta seria a solução número um. Justamente por necessitar de poucas mudanças no código. Apenas uma breve pesquisa na documentação e a adoção de coisas já mostradas nos artigos anteriores.

Agora vamos ver uma solução um pouco diferente, que irá jogar parte do trabalho de zelar pelo valor da contagem nas mãos do MetaTrader 5. Mas como você já deve estar imaginando, vamos fazer isto em um novo tópico.

Possível segunda solução

Está segunda solução é bem mais divertida, maluca e interessante. Tanto pelo ponto de vista prático, quanto pelo fato de jogarmos nas mãos do MetaTrader 5, a responsabilidade de manter o valor do contador. Porém, antes de que você, já fique todo empolgado e pensando: Porque não vimos esta solução antes ? Vou fazer as coisas, de forma inversa. Primeiro vamos falar, das vantagens e desvantagens em se utilizar esta segunda proposta de solução. Para somente depois, podermos ir e ver como a solução poderia ser implementada. E da mesma maneira que foi feita na solução anterior, irei mencionar uma vantagem e um desvantagem, isto para não tornar a coisa chata, longa e cansativa.

Como vantagem, para esta segunda solução, podemos mencionar o fato, de remove parte da nossa responsabilidade em precisar manter o valor da variável em algum lugar, sendo o mais provável a utilização de um arquivo, para isto. E como desvantagem, para esta mesma solução, podemos dizer que é o fato de que ao remove parte da nossa responsabilidade em manter o valor da variável, torna a coisa um pouco mais complicada dependendo do que estamos tentando fazer. Já que a responsabilidade passa a ser do MetaTrader 5, e não nossa.

Mas como assim ? Ficou maluco. Como pode a mesma coisa, ser considerada uma vantagem e uma desvantagem ao mesmo tempo ? Bem meu caro leitor, para entender o motivo pelo qual estou colocando isto, como sendo uma vantagem e desvantagem. Precisamos ver que solução seria esta, em que uma vantagem e desvantagem sejam praticamente a mesma coisa e ao mesmo tempo. Dando a impressão de ser algo improvável de acontecer. Bem, esta solução é um recurso presente no MetaTrader 5, da qual praticamente não se ouve falar muito sobre ela. Em um passado remoto, a utilizei para outros fins. Algo que com toda a certeza, os desenvolvedores do MetaTrader 5, não pensaram que um dia alguém iria utilizar aquele recurso, para tal proposito.

Pois bem, você pode ver isto sendo feito, em Desenvolvendo um EA de negociação do zero (Parte 17): Acessando dados na WEB (III). Na época, imaginei que recursos do MetaTrader 5, eram bem mais explorados por parte de uma ampla gama de programadores, isto de maneira geral. Porém acabei notando que havia muito mais pessoas, com uma base de conhecimento bem mais superficial do que eu imaginava de fato existir. Tentando fazer as coisas, quase que na raça, utilizando para isto o MQL5. Daí, o motivo de ter dado uma parada, refletido e tendo no final o amadurecimento da ideia de se criar estes artigos, que agora você pode contar como forma de aprender MQL5 de uma forma divertida e prazerosa. Justamente para atender a este público, sedento por conhecimento. Porém com tão poucas referências voltadas aos iniciantes.

Espero que estes artigos de agora estejam lhe ajudando a começar de maneira correta. Qualquer dúvida, ou sugestão, visando melhorar este conteúdo, serão bem aceitas.

Bem, mas voltando a nossa questão. A ideia aqui é usar variáveis globais de terminal. Este definitivamente é um recurso muito interessante, que podemos acessar fazendo uso de funções e procedimentos, definidos na biblioteca do MQL5. Sendo algo simples, prático e bastante útil em diversas situações diferentes. Sendo assim, vamos ver como fica o código do indicador, visando agora utilizar tal recurso. Este pode ser visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. union u_01
05. {
06.     double  d_value;
07.     uint    u_Counter;
08. }gl_Union;
09. //+------------------------------------------------------------------+
10. int OnInit()
11. {
12.     ZeroMemory(gl_Union);
13. 
14.     if (!GlobalVariableGet(_Symbol, gl_Union.d_value))
15.         if (!GlobalVariableTemp(_Symbol))
16.             return INIT_FAILED;
17. 
18.     GlobalVariableSet(_Symbol, gl_Union.d_value);
19. 
20.     Print(__FUNCTION__);
21. 
22.     return INIT_SUCCEEDED;
23. };
24. //+------------------------------------------------------------------+
25. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
26. {
27.     Print(__FUNCTION__, " :: ", ++gl_Union.u_Counter);
28. 
29.     return rates_total;
30. };
31. //+------------------------------------------------------------------+
32. void OnDeinit(const int reason)
33. {
34.     switch(reason)
35.     {
36.         case REASON_CHARTCHANGE:
37.             GlobalVariableSet(_Symbol, gl_Union.d_value);
38.             break;
39.         default:
40.             GlobalVariableDel(_Symbol);
41.     }
42. 
43.     Print(__FUNCTION__);
44. };
45. //+------------------------------------------------------------------+

Código 03

Ok, quando você executar este código 03, irá poder ver algo parecido com o visto na animação logo abaixo.

Animação 01

Note que em um dado momento, fizemos uma mudança no tempo gráfico. E ao fazer isto, foi gerado a mesma sequência de eventos, explicada no tópico anterior. Isto pode ser observado olhando as informações que estão sendo impressas no terminal. Mas não é somente isto que está acontecendo aqui. Veja que diferentemente do que era feito até então. Aqui neste código 03, não estamos utilizando um arquivo para armazenar de maneira temporária algumas informações. No caso o valor do contador. Mas estamos pedindo para o MetaTrader 5, armazenar estas mesmas informações, de uma maneira muito específica.

Para verificar isto, antes mesmo de haver uma explicação sobre o código 03. Podemos visualizar se existe e caso exista, quais são as variáveis globais de terminal presentes no MetaTrader 5. Para tal, basta utilizar a tecla de atalho F3, ou o caminho mostrado na imagem abaixo.

Imagem 01

Caso o indicador, visto no código 03, esteja sendo executado, poderemos ver a presença de uma variável na janela que será aberta. Assim como é mostrado na imagem logo na sequência.

Imagem 02

Caso o indicador do código 03, não esteja sendo executado. Esta mesma janela vista na imagem 02, poderá não conter nenhuma informação. Já que normalmente, e até onde sei, poucas pessoas de fato utilizam variáveis globais de terminal. Seja lá por qual motivo for. Mas se o recurso existe, e está disponível. Por que não utilizar ele de uma forma criativa ?

Com base nestas informações vistas nas imagens e na animação. Já temos elementos suficientes para entender como o código 03 funciona. De certa forma, não vejo necessidade de explicar como ele de fato funciona. Isto por conta de que ele é uma simples modificação do código 02. Mas não vou cometer esta maldade. Já que variáveis globais de terminal, são um tipo de recurso, cujo uso é muito específico. Vou aproveitar a oportunidade e explicar como você pode pensar em formas de as utilizar em outras situações.

Para começar, se você de fato, deseja utilizar uma variável global de terminal, seja lá por que motivo for. Precisa estar ciente de que elas somente podem conter valores do tipo double. Ou seja, não podemos a princípio, colocar texto ou um valor inteiro em tal variável. Isto a princípio. Porém, pelo fato de que o MQL5, conta com a possibilidade de criamos uniões, e já expliquei como elas podem ser uteis no dia a dia. Criamos uma união na linha quatro a fim de poder colocar um valor que não seja um ponto flutuante dentro de uma variável global de terminal.

Ao fazermos isto, abrimos diversas possibilidades de uso de tais variáveis. Já que neste caso poderemos colocar pequenos trechos de texto dentro das mesmas. Desde é claro, o texto possa ser colocado dentro do que seria um tipo double. Se você não faz ideia do que estou falando, procure ver os artigos anteriores para se inteirar melhor sobre este assunto.

Pois bem, para evitar acessos desnecessários as variáveis globais de terminal. Declaramos a união, como uma variável global. Isto pode ser observado na linha oito. Agora preste atenção meu caro leitor, isto que estamos fazendo, não é obrigatório. Poderíamos implementar este código 03, de modo a não termos nenhuma variável global no mesmo. Porém, isto nos forçaria a jogar esta variável global que seria declarada no nosso código para fora do código. A tornando uma variável global de terminal. De certa forma, isto acabaria prejudicando a performance geral. Porém, em alguns cenários, muito, mas muito específicos, pode vir a ser interessante e necessário adotar este tipo de implementação. Cada caso é um caso. Então não generalize, ou pense que precisamos fazer as coisas desta e não daquela maneira. Pois nem sempre será assim.

Por conta de algumas questões práticas, utilizamos a linha 12 para limpar a região de memória onde estará nosso contador. Poderíamos fazer isto de outras maneiras. Então pense em outras formas de fazer isto, e pratique para ver o resultado. Logo depois, na linha 14 tentamos ler a variável que pode ser vista na imagem 02. Caso esta variável não exista, iremos na linha 15 tentar criar a mesma. Note que o nome da variável será o nome do ativo, no qual o indicador está sendo utilizado. Se esta tentativa de criar a variável falhar. O indicador irá retornar um valor de erro, para o MetaTrader 5. Neste caso o MetaTrader 5, irá disparar um novo evento, no caso um evento Deinit. Já que a inicialização falhou. Isto irá fazer com que o procedimento da linha 32 seja executado. Finalizando assim a presença do indicador no gráfico.

É curioso como as coisas funcionam e podem ser implementadas de maneira muito simples, quando se entende o que se está fazendo. E como as coisas são geradas. No entanto, o que preciso que você, meu caro leitor, entenda é o seguinte: Esta função da linha 15 irá tentar criar uma variável global de terminal, que seja temporária. E é importante que isto seja feito, ANTES da chamada da linha 18. Caso contrário a variável não será temporária. Se bem que ainda assim continuará sendo por outros critérios. Mas não pelo critério que desejamos utilizar.

Quando criamos uma variável global de terminal, que venha a ser temporária, ela somente irá existir, enquanto a plataforma MetaTrader 5 estiver aberta. Caso ela venha a ser fechada por qualquer motivo, toda e qualquer variável global de terminal, que tenha sido criada pela função da linha 15, será esquecida, ou melhor dizendo, destruída. Este tipo de situação é muito interessante, quando queremos manter valores durante todo o tempo em que o MetaTrader 5 estiver aberto. Independentemente do tipo de coisa que possa está sendo executado. E quando a plataforma é fechada, aquelas informações venham a ser esquecida. Porém, isto somente acontece se, e somente se, quem criar a variável global de terminal ter sido a função GlobalVariableTemp.

Você pode também criar a mesma variável, porém sem este detalhe de ela ser apagada, se utilizar a função da linha 18. Neste caso, a variável será apagada, pelo MetaTrader 5, depois de passado um determinado período. Veja a documentação para mais detalhes sobre isto. Já que, pode ser que você precise de uma informação presente por um tempo maior, mas não queira colocar ela em um arquivo. Neste caso, variáveis globais de terminal, podem ser um recurso bastante interessante de ser utilizado.

Ok, com relação a função OnCalculate, não temos nada a acrescentar. Mas temos algo a acrescentar com relação ao procedimento OnDeinit. Observe o seguinte detalhe: Devido a linha 34, estaremos testando, que tipo de situação provocou o evento Deinit. Caso seja a situação de troca de tempo gráfico, como imaginado. Iremos usar a linha 37 para armazenar o atual valor do nosso contador. Agora caso seja outra situação qualquer, usamos a linha 40 para remover a variável global de terminal que tenha sido criada. Mas por que fazer isto ? Se a variável que será criada é do tipo temporária ? O motivo é simplesmente a didática meu caro leitor. Pode ser que você queira experimentar alguns tipos de situação com base neste código 03. Nada mais justo que mostrar como podemos criar e remover uma variável global de terminal, diretamente via código. Por isto esta linha 40.

Então a ideia aqui é expor e mostrar que sim, podemos fazer uso de diferentes meios para conseguir o mesmo tipo de resultado. Qual o meio a ser adotado irá depender do tipo de cenário ou situação que estamos enfrentando.

Considerações finais

Muito bem meu caro leitor, chegamos ao final de mais um artigo. Este artigo é um complemento do que foi visto no artigo anterior. Sendo por isto, necessário que você os veja como sendo um único artigo. Estudar o que foi mostrado no artigo anterior e aplicar o conhecimento visto nos demais artigos desta sequência. Fará com que você, possa de fato conseguir compreender, a fundo o que foi explicado e demonstrado neste artigo. Mesmo que nele eu não tenha dados muitos detalhes sobre como cada linha de código trabalha. Meu objetivo não é mais este. Quero que você aprenda a pescar o peixe. Estou lhe fornecendo o conhecimento e material para que você possa praticar e estudar a melhor maneira de atingir seus objetivos. Depende de você procurar praticar e estudar cada detalhe mostrado.

Sendo assim, no próximo artigo, iremos ver como um indicador real poderia ser pensado. Isto de forma que possamos aplicar tudo que foi mostrado até este momento. Porém para entender de maneira adequada o que será mostrado no próximo artigo, será preciso que você, tenha conseguido compreender como eventos são gerados e até onde o MetaTrader 5 irá nos ajudar. Pois sem entender isto, diversas portas se manterão fechadas para você.

No anexo, você terá acesso aos códigos vistos neste artigo. Então bons estudos e nos vemos no próximo artigo.