Desenvolvimento do Toolkit de Análise de Price Action (Parte 8): Painel de Métricas

MetaTrader 5 — Negociação | 16 dezembro 2025, 15:09

132

Christian Benjamin

Conteúdo:

Introdução

Nos estágios iniciais da nossa série, lançamos um artigo intitulado "Analytics Master," que explorou métodos para recuperar e visualizar as métricas de mercado do dia anterior. Esse trabalho fundamental preparou o terreno para o desenvolvimento de ferramentas mais sofisticadas. Temos o prazer de apresentar o Metrics Board EA, uma solução inovadora e de qualidade premium que revoluciona a análise de mercado no MetaTrader 5. Esta ferramenta funciona como um aplicativo perfeitamente integrado, oferecendo uma interface simplificada e intuitiva, equipada com botões dedicados para análises avançadas, incluindo:

Análise de Máxima/Mínima: Detecta facilmente níveis críticos de preço para avaliar tendências de mercado e identificar possíveis reversões.
Análise de Volume: Analisa os volumes negociados para avaliar o engajamento do mercado e as condições de liquidez.
Análise de Tendência: Avalia a força direcional e a sustentabilidade por meio de métricas precisas.
Análise de Volatilidade: Quantifica as flutuações do mercado para formular estratégias adaptadas a diferentes ambientes de negociação.
Análise de Médias Móveis: Monitora tendências dinâmicas de preço para uma compreensão mais clara do comportamento do mercado.
Análise de Suporte/Resistência: Identifique níveis-chave de preço para otimizar entradas, saídas e estratégias de gerenciamento de risco.

Cada botão oferece entrega de dados ao vivo com um simples clique, transformando instantaneamente dados complexos do mercado em insights acionáveis. O EA Painel de Métricas é alimentado por algoritmos avançados, garantindo cálculos rápidos e precisos que atendem às necessidades de traders profissionais. Ao utilizar esta ferramenta, os traders podem transformar dados complexos de mercado em insights diretos e acionáveis. Este EA serve como um recurso essencial para aqueles que buscam aprimorar suas estratégias de negociação.

Visão Geral do Sistema

Nesta seção, fornecerei uma breve visão geral da lógica do sistema. Uma explicação detalhada das etapas está na seção Análise do Código e Implementação. Vamos percorrer as etapas abaixo:

Configuração da Classe: A classe cria um diálogo com botões para diferentes análises.
Tratamento de Eventos: Os cliques nos botões acionam os respectivos métodos de análise.
Análise e Exibição: Os dados de mercado são processados e exibidos no painel.
Encerramento: Um botão "Fechar" permite que o usuário feche o painel de métricas.

As etapas acima descrevem os estágios que o nosso EA irá gerenciar para alcançar os resultados esperados. Cada estágio é cuidadosamente projetado para garantir uma execução precisa, cobrindo tudo desde a análise de mercado até a geração de insights acionáveis. Ao seguir esses estágios, o EA assegura um processo contínuo e eficiente. Vamos também consultar o diagrama abaixo para uma representação visual de todo o processo.

Resumo da Lógica do EA

Fig 1. Resumo da Lógica do EA

Código MQL5

//+------------------------------------------------------------------+
//|                                                Metrics Board.mql5|
//|                                Copyright 2025, Christian Benjamin|
//|                                              https://www.mql5.com|
//+------------------------------------------------------------------+
#property copyright "2025, MetaQuotes Software Corp."
#property link      "https://www.mql5.com/en/users/lynnchris"
#property version   "1.0"
#property strict

#include <Trade\Trade.mqh>
#include <Controls\Dialog.mqh>
#include <Controls\Button.mqh>
#include <Controls\Label.mqh>
#include <Controls\Panel.mqh>

// Metrics Board Class
class CMetricsBoard : public CAppDialog
  {
private:
   CButton           m_btnClose; // Close Button
   CButton           m_btnHighLowAnalysis;
   CButton           m_btnVolumeAnalysis;
   CButton           m_btnTrendAnalysis;
   CButton           m_btnVolatilityAnalysis;
   CButton           m_btnMovingAverage;
   CButton           m_btnSupportResistance;
   CPanel            m_panelResults;
   CLabel            m_lblResults;

public:
                     CMetricsBoard(void);
                    ~CMetricsBoard(void);
   virtual bool      Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2);
   virtual void      Minimize();
   virtual bool      Run(); // Declaration of Run method
   virtual bool      OnEvent(const int id, const long &lparam, const double &dparam, const string &sparam);
   virtual bool      ChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam);
   virtual void      Destroy(const int reason = REASON_PROGRAM); // Override Destroy method

private:
   bool              CreateButtons(void);
   bool              CreateResultsPanel(void);
   void              OnClickButtonClose(); // New close button handler
   void              PerformHighLowAnalysis(void);
   void              PerformVolumeAnalysis(void);
   void              PerformTrendAnalysis(void);
   void              PerformVolatilityAnalysis(void);
   void              PerformMovingAverageAnalysis(void);
   void              PerformSupportResistanceAnalysis(void);
   double            CalculateMovingAverage(int period);
  };

CMetricsBoard::CMetricsBoard(void) {}

CMetricsBoard::~CMetricsBoard(void) {}

// Override Destroy method
void CMetricsBoard::Destroy(const int reason)
  {
// Call base class Destroy method to release resources
   CAppDialog::Destroy(reason);
  }

//+------------------------------------------------------------------+
//| Create a control dialog                                          |
//+------------------------------------------------------------------+
bool CMetricsBoard::Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2)
  {
   if(!CAppDialog::Create(chart, name, subwin, x1, y1, x2, y2))
     {
      Print("Failed to create CAppDialog instance.");
      return false; // Failed to create the dialog
     }

   if(!CreateResultsPanel())
     {
      Print("Failed to create results panel.");
      return false; // Failed to create the results panel
     }

   if(!CreateButtons())
     {
      Print("Failed to create buttons.");
      return false; // Failed to create buttons
     }

   Show(); // Show the dialog after creation
   return true; // Successfully created the dialog
  }

//+------------------------------------------------------------------+
//| Minimize the control window                                      |
//+------------------------------------------------------------------+
void CMetricsBoard::Minimize()
  {
   CAppDialog::Minimize();
  }

//+------------------------------------------------------------------+
//| Run the control.                                                 |
//+------------------------------------------------------------------+
bool CMetricsBoard::Run()
  {
// Assuming Run makes the dialog functional
   if(!Show())
     {
      Print("Failed to show the control.");
      return false; // Could not show the control
     }
// Additional initialization or starting logic can be added here
   return true; // Successfully run the control
  }

//+------------------------------------------------------------------+
//| Create the results panel                                         |
//+------------------------------------------------------------------+
bool CMetricsBoard::CreateResultsPanel(void)
  {
   if(!m_panelResults.Create(0, "ResultsPanel", 0, 10, 10, 330, 60))
      return false;

   m_panelResults.Color(clrLightGray);
   Add(m_panelResults);

   if(!m_lblResults.Create(0, "ResultsLabel", 0, 15, 15, 315, 30))
      return false;

   m_lblResults.Text("Results will be displayed here.");
   m_lblResults.Color(clrBlack);
   m_lblResults.FontSize(12);
   Add(m_lblResults);

   return true;
  }

//+------------------------------------------------------------------+
//| Create buttons for the panel                                     |
//+------------------------------------------------------------------+
bool CMetricsBoard::CreateButtons(void)
  {
   int x = 20;
   int y = 80;
   int buttonWidth = 300;
   int buttonHeight = 30;
   int spacing = 15;

// Create Close Button
   if(!m_btnClose.Create(0, "CloseButton", 0, x, y, x + buttonWidth, y + buttonHeight))
      return false;

   m_btnClose.Text("Close Panel");
   Add(m_btnClose);
   y += buttonHeight + spacing;

   struct ButtonData
     {
      CButton        *button;
      string         name;
      string         text;
     };

   ButtonData buttons[] =
     {
        {&m_btnHighLowAnalysis, "HighLowButton", "High/Low Analysis"},
        {&m_btnVolumeAnalysis, "VolumeButton", "Volume Analysis"},
        {&m_btnTrendAnalysis, "TrendButton", "Trend Analysis"},
        {&m_btnVolatilityAnalysis, "VolatilityButton", "Volatility Analysis"},
        {&m_btnMovingAverage, "MovingAverageButton", "Moving Average"},
        {&m_btnSupportResistance, "SupportResistanceButton", "Support/Resistance"}
     };

   for(int i = 0; i < ArraySize(buttons); i++)
     {
      if(!buttons[i].button.Create(0, buttons[i].name, 0, x, y, x + buttonWidth, y + buttonHeight))
         return false;

      buttons[i].button.Text(buttons[i].text);
      Add(buttons[i].button);
      y += buttonHeight + spacing;
     }

   return true;
  }

//+------------------------------------------------------------------+
//| Handle events for button clicks                                  |
//+------------------------------------------------------------------+
bool CMetricsBoard::OnEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
  {
   if(id == CHARTEVENT_OBJECT_CLICK)
     {
      Print("Event ID: ", id, ", Event parameter (sparam): ", sparam);

      if(sparam == "CloseButton") // Handle close button click
        {
         OnClickButtonClose(); // Call to new close button handler
         return true; // Event processed
        }
      else
         if(sparam == "HighLowButton")
           {
            Print("High/Low Analysis Button Clicked");
            m_lblResults.Text("Performing High/Low Analysis...");
            PerformHighLowAnalysis();
            return true; // Event processed
           }
         else
            if(sparam == "VolumeButton")
              {
               Print("Volume Analysis Button Clicked");
               m_lblResults.Text("Performing Volume Analysis...");
               PerformVolumeAnalysis();
               return true; // Event processed
              }
            else
               if(sparam == "TrendButton")
                 {
                  Print("Trend Analysis Button Clicked");
                  m_lblResults.Text("Performing Trend Analysis...");
                  PerformTrendAnalysis();
                  return true; // Event processed
                 }
               else
                  if(sparam == "VolatilityButton")
                    {
                     Print("Volatility Analysis Button Clicked");
                     m_lblResults.Text("Performing Volatility Analysis...");
                     PerformVolatilityAnalysis();
                     return true; // Event processed
                    }
                  else
                     if(sparam == "MovingAverageButton")
                       {
                        Print("Moving Average Analysis Button Clicked");
                        m_lblResults.Text("Calculating Moving Average...");
                        PerformMovingAverageAnalysis();
                        return true; // Event processed
                       }
                     else
                        if(sparam == "SupportResistanceButton")
                          {
                           Print("Support/Resistance Analysis Button Clicked");
                           m_lblResults.Text("Calculating Support/Resistance...");
                           PerformSupportResistanceAnalysis();
                           return true; // Event processed
                          }
     }

   return false; // If we reach here, the event was not processed
  }

//+------------------------------------------------------------------+
//| Handle chart events                                              |
//+------------------------------------------------------------------+
bool CMetricsBoard::ChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
  {
   Print("ChartEvent ID: ", id, ", lparam: ", lparam, ", dparam: ", dparam, ", sparam: ", sparam);

   if(id == CHARTEVENT_OBJECT_CLICK)
     {
      return OnEvent(id, lparam, dparam, sparam);
     }

   return false;
  }

//+------------------------------------------------------------------+
//| Analysis operations                                              |
//+------------------------------------------------------------------+
void CMetricsBoard::PerformHighLowAnalysis(void)
  {
   double high = iHigh(Symbol(), PERIOD_H1, 0);
   double low = iLow(Symbol(), PERIOD_H1, 0);

   Print("Retrieved High: ", high, ", Low: ", low);

   if(high == 0 || low == 0)
     {
      m_lblResults.Text("Failed to retrieve high/low values.");
      return;
     }

   string result = StringFormat("High: %.5f, Low: %.5f", high, low);
   m_lblResults.Text(result);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMetricsBoard::PerformVolumeAnalysis(void)
  {
   double volume = iVolume(Symbol(), PERIOD_H1, 0);
   Print("Retrieved Volume: ", volume);

   if(volume < 0)
     {
      m_lblResults.Text("Failed to retrieve volume.");
      return;
     }

   string result = StringFormat("Volume (Last Hour): %.1f", volume);
   m_lblResults.Text(result);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMetricsBoard::PerformTrendAnalysis(void)
  {
   double ma = CalculateMovingAverage(14);
   Print("Calculated 14-period MA: ", ma);

   if(ma <= 0)
     {
      m_lblResults.Text("Not enough data for moving average calculation.");
      return;
     }

   string result = StringFormat("14-period MA: %.5f", ma);
   m_lblResults.Text(result);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMetricsBoard::PerformVolatilityAnalysis(void)
  {
   int atr_period = 14;
   int atr_handle = iATR(Symbol(), PERIOD_H1, atr_period);

   if(atr_handle == INVALID_HANDLE)
     {
      m_lblResults.Text("Failed to get ATR handle.");
      return;
     }

   double atr_value[];
   if(CopyBuffer(atr_handle, 0, 0, 1, atr_value) < 0)
     {
      m_lblResults.Text("Failed to copy ATR value.");
      IndicatorRelease(atr_handle);
      return;
     }

   string result = StringFormat("ATR (14): %.5f", atr_value[0]);
   m_lblResults.Text(result);
   IndicatorRelease(atr_handle);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMetricsBoard::PerformMovingAverageAnalysis(void)
  {
   double ma = CalculateMovingAverage(50);
   Print("Calculated 50-period MA: ", ma);

   if(ma <= 0)
     {
      m_lblResults.Text("Not enough data for moving average calculation.");
      return;
     }

   string result = StringFormat("50-period MA: %.5f", ma);
   m_lblResults.Text(result);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CMetricsBoard::PerformSupportResistanceAnalysis(void)
  {
   double support = iLow(Symbol(), PERIOD_H1, 1);
   double resistance = iHigh(Symbol(), PERIOD_H1, 1);
   Print("Retrieved Support: ", support, ", Resistance: ", resistance);

   if(support == 0 || resistance == 0)
     {
      m_lblResults.Text("Failed to retrieve support/resistance levels.");
      return;
     }

   string result = StringFormat("Support: %.5f, Resistance: %.5f", support, resistance);
   m_lblResults.Text(result);
  }

//+------------------------------------------------------------------+
//| Calculate moving average                                         |
//+------------------------------------------------------------------+
double CMetricsBoard::CalculateMovingAverage(int period)
  {
   if(period <= 0)
      return 0;

   double sum = 0.0;
   int bars = Bars(Symbol(), PERIOD_H1);

   if(bars < period)
     {
      return 0;
     }

   for(int i = 0; i < period; i++)
     {
      sum += iClose(Symbol(), PERIOD_H1, i);
     }
   return sum / period;
  }

// Implementation of OnClickButtonClose
void CMetricsBoard::OnClickButtonClose()
  {
   Print("Close button clicked. Closing the Metrics Board...");
   Destroy();  // This method destroys the panel
  }

CMetricsBoard ExtDialog;

//+------------------------------------------------------------------+
//| Initialize the application                                       |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(!ExtDialog.Create(0, "Metrics Board", 0, 10, 10, 350, 500))
     {
      Print("Failed to create Metrics Board.");
      return INIT_FAILED;
     }

   if(!ExtDialog.Run()) // Call Run to make the dialog functional
     {
      Print("Failed to run Metrics Board.");
      return INIT_FAILED; // Call to Run failed
     }

   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Deinitialize the application                                     |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ExtDialog.Destroy(reason); // Properly call Destroy method
  }

//+------------------------------------------------------------------+
//| Handle chart events                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
  {
   ExtDialog.ChartEvent(id, lparam, dparam, sparam);
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+

Análise do Código e Implementação

Cabeçalho e Metadados

A primeira parte do código é a seção de cabeçalho e metadados. Esta seção fornece informações básicas sobre o script, incluindo detalhes de direitos autorais, links, versionamento e regras de compilação estrita.

//+------------------------------------------------------------------+
//|                                                Metrics Board.mql5|
//|                                Copyright 2025, Christian Benjamin|
//|                                              https://www.mql5.com|
//+------------------------------------------------------------------+
#property copyright "2025, MetaQuotes Software Corp."
#property link      "https://www.mql5.com/en/users/lynnchris"
#property version   "1.0"
#property strict

O bloco de comentários delimita o propósito do script e atribui os créditos, o que é essencial para identificar a autoria e garantir a devida atribuição para usuários futuros. As diretivas #property servem para definir várias características do script, como informações de direitos autorais, um link para o autor ou documentação, o número da versão e a configuração do modo estrito, que ajuda a identificar possíveis problemas durante a compilação.

Inclusão das Bibliotecas Necessárias

Em seguida, incluímos as bibliotecas necessárias para a nossa aplicação. Essas bibliotecas fornecem funcionalidades pré-definidas que simplificam a codificação.

#include <Trade\Trade.mqh>
#include <Controls\Dialog.mqh>
#include <Controls\Button.mqh>
#include <Controls\Label.mqh>
#include <Controls\Panel.mqh>

Aqui, incorporamos as bibliotecas relacionadas às operações de trade e aos controles da interface do usuário. Por exemplo, Trade.mqh é vital para executar funções de negociação, enquanto Dialog.mqh, Button.mqh, Label.mqh, e Panel.mqh são usadas para criar e gerenciar os componentes da interface do usuário do Painel de Métricas.

Definição da Classe

Após a inclusão das bibliotecas, definimos a classe principal do Painel de Métricas. A classe CMetricsBoard herda de CAppDialog, permitindo-nos utilizar funcionalidades de diálogo. Declaramos várias variáveis membro privadas, principalmente botões e painéis, que serão usados para interagir com a aplicação. Cada botão corresponde a uma função de análise, e os resultados serão exibidos em um painel denominado m_panelResults.

class CMetricsBoard : public CAppDialog
{
private:
   CButton           m_btnClose; 
   CButton           m_btnHighLowAnalysis;
   CButton           m_btnVolumeAnalysis;
   CButton           m_btnTrendAnalysis;
   CButton           m_btnVolatilityAnalysis;
   CButton           m_btnMovingAverage;
   CButton           m_btnSupportResistance;
   CPanel            m_panelResults;
   CLabel            m_lblResults;

A classe também inclui um construtor e um destrutor.

public:
                     CMetricsBoard(void);
                    ~CMetricsBoard(void);

CMetricsBoard::CMetricsBoard(void) {}

CMetricsBoard::~CMetricsBoard(void) {}

O construtor inicializa a classe, e o destruidor é definido (embora vazio neste caso) para garantir que qualquer limpeza necessária ocorra quando uma instância do CMetricsBoard for destruída. Isso é essencial para gerenciar recursos de forma eficiente.

Criando o Diálogo

O método Create é responsável por construir o diálogo de controle completo. Neste método, primeiro tentamos criar o diálogo através da classe base (CAppDialog::Create). Se falhar, registramos um erro e retornamos falso. Em seguida, criamos um painel de resultados e botões, novamente verificando possíveis falhas. Finalmente, se todas as etapas forem bem-sucedidas, exibimos o diálogo e retornamos verdadeiro.

bool CMetricsBoard::Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2)
{
   if(!CAppDialog::Create(chart, name, subwin, x1, y1, x2, y2))
   {
      Print("Failed to create CAppDialog instance.");
      return false; 
   }

   if(!CreateResultsPanel())
   {
      Print("Failed to create results panel.");
      return false; 
   }

   if(!CreateButtons())
   {
      Print("Failed to create buttons.");
      return false; 
   }

   Show(); 
   return true; 
}

Agora, o diálogo Run aparece. O método Run é essencial para tornar o diálogo funcional.

bool CMetricsBoard::Run()
{
   if(!Show())
   {
      Print("Failed to show the control.");
      return false; 
   }
   return true; 
}

Aqui, exibimos o diálogo usando o método Show. Se a exibição do diálogo falhar, uma mensagem de erro é impressa, retornando falso.

Criando o Painel de Resultados

O método CreateResultsPanel constrói o painel onde os resultados da análise serão exibidos. Inicialmente, criamos o painel de resultados e definimos suas propriedades, como cor e dimensões. Subsequentemente, adicionamos este painel ao diálogo. Também criamos um rótulo dentro do painel para exibir os resultados e personalizamos sua aparência antes de adicioná-lo ao painel. Este método retorna verdadeiro quando a criação for bem-sucedida.

bool CMetricsBoard::CreateResultsPanel(void)
{
   if(!m_panelResults.Create(0, "ResultsPanel", 0, 10, 10, 330, 60))
      return false;

   m_panelResults.Color(clrLightGray);
   Add(m_panelResults);

   if(!m_lblResults.Create(0, "ResultsLabel", 0, 15, 15, 315, 30))
      return false;

   m_lblResults.Text("Results will be displayed here.");
   m_lblResults.Color(clrBlack);
   m_lblResults.FontSize(12);
   Add(m_lblResults);

   return true;
}

Criando Botões

O método CreateButtons é responsável por inicializar os botões interativos no diálogo.

bool CMetricsBoard::CreateButtons(void)
{
   int x = 20;
   int y = 80;
   int buttonWidth = 300;
   int buttonHeight = 30;
   int spacing = 15;

   if(!m_btnClose.Create(0, "CloseButton", 0, x, y, x + buttonWidth, y + buttonHeight))
      return false;

   m_btnClose.Text("Close Panel");
   Add(m_btnClose);
   y += buttonHeight + spacing;

   struct ButtonData
   {
      CButton        *button;
      string         name;
      string         text;
   };

   ButtonData buttons[] =
   {
      {&m_btnHighLowAnalysis, "HighLowButton", "High/Low Analysis"},
      {&m_btnVolumeAnalysis, "VolumeButton", "Volume Analysis"},
      {&m_btnTrendAnalysis, "TrendButton", "Trend Analysis"},
      {&m_btnVolatilityAnalysis, "VolatilityButton", "Volatility Analysis"},
      {&m_btnMovingAverage, "MovingAverageButton", "Moving Average"},
      {&m_btnSupportResistance, "SupportResistanceButton", "Support/Resistance"}
   };

   for(int i = 0; i < ArraySize(buttons); i++)
   {
      if(!buttons[i].button.Create(0, buttons[i].name, 0, x, y, x + buttonWidth, y + buttonHeight))
         return false;

      buttons[i].button.Text(buttons[i].text);
      Add(buttons[i].button);
      y += buttonHeight + spacing;
   }

   return true;
}

Nesta implementação, definimos coordenadas iniciais, dimensões e espaçamento para nossos botões. Criamos cada botão, primeiro para fechar o painel, adicionando-o ao diálogo. Em seguida, usamos um array de estruturas ButtonData, o que nos permite percorrer efetivamente as definições dos botões. Cada botão é configurado com o texto correspondente e adicionado ao diálogo. O método conclui retornando verdadeiro se todos os botões forem criados com sucesso.

Tratamento de Eventos

1. Cliques nos Botões

O método OnEvent processa os eventos gerados pela interação do usuário, como cliques nos botões.

bool CMetricsBoard::OnEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
   if(id == CHARTEVENT_OBJECT_CLICK)
   {
      Print("Event ID: ", id, ", Event parameter (sparam): ", sparam);

      if(sparam == "CloseButton") 
      {
         OnClickButtonClose(); 
         return true; 
      }
      // ... Handling for other button clicks
   }

   return false; 
}

Quando um evento ocorre, verificamos primeiro se é um evento de clique em um botão. Imprimimos os detalhes do evento para fins de depuração e reagimos a cliques específicos nos botões chamando as funções de tratamento correspondentes. Se o botão clicado for o botão de fechar, invocamos o método OnClickButtonClose().

2. Eventos do Gráfico

O método ChartEvent tem um propósito similar, mas foca especificamente nos eventos relacionados ao gráfico.

bool CMetricsBoard::ChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
   Print("ChartEvent ID: ", id, ", lparam: ", lparam, ", dparam: ", dparam, ", sparam: ", sparam);

   if(id == CHARTEVENT_OBJECT_CLICK)
   {
      return OnEvent(id, lparam, dparam, sparam);
   }

   return false;
}

Este método captura quaisquer cliques em objetos do gráfico e passa o evento para o método OnEvent para processamento posterior.

Operações de Análise

Os seguintes métodos implementam os diferentes tipos de análise de mercado que nosso Painel de Métricas pode realizar. Por exemplo, o método PerformHighLowAnalysis recupera os preços altos e baixos para um período definido:

void CMetricsBoard::PerformHighLowAnalysis(void)
{
   double high = iHigh(Symbol(), PERIOD_H1, 0);
   double low = iLow(Symbol(), PERIOD_H1, 0);

   Print("Retrieved High: ", high, ", Low: ", low);

   if(high == 0 || low == 0)
   {
      m_lblResults.Text("Failed to retrieve high/low values.");
      return;
   }

   string result = StringFormat("High: %.5f, Low: %.5f", high, low);
   m_lblResults.Text(result);
}

Neste método, usamos funções integradas para recuperar os preços mais altos e mais baixos da última hora. Se for bem-sucedido, os resultados são exibidos no rótulo. Caso contrário, uma mensagem de erro é mostrada.

Uma lógica similar é aplicada a outras funções de análise, como PerformVolumeAnalysis, PerformTrendAnalysis, PerformVolatilityAnalysis, PerformMovingAverageAnalysis, e PerformSupportResistanceAnalysis. Cada método recupera dados específicos para seu tipo de análise e atualiza a interface do usuário de acordo.

Calcular Média Móvel

Um dos métodos utilitários incluídos é CalculateMovingAverage, que calcula a média móvel sobre um período especificado. Este método soma os preços de fechamento ao longo do período especificado e divide por esse número para determinar a média. Ele verifica a validade da entrada e a quantidade de dados antes de realizar o cálculo.

double CMetricsBoard::CalculateMovingAverage(int period)
{
   if(period <= 0)
      return 0;

   double sum = 0.0;
   int bars = Bars(Symbol(), PERIOD_H1);

   if(bars < period)
   {
      return 0;
   }

   for(int i = 0; i < period; i++)
   {
      sum += iClose(Symbol(), PERIOD_H1, i);
   }
   return sum / period;
}

Instância Global e Inicialização

Uma instância da classe CMetricsBoard é criada globalmente, seguida pelos processos de inicialização e desinicialização para a aplicação.

CMetricsBoard ExtDialog;

int OnInit()
{
   if(!ExtDialog.Create(0, "Metrics Board", 0, 10, 10, 350, 500))
   {
      Print("Failed to create Metrics Board.");
      return INIT_FAILED;
   }

   if(!ExtDialog.Run())
   {
      Print("Failed to run Metrics Board.");
      return INIT_FAILED;
   }

   return INIT_SUCCEEDED;
}

Na função OnInit, inicializamos o Painel de Métricas chamando o método Create. Se for bem-sucedido, prosseguimos para executá-lo. Erros são registrados conforme necessário, com a função indicando sucesso ou falha.

O processo de desinicialização garante que os recursos sejam liberados corretamente quando o EA for removido.

void OnDeinit(const int reason)
{
   ExtDialog.Destroy(reason); // Properly call Destroy method
}

Tratamento de Eventos do Gráfico

Finalmente, definimos a função OnChartEvent para gerenciar eventos relacionados ao gráfico. Isso integra interações do usuário diretamente à funcionalidade da aplicação. Este método captura eventos do gráfico e os passa para o método ChartEvent da nossa instância CMetricsBoard.

void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
   ExtDialog.ChartEvent(id, lparam, dparam, sparam);
}

Incluindo Bibliotecas

Se você compilar seu código sem incluir as bibliotecas mencionadas na seção anterior, poderá encontrar erros. Para resolver isso, abra o MetaEditor e navegue até o painel Navigator. Role para baixo até a seção 'Include', onde você pode acessar as bibliotecas necessárias. Abra as subpastas necessárias, selecione os arquivos relevantes e compile-os individualmente. Certifique-se de que as bibliotecas estejam corretamente referenciadas no seu código usando a diretiva #include no início do seu script. Este passo garante que todas as dependências sejam carregadas corretamente, evitando potenciais erros de compilação. O GIF abaixo ilustra como acessar e incluir bibliotecas no MetaEditor.

Incluindo Bibliotecas

Fig 2. Incluindo Bibliotecas

No MQL5, uma biblioteca incluída permite integrar código, funções ou classes externas ao seu programa, ampliando sua funcionalidade e possibilitando a reutilização de código de várias fontes. Ao incluir uma biblioteca, você ganha acesso às funções, classes ou variáveis definidas dentro dela, tornando-as disponíveis para uso no seu script, especialista (EA) ou indicador. A maioria das bibliotecas no MQL5 são integradas, oferecendo soluções prontas para tarefas comuns como funções de negociação, indicadores técnicos e mais.

Resultados

Após compilar o EA com sucesso, agora você pode acessar o MetaTrader 5 e anexar o EA a um gráfico. Vamos revisar os resultados que obtivemos durante os testes.

RESULTADOS

Fig 3. Resultados

De acordo com o diagrama acima, é evidente que o Metrics Board EA oferece funcionalidade ideal, respondendo de forma eficaz a cada acionamento de botão. Essa capacidade garante que o EA forneça as métricas necessárias em tempo real, aprimorando a interação do usuário e o desempenho.

Registro do EA

Também podemos revisar o log de Experts no MetaTrader 5 para observar a interação entre os botões pressionados e os eventos exibidos no gráfico. Como nosso EA inclui uma função de registro integrada, ele capturará essas interações. Vamos dar uma olhada nas informações registradas e analisar o que foi gravado.

REGISTRO DE EXPERTS

Fig 4. Registro de Experts

Conclusão

O Metrics Board EA apresenta um painel dinâmico e fácil de usar, incorporado diretamente ao MetaTrader 5, integrando a função de objeto de desenho. Sua integração suave transmite a impressão de estar trabalhando com controles nativos do MetaTrader 5, oferecendo uma experiência comparável ao uso de um aplicativo integrado. Na minha visão, ele representa um avanço significativo nas ferramentas de trading, entregando funcionalidade e facilidade de uso que superam as capacidades de alguns scripts analíticos que desenvolvi anteriormente. Ao permitir que os usuários se concentrem em informações específicas com um único clique de botão, ele garante que apenas os dados necessários sejam exibidos, otimizando o processo de análise. Embora esses scripts anteriores tenham cumprido seus propósitos de forma eficaz, o Metrics Board EA eleva a análise de mercado a um nível superior de eficiência e acessibilidade.

Os principais recursos do Metrics Board EA incluem:

Recurso	Vantagem
Análise de Máxima/Mínima	Identifica rapidamente níveis significativos do mercado para auxiliar os traders.
Rastreamento de Volume	Fornece atualizações em tempo real sobre o volume negociado para um melhor contexto de mercado.
Identificação de Tendência	Simplifica o processo de reconhecimento das tendências atuais do mercado.
Níveis de suporte/resistência	Identifica com precisão zonas de preço cruciais para negociações estratégicas.

Esta ferramenta capacita os traders a analisar os mercados de forma eficaz e tomar melhores decisões. Seu design direto simplifica análises complexas, permitindo que os usuários se concentrem no aprimoramento de suas estratégias. Olhando para o futuro, há potencial para expandir suas capacidades com a adição de novos recursos e o aprimoramento adicional da interface.

Data	Nome da Ferramenta	Descrição	Versão	Atualizações	Notas
01/10/24	Projetor de Gráficos	Script para sobrepor a ação de preço do dia anterior com efeito fantasma.	1.0	Lançamento Inicial	A primeira ferramenta do Lynnchris Tools Chest
18/11/24	Comentário Analítico	Fornece informações do dia anterior em formato tabular, além de antecipar a direção futura do mercado.	1.0	Lançamento Inicial	Segunda ferramenta no Lynnchris Tool Chest
27/11/24	Mestre em Análise	Atualização Regular das métricas de mercado a cada duas horas	1.01	Segundo Lançamento	Terceira ferramenta no Lynnchris Tool Chest
02/12/24	Previsor Analítico	Atualização regular das métricas de mercado a cada duas horas com integração ao Telegram	1.1	Terceira Edição	Ferramenta número 4
09/12/24	Navegador de Volatilidade	O EA analisa as condições de mercado usando os indicadores Bandas de Bollinger, RSI e ATR	1.0	Lançamento Inicial	Ferramenta número 5
19/12/24	Reversão à Média Ceifador de Sinal	Analisa o mercado usando a estratégia de reversão à média e fornece sinais.	1.0	Lançamento Inicial	Ferramenta número 6
9/01/2025	Pulso de sinal	Analisador de múltiplos timeframes	1.0	Lançamento Inicial	Ferramenta número 7
17/01/2025	Quadro de Métricas	Painel com botão para análise	1.0	Lançamento Inicial	Ferramenta número 8

Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/16584

Arquivos anexados |

Baixar como ZIP

Metrics_Board.mq5 (15.92 KB)

Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.

Esse artigo foi escrito por um usuário do site e reflete seu ponto de vista pessoal. A MetaQuotes Ltd. não se responsabiliza pela precisão das informações apresentadas nem pelas possíveis consequências decorrentes do uso das soluções, estratégias ou recomendações descritas.

Outros artigos do autor

Ir para discussão

Trading de arbitragem no Forex: sistema de negociação matricial para retorno ao valor justo com limitação de risco

O artigo contém uma descrição detalhada do algoritmo de cálculo de taxas cruzadas, a visualização da matriz de desequilíbrios e recomendações para a configuração ideal dos parâmetros MinDiscrepancy e MaxRisk para uma negociação eficiente. O sistema calcula automaticamente o "valor justo" de cada par de moedas por meio de taxas cruzadas, gerando sinais de compra em desvios negativos e de venda em desvios positivos.

Introdução ao MQL5 (Parte 11): Um guia para iniciantes sobre como trabalhar com indicadores incorporados no MQL5 (II)

Descubra como desenvolver um Expert Advisor (EA) em MQL5 usando múltiplos indicadores como RSI, MA e Oscilador Estocástico para detectar divergências ocultas de alta e de baixa. Aprenda a implementar um gerenciamento de risco eficaz e a automatizar negociações com exemplos detalhados e código-fonte totalmente comentado para fins educacionais!

Algoritmo de otimização caótica — Chaos optimization algorithm (COA): Continuação

Continuação do estudo do algoritmo de otimização caótica. A segunda parte do artigo é dedicada aos aspectos práticos da implementação do algoritmo, ao seu teste e às conclusões.

Visão computacional para trading (Parte 1): Criando uma funcionalidade básica simples

Sistema de previsão do EURUSD usando visão computacional e aprendizado profundo. Descubra como redes neurais convolucionais podem reconhecer padrões complexos de preços no mercado cambial e prever o movimento da cotação com precisão de até 54%. O artigo revela a metodologia de criação de um algoritmo que utiliza tecnologias de inteligência artificial para análise visual de gráficos, em vez de indicadores técnicos tradicionais. O autor demonstra o processo de transformação dos dados de preços em "imagens", seu processamento por uma rede neural e a oportunidade única de olhar para a "consciência" da IA por meio de mapas de ativação e mapas de calor de atenção. O código prático em Python, com a utilização da biblioteca MetaTrader 5, possibilita que os leitores reproduzam o sistema e o apliquem em seu próprio trading.