Introdução ao MQL5 (Parte 9): Compreendendo e Usando Objetos no MQL5

Introdução

Bem-vindo de volta à nossa série sobre MQL5! Vamos discutir um assunto fascinante neste capítulo que acredito que você achará muito útil e interessante. Iniciaremos um projeto no qual trabalharemos com diferentes objetos de gráfico no MQL5, o que será uma base essencial para nossos projetos futuros. Este ponto de partida será especialmente útil quando entrarmos em projetos mais complexos, como o uso de vários padrões harmônicos. Objetos de gráfico no MQL5 são elementos gráficos que podem ser colocados nos gráficos de negociação para representar visualmente vários tipos de dados, incluindo níveis de preço, zonas de negociação e anotações de texto. Esses objetos oferecem aos traders e desenvolvedores a flexibilidade para criar visuais personalizados que aprimoram a análise gráfica, tornando mais fácil identificar tendências de mercado, níveis de preço importantes e oportunidades de negociação.

Existem diferentes objetos de gráfico disponíveis no MQL5, variando desde linhas e formas básicas até componentes mais complexos, como textos, setas e indicadores personalizados. Um ambiente de negociação altamente personalizado pode ser criado ao alterar a cor, tamanho, posição e outros atributos de cada objeto. Objetos de gráfico são mais do que meros enfeites decorativos; eles são instrumentos eficazes para produzir representações visuais claras e compreensíveis dos dados de mercado. Por exemplo, pode ser mais fácil identificar possíveis pontos de reversão se os níveis de suporte e resistência forem destacados com retângulos. Por meio de um projeto prático, este artigo apresentará a ideia de objetos de gráfico no MQL5 e mostrará como usá-los.

Desenvolveremos um Expert Advisor (EA) neste projeto que melhora a negociação ao exibir visualizações claras diretamente no gráfico. O caminho do ponto de entrada até as zonas de stop loss e take profit será automaticamente exibido pelo EA, proporcionando a você uma avaliação visual rápida do risco e da recompensa da operação. Sem a necessidade de consultar outras fontes de dados, o EA será atualizado em tempo real para refletir seu lucro ou prejuízo atual conforme o mercado se move. Além disso, ele fornecerá informações precisas de forma rápida ao exibir os preços de entrada, stop loss e take profit da posição atual sob observação.

A adaptabilidade deste EA às modificações na sua configuração de negociação é uma de suas principais características. Suas indicações visuais estarão sempre atualizadas porque o EA atualizará instantaneamente o gráfico quando você modificar seus níveis de take profit ou stop loss. O EA também se ajusta à duração da sua negociação. Quando você mantém a negociação por mais tempo, o EA se ajustará gradualmente para que os elementos visuais se tornem mais visíveis. Isso permitirá que você acompanhe a operação de forma eficaz em vários períodos de tempo, mesmo que no início eles possam não ser muito perceptíveis em timeframes mais altos. Agora é mais fácil gerenciar operações a partir de timeframes menores e acompanhá-las conforme evoluem, graças a essa adaptação dinâmica.

O EA permite que você analise negociações anteriores, fornecendo uma visão histórica valiosa. Ele ajuda a avaliar seu desempenho e tomar decisões mais inteligentes ao mostrar quanto você ganhou ou perdeu em posições anteriores. Você pode ver os dados históricos diretamente no gráfico definindo o intervalo de datas. Isso oferece uma visão abrangente do seu histórico de negociações e a opção de ampliar negociações específicas para uma análise mais detalhada.

Visualização da Negociação Atual:

Informações sobre Negociações Históricas:

Neste artigo, você aprenderá:

• Criar e modificar objetos gráficos para uma análise visual aprimorada
• Percorrer posições para gerenciar e exibir negociações no gráfico de forma eficiente
• Usar dados de negociações históricas para posicionar objetos gráficos
• Visualizar lucro/prejuízo de negociações históricas no gráfico para acompanhar desempenho
• Usar conversões de datetime para cronometrar com precisão a criação de objetos gráficos
• Anotar detalhes de entrada, take profit (TP) e stop loss (SL) no gráfico
• Usar parâmetros de entrada para personalizar seu Expert Advisor

Este projeto tem como objetivo familiarizá-lo com as aplicações práticas dos objetos gráficos no MQL5. Essa abordagem prática ensinará como gerenciar negociações, melhorar a análise visual e exibir dados importantes diretamente nos seus gráficos, integrando e modificando objetos gráficos no Expert Advisor (EA) de forma eficiente. Para ajudá-lo a compreender melhor como usar essas ferramentas nas decisões de negociação e no acompanhamento de desempenho, este projeto guiará você pelo processo de criação, modificação e gerenciamento de vários objetos gráficos.

1. Objetos Gráficos no MQL5

1.1. O que são Objetos Gráficos?

Objetos gráficos no MQL5 são componentes visuais que os traders podem incluir em seus gráficos para melhorar a análise e a tomada de decisões. Esses objetos podem ser elementos mais complexos como canais ou setas, ou formas simples, linhas e textos. Objetos gráficos são usados principalmente para representar visualmente dados significativos, o que ajuda os traders a planejar operações, avaliar condições de mercado e acompanhar posições abertas. Com os objetos gráficos, é possível destacar níveis de preços importantes e desenhar linhas de tendência no gráfico que indicam a direção do mercado. Ao visualizar esses dados no gráfico, os traders podem tomar decisões de negociação bem-informadas e avaliar rapidamente as condições do mercado, em vez de depender apenas de dados numéricos.

1.2. Por que a Personalização de Objetos do Gráfico é Importante?

Você pode melhorar a clareza visual dos seus gráficos de negociação e tomar decisões melhores ao personalizar os objetos do gráfico. Alterando a cor, o tamanho ou a posição desses objetos, você pode deixar o gráfico mais adaptado às suas preferências e estilo de negociação. Essa personalização permite destacar as informações mais importantes à primeira vista, dando-lhes ênfase.

Se sua atenção estiver nos níveis de suporte e resistência, você pode querer usar linhas grossas e em negrito, com cores vivas e fáceis de visualizar mesmo em uma análise rápida do gráfico. Dessa forma, você reduz as chances de ignorar sinais cruciais durante uma sessão de negociação movimentada. Da mesma forma, destacar anotações em texto pode servir como um lembrete visual para ajudá-lo a lembrar de decisões importantes ou estratégias planejadas.

1.3. Objetos do Gráfico que Usaremos no Projeto

Vários objetos gráficos importantes do MQL5 serão usados neste projeto para aprimorar nossa análise de negociação. Os objetos de gráfico que utilizaremos são os seguintes:

1.3.1. Linhas de Tendência

Uma ferramenta essencial em nosso projeto é a linha de tendência, usada principalmente para acompanhar o preço atual do mercado em relação a níveis importantes de tendência e identificar o ponto de entrada. Para determinar a direção geral do mercado, desenharemos uma linha de tendência entre pontos de preço importantes. Conforme o preço de mercado muda (ou "ticks"), a linha de tendência é atualizada em tempo real, estendendo-se continuamente do preço de entrada até o preço de mercado mais recente.

Isso garante que a linha de tendência reflita sempre os dados de preço mais recentes, auxiliando no acompanhamento preciso do desempenho da operação e na tomada de decisões sobre o gerenciamento da posição. A linha de tendência geralmente começa no preço em que a posição foi aberta, refletindo o ponto de partida da operação. A linha se estende até o preço de mercado atual ou preço de venda. Isso mostra como o preço se movimentou desde a abertura da operação.

1.3.2. Rótulos de Texto

Como mostram os comentários no gráfico, os rótulos de texto oferecem detalhes claros e compreensíveis sobre diferentes aspectos de uma operação. Informações importantes como pontos de entrada, níveis de stop-loss, alvos de take-profit e outras observações pertinentes para a estratégia de negociação podem ser mostradas com eles. Ao adicionar rótulos de texto a áreas significativas do gráfico, você pode acessar facilmente informações essenciais sem recorrer a anotações externas ou à memória. Esse auxílio visual facilita ter todas as informações necessárias à mão ao tomar decisões.

Um rótulo de texto indicando o lucro ou prejuízo atual da posição aberta aparecerá a cada tick. Com essa atualização em tempo real, você pode acompanhar o desempenho da operação conforme o mercado se movimenta e ter uma ideia instantânea de se a operação está indo na direção certa. Com um rótulo como +$100 ou -$50 próximo à operação, o lucro ou prejuízo atual será exibido em tempo real conforme o mercado atualiza. Isso permite monitorar o desempenho da operação e fazer os ajustes necessários.

1.3.3. Objetos Retangulares

Objetos retangulares podem ser usados para indicar níveis de suporte e resistência em um gráfico, entre outras coisas. Mas neste projeto, seu uso será limitado à identificação de zonas de ganho e perda em uma operação. Quando uma posição estiver gerando prejuízo, desenharemos um retângulo do ponto de entrada até o nível de stop-loss. Isso nos ajuda a reconhecer rapidamente quando a posição está se aproximando do stop-loss, representando visualmente a área onde a operação está em direção negativa. Um retângulo será desenhado do ponto de entrada até o nível de take-profit assim que a posição estiver em lucro. Isso nos ajuda a acompanhar o progresso da operação em direção ao objetivo de lucro, destacando as áreas de bom desempenho.

Há muitos objetos de gráfico disponíveis no MQL5, cada um com a intenção de melhorar a análise de negociação de forma específica. No entanto, seria demais cobrir todos esses itens em um único artigo. Por isso, foquei apenas nos objetos que serão utilizados no nosso projeto. Esses objetos escolhidos — que incluem retângulos, linhas de tendência e rótulos de texto — não são apenas essenciais para esta estratégia específica, mas também compartilham processos semelhantes de criação e modificação com outros objetos do MQL5. Ao entender os conceitos e estratégias para esses objetos específicos, você adquirirá o conhecimento fundamental necessário para trabalhar com diversos objetos gráficos no MQL5, usando métodos semelhantes para criá-los e personalizá-los de acordo com suas necessidades de negociação.

2. Criando e Personalizando Objetos

Nesta seção, vamos nos concentrar na criação e modificação de diferentes objetos de gráfico no MQL5. A criação de objetos como retângulos, linhas de tendência e rótulos de texto será demonstrada, além de como ajustar suas cores, estilos e espessuras para se adequar ao seu plano de negociação. 

2.1. Pseudocódigo

Neste projeto, o pseudocódigo é essencial porque, antes de escrever qualquer código, ele oferece um resumo bem organizado e conciso do raciocínio e dos procedimentos necessários para alcançar nossos objetivos. Ajuda a dividir tarefas complexas em partes menores e mais gerenciáveis, o que facilita o planejamento, ajuda a identificar possíveis problemas e garante que o código seja eficiente e bem estruturado. O pseudocódigo nos permite visualizar todo o fluxo do Expert Advisor, facilitando a implementação dos objetos gráficos e de outras funcionalidades.

Este é o pseudocódigo básico do nosso EA:

1. Inicialização:

• Definir cores para a zona de SL, zona de TP e linha de tendência.
• Definir o índice da posição.
• Especificar se os dados históricos devem ser exibidos.
• Definir as datas de início e fim para os dados históricos.
• Definir o horário para fechamento da zona.
• Obter o ID atual do gráfico.
• Inicializar variáveis para armazenar os detalhes da posição (preço de abertura, stop loss, take profit, lucro, horário de abertura).

2. A Cada Tick:

• Converter o horário (string) para um objeto datetime para a zona de fechamento.
• Obter o preço de venda atual (ask).
• Percorrer todas as posições.
• Obter o número do ticket da posição.
• Verificar se a posição corresponde ao símbolo do gráfico.
• Recuperar detalhes: preço de entrada, stop loss, take profit, horário de entrada e lucro.
• Se a posição corresponder ao índice especificado.
• Criar e configurar a zona de SL (retângulo).
• Definir propriedades (cor, estilo, largura, preenchimento).
• Criar e configurar a zona de TP (retângulo).
• Definir propriedades (cor, estilo, largura, preenchimento).
• Criar e configurar a linha de tendência.
• Definir propriedades (cor, estilo, largura).
• Calcular e exibir o lucro da posição.
• Formatar e exibir o lucro como texto.
• Criar e configurar objetos de texto para Entrada, TP e SL:
• Definir propriedades (cor, tamanho da fonte).

3. Se a Exibição de Dados Históricos estiver habilitada:

• Limpar comentários anteriores.
• Selecionar e iterar sobre negociações históricas dentro do intervalo de datas especificado:
• Obter detalhes de cada negociação (preço de entrada, preço de saída, SL, TP, lucro, horários).
• Exibir informações de lucro/prejuízo.
• Criar e configurar zona de SL, zona de TP e linha de tendência para as negociações históricas:
• Definir propriedades (cor, estilo, largura).

2.2. Aplicação Prática: Criando e Personalizando Objetos

2.2.1 Criação de Objetos Gráficos

Uma ferramenta essencial no MQL5 que permite criar diferentes tipos de objetos no seu gráfico de negociação é a função ObjectCreate(). Esses objetos, que ajudam os traders a visualizar melhor os dados do mercado, analisar tendências e marcar pontos importantes no gráfico, podem incluir linhas de tendência, retângulos, rótulos de texto, setas e mais.

Além da Criação: Especificando a Posição do Objeto

Com o ObjectCreate(), você não apenas cria objetos no gráfico, mas seus parâmetros também oferecem controle preciso sobre onde esses objetos aparecem. Você pode direcionar e melhorar a eficácia da sua análise ao posicionar esses objetos em locais específicos no seu gráfico e especificar parâmetros adequados. O tempo e o preço são os dois principais fatores que determinam onde os objetos são posicionados no gráfico. Esses elementos servem como âncoras para o objeto naquele local exato do gráfico.

Sintaxe:

ObjectCreate(chart_id, object_name, object_type, sub_window, time1, price1, time2, price2, time3, price3);

A Relação entre Tempo e Preço no Posicionamento de Objetos

Cada ponto em um gráfico de negociação no MQL5 é determinado pela interação entre o preço (eixo vertical) e o tempo (eixo horizontal). Essas duas dimensões são usadas para especificar a localização exata do objeto no gráfico ao criá-lo com o ObjectCreate.

Compreendendo os Pontos de Âncora: time1, price1, time2, price2, time3, price3

É comum precisar definir um ou mais pontos de âncora ao usar ObjectCreate() para criar objetos. A localização precisa do objeto no gráfico é estabelecida por esses pontos. Esses pontos de âncora são os parâmetros time1, price1, time2, price2, time3 e price3.

• time1 e price1: Esses parâmetros estabelecem o ponto de âncora inicial do objeto. Se você estiver desenhando uma linha de tendência, por exemplo, time1 indicaria o horário do ponto inicial (uma vela específica, por exemplo), e price1 indicaria o nível de preço nesse ponto.
• time2 e price2: Especificam o segundo ponto de âncora do objeto. Esse seria o ponto final da linha, no caso da linha de tendência. Price2 indica o nível de preço nesse momento, e time2 indica o horário do segundo ponto.
  

• time3 e price3: Um terceiro ponto de âncora é necessário para certos objetos mais complexos, como canais ou triângulos. Você pode especificar esse terceiro ponto usando time3 e price3, que podem ser exigidos ao desenhar formas que requerem três coordenadas.

Exemplo:

// Get the ID of the current chart
long chart_id = ChartID();

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
// Define the first anchor point for the trendline
// 'time1' is the datetime for the first point, and 'price1' is the price at that time
   datetime time1  = D'2024.08.21 16:00';
   double   price1 = 8766.01;

// Define the second anchor point for the trendline
// 'time2' is the datetime for the second point, and 'price2' is the price at that time
   datetime time2  = D'2024.08.28 08:00';
   double   price2 = 8854.51;

// Create a trendline object on the chart
// 'chart_id' is the ID of the chart where the object will be placed
// "Trend Line" is the name of the trendline object
// 'OBJ_TREND' specifies that the object is a trendline
// The last four parameters (0, time1, price1, time2, price2) specify the anchor points of the trendline
   ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, time1, price1, time2, price2);
  }

Saída:

Rótulos de texto (OBJ_TEXT) podem ser posicionados no gráfico com apenas um ponto de âncora. O ponto de âncora indica a localização do texto com base nas coordenadas de preço e tempo fornecidas. Um rótulo de texto no gráfico com a frase “Compre Aqui” em um momento e preço específicos.

Exemplo:

// Get the ID of the current chart
long chart_id = ChartID();

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
// Define the time for the text label's position (August 21, 2024, at 16:00)
   datetime time1  = D'2024.08.21 16:00';

// Define the price level for the text label's position (8766.01)
   double   price1 = 8766.01;

// Create a text object named "Text" on the chart at the specified time and price
   ObjectCreate(chart_id, "Text", OBJ_TEXT, 0, time1, price1);

// Set the text content of the object to display "Buy Here"
   ObjectSetString(chart_id, "Text", OBJPROP_TEXT, "Buy Here");
  }

Saída:

2.3. Personalizando Objetos

Você pode personalizar os componentes visuais dos objetos do gráfico para se adequarem ao seu estilo de negociação. Felizmente, você também pode modificar seu tamanho, cor e estilo. Por exemplo, para destacar uma linha de tendência dos demais elementos no gráfico, você pode alterar sua cor, espessura e localização para garantir que estejam alinhadas com níveis de mercado importantes. Da mesma forma, os rótulos de texto podem ser alterados mudando a fonte e o esquema de cores para chamar atenção para detalhes cruciais como metas de lucro ou pontos de entrada.

Exemplo:

// Define the time for the text label's position (August 21, 2024, at 16:00)
datetime time1  = D'2024.08.21 16:00';

// Define the price level for the text label's position (8766.01)
double   price1 = 8766.01;

// Create a text object named "Text" on the chart at the specified time and price
ObjectCreate(chart_id, "Text", OBJ_TEXT, 0, time1, price1);

// Set the text content of the object to display "Buy Here"
ObjectSetString(chart_id, "Text", OBJPROP_TEXT, "Buy Here");

// Set the color of the text object to Medium Blue
ObjectSetInteger(chart_id, "Text", OBJPROP_COLOR, clrMediumBlue);

Este código exibe o texto “Compre Aqui”, adiciona um rótulo de texto ao gráfico em um tempo e preço específicos, e altera a cor do texto para Azul Médio (Medium Blue).

Saída:

2.3.1. Funções de Objeto para Personalizar Objetos Gráficos no MQL5

Os objetos de gráfico no MQL5 podem ser personalizados utilizando várias funções de objeto. Com a ajuda dessas funções, você pode alterar a aparência, comportamento e localização dos objetos no gráfico para atender melhor às suas necessidades específicas de negociação.

ObjectSetInteger()

Usado para definir propriedades do tipo inteiro de um objeto de gráfico, como cor, largura e estilo.

Exemplo:

// Get the ID of the current chart
long chart_id = ChartID();

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {

   datetime time1  = D'2024.08.21 16:00';
   double   price1 = 8766.01;

// Define the second anchor point for the trendline
// 'time2' is the datetime for the second point, and 'price2' is the price at that time
   datetime time2  = D'2024.08.28 08:00';
   double   price2 = 8854.51;

// Create a trend line object on the chart with the name "Trend Line"
// The trend line will be drawn from time1/price1 to time2/price2
   ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, time1, price1, time2, price2);

// Set the style of the trend line to a dashed line
   ObjectSetInteger(chart_id, "Trend Line", OBJPROP_STYLE, STYLE_DASH);

// Set the width of the trend line to 2
   ObjectSetInteger(chart_id, "Trend Line", OBJPROP_WIDTH, 2);
  }

Saída:

ObjectSetDouble()

Define atributos do tipo double, frequentemente relacionados a preço ou tempo. Exemplo: Ajustar as coordenadas dos pontos de âncora de uma linha de tendência.

ObjectSetString()

Usado para definir propriedades do tipo string, como o texto exibido por um rótulo de texto.

Exemplo: Adicionar anotações ou observações diretamente no gráfico.

// Create a text object named "Text" on the chart at the specified time and price
ObjectCreate(chart_id, "Text", OBJ_TEXT, 0, time1, price1);

// Set the text content of the object to display "Buy Here"
ObjectSetString(chart_id, "Text", OBJPROP_TEXT, "Buy Here");

Diferentes tipos de objetos de gráfico podem ser criados, personalizados e gerenciados usando várias funções de objeto disponíveis no MQL5. Esses recursos são cruciais para melhorar a forma como os dados de negociação são apresentados visualmente nos seus gráficos. ObjectCreate e ObjectSetInteger são duas funções importantes que discutimos em nosso projeto, mas existem muitas outras. Você pode consultar a documentação do MQL5, que oferece detalhes abrangentes sobre todas as funções de gráfico disponíveis, para um entendimento mais aprofundado de outras funções.

3. Implementando Objetos Gráficos em Nosso Projeto

3.1. Criando Objetos Gráficos para Posições Atuais

Esta seção vai se concentrar na configuração de objetos gráficos para lidar e apresentar dados sobre as posições atuais no gráfico. Para representar visualmente os dados das operações em tempo real, isso envolve a criação e modificação de retângulos, linhas de tendência e rótulos de texto.

3.1.1. Usando Retângulos para Destacar Áreas

Vamos usar dois retângulos diferentes para enfatizar visualmente as zonas críticas no seu gráfico onde os níveis de Stop Loss (SL) e Take Profit (TP) estão definidos. Esses retângulos representarão dinamicamente as zonas de SL e TP, para que você possa acompanhar facilmente os níveis de risco e recompensa com um simples olhar.

a. Destacando a Zona de SL:

• Âncora 1: A primeira âncora do retângulo da zona de SL será posicionada no preço de entrada da operação e no exato momento em que a posição foi aberta.
• Âncora 2: A segunda âncora será posicionada no preço de SL e se estenderá horizontalmente até às 23:59 do dia atual. Essa extensão garante que o retângulo seja atualizado dinamicamente a cada dia, expandindo-se para cobrir visualmente a zona de SL até que a operação seja encerrada ou o dia termine.
• Objetivo: Este retângulo marca a área de risco no gráfico, permitindo identificar rapidamente o quão próximo o preço atual está do nível de SL.

b. Destacando a Zona de TP:

• Âncora 1: A primeira âncora do retângulo da zona de TP também começará no preço de entrada da operação.
• Âncora 2: A segunda âncora, que se estende horizontalmente até às 23:59 do dia atual, será posicionada no preço de TP da posição atual. Assim como a zona de SL, a área de recompensa potencial será continuamente destacada por esse retângulo que se expande diariamente.

Os retângulos que destacam as zonas de SL e TP só podem ser criados depois que recuperamos programaticamente as informações necessárias para cada posição. Isso inclui o preço de abertura, nível de stop loss (SL), nível de take profit (TP) e o momento de abertura da operação. Isso inclui o preço de abertura, nível de stop loss (SL), nível de take profit (TP) e o momento de abertura da operação. Graças a esse método automatizado, os retângulos também podem ser atualizados dinamicamente com novas posições, mantendo a representação visual sempre atualizada e relevante.

Exemplo:

// Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      // Retrieve and store the entry price of the position
      open_price = PositionGetDouble(POSITION_PRICE_OPEN);

      // Retrieve and store the Stop Loss level of the position
      stop_loss = PositionGetDouble(POSITION_SL);

      // Retrieve and store the Take Profit level of the position
      take_profit = PositionGetDouble(POSITION_TP);

      // Retrieve and store the open time of the position
      position_open_time = (int)PositionGetInteger(POSITION_TIME);

      // Print the retrieved values for debugging or verification
      Print("Open Price index ",i,": ",open_price);
      Print("SL index ",i,": ",stop_loss);
      Print("TP index ",i,": ",take_profit);
      Print("Open time index ",i,": ",position_open_time);
     }
  }

Explicação:

Cada vez que o preço do instrumento de negociação sofre um tick, ou alteração, a função OnTick executa o código. Informações importantes sobre cada posição aberta na conta de negociação são recuperadas. Todas as posições abertas na conta de negociação são percorridas em um loop. A função PositionsTotal() retorna informações específicas sobre cada posição com base em seu índice na lista total de posições. Use as funções PositionGetDouble e PositionGetInteger para recuperar esses detalhes. Para depuração ou verificação, os dados recuperados são impressos no terminal antes de qualquer elemento visual ser adicionado ao gráfico, como os retângulos que destacam as zonas de SL e TP. Isso garante que dados precisos estejam sendo coletados.

Duas questões surgem com a implementação atual:

• Identificando a Posição Exata: Do jeito que está, o EA não sabe qual posição exata está sendo percorrida para obter os dados de tempo e preço. Isso significa que, ao querermos informações de uma posição específica, o código irá extrair dados de todas as posições abertas, o que pode causar confusão ou uso incorreto dos dados.
• Dados Específicos do Instrumento no Gráfico: As informações recuperadas precisam estar relacionadas às posições e operações do instrumento que está sendo exibido no gráfico no momento. O EA pode extrair dados de posições de outros instrumentos que não são relevantes para o gráfico atual se o símbolo do gráfico não for filtrado, o que pode gerar representações visuais imprecisas ou enganosas.

A solução para esse problema é fornecer uma entrada onde o usuário possa escolher qual índice de posição deseja recuperar os dados. Com essa informação, o EA poderá focar na posição específica que o usuário deseja. O código também deve garantir que a posição selecionada corresponda ao instrumento que está atualmente visível no gráfico, assegurando que apenas dados relevantes sejam usados na representação visual.

Exemplo:

// Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position

// Define the position index for the first position
input int position_index  = 0; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();


//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {


// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      if(PositionGetInteger(POSITION_TICKET) == PositionGetTicket(position_index) && PositionGetString(POSITION_SYMBOL) == ChartSymbol(chart_id))
        {

         // Retrieve and store the entry price of the position
         open_price = PositionGetDouble(POSITION_PRICE_OPEN);

         // Retrieve and store the Stop Loss level of the position
         stop_loss = PositionGetDouble(POSITION_SL);

         // Retrieve and store the Take Profit level of the position
         take_profit = PositionGetDouble(POSITION_TP);

         // Retrieve and store the open time of the position
         position_open_time = (int)PositionGetInteger(POSITION_TIME);

         // Print the retrieved values for debugging or verification
         Print("Open Price index ",i,": ",open_price);
         Print("SL index ",i,": ",stop_loss);
         Print("TP index ",i,": ",take_profit);
         Print("Open time index ",i,": ",position_open_time);

        }
     }

  }

O algoritmo itera sobre cada posição aberta, determina se ela corresponde ao índice escolhido e ao símbolo do gráfico, e então obtém as informações pertinentes. Após recuperar com sucesso os dados de preço e tempo da posição especificada, podemos agora criar os dois retângulos que indicarão as zonas de SL (Stop Loss) e TP (Take Profit). Para garantir que esses retângulos representem adequadamente as regiões de SL e TP no gráfico, os dados obtidos serão usados como entradas para a função ObjectCreate().

Exemplo:

// Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position

// Define the position index for the first position
input int position_index  = 1; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();  // Store the ID of the current chart

string time = "23:59";      // Define a specific time as a string

// Define the color for the losing zone
input color sl_zonez_color   = clrPink; // Choose a color for Losing Zone

// Define the color for the winning zone
input color tp_zonez_color   = clrSpringGreen; // Choose a color for Winning Zone


//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {

// Convert the string time to datetime
   datetime close_zone = StringToTime(time);

// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      // Check if the position matches the specified index and symbol of the current chart
      if(PositionGetInteger(POSITION_TICKET) == PositionGetTicket(position_index) && PositionGetString(POSITION_SYMBOL) == ChartSymbol(chart_id))
        {

         // Retrieve and store the entry price of the position
         open_price = PositionGetDouble(POSITION_PRICE_OPEN);

         // Retrieve and store the Stop Loss level of the position
         stop_loss = PositionGetDouble(POSITION_SL);

         // Retrieve and store the Take Profit level of the position
         take_profit = PositionGetDouble(POSITION_TP);

         // Retrieve and store the open time of the position
         position_open_time = (int)PositionGetInteger(POSITION_TIME);

         // Print the retrieved values for debugging or verification
         Print("Open Price index ",i,": ",open_price);
         Print("SL index ",i,": ",stop_loss);
         Print("TP index ",i,": ",take_profit);
         Print("Open time index ",i,": ",position_open_time);

         // Create a rectangle to represent the Stop Loss (SL) zone on the chart
         ObjectCreate(chart_id, "SL Zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, stop_loss);

         // Create a rectangle to represent the Take Profit (TP) zone on the chart
         ObjectCreate(chart_id, "TP zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, take_profit);

         // Set properties for the SL zone rectangle
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_COLOR, sl_zonez_color); // Set color to the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_FILL, sl_zonez_color);  // Fill the rectangle with the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

         // Set properties for the TP zone rectangle
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_COLOR, tp_zonez_color); // Set color to the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_FILL, tp_zonez_color);  // Fill the rectangle with the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

        }
     }

  }

Explicação:

Este código obtém o horário de abertura da posição, SL, TP e preço de entrada para cada posição. Ele utiliza essas informações para desenhar dois retângulos visíveis no gráfico: um para a área de possível perda e outro para a área de lucro potencial. Por outro lado, a ausência de definição dos níveis de TP ou SL pode gerar problemas com os pontos de âncora desses retângulos, o que pode afetar seu posicionamento ou exibição no gráfico. Para garantir uma visualização precisa, implementarei código para corrigir esse comportamento.

if(stop_loss > 0)
  {
// Create a rectangle to represent the Stop Loss (SL) zone on the chart
   ObjectCreate(chart_id, "SL Zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, stop_loss);
  }


if(take_profit > 0)
  {
// Create a rectangle to represent the Take Profit (TP) zone on the chart
   ObjectCreate(chart_id, "TP zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, take_profit);
  }

Explicação:

Antes de criar os retângulos correspondentes no gráfico, o trecho de código verifica se os níveis de Stop Loss e Take Profit são maiores que zero. Se o SL estiver definido (ou seja, maior que 0), um retângulo será desenhado para representar a zona de SL, marcando a área de perda potencial; se o TP estiver definido, outro retângulo será criado para representar a zona de TP, indicando a área de lucro potencial. Ao evitar a criação de retângulos com pontos de âncora inválidos, essas verificações garantem a visualização correta no gráfico.

Saída:

3.1.2. Criando Linhas de Tendência

Para ilustrar o movimento de preço desde a abertura da operação, nesta parte vamos nos concentrar em desenhar uma linha de tendência do preço de entrada da posição até o preço atual. É fácil visualizar como o mercado se comportou em torno desses dois pontos de entrada, o que facilita uma análise mais detalhada do desenvolvimento da operação.

Exemplo:

// Get the current ask price
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
// Create a trend line object on the chart from the position's open time and price to the current time and ask price
ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, position_open_time, open_price, TimeCurrent(), ask);

// Set the color of the trend line
ObjectSetInteger(chart_id, "Trend Line", OBJPROP_COLOR, clrYellow);

// Set the style of the trend line to dashed
ObjectSetInteger(chart_id, "Trend Line", OBJPROP_STYLE, STYLE_DASH);

// Set the width of the trend line
ObjectSetInteger(chart_id, "Trend Line", OBJPROP_WIDTH, 2);

Saída:

3.1.3. Adicionando Rótulos de Texto

Neste estágio, vamos adicionar quatro rótulos de texto distintos no gráfico. Serão exibidos nestes rótulos o preço de entrada, o take-profit (TP), o stop-loss (SL) e o lucro atual. Esses parâmetros de negociação cruciais terão referências visuais distintas para cada rótulo no gráfico, tornando mais fácil acompanhar o status da operação diretamente no gráfico.

Exemplo:

// Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position


// Define the position index for the first position
input int position_index  = 1; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();  // Store the ID of the current chart

string time = "23:59";      // Define a specific time as a string

// Define the color for the losing zone
input color sl_zonez_color   = clrPink; // Choose a color for Losing Zone

// Define the color for the winning zone
input color tp_zonez_color   = clrSpringGreen; // Choose a color for Winning Zone

// Define the color for the trend line
input color line_zonez_color = clrYellow; // Choose a color for the line


//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {

// Get the current ask price
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

// Convert the string time to datetime
   datetime close_zone = StringToTime(time);

// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      // Check if the position matches the specified index and symbol of the current chart
      if(PositionGetInteger(POSITION_TICKET) == PositionGetTicket(position_index) && PositionGetString(POSITION_SYMBOL) == ChartSymbol(chart_id))
        {

         // Retrieve and store the entry price of the position
         open_price = PositionGetDouble(POSITION_PRICE_OPEN);

         // Retrieve and store the Stop Loss level of the position
         stop_loss = PositionGetDouble(POSITION_SL);

         // Retrieve and store the Take Profit level of the position
         take_profit = PositionGetDouble(POSITION_TP);

         // Retrieve and store the open time of the position
         position_open_time = (int)PositionGetInteger(POSITION_TIME);



         if(stop_loss > 0)
           {
            // Create a rectangle to represent the Stop Loss (SL) zone on the chart
            ObjectCreate(chart_id, "SL Zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, stop_loss);
           }

         if(take_profit > 0)
           {
            // Create a rectangle to represent the Take Profit (TP) zone on the chart
            ObjectCreate(chart_id, "TP zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, take_profit);
           }

         // Set properties for the SL zone rectangle
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_COLOR, sl_zonez_color); // Set color to the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_FILL, sl_zonez_color);  // Fill the rectangle with the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

         // Set properties for the TP zone rectangle
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_COLOR, tp_zonez_color); // Set color to the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_FILL, tp_zonez_color);  // Fill the rectangle with the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

         // Create a trend line object on the chart from the position's open time and price to the current time and ask price
         ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, position_open_time, open_price, TimeCurrent(), ask);

         // Set Trend Line properties
         ObjectSetInteger(chart_id, "Trend Line", OBJPROP_COLOR, line_zonez_color);
         ObjectSetInteger(chart_id, "Trend Line", OBJPROP_STYLE, STYLE_DASH);
         ObjectSetInteger(chart_id, "Trend Line", OBJPROP_WIDTH, 2);



         // Calculate the profit of the current position
         double profit = PositionGetDouble(POSITION_PROFIT);

         // Variables to store the formatted profit text
         string curent_profits;
         string profit_to_string;

         // Check if the profit is positive or zero
         if(profit >= 0)
           {
            // Convert the profit to a string with 2 decimal places
            profit_to_string = DoubleToString(profit, 2);
            // Format the profit as a positive amount with a '+' sign
            curent_profits = StringFormat("+$%s", profit_to_string);
           }
         // Check if the profit is negative
         else
            if(profit < 0)
              {
               // Convert the negative profit to a positive number
               double profit_to_positive = MathAbs(profit);
               // Convert the positive profit to a string with 2 decimal places
               profit_to_string = DoubleToString(profit_to_positive, 2);
               // Format the profit as a negative amount with a '-' sign
               curent_profits = StringFormat("-$%s", profit_to_string);
              }

         // Create a text label on the chart to display the current profit
         string text_object_name = "Profit";
         ObjectCreate(chart_id, text_object_name, OBJ_TEXT, 0, TimeCurrent(), ask);
         ObjectSetString(chart_id, text_object_name, OBJPROP_TEXT, curent_profits);

         // Set the color of the profit text based on whether the profit is positive or negative
         if(profit > 0)
           {
            ObjectSetInteger(chart_id, text_object_name, OBJPROP_COLOR, clrMediumBlue); // Positive profit in blue
           }
         else
            if(profit < 0)
              {
               ObjectSetInteger(chart_id, text_object_name, OBJPROP_COLOR, clrRed); // Negative profit in red
              }

         // Display the Take Profit (TP) level on the chart
         string tp_display = "TP";
         string t_display = StringFormat("Take Profit: %.5f", take_profit);
         ObjectCreate(chart_id, tp_display, OBJ_TEXT, 0, close_zone, take_profit);
         ObjectSetString(chart_id, tp_display, OBJPROP_TEXT, t_display);
         ObjectSetInteger(chart_id, tp_display, OBJPROP_COLOR, clrBlue); // TP text in blue
         ObjectSetInteger(chart_id, tp_display, OBJPROP_FONTSIZE, 8); // Set font size for TP

         // Display the Stop Loss (SL) level on the chart
         string sl_display = "SL";
         string s_display = StringFormat("Stop Loss: %.5f", stop_loss);
         ObjectCreate(chart_id, sl_display, OBJ_TEXT, 0, close_zone, stop_loss);
         ObjectSetString(chart_id, sl_display, OBJPROP_TEXT, s_display);
         ObjectSetInteger(chart_id, sl_display, OBJPROP_COLOR, clrRed); // SL text in red
         ObjectSetInteger(chart_id, sl_display, OBJPROP_FONTSIZE, 8); // Set font size for SL

         // Display the Entry Price on the chart
         string en_display = "Entry Price";
         string e_display = StringFormat("Entry Point: %.5f", open_price);
         ObjectCreate(chart_id, en_display, OBJ_TEXT, 0, close_zone, open_price);
         ObjectSetString(chart_id, en_display, OBJPROP_TEXT, e_display);
         ObjectSetInteger(chart_id, en_display, OBJPROP_COLOR, clrPaleVioletRed); // Entry Price text in pale violet red
         ObjectSetInteger(chart_id, en_display, OBJPROP_FONTSIZE, 8); // Set font size for Entry Price


        }
     }

  }

Explicação:

Esta parte do código tem como objetivo exibir diretamente no gráfico dados importantes da negociação. Ela calcula o lucro atual da posição e o apresenta como um rótulo de texto, exibindo o lucro em vermelho se for negativo e em azul se for positivo. Para distinguir visualmente o nível de TP, o nível de SL e o preço de entrada, também são inseridos rótulos de texto para cada um. Esses rótulos são coloridos de forma diferente. Os rótulos foram posicionados no gráfico para ajudar os traders a identificar rapidamente os níveis cruciais e o status atual de lucro da sua posição.

Saída:

3.2. Criando Objetos Gráficos para Dados Históricos

O capítulo 3 abordou até agora a criação de objetos gráficos que simbolizam a posição atual. Agora voltaremos nosso foco para lidar com registros históricos, o que nos permitirá visualizar tendências de operações anteriores e dados no gráfico. Isso nos permitirá analisar transações anteriores e aplicar o conhecimento histórico aos planos de negociação atuais.

Exemplo:

// Define the position index for the first position
input int position_index  = 1; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();  // Store the ID of the current chart

string time = "23:59";      // Define a specific time as a string

// Define the color for the losing zone
input color sl_zonez_color   = clrPink; // Choose a color for Losing Zone

// Define the color for the winning zone
input color tp_zonez_color   = clrSpringGreen; // Choose a color for Winning Zone

// Define the color for the trend line
input color line_zonez_color = clrYellow; // Choose a color for the line

// Define whether to show past history or not
input string show_history = "no"; // Type yes to show past history

// Define the start date to show history
input datetime date1 = D'1970.08.10 00:00:00'; // Show history from this date

// Define the end date to show history
input datetime date2 = D'2024.08.15 00:00:00'; // To this date


//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {

// Check if history display is enabled
   if(show_history == "yes")
     {
      Comment(""); // Clear previous comments

      // Select deal history within the specified date range
      bool deal_history = HistorySelect(date1, date2);

      // Variables to store deal details
      double deal_close_price = 0.0;
      double deal_open_price = 0.0;
      double deal_sl = 0.0;
      double deal_tp = 0.0;
      double deal_profit = 0.0;
      datetime deal_close_time = 0;
      datetime deal_open_time = 0;

      // Check if deal history is available
      if(deal_history)
        {
         // Loop through all history deals
         for(int i = 0; i < HistoryDealsTotal(); i++)
           {
            ulong ticket = HistoryDealGetTicket(i);

            // Check for deal entry in
            if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_IN)
              {
               if(HistoryDealGetString(ticket, DEAL_SYMBOL) == ChartSymbol(chart_id))
                 {
                  deal_open_price = HistoryDealGetDouble(ticket, DEAL_PRICE);
                  deal_open_time = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);
                 }
              }

            // Check for deal entry out
            if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_OUT)
              {
               deal_profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
               deal_close_price = HistoryDealGetDouble(ticket, DEAL_PRICE);
               deal_sl = HistoryDealGetDouble(ticket, DEAL_SL);
               deal_tp = HistoryDealGetDouble(ticket, DEAL_TP);
               deal_close_time = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);

               if(HistoryDealGetString(ticket, DEAL_SYMBOL) == ChartSymbol(chart_id))
                 {
                  string deal_string;
                  string current_deal_profit;
                  string object_name;

                  // Display deal profit/loss
                  if(deal_profit > 0)
                    {
                     deal_string = DoubleToString(deal_profit, 2);
                     current_deal_profit = StringFormat("YOU WON +$%s", deal_string);
                     object_name = StringFormat("PROFIT %d", i);
                     ObjectCreate(chart_id, object_name, OBJ_TEXT, 0, deal_close_time, deal_close_price);
                     ObjectSetString(chart_id, object_name, OBJPROP_TEXT, current_deal_profit);
                     ObjectSetInteger(chart_id, object_name, OBJPROP_COLOR, clrMediumBlue);
                     ObjectSetInteger(chart_id, object_name, OBJPROP_FONTSIZE,8);
                    }
                  else
                     if(deal_profit < 0)
                       {
                        double deal_to_positive = MathAbs(deal_profit);
                        deal_string = DoubleToString(deal_to_positive, 2);
                        object_name = StringFormat("PROFIT %d", i);
                        current_deal_profit = StringFormat("YOU LOST -$%s", deal_string);
                        ObjectCreate(chart_id, object_name, OBJ_TEXT, 0, deal_close_time, deal_close_price);
                        ObjectSetString(chart_id, object_name, OBJPROP_TEXT, current_deal_profit);
                        ObjectSetInteger(chart_id, object_name, OBJPROP_COLOR, clrRed);
                        ObjectSetInteger(chart_id, object_name, OBJPROP_FONTSIZE,8);
                       }

                  // Display deal SL zone
                  string sl_obj_name = StringFormat("SL ZONE %d", i);
                  if(deal_sl > 0)
                    {
                     ObjectCreate(chart_id, sl_obj_name, OBJ_RECTANGLE, 0, deal_open_time, deal_open_price, deal_close_time, deal_sl);
                    }
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_COLOR, sl_zonez_color);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_STYLE, STYLE_SOLID);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_WIDTH, 1);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_FILL, sl_zonez_color);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_BACK, true);

                  // Display deal TP zone
                  string tp_obj_name = StringFormat("TP ZONE %d", i);
                  if(deal_tp > 0)
                    {
                     ObjectCreate(chart_id, tp_obj_name, OBJ_RECTANGLE, 0, deal_open_time, deal_open_price, deal_close_time, deal_tp);
                    }
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_COLOR, tp_zonez_color);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_STYLE, STYLE_SOLID);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_WIDTH, 1);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_FILL, tp_zonez_color);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_BACK, true);

                  // Display deal trend line
                  string line_obj_name = StringFormat("line %d", i);
                  ObjectCreate(chart_id, line_obj_name, OBJ_TREND, 0, deal_open_time, deal_open_price, deal_close_time, deal_close_price);
                  ObjectSetInteger(chart_id, line_obj_name, OBJPROP_COLOR, line_zonez_color);
                  ObjectSetInteger(chart_id, line_obj_name, OBJPROP_STYLE, STYLE_DASH);
                  ObjectSetInteger(chart_id, line_obj_name, OBJPROP_WIDTH, 2);


                 }
              }
           }
        }
     }

  }

Explicação:

Esta seção do código inicialmente avalia a variável show_history para verificar se a funcionalidade de exibição do histórico está habilitada. Se "sim" for selecionado, o código usa Comment("") para remover quaisquer comentários anteriores do gráfico, deixando apenas os dados mais recentes visíveis. O resultado é então armazenado na variável booleana deal_history. O método HistorySelect(date1, date2) é então usado para selecionar as operações históricas dentro do intervalo de datas fornecido. Podemos utilizar os dados históricos de negociação com essa seleção. Os dados de cada operação anterior são então armazenados em várias variáveis. Os preços de abertura e fechamento da operação são registrados em deal_close_price e deal_open_price. As variáveis "deal_sl" e "deal_tp" são usadas para registrar os valores de Take Profit e Stop Loss. As variáveis "deal_close_time" e "deal_open_time" documentam os períodos de fechamento e abertura da operação, bem como deal_profit, que registra o lucro ou prejuízo da negociação.

O código determina se há histórico de operações acessível. Se houver, ele inicia um loop que usa HistoryDealGetTicket(i) para recuperar o número do ticket de cada operação à medida que percorre todas as possíveis transações. Ele diferencia entre operações de entrada e de saída para cada ticket. Enquanto as transações de saída fornecem o preço de fechamento, lucro, stop loss e valores de take profit, as operações de entrada são utilizadas para registrar o preço de abertura e o horário. Esses detalhes são usados para gerar diversos elementos gráficos, como linhas de tendência que mostram o movimento de preço durante a transação, rótulos de texto que indicam lucro ou prejuízo e retângulos que representam as zonas de take-profit e stop-loss. Esse método garante que os dados históricos de negociação sejam exibidos na tela de forma eficiente, fornecendo insights importantes sobre o desempenho anterior.

Saída:

Conclusão

Neste artigo, exploramos o trabalho com objetos no MQL5, focando na construção e modificação de elementos gráficos para melhorar a análise de negociações. Cobrimos a criação de retângulos para zonas de take-profit e stop-loss, linhas de tendência para acompanhar mudanças de preço e rótulos de texto para dados importantes de negociação. Também examinamos como exibir operações anteriores usando rótulos e auxiliares visuais, oferecendo uma visão clara do desempenho histórico.