Simulação de mercado: Position View (I)

Introdução

Olá pessoal, e sejam bem-vindos a mais um artigo da série sobre como construir um sistema de replay/simulação.

No artigo anterior Simulação de mercado: Iniciando o SQL no MQL5 (V), finalizei a explicação, sobre tudo que imaginamos ser necessário para que você, caro leitor, consiga compreender o que veremos nos próximos artigos. Sei que todo este assunto, no qual estivemos tratando, nestes últimos artigos, não é algo assim, tão simples de ser compreendido de uma hora para outra. E acredito que muitos de vocês, se quer faziam ideia, de que era possível fazer certas coisas aqui no MQL5. Porém, tudo que foi visto até agora, foi apenas a ponta da ponta de um imenso iceberg. Isto por que, apenas apresentei um pouco sobre soquetes e um pouco sobre SQL.

Porém ao meu ver, o que foi introduzido, durante este tempo. Irá de fato, lhe beneficiar nos próximos passos. Já que de agora em diante, começaremos a tratar de um assunto, ainda mais denso e complexo. No entanto, irei tentar ao máximo, não dificultar a sua vida, caro leitor e entusiasta. Quero sim lhe motivar a procurar estudar e se aprofunda ainda mais no que irei mostrar a partir deste ponto.

Então tome um folego. Respire fundo, e se prepare, pois agora iremos mergulhar ainda mais profundamente, no sistema de replay/simulação. O que eu me propus a mostrar, sobre como desenvolver tal sistema, já está quase em seu apogeu. Ou seja, falta muito pouco a ser mostrado. Mas como o conteúdo, é muito mais complicado em termos de teorias e conceitos. Tentarei deixar o conteúdo o mais simples quanto for possível fazer. A parte referente a programação em si. É até bastante simples e direta. Mas se você não compreender toda a teórica, que está debaixo dos panos. Ficará completamente sem meios para poder melhorar, ou mesmo adaptar o sistema de replay/simulador. A algo diferente do que irei mostrar.

Meu intuito não é que você simplesmente compile e use o código que estou mostrando. Quero que você aprenda, entenda e se possível, possa criar algo ainda melhor. Já que existem uma série de coisas que não mostrarei como fazer. Isto por que, tais coisas são modelos que utilizo na prática. E foram desenvolvidos especialmente, para permitir gerar, ou melhor dizendo implementar, um sistema de negociação, o tal Expert Advisor, que consegue aprender com o tempo. E que cria o seu próprio método de operação. Chegando próximo ao que um operador humano faria na prática.

No último artigo que foi Simulação de mercado (Parte 05): Iniciando a classe C_Orders (II), onde falei sobre o sistema de replay/simulador. Fizemos um pequeno Expert Advisor, que era capaz de se comunicar com o Chart Trade, que havia sido desenvolvido anteriormente. Isto já faz algum tempo. Então, se você não se lembra de como o código se encontrava. Vamos relembrar rapidamente como as coisas foram deixadas. Isto por que, partiremos daquele ponto. O conteúdo presente daquele momento até este momento atual. Irá ser utilizado muito em breve. Mas vamos relembrar como as coisas eram feitas.

Relembrando o que já foi desenvolvido no replay/simulador

Este é um ponto importante. Pois sem saber o que já foi desenvolvido. Você acabará voltando em pontos que já se encontram em plena atividade. Não precisando ser revisto. Apesar de tudo, ainda planejo mostrar como fazer uma determinada coisa. Mas isto fica para outro momento. Primeiramente vamos rever o que já se encontra em pleno funcionamento.

A aplicação de replay/simulador, conta com diversos aplicativos separados entre si. Porém, quando combinados, permitem a você ter uma interação com o MetaTrader 5, muito parecida com o que seria feito, quando você estivesse logado em uma conta demo ou conta real. Tais coisas, são, a presença de um indicador de mouse, que é responsável por nos permitir gerar estudos, ou interagir com elementos no gráfico. Assim como um Chart Trade, que consegue enviar ordens ou pedidos de execução a mercado, via Expert Advisor. Isto por que, ao usar o indicador de mouse, o Chart Trade, que também é um indicador. Podemos nos comunicar via protocolo de mensagens com o Expert Advisor que também se encontra no gráfico.

Todas estas três aplicações, individualmente não são muito práticas. Porém uma vez que ambas estejam no gráfico, você poderá interagir muito facilmente com o MetaTrader 5, enviando pedidos de execução a mercado. No entanto, quando uma posição é aberta ou fechada, não temos nenhuma indicação ainda no gráfico, sobre tal coisa. Se bem, que não é bem assim. Podemos contar com a indicação feita pelo MetaTrader 5. Mas, caso você queira fazer uso de um sistema de cross order. Você ficará completamente sem um suporte adequado. Isto por que, quando fazemos uso de ordens cruzadas. Temos como gráfico um ativo sendo observado. Porém, a ordem, ou pedido de operação é feito em outro ativo, cujo gráfico não se encontra aberto. E neste ponto o MetaTrader 5, não pode nos ajudar, com o sistema de indicação presente nele.

A mesma coisa acontece, quando estamos usando o serviço de replay/simulador. Mesmo que possamos, e iremos fazer isto em breve, uma forma de visualizar operações no replay/simulador. Não temos uma maneira adequada de fazer isto. O motivo: Não temos um sistema de indicação gráfica, que nos permite interagir com as ordens ou posições, que por ventura possam existir naquele ativo específico. Seja, ele um ativo real, seja ele um ativo simulado. Ou seja, ele um ativo no qual estamos reprisando dados.

Assim, mesmo que já tenhamos, o replay/simulador, sendo capaz de efetuar a tarefa a ele proposta. Precisamos antes de mais nada, criar alguma forma de visualizar e poder interagir com qualquer posição ou ordem, que por ventura esteja no ativo. Isto por que, sem fazer isto, criar um sistema de ordens, a fim de efetuar estudos no replay/simulador. É algo completamente inútil. Já que você não poderá interagir com as ordens ou posições que estejam no ativo.

A criação desta parte então, começa a ser a nossa primeira prioridade. Porém, não se preocupem. Iremos inicialmente criar um sistema bastante simples. Algo quase singelo, apenas para nos permitir ter algum controle, quando formos trabalhar no replay/simulador. Então vamos começar a fazer isto, neste momento. E para isto, um novo tópico se inicia.

Confeccionando um indicador simples de posições

Vamos começar fazendo o seguinte: Como o nosso indicador Chart Trade, não é um sistema voltado, para ordens pendentes. Apenas para envio imediato. Iremos começar criando um indicador básico para indicar as posições abertas. Então neste momento, não iremos tratar das ordens pendentes. Iremos apenas focar nas posições abertas e como mostrar isto no gráfico. Novamente lembrando, que o intuito aqui, não é informar algo que já está sendo feito pele MetaTrader 5. A ideia é informar algo que o MetaTrader 5, não estaria nos informando. Principalmente quando fazendo uso de um sistema cross orders.

Antes de começarmos a ver o código a ser implementado, gostaria de deixar claro, que neste momento, a ideia, é apenas conseguir implementar algo que consiga mostrar as linhas de preço. Não estarei de maneira alguma, neste momento criando algo, que você deverá utilizar de uma forma massiva. Ou seja, primeiro devemos conseguir fazer com que as linhas aparecem, quando existir uma e somente uma posição aberta. Não focaremos, neste momento em tratar diversas posições abertas. Então para os afobados, peço um pouco de paciência. O objetivo aqui, será explicar para os iniciantes, ou entusiastas como fazer as coisas funcionarem.

A primeira coisa que faremos será criar, um novo arquivo. Você pode estar pensando que seria um arquivo do tipo Expert Advisor, já que mexeremos com posições que por ventura possam estar presentes no servidor de negociação. Mas não, não criaremos um Expert Advisor. Iremos sim criar um indicador. Então o código inicial dele pode ser visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "Indicator for tracking an open position on the server."
04. #property version   "1.00"
05. #property indicator_chart_window
06. #property indicator_plots 0
07. //+------------------------------------------------------------------+
08. int OnInit()
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. //+------------------------------------------------------------------+
18. void OnDeinit(const int reason)
19. {
20. }
21. //+------------------------------------------------------------------+

Código fonte inicial

Olhando isto, você pode estar pensando o seguinte: Você está louco, ou pirou de vez? Não tem como usar um indicador para tal coisa. Calma, meu caro leitor, calma, não seja tão impaciente. Tenha calma. O fato de você nunca ter visto algo, não significa que aquilo não pode ser feito, ou que não existe. Existem algumas vantagens em se usar um indicador para tal tarefa. Apesar de não ser algo que muitos recomendarão. Mas conforme você for vendo o código sendo confeccionado. Você acabará entendendo por que estaremos usando um indicador e não um Expert Advisor para tal coisa. Como estamos vindo dizendo a algum tempo. O material desta série sobre o replay/simulador, ficará cada vez mais e mais complicado. Porém, estou tentando deixar as coisas, o mais simples e palatável quando for possível ser feito.

O problema em se usar um indicador, é que se você não implementar o código de uma forma adequada. Irá acabar prejudicando completamente o funcionamento do gráfico. Isto por que o MetaTrader 5, coloca todos os indicadores dentro de uma única Thread de execução. Sendo assim, se um dos indicadores travar, ou ficar inoperante por um tempo. O gráfico em que ele estiver também sofrerá do mesmo mal. Muita gente, as veze enche o gráfico com indicadores. Mas isto, apesar de parecer ser algo aceitável, não é o recomendado, devido ao fato de que todos estão na mesma Thread. E um indicador pode prejudicar outros, fazendo com que o desempenho geral da plataforma fique comprometido.

Porém, a nossa ideia aqui é justamente a seguinte: Colocar o indicador no gráfico e não mexer nele. Ou seja, ele não sofrerá nenhuma atualização. Mesmo que você modifique manualmente o preço do take profit ou do stop loss. Neste momento o indicador não refletirá tal mudança. Isto será feito depois. Onde explicarei em detalhes como tal atualização será feita. Então vamos com calma. A primeira coisa é de fato mostrar as linhas de preço. Esqueçam todo o resto, por hora. Pois implementaremos a coisa, da forma, o mais simples, e didática quanto for possível ser feita. Quero que você aprenda a fazer a coisa, e assim consiga criar as modificações necessárias a fim de atender as suas necessidades pessoais. E não simplesmente use o que mostrarei como criar, e que fique totalmente engessado, sem saber para onde ir depois.

Muito bem, agora, vamos modificar o código visto anteriormente. A fim de que possamos testar algumas coisas. O nosso novo código é visto logo abaixo:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "Indicator for tracking an open position on the server."
04. #property version   "1.00"
05. #property indicator_chart_window
06. #property indicator_plots 0
07. //+------------------------------------------------------------------+
08. #include <Market Replay\Auxiliar\C_Terminal.mqh>
09. //+------------------------------------------------------------------+
10. C_Terminal *Terminal;
11. //+------------------------------------------------------------------+
12. int OnInit()
13. {
14.     Terminal = new C_Terminal();
15.     if (!PositionSelect((*Terminal).GetInfoTerminal().szSymbol)) return INIT_FAILED;
16.     Print (
17.             "Position Ticket: ", PositionGetInteger(POSITION_TICKET), "   ",
18.             "Opening Price: ",PositionGetDouble(POSITION_PRICE_OPEN), "   ",
19.             "Stop Position: ", PositionGetDouble(POSITION_SL), "   ",
20.             "Take Position: ", PositionGetDouble(POSITION_TP)
21.           );
22.           
23.     return INIT_SUCCEEDED;
24. }
25. //+------------------------------------------------------------------+
26. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
27. {
28.     return rates_total;
29. }
30. //+------------------------------------------------------------------+
31. void OnDeinit(const int reason)
32. {
33.     delete Terminal;
34. }
35. //+------------------------------------------------------------------+

Código fonte de um indicador de posição básico

Como este código é bastante simples. Vou passar rapidamente por ele, apenas para que você entenda, como ele funciona. Estou imaginando que você não saiba apenas olhando o código. Na linha oito, incluímos um arquivo já presente no sistema de replay/simulação. Este artigo não sofreu nenhuma mudança desde a sua última atualização mostrada aqui nesta série. Na linha dez, dizemos que a classe presente no arquivo de cabeçalho será referenciada como sendo um ponteiro. Na linha 14, inicializamos a classe. Já na linha 15, dizemos ao MetaTrader 5, para nos informar se existe ou não uma posição aberta no ativo. Caso não exista, iremos encerrar a execução do indicador como sendo uma falha.

Agora preste atenção. Quando a linha 15, fizer seu trabalho, e retornar verdadeiro. Os dados referentes a posição do ativo, que estamos dizendo para serem buscados, estarão disponíveis para nosso uso. Antes de fazermos isto, nenhuma informação válida nos será fornecida. Atenção a este detalhe. Caso a linha 15 tenha sucesso, teremos a execução da linha 16. Nesta linha imprimiremos no terminal, os dados referentes a posição que foi capturada pela chamada na linha 15. No final, na linha 23 retornamos que o indicador foi inicializado com sucesso.

Nada mais acontecerá dentro deste indicador. Até que ele venha a ser removido do gráfico por qualquer motivo. Quando isto ocorrer, na linha 33, destruiremos a classe devolvendo a memória alocada de volta ao sistema.

Simples assim. Como resultado, você irá ver os seguintes dados sendo visto no terminal. Começando com a posição que é vista logo na imagem abaixo.

Depois que o indicador tenha executado a sua tarefa. Você poderá conferir o resultado da execução, conforme mostrada na imagem abaixo.

Observe, que tivemos sucesso em obter os dados. Diferente do que muitos pensam, não ser possível fazer. Podemos sim, obter dados de posições ou ordens pendentes diretamente de um indicador. Não precisamos necessariamente usar um Expert Advisor para isto. Porém, o fato de você poder obter os dados de uma posição ou ordem pendente. Não significa que você, poderá usar um indicador, para enviar ou mudar os dados de uma posição ou ordem pendente. Por favor, não confunda as coisas. Quem é responsável por tal coisa, que no caso, é enviar ou mudar uma posição ou ordem pendente, é o Expert Advisor. Não tente fazer isto via indicador, pois não funcionará.

Ok. Tudo muito lindo. Tudo muito maravilhoso. Mas ainda não chegamos nem perto do que realmente precisamos implementar. Porém, como muitos dizem:

Para um bom entendedor, meia palavra já basta.

Então, quem já sabe, como adicionar objetos no gráfico, já deve ter logo captado a ideia. Mas se este não foi o seu caso, meu caro leitor, não fique desanimado. Pois agora vamos para o próximo passo a ser implementado. Este é um passo um pouco mais longo. Porém, vamos fazer com que ele seja pelo menos divertido de ser feito. Isto por conta das possibilidades que se tornam possíveis de serem implementadas. No entanto, não vamos direto aos finalmente. Vamos ir devagar. Pois existem alguns pontos a serem observados a fim de que precisemos programar o mínimo possível. Lembre-se: Já temos a nossa disposição algumas aplicações já construídas. Como o Chart Trade, o Indicador de Mouse e um Expert Advisor básico.

Agora teremos de criar o indicador de posição. Mas ele deverá preferencialmente ser colocado no gráfico, quando estas três outras aplicações também estivem no gráfico. Mas por hora, não iremos nos preocupar com isto. Primeiro vamos continuar, e criar alguns objetos para serem colocados no gráfico. Isto para que possamos ver as mesmas informações que veríamos caso o MetaTrader 5, conseguisse trabalhar, por padrão com cross order. Então mão a obra.

Colocando objetos no gráfico

Você possivelmente, deve estar achando que colocar objetos diretamente no gráfico, via MQL5 é muito complicado, ou é muito simples. De certa maneira, tudo irá depender de como você deseja trabalhar, e do que você espera em termos de funcionalidade. Mas colocar objetos gráfico no terminal do MetaTrader 5. Não é de fato algo complicado. É até bastante simples. Seja via código MQL5, seja diretamente pelo MetaTrader 5. Onde temos no menu, uma opção chamada Insert, que dentro contém um sub menu, chamado Objects, que nos permite colocar alguns objetos diretamente no gráfico. De forma muito simples e direta. Você pode ver isto na imagem abaixo.

Porém existe um problema. Não tenho total certeza se já comentei sobre isto. Mas de qualquer forma, deste momento em diante. Você, meu caro leitor, deverá passar a entender, que não podemos fazer as coisas de qualquer maneira. Devemos adicionar os objetos no gráfico, não por conta que isto deixará o gráfico mais bonito, ou mesmo, com dados, ou informações que consideramos necessárias. Fazer isto sem um devido cuidado, é uma grande e tremenda de uma burrice. Por favor, não me entenda mal. Mas existe algo, do qual muitos se quer se dão conta. E mais hora ou menos hora, acabam se deparando com um baita de um problema. Que literalmente arruína totalmente a experiência que você, meu caro leitor, possa vir a ter ao usar o MetaTrader 5.

Se bem, que o problema, não é devido ao MetaTrader 5, mas sim por conta de aplicações distintas que vão simplesmente lançando a revelia objetos no gráfico. Mesmo que tais objetos, não venha a poluir o gráfico, impedindo completamente a devida leitura do mesmo. Eles podem ser tornar um tremendo de um tormento. Estilo uma pedra fincada, que você imagina ser um pequeno pedregulho, e quando vai removê-la. Nota que no entanto era uma tremenda de uma imensa pedra. Muito maior do que você imaginava.

Talvez você possa pensar: Bem, e daí? No que isto me interessa, ou por que eu deveria me importar com tal coisa? Bem, se você pensa assim, não tenho muito o que fazer, a não ser boa sorte. Mas se você de fato, se interessa e deseja ter a melhor experiência possível, ao usar aplicações que fazem de objetos no gráfico. Este assunto poderá lhe interessar muito. O problema, não é muito difícil de ser visto. Muito pelo contrário. Ele é bastante simples de ser visto. E se você deseja realmente ver o problema ocorrer. Bastará usar um código que postei a um tempo atrás. Na época, eu não imaginava como o MetaTrader 5, lidava com algumas situações. Mas para o que iremos fazer, saber como o MetaTrader 5, lida com algumas situações será imprescindível.

Se você adicionar uma imagem no gráfico, de maneira a cobrir toda a área gráfica. Terá como resultado um papel de parede, que poderá servir como uma maneira de você, rapidamente reconhecer qual o ativo na tela. Mesmo por que, usar uma imagem no gráfico, é algo muito mais bacana do que usar um fundo monocromático. Bem, gosto não se discute, no máximo podemos lamentar por ele. Ok. Você pode fazer isto colocando o objeto diretamente no gráfico, ou pode usar uma aplicação para fazer isto. No primeiro caso, você não terá controle sobre certas coisas. No segundo caso, você terá total controle sobre como as coisas ocorreram.

Muito bem. Quem vem acompanhando meus artigos, sabe que dentro do que já foi mostrado. Em um dado momento, criamos uma classe chamada C_DrawImage. Esta tem como finalidade permitir que possamos colocar objetos, cujo conteúdo será imagens do tipo bitmap. Pelo menos por hora, já que ainda não mostrei como fazer para cobrir outros formados de imagem. Mas o que nos interessa aqui, não é isto. E sim outro fato. Assim sendo, usando todo o conjunto de códigos que venho mostrado, podemos criar o seguinte arquivo, mostrado abaixo:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "This indicator allows you to add"
04. #property description "a wallpaper to the chart."
05. #property version   "1.00"
06. #property indicator_chart_window
07. #property indicator_plots 0
08. //+------------------------------------------------------------------+
09. #include <Market Replay\Auxiliar\C_DrawImage.mqh>
10. //+------------------------------------------------------------------+
11. input string    user00 = "WallPaper_1";         //WallPaper
12. input uchar     user01 = 60;                    //Transparency
13. //+------------------------------------------------------------------+
14. C_DrawImage *Draw;
15. C_Terminal *Terminal;
16. //+------------------------------------------------------------------+
17. int OnInit()
18. {
19.     Terminal = new C_Terminal();
20.     if (!Terminal.IndicatorCheckPass("Indicator WallPaper")) return INIT_FAILED;
21.     Draw = new C_DrawImage(Terminal, "WallPaper", 0, "WallPapers\\" + user00 + ".bmp", NULL);
22.     
23.     return INIT_SUCCEEDED;
24. }
25. //+------------------------------------------------------------------+
26. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
27. {
28.     return rates_total;
29. }
30. //+------------------------------------------------------------------+
31. void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
32. {
33.     switch (id)
34.     {
35.         case CHARTEVENT_CHART_CHANGE:
36.             (*Terminal).DispatchMessage(id, lparam, dparam, sparam);
37.             (*Draw).Paint(0, 0, (*Terminal).GetInfoTerminal().Width, (*Terminal).GetInfoTerminal().Height, user01, 0);
38.             break;
39.     }
40.     ChartRedraw((*Terminal).GetInfoTerminal().ID);
41. }
42. //+------------------------------------------------------------------+
43. void OnDeinit(const int reason)
44. {
45.     delete Draw;
46.     delete Terminal;
47. }
48. //+------------------------------------------------------------------+

Código fonte do Wallpaper.mq5

Observe que se trata de um indicador. Mas o que este arquivo faz de fato? Bem, isto é simples. Este pequeno e modesto arquivo é na verdade, uma atualização de um outro arquivo, presente em um dos meus primeiros artigos. Como eu havia dito, na época eu não tinha noção de algumas coisas sobre o MetaTrader 5.

O artigo em questão é Deixando o gráfico mais interessante — Adicionando uma tela de fundo, isto para quem tiver curioso, em saber a motivação e mais detalhes sobre a ideia por trás de todo o trabalho. Se você comparar os códigos, poderá dizer que eles são completamente diferentes. E sim, eles não, mas não tão diferente, quanto você possa imaginar. O código presente naquele artigo, tem um problema. Cuja a solução é extremamente simples. Depois de você compilar aquele código, e o lançar no gráfico, como sendo uma aplicação do MetaTrader 5. Terá como resultado a apresentação de um fundo no gráfico. De fato, a imagem deveria ser um fundo.

Mas, porém, toda via e entretanto, apesar de no código, isto ficar claro. Não é bem o que acontece, quando você muda o tempo gráfico. Mesmo que você diga, ao MetaTrader 5, que deseja que as barras fiquem em primeiro plano, o tal papel de parede, vai para o primeiro plano. Podendo ocultar totalmente o gráfico. Mas é bem pior do que isto. O objeto criado ali, originalmente, tem a prioridade padrão, para receber eventos de clique. Diferente deste código, atualizado que estou mostrando acima.

Mas qual o problema disto? Nenhum, se você tiver pouco objetos no gráfico, e eles ficarem isolados uns dos outros. Mas, e quando colocamos um objeto, como um papel de parede que cobrirá todo o gráfico. E este tem a mesma prioridade em receber eventos, que outros objetos presentes também no gráfico? Percebem, que a coisa começa a ficar um pouco mais complicada. Isto por que o MetaTrader 5, não saberá para qual objeto enviar os eventos.

Agora pense o seguinte: Já temos no gráfico, diversos objetos, necessários. Eles estão no indicador de mouse, e no indicador Chart Trade. Porém, os objetos de mouse, foram rebaixados para a prioridade -1. E os objetos do indicador chart Trade estão na prioridade zero. Ou seja, mesmo que você tente, enviar um evento de clique, para um objeto criado no indicador de mouse. Você não conseguirá obter o evento, caso o ponteiro do mouse esteja sobre algum objeto do Chart Trade. Vimos isto, durante a implementação do Chart Trade. Porém não sei se isto ainda está fresco em sua memória, meu caro leitor.

E agora surge um novo agravante. Teremos ainda mais objetos sendo criados e colocados no gráfico. Isto por que iremos criar um indicador de ordens e posições. No entanto, a questão permanece. O que deveremos de fato fazer? Isto ao criar objetos no indicador de ordens e posições. Já que se eles tiverem a mesma prioridade de receber eventos que o Chart Trade. Poderemos ter problemas quando um estiver sobrepondo o outro.

Você pode pensar: Mas é simples. O objeto que estiver a frente terá prioridade. Sim, mas volto a repetir: Qual objeto? Isto por que, se dois objetos forem criados com a mesma prioridade, e ambos estiverem na mesma posição, o MetaTrader 5, plotará eles na ordem que foram colocados. Ou seja, o objeto que foi colocado por último, irá se sobrepor aos que foram criados antes. Mas o problema não é este. E sim, quando acontece um evento, onde o gráfico precisa ser repintado. Como o que acontece, quando você, caro leitor, muda o tempo gráfico. Neste momento, a ordem em que os objetos serão criados, pode ser diferente, da ordem que existia antes. Tornando tudo muito confuso e de difícil interação. Se você colocar todos os objetos para serem criados apenas por uma única aplicação. Ok, problema resolvido. Porém, temos dados prioridade em não concentrar tudo em um único e imenso arquivo. Assim precisamos fazer com que as coisas sejam criadas de uma forma um pouco mais controladas.

Considerações finais

Para quem simplesmente esperava ver as coisas, acontecendo de forma rápida e alucinada. Este artigo, talvez tenha lhes jogado um balde de água fria. Já que aqui, comecei a apresentar, qual será a diretriz a ser tomada com relação a implementação do sistema de ordens. Primeiro, precisamos de fato, criar algum tipo de indicação para podermos interagir com o sistema. Segundo, a criação, ou melhor implementação, não deve ser feita de qualquer maneira. Visto que se isto ocorrer, poderemos perder completamente o controle sobre os objetos presentes no gráfico. Terceiro, como o indicador que iremos ter de implementar adicionará ainda mais objetos no gráfico. Precisamos de alguma contornar possíveis falhas na interação. Já que se dois objetos estiverem no mesmo local. Um poderá receber eventos, mesmo estando encoberto, apenas por ter uma prioridade maior.

No entanto, não quero ter problemas, quando estivermos trabalhando com mais de uma ordem ou posição no gráfico. Isto por que, se a implementação não for feita de maneira correta, você poderá acabar fechando algo, que gostaria de manter aberto. E deixando aberto, algo que gostaria de fechar. Este tipo de aborrecimento, eu desejo mostrar como você faz para eliminar. Desta maneira espero que você, meu caro leitor, realmente esteja disposto a aprender, pois iremos ver muita coisa, antes do replay/simulador, vier a estar de fato concluído.

Arquivo	Descrição
Experts\Expert Advisor.mq5	Demonstra a interação entre o Chart Trade e o Expert Advisor (É necessário o Mouse Study para interação)
Indicators\Chart Trade.mq5	Cria a janela para configuração da ordem a ser enviada (É necessário o Mouse Study para interação)
Indicators\Market Replay.mq5	Cria os controles para interação com o serviço de replay/simulador (É necessário o Mouse Study para interação)
Indicators\Mouse Study.mq5	Permite interação entre os controles gráficos e o usuário (Necessário tanto para operar o replay simulador, quanto no mercado real)
Indicators\Order Indicator.mq5	Responsável pela indicação de ordens de mercado, permitindo interação e controle das mesmas
Indicators\Position View.mq5	Responsável pela indicação de posições de mercado, permitindo interação e controle das mesmas
Services\Market Replay.mq5	Cria e mantém o serviço de replay e simulação de mercado (Arquivo principal de todo o sistema)