Do iniciante ao especialista: Criando um EA animado para negociação baseada em notícias em MQL5 (X) - Visualização de múltiplos símbolos em um único gráfico para negociação baseada em notícias
Sumário:
Introdução
No artigo anterior, apresentamos uma funcionalidade de gerenciamento de múltiplos símbolos que permite aos traders selecionar rapidamente seus pares de negociação preferidos. Isso reduziu o tempo gasto alternando entre gráficos apenas para configurar o par com o qual desejam operar.
No entanto, ainda havia uma limitação: embora os traders pudessem gerenciar os pares selecionados, não tinham acesso direto às interfaces gráficas correspondentes a esses pares e, portanto, não conseguiam acompanhar facilmente os movimentos dos preços para realizar suas análises. Para resolver essa questão, hoje vamos aprimorar nossa solução de negociação com múltiplos símbolos, desenvolvendo uma classe específica para a visualização de vários gráficos. Essa funcionalidade poderá ser controlada diretamente no gráfico principal e será integrada ao conjunto mais amplo de recursos do News Headline EA.
Se você perdeu o fio da meada, aqui está um breve resumo do que desenvolvemos até agora. Para compreender melhor a evolução do projeto, também recomendo consultar nossos artigos anteriores sobre o tema.
A primeira versão do News Headline EA tinha como foco a exibição de eventos programados do calendário econômico em faixas bem definidas no gráfico, organizadas de acordo com seu nível de importância. O conceito de "faixas" evoluiu rapidamente: integramos a API de notícias da Alpha Vantage, incorporamos análises geradas por modelos de IA hospedados localmente e criamos faixas para exibir dados analíticos incorporados, baseados em indicadores. A partir dessa estrutura, implementamos funcionalidades de negociação automatizada baseada em notícias, incluindo recursos específicos para operar durante a divulgação do NFP (relatório de empregos não agrícolas), além de integrar botões para negociação manual.
Mais recentemente, avançamos para a negociação com múltiplos símbolos, desenvolvida para facilitar a tomada rápida de decisões durante eventos de alta volatilidade. Essa funcionalidade simplificou significativamente o gerenciamento e a negociação de vários pares em condições de mercado que mudam rapidamente.
Hoje, vamos aperfeiçoar essa abordagem de negociação com múltiplos símbolos, permitindo que os traders visualizem vários gráficos em tempo real diretamente no EA.
Estratégia de implementação
Uma das nossas principais prioridades é apresentar o conteúdo de forma que até mesmo leitores iniciantes consigam compreender os conceitos fundamentais com facilidade e clareza. Nesta seção, vamos examinar a abordagem que adotaremos e como será implementada.
À medida que nosso programa se torna mais complexo, é importante adotar uma abordagem estruturada que facilite a integração de novas funcionalidades e a manutenção do código. Um dos meus métodos preferidos é a modularidade, que simplifica o desenvolvimento e permite criar componentes reutilizáveis por meio de arquivos de cabeçalho e classes.
Para um programa complexo como o News Headline EA, sigo uma sequência de desenvolvimento bem definida:
- Comece criando um pequeno programa independente para testar a nova funcionalidade.
- Depois que a funcionalidade estiver implementada e funcionando de forma estável, integre-a ao EA principal.
Essa abordagem permite concentrar os esforços em cada etapa, reduz a ocorrência de erros e facilita a incorporação de novas funcionalidades sem comprometer as existentes.
Nossa tarefa de desenvolvimento de hoje consiste em criar a classe CChartMiniTiles, responsável por exibir vários gráficos de diferentes símbolos dentro de um único gráfico principal, cada um com dimensões configuráveis. Em seguida, vamos implementar essa classe em um EA de teste (MiniChartsEA) para validar o conceito. Depois de confirmar seu funcionamento, integraremos a classe ao News Headline EA e faremos os ajustes necessários para garantir que funcione corretamente em conjunto com os demais recursos.
Vale observar que nomes como CChartMiniTiles e MiniChartsEA são apenas identificadores de exemplo que escolhi para este tutorial passo a passo. Você pode utilizar outros nomes, desde que compreenda o funcionamento do programa.
Nas próximas quatro subseções, vamos abordar as seguintes etapas de implementação:
- Arquivo de cabeçalho ChartMiniTiles
- EA de exemplo (MiniChartsEA) para testar o arquivo de cabeçalho
- Testes iniciais
- Integração de ChartsMiniTiles ao News Headline EA
1.0 Arquivo de cabeçalho ChartMiniTiles
Este arquivo de cabeçalho define a classe CChartMiniTiles, uma classe utilitária reutilizável desenvolvida para exibir e gerenciar vários minigráficos dentro de um único gráfico no MetaTrader 5. O objetivo da classe é facilitar a integração de gráficos de múltiplos símbolos em projetos maiores, como o News Headline EA, preservando a modularidade do código e facilitando sua manutenção.
Ao separar essa funcionalidade em um arquivo de cabeçalho próprio, podemos testá-la de forma independente, por exemplo, utilizando um EA de teste, para depois integrá-la com facilidade a sistemas mais complexos. Essa abordagem torna o desenvolvimento mais eficiente e reduz a probabilidade de erros durante o desenvolvimento.
Nas próximas seções, vamos dividir o desenvolvimento do código em etapas numeradas, cada uma dedicada a um aspecto específico da estrutura e das funcionalidades do programa.
1.1. Visão geral e finalidade da classe
Este bloco inicial documenta a finalidade do arquivo de cabeçalho e define os valores padrão estabelecidos em tempo de compilação, utilizados em toda a classe. O uso de macros centraliza as configurações padrão de layout, temporização e opções padrão de ativação e desativação, permitindo que os desenvolvedores ajustem rapidamente o comportamento da classe sem precisar examinar os detalhes da implementação. O comentário de cabeçalho apresenta as principais funcionalidades: um mosaico de minigráficos ancorado à parte inferior do gráfico, criados com OBJ_CHART; resolução automática dos nomes dos símbolos para diferentes corretoras; um botão para controlar rapidamente a visibilidade dos minigráficos; cálculo adaptativo do layout; e a possibilidade de reservar uma área superior para evitar sobreposições com outros elementos da interface do usuário. Esta seção apresenta a estrutura geral da classe e sua finalidade.
//+------------------------------------------------------------------+ //| ChartMiniTilesClass.mqh | //| Class wrapper for ChartMiniTiles functionality | //| - CChartMiniTiles class | //| - bottom-anchored mini-chart tiles using OBJ_CHART | //| - broker-adaptive symbol lookup, toggle button, responsive layout | //| - supports top-reserved area to avoid overlapping top UI | //+------------------------------------------------------------------+ #ifndef __CHART_MINI_TILES_CLASS_MQH__ #define __CHART_MINI_TILES_CLASS_MQH__ //--- compile-time defaults (macros are safe in MQL5) #define CMT_DEFAULT_WIDTH 120 #define CMT_DEFAULT_HEIGHT 112 // quadrupled default #define CMT_DEFAULT_X_OFFSET 10 #define CMT_DEFAULT_Y_OFFSET 40 // bottom offset from bottom #define CMT_DEFAULT_SPACING 6 #define CMT_DEFAULT_PERIOD PERIOD_M1 #define CMT_DEFAULT_CHART_SCALE 2 // toggle button defaults #define CMT_TOG_X 8 #define CMT_TOG_Y 6 #define CMT_TOG_W 72 #define CMT_TOG_H 20 #define CMT_TOG_NAME "CMT_ToggleButton"
1.2. Construtor e destrutor
O construtor inicializa a classe em um estado conhecido e seguro, utilizando os valores padrão definidos em tempo de compilação. Ele prepara os arrays internos, configura as dimensões e os deslocamentos padrão dos blocos de minigráficos, define as configurações do botão de alternância e inicializa m_top_reserved com zero, indicando que, por padrão, nenhuma área superior está reservada. O destrutor chama Delete() para garantir que todos os objetos criados pela classe sejam removidos quando a instância sair do escopo. Essa inicialização e limpeza determinísticas evitam que objetos residuais permaneçam no gráfico e facilitam a depuração.
//+------------------------------------------------------------------+ //| CChartMiniTiles class declaration | //+------------------------------------------------------------------+ class CChartMiniTiles { public: CChartMiniTiles(void); ~CChartMiniTiles(void); bool Init(const string majorSymbols, const int width = -1, const int height = -1, const int xOffset = -1, const int yOffset = -1, // bottom offset (pixels from bottom) const int spacing = -1, const int period = -1, const bool dateScale = true, const bool priceScale = false, const int chartScale = -1); void UpdateLayout(void); void Delete(void); bool HandleEvent(const int id,const string sparam); // forward OnChartEvent void SetToggleButtonPos(const int x,const int y); void SetTilesVisible(const bool visible); void Toggle(void); // NEW: reserve top area height (pixels from top) that tiles must NOT cover void SetTopReservedHeight(const int pixels); private: // state string m_object_names[]; // object names created string m_symbols[]; // resolved broker symbols int m_count; int m_width; int m_height; int m_xoffset; int m_yoffset; // bottom offset int m_spacing; int m_period; bool m_date_scale; bool m_price_scale; int m_chart_scale; bool m_visible; int m_tog_x; int m_tog_y; int m_tog_w; int m_tog_h; string m_tog_name; // NEW int m_top_reserved; // pixels from top that must be left free for other UI private: // helpers string MakeObjectName(const string base); string TrimString(const string s); string FindBrokerSymbol(const string baseSymbol); int ComputeBaseYFromTop(void); void CreateToggleButton(void); void DeleteToggleButton(void); void CollapseAll(void); }; //+------------------------------------------------------------------+ //| Constructor / Destructor | //+------------------------------------------------------------------+ CChartMiniTiles::CChartMiniTiles(void) { m_count = 0; ArrayResize(m_object_names,0); ArrayResize(m_symbols,0); m_width = CMT_DEFAULT_WIDTH; m_height = CMT_DEFAULT_HEIGHT; m_xoffset = CMT_DEFAULT_X_OFFSET; m_yoffset = CMT_DEFAULT_Y_OFFSET; m_spacing = CMT_DEFAULT_SPACING; m_period = CMT_DEFAULT_PERIOD; m_date_scale = false; m_price_scale = false; m_chart_scale = CMT_DEFAULT_CHART_SCALE; m_visible = true; m_tog_x = CMT_TOG_X; m_tog_y = CMT_TOG_Y; m_tog_w = CMT_TOG_W; m_tog_h = CMT_TOG_H; m_tog_name = CMT_TOG_NAME; m_top_reserved = 0; // default: no reserved area } CChartMiniTiles::~CChartMiniTiles(void) { Delete(); }
1.3. Métodos auxiliares
Esses métodos auxiliares especializados normalizam os dados de entrada e tratam as particularidades das corretoras, simplificando o restante da implementação da classe. MakeObjectName converte strings em nomes válidos para objetos, substituindo espaços e caracteres especiais. TrimString remove espaços em branco do início e do final das strings, incluindo tabulações e quebras de linha. FindBrokerSymbol primeiro tenta selecionar o símbolo exato por meio de SymbolSelect. Se a tentativa falhar, realiza uma busca sem diferenciar maiúsculas de minúsculas na lista de símbolos da corretora para encontrar uma correspondência. Isso é importante para garantir a portabilidade entre corretoras que adicionam sufixos ou adotam diferentes convenções de nomenclatura. ComputeBaseYFromTop calcula a posição vertical de referência para os blocos de minigráficos alinhados à parte inferior, protegendo o cálculo contra valores inválidos de altura do gráfico.
//+------------------------------------------------------------------+ //| Helpers implementation | //+------------------------------------------------------------------+ string CChartMiniTiles::MakeObjectName(const string base) { string name = base; StringReplace(name, " ", "_"); StringReplace(name, ".", "_"); StringReplace(name, ":", "_"); StringReplace(name, "/", "_"); StringReplace(name, "\\", "_"); return(name); } string CChartMiniTiles::TrimString(const string s) { if(s == NULL) return(""); int len = StringLen(s); if(len == 0) return(""); int left = 0; int right = len - 1; while(left <= right) { int ch = StringGetCharacter(s, left); if(ch == 32 || ch == 9 || ch == 10 || ch == 13) left++; else break; } while(right >= left) { int ch = StringGetCharacter(s, right); if(ch == 32 || ch == 9 || ch == 10 || ch == 13) right--; else break; } if(left > right) return(""); return StringSubstr(s, left, right - left + 1); } string CChartMiniTiles::FindBrokerSymbol(const string baseSymbol) { if(StringLen(baseSymbol) == 0) return(""); if(SymbolSelect(baseSymbol, true)) return(baseSymbol); string baseUpper = baseSymbol; StringToUpper(baseUpper); int total = SymbolsTotal(true); for(int i = 0; i < total; i++) { string s = SymbolName(i, true); if(StringLen(s) == 0) continue; string sUpper = s; StringToUpper(sUpper); if(StringFind(sUpper, baseUpper) >= 0) return(s); } return(""); } int CChartMiniTiles::ComputeBaseYFromTop(void) { int chartTotalHeight = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS); if(chartTotalHeight <= 0) chartTotalHeight = 600; int base_y_from_top = chartTotalHeight - m_yoffset - m_height; if(base_y_from_top < 0) base_y_from_top = 0; if(base_y_from_top + m_height > chartTotalHeight) base_y_from_top = MathMax(0, chartTotalHeight - m_height); return base_y_from_top; }
1.4. Controle por botão de alternância
O controle interativo é feito por meio de um botão de alternância. CreateToggleButton verifica se o objeto do botão já existe e, caso contrário, cria-o. Em seguida, configura suas propriedades visuais: posição, dimensões, fonte, cor de fundo, cor do texto, possibilidade de seleção e texto que indica o estado inicial, determinado por m_visible. DeleteToggleButton remove o botão de forma adequada. CollapseAll é um método simplificado para ocultar os blocos de minigráficos sem excluí-los. Para isso, desloca os blocos para fora da área visível do gráfico e define suas dimensões como zero. Dessa forma, o estado dos objetos é preservado, permitindo exibi-los novamente com rapidez e evitando o custo de recriá-los.
//+------------------------------------------------------------------+ //| Toggle button helpers | //+------------------------------------------------------------------+ void CChartMiniTiles::CreateToggleButton(void) { if(ObjectFind(ChartID(), m_tog_name) == -1) ObjectCreate(ChartID(), m_tog_name, OBJ_BUTTON, 0, 0, 0, 0, 0); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_XDISTANCE, m_tog_x); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_YDISTANCE, m_tog_y); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_XSIZE, m_tog_w); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_YSIZE, m_tog_h); ObjectSetString(ChartID(), m_tog_name, OBJPROP_FONT, "Arial"); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_FONTSIZE, 10); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_BGCOLOR, clrDarkSlateGray); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_COLOR, clrWhite); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_SELECTABLE, 1); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_STATE, m_visible ? 1 : 0); ObjectSetString(ChartID(), m_tog_name, OBJPROP_TEXT, m_visible ? "Tiles: ON" : "Tiles: OFF"); } void CChartMiniTiles::DeleteToggleButton(void) { if(ObjectFind(ChartID(), m_tog_name) >= 0) ObjectDelete(ChartID(), m_tog_name); } void CChartMiniTiles::CollapseAll(void) { for(int i = 0; i < ArraySize(m_object_names); i++) { string name = m_object_names[i]; if(StringLen(name) == 0) continue; if(ObjectFind(ChartID(), name) == -1) continue; ObjectSetInteger(ChartID(), name, OBJPROP_XDISTANCE, -1); ObjectSetInteger(ChartID(), name, OBJPROP_YDISTANCE, -1); ObjectSetInteger(ChartID(), name, OBJPROP_XSIZE, 0); ObjectSetInteger(ChartID(), name, OBJPROP_YSIZE, 0); } }
1.5. Inicialização dos minigráficos
Init é o principal método de inicialização. Primeiro, limpa qualquer estado anterior e aplica os parâmetros recebidos, utilizando os valores padrão quando necessário. Em seguida, processa a lista de símbolos majorSymbols, separados por vírgulas, remove os espaços em branco desnecessários e utiliza FindBrokerSymbol para encontrar o nome correspondente de cada símbolo na corretora, armazenando os resultados no array m_symbols. Depois, calcula os limites do layout com base na largura do gráfico e nas dimensões dos blocos, estabelecendo um limite para o número de linhas de modo a preservar a área superior reservada, definida por m_top_reserved. Para cada símbolo cujo nome foi resolvido, cria um objeto OBJ_CHART e configura suas propriedades, incluindo símbolo, período gráfico, distâncias, dimensões, exibição das escalas de data e preço e escala do gráfico. O nome de cada objeto criado é armazenado para permitir futuras atualizações ou sua remoção. Após criar os minigráficos, o método configura o botão de alternância, respeita a configuração inicial de visibilidade, redesenha o gráfico e retorna um valor indicando sucesso. O método também registra em log informações sobre a resolução dos nomes dos símbolos e os objetos criados, facilitando o acompanhamento do comportamento do sistema durante a execução.
//+------------------------------------------------------------------+ //| NEW: set top reserved height (pixels from top) | //+------------------------------------------------------------------+ void CChartMiniTiles::SetTopReservedHeight(const int pixels) { m_top_reserved = MathMax(0, pixels); } //+------------------------------------------------------------------+ //| Init: create mini tiles | //+------------------------------------------------------------------+ bool CChartMiniTiles::Init(const string majorSymbols, const int width, const int height, const int xOffset, const int yOffset, const int spacing, const int period, const bool dateScale, const bool priceScale, const int chartScale) { Delete(); m_width = (width <= 0) ? CMT_DEFAULT_WIDTH : width; m_height = (height <= 0) ? CMT_DEFAULT_HEIGHT : height; m_xoffset = (xOffset <= 0) ? CMT_DEFAULT_X_OFFSET : xOffset; m_yoffset = (yOffset <= 0) ? CMT_DEFAULT_Y_OFFSET : yOffset; m_spacing = (spacing <= 0) ? CMT_DEFAULT_SPACING : spacing; m_period = (period <= 0) ? CMT_DEFAULT_PERIOD : period; m_date_scale = dateScale; m_price_scale = priceScale; m_chart_scale = (chartScale <= 0) ? CMT_DEFAULT_CHART_SCALE : chartScale; ArrayFree(m_object_names); ArrayFree(m_symbols); m_count = 0; string raw[]; StringSplit(majorSymbols, ',', raw); int rawCount = ArraySize(raw); if(rawCount == 0) return(false); for(int i = 0; i < rawCount; i++) { string base = TrimString(raw[i]); if(StringLen(base) == 0) continue; string resolved = FindBrokerSymbol(base); if(resolved == "") { PrintFormat("CMT: symbol not found on this broker: %s", base); continue; } int n = ArraySize(m_symbols); ArrayResize(m_symbols, n + 1); m_symbols[n] = resolved; } m_count = ArraySize(m_symbols); PrintFormat("CMT: %d symbols resolved for mini-tiles.", m_count); for(int i=0;i<m_count;i++) PrintFormat("CMT: symbol[%d] = %s", i, m_symbols[i]); if(m_count == 0) return(false); ArrayResize(m_object_names, m_count); for(int i = 0; i < m_count; i++) m_object_names[i] = ""; int base_y_from_top = ComputeBaseYFromTop(); int chartW = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS); if(chartW <= 0) chartW = 800; int columns = MathMax(1, chartW / (m_width + m_spacing)); // --- NEW: limit rows to avoid top reserved region int rows = (m_count + columns - 1) / columns; int availableAbove = MathMax(0, base_y_from_top - m_top_reserved); int maxRowsAllowed = 1 + (availableAbove / (m_height + m_spacing)); // bottom row + how many rows can fit above if(maxRowsAllowed < 1) maxRowsAllowed = 1; if(rows > maxRowsAllowed) { // increase columns to fit within allowed rows columns = (m_count + maxRowsAllowed - 1) / maxRowsAllowed; if(columns < 1) columns = 1; rows = (m_count + columns - 1) / columns; } // --- int createdCount = 0; for(int i = 0; i < m_count; i++) { string sym = m_symbols[i]; string objName = MakeObjectName("CMT_" + sym + "_" + IntegerToString(i)); m_object_names[i] = objName; int col = i % columns; int row = i / columns; int xdist = m_xoffset + col * (m_width + m_spacing); int ydist = base_y_from_top - row * (m_height + m_spacing); if(ydist < 0) ydist = 0; bool created = ObjectCreate(ChartID(), objName, OBJ_CHART, 0, 0, 0, 0, 0); if(!created) { PrintFormat("CMT: failed to create OBJ_CHART for %s (obj=%s)", sym, objName); m_object_names[i] = ""; continue; } ObjectSetString(ChartID(), objName, OBJPROP_SYMBOL, sym); ObjectSetInteger(ChartID(), objName, OBJPROP_PERIOD, m_period); ObjectSetInteger(ChartID(), objName, OBJPROP_XDISTANCE, xdist); ObjectSetInteger(ChartID(), objName, OBJPROP_YDISTANCE, ydist); ObjectSetInteger(ChartID(), objName, OBJPROP_XSIZE, m_width); ObjectSetInteger(ChartID(), objName, OBJPROP_YSIZE, m_height); ObjectSetInteger(ChartID(), objName, OBJPROP_DATE_SCALE, (int)m_date_scale); ObjectSetInteger(ChartID(), objName, OBJPROP_PRICE_SCALE, (int)m_price_scale); ObjectSetInteger(ChartID(), objName, OBJPROP_SELECTABLE, 1); ObjectSetInteger(ChartID(), objName, OBJPROP_CHART_SCALE, m_chart_scale); createdCount++; } PrintFormat("CMT: created %d / %d mini-chart objects.", createdCount, m_count); CreateToggleButton(); if(!m_visible) SetTilesVisible(false); ChartRedraw(); return(true); }
1.6. Atualizações do layout
UpdateLayout recalcula as posições e dimensões dos minigráficos quando a geometria do gráfico ou o estado de visibilidade é alterado. Primeiro, verifica se os minigráficos estão ocultos. Nesse caso, recolhe os blocos e coloca o botão de alternância no estado "DESLIGADO". Quando os minigráficos estão visíveis, recalcula o número de colunas de acordo com a largura do gráfico, respeita o limite da área superior reservada para impedir que as linhas de minigráficos ocupem esse espaço e atualiza cada objeto OBJ_CHART com os valores correspondentes de OBJPROP_XDISTANCE, OBJPROP_YDISTANCE, dimensões e escala do gráfico. Por fim, altera o estado do botão para "LIGADO" e chama ChartRedraw() para atualizar a interface. Esse método deve ser chamado sempre que o gráfico for redimensionado ou quando o EA precisar atualizar o layout.
//+------------------------------------------------------------------+ //| UpdateLayout - reposition tiles (respects m_visible and top reserved)| //+------------------------------------------------------------------+ void CChartMiniTiles::UpdateLayout(void) { if(!m_visible) { CollapseAll(); if(ObjectFind(ChartID(), m_tog_name) >= 0) { ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_XDISTANCE, m_tog_x); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_YDISTANCE, m_tog_y); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_STATE, 0); ObjectSetString(ChartID(), m_tog_name, OBJPROP_TEXT, "Tiles: OFF"); } ChartRedraw(); return; } if(m_count == 0) return; int chartW = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS); if(chartW <= 0) chartW = 800; int chartTotalHeight = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS); if(chartTotalHeight <= 0) chartTotalHeight = 600; int columns = MathMax(1, chartW / (m_width + m_spacing)); int base_y_from_top = ComputeBaseYFromTop(); // --- NEW: ensure rows don't surpass top-reserved area int rows = (m_count + columns - 1) / columns; int availableAbove = MathMax(0, base_y_from_top - m_top_reserved); int maxRowsAllowed = 1 + (availableAbove / (m_height + m_spacing)); if(maxRowsAllowed < 1) maxRowsAllowed = 1; if(rows > maxRowsAllowed) { columns = (m_count + maxRowsAllowed - 1) / maxRowsAllowed; if(columns < 1) columns = 1; rows = (m_count + columns - 1) / columns; } // --- for(int i = 0; i < m_count; i++) { string name = m_object_names[i]; if(StringLen(name) == 0) continue; if(ObjectFind(ChartID(), name) == -1) continue; int col = i % columns; int row = i / columns; int xdist = m_xoffset + col * (m_width + m_spacing); int ydist = base_y_from_top - row * (m_height + m_spacing); if(ydist < 0) ydist = 0; ObjectSetInteger(ChartID(), name, OBJPROP_XDISTANCE, xdist); ObjectSetInteger(ChartID(), name, OBJPROP_YDISTANCE, ydist); ObjectSetInteger(ChartID(), name, OBJPROP_XSIZE, m_width); ObjectSetInteger(ChartID(), name, OBJPROP_YSIZE, m_height); ObjectSetInteger(ChartID(), name, OBJPROP_CHART_SCALE, m_chart_scale); } if(ObjectFind(ChartID(), m_tog_name) >= 0) { ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_XDISTANCE, m_tog_x); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_YDISTANCE, m_tog_y); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_STATE, 1); ObjectSetString(ChartID(), m_tog_name, OBJPROP_TEXT, "Tiles: ON"); } ChartRedraw(); }
1.7. Visibilidade e alternância
Este pequeno conjunto de métodos controla a visibilidade dos blocos de minigráficos. SetTilesVisible atualiza o sinalizador m_visible e, dependendo do novo estado, reposiciona os blocos para exibição ou os recolhe. O método também atualiza o estado e o texto do botão de alternância. Toggle é um método auxiliar que inverte o estado de visibilidade e chama SetTilesVisible. SetToggleButtonPos permite alterar dinamicamente a posição do botão de alternância. Se o botão já existir, o método atualiza suas propriedades OBJPROP_XDISTANCE e OBJPROP_YDISTANCE. Esses métodos permitem controlar por código ou pela interface a exibição e a ocultação dos blocos de minigráficos, além da posição do botão de alternância.
//+------------------------------------------------------------------+ //| Set visibility programmatically | //+------------------------------------------------------------------+ void CChartMiniTiles::SetTilesVisible(const bool visible) { m_visible = visible; if(m_count == 0) { if(ObjectFind(ChartID(), m_tog_name) >= 0) { ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_STATE, m_visible ? 1 : 0); ObjectSetString(ChartID(), m_tog_name, OBJPROP_TEXT, m_visible ? "Tiles: ON" : "Tiles: OFF"); ChartRedraw(); } return; } if(m_visible) UpdateLayout(); else { CollapseAll(); ChartRedraw(); } if(ObjectFind(ChartID(), m_tog_name) >= 0) { ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_STATE, m_visible ? 1 : 0); ObjectSetString(ChartID(), m_tog_name, OBJPROP_TEXT, m_visible ? "Tiles: ON" : "Tiles: OFF"); } } //+------------------------------------------------------------------+ //| Toggle | //+------------------------------------------------------------------+ void CChartMiniTiles::Toggle(void) { SetTilesVisible(!m_visible); } //+------------------------------------------------------------------+ //| Set toggle position | //+------------------------------------------------------------------+ void CChartMiniTiles::SetToggleButtonPos(const int x,const int y) { m_tog_x = x; m_tog_y = y; if(ObjectFind(ChartID(), m_tog_name) >= 0) { ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_XDISTANCE, m_tog_x); ObjectSetInteger(ChartID(), m_tog_name, OBJPROP_YDISTANCE, m_tog_y); } }
1.8. Limpeza e tratamento de eventos
Por fim, Delete realiza uma limpeza completa: percorre o array de nomes dos objetos e remove cada OBJ_CHART criado, exclui o botão de alternância, libera a memória dos arrays com ArrayFree, redefine m_count e redesenha o gráfico. HandleEvent é um método de encaminhamento de eventos, desenvolvido para ser chamado a partir de OnChartEvent do EA. Ele filtra os eventos pelo tipo CHARTEVENT_OBJECT_CLICK e pelo nome do botão de alternância. Se o botão tiver sido clicado, chama Toggle() e retorna true, indicando que o evento foi tratado. Isso simplifica a integração com o EA, pois basta encaminhar os eventos e chamar Init e Delete em OnInit e OnDeinit, respectivamente.
//+------------------------------------------------------------------+ //| Delete all objects | //+------------------------------------------------------------------+ void CChartMiniTiles::Delete(void) { for(int i = 0; i < ArraySize(m_object_names); i++) { string name = m_object_names[i]; if(StringLen(name) == 0) continue; if(ObjectFind(ChartID(), name) >= 0) ObjectDelete(ChartID(), name); } DeleteToggleButton(); ArrayFree(m_object_names); ArrayFree(m_symbols); m_count = 0; ChartRedraw(); } //+------------------------------------------------------------------+ //| HandleEvent - forward OnChartEvent to class (returns true if handled)| //+------------------------------------------------------------------+ bool CChartMiniTiles::HandleEvent(const int id,const string sparam) { if(id != CHARTEVENT_OBJECT_CLICK) return(false); if(StringLen(sparam) == 0) return(false); if(sparam == m_tog_name) { Toggle(); return(true); } return(false); } //+------------------------------------------------------------------+ #endif // __CHART_MINI_TILES_CLASS_MQH__
O código-fonte completo desse arquivo de cabeçalho, assim como os demais arquivos mencionados neste artigo, está disponível ao final desta publicação.
2.0 EA de exemplo (MiniChartsEA) para testar o arquivo de cabeçalho
2.1. Visão geral e finalidade do EA
Este EA funciona como um ambiente de testes para a classe CChartMiniTiles. Ele cria uma instância da classe, inicializa os minigráficos de múltiplos símbolos e verifica as funcionalidades de alternância de visibilidade, redimensionamento e atualização antes da integração em projetos maiores.
//+------------------------------------------------------------------+ //| MiniChartsEA.mq5| //| Dummy EA to test CChartMiniTiles (ChartMiniTilesClass) | //+------------------------------------------------------------------+ #property copyright "2025" #property link "https://www.mql5.com/ru/users/billionaire2024/seller" #property version "1.00" #property description "Mini-charts EA using CChartMiniTiles class" // --- Include the class header #include <ChartMiniTiles.mqh>
2.2. Parâmetros de entrada e variáveis globais
Esta seção define os parâmetros e as variáveis de estado que controlam os minigráficos, incluindo a lista de símbolos, as dimensões e o comportamento das atualizações.
//--- Inputs input string MajorSymbols = "EURUSD,GBPUSD,USDJPY,USDCHF,USDCAD,AUDUSD,NZDUSD"; input int BarsWidth = 20; // bars used to estimate tile pixel width input int TileHeightPx = 112; // tile height in pixels input int HorizontalSpacing = 6; // spacing between tiles input int UpdateInterval = 1000; // ms timer update interval input int XOffset = 10; // left margin in pixels input int BottomOffset = 40; // distance from bottom in pixels input int ToggleButtonX = 8; // toggle button X input int ToggleButtonY = 6; // toggle button Y input bool DateScale = false;// show date scale input bool PriceScale = false;// show price scale input int ChartScale = 2; // chart zoom level //--- object instance of our class CChartMiniTiles tiles; //--- internal state int pixelWidth = 120;
2.3. Métodos auxiliares
Este método estima dinamicamente a largura dos blocos em pixels com base no número de barras visíveis no momento.
//+------------------------------------------------------------------+ //| Helper: estimate pixel width from BarsWidth | //+------------------------------------------------------------------+ int CalculateChartWidthFromBars(int barsWidth) { int mainChartWidth = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS); int visibleBars = (int)ChartGetInteger(0, CHART_VISIBLE_BARS); if(visibleBars <= 0 || mainChartWidth <= 0) return MathMax(80, BarsWidth * 6); // fallback return MathMax(80, barsWidth * mainChartWidth / visibleBars); }
2.4. Controle por botão de alternância
O controle é gerenciado pelo objeto tiles, da classe CChartMiniTiles. O próprio EA apenas define a posição inicial do botão de alternância.
// Inside OnInit we call:
tiles.SetToggleButtonPos(ToggleButtonX, ToggleButtonY);
2.5. Inicialização dos minigráficos
Nesta etapa, todos os minigráficos são criados de acordo com as configurações definidas pelo usuário.
//+------------------------------------------------------------------+ //| Expert initialization | //+------------------------------------------------------------------+ int OnInit() { // compute pixel width from BarsWidth heuristic pixelWidth = CalculateChartWidthFromBars(BarsWidth); // set toggle button position tiles.SetToggleButtonPos(ToggleButtonX, ToggleButtonY); // initialize tiles bool ok = tiles.Init(MajorSymbols, pixelWidth, TileHeightPx, XOffset, BottomOffset, HorizontalSpacing, PERIOD_M1, DateScale, PriceScale, ChartScale); if(!ok) { Print("MiniChartsEA: tiles.Init() failed. Check Experts log for symbol issues."); return(INIT_FAILED); } // start timer for adaptive updates EventSetMillisecondTimer(UpdateInterval); Print("MiniChartsEA initialized."); return(INIT_SUCCEEDED); }
2.6. Atualizações do layout
Esta funcionalidade garante que as dimensões e as posições dos blocos sejam ajustadas corretamente quando o gráfico sofre alterações ou à medida que o tempo passa.
//+------------------------------------------------------------------+ //| Timer: update layout | //+------------------------------------------------------------------+ void OnTimer() { tiles.UpdateLayout(); }
2.7. Visibilidade e alternância
Nesta etapa, o EA encaminha os cliques no botão de alternância para a classe e monitora as alterações no gráfico para manter o alinhamento dos minigráficos.
//+------------------------------------------------------------------+ //| Chart events - forward to tiles | //+------------------------------------------------------------------+ void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) { // Let tiles handle toggle button clicks if(tiles.HandleEvent(id, sparam)) return; // If chart resized or layout changed, reflow tiles if(id == CHARTEVENT_CHART_CHANGE) tiles.UpdateLayout(); }
2.8. Limpeza e tratamento de eventos
Esta funcionalidade garante que os objetos sejam removidos corretamente quando o EA é encerrado.
//+------------------------------------------------------------------+ //| Deinitialization | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { EventKillTimer(); tiles.Delete(); Print("MiniChartsEA deinitialized."); }
3.0 Testes iniciais
Nesta etapa, adicionamos o EA de exemplo ao gráfico e observamos os resultados. Durante meus testes, os blocos de minigráficos foram exibidos para os principais pares que selecionei, cada um configurado de acordo com a nomenclatura dos símbolos da minha corretora, que utiliza o sufixo .0. O botão de alternância funcionou perfeitamente, permitindo exibir e ocultar os blocos com facilidade. Essa funcionalidade permite que os traders visualizem todo o gráfico principal sempre que necessário, oferecendo um controle simples, mas muito útil.
Esse recurso se tornará ainda mais valioso quando a classe for integrada ao News Headline EA, no qual diversos componentes formarão uma interface gráfica mais complexa. A possibilidade de exibir ou ocultar rapidamente os blocos de minigráficos proporcionará uma área de trabalho mais organizada e prática.
Veja a imagem abaixo, que mostra a implantação do MiniChartsEA e os dados exibidos no gráfico.

Figura 1: Resultados dos testes do MiniChartsEA no gráfico do par de moedas EURUSD.
Agora podemos prosseguir com a integração da classe CChartMiniTiles ao News Headline EA. Na próxima seção, examinaremos detalhadamente o código atualizado e, em seguida, analisaremos o funcionamento da nova funcionalidade no gráfico.
4.0 Integração de ChartsMiniTiles ao News Headline EA
4.1. Incluir o arquivo de cabeçalho ChartMiniTiles para disponibilizar a classe ao EA
Para utilizar a classe responsável pelos blocos de minigráficos, é necessário incluir seu arquivo de cabeçalho no início do código do EA. Isso disponibiliza a declaração e a implementação da classe na unidade de compilação do EA, permitindo criar uma instância e chamar seus métodos. Manter a diretiva #include junto às demais diretivas de inclusão dos arquivos de cabeçalho (TradingButtons, Canvas, Trade) facilita a organização das dependências e permite que outros desenvolvedores identifiquem os componentes necessários. Se o arquivo não estiver disponível em MQL5/Include/, o compilador emitirá um erro nessa etapa. Por isso, a inclusão do cabeçalho é o primeiro passo da integração.
#include <TradingButtons.mqh> #include <Trade\Trade.mqh> #include <Canvas\Canvas.mqh> #include <ChartMiniTiles.mqh> // <-- CTM class include (make sure this file is in MQL5/Include/)
4.2. Declarar uma instância de CChartMiniTiles para gerenciar os blocos de minigráficos do EA
A declaração de uma instância global de CChartMiniTiles permite que todas as partes do EA acessem o mesmo gerenciador de blocos de minigráficos. Essa instância mantém o estado da funcionalidade, incluindo os nomes dos objetos criados, a lista de símbolos, o sinalizador de visibilidade e a altura máxima reservada. Além disso, disponibiliza métodos para inicialização, atualização do layout, tratamento de eventos e limpeza. Declarar a instância junto às demais variáveis globais facilita o gerenciamento de seu ciclo de vida por meio de OnInit, OnTimer, OnChartEvent e OnDeinit.
//+------------------------------------------------------------------+ //| ChartMiniTiles instance (CTM) | //+------------------------------------------------------------------+ CChartMiniTiles tiles; // class instance for mini tiles
4.3. Criar a lista de símbolos e estimar a largura dos blocos em pixels para preparar os dados de entrada do CMT
Antes de chamar tiles.Init, precisamos de uma string contendo os símbolos separados por vírgulas e de uma largura adequada, em pixels, para os blocos de minigráficos. Nesta seção, criamos ctmSymbols a partir do array majorPairs[] utilizando a função JoinSymbolArray() e estimamos pixelWidth por meio de uma heurística que relaciona o número de barras à largura em pixels, considerando a largura do gráfico principal e a quantidade de barras visíveis. Realizar esses cálculos durante a inicialização permite adaptar as dimensões dos blocos ao layout atual do gráfico. A resolução dos nomes dos símbolos conforme as convenções da corretora fica a cargo de FindBrokerSymbol, dentro da classe.
// Build a comma-separated symbol list from majorPairs[] and initialize CTM. string ctmSymbols = JoinSymbolArray(majorPairs); // Estimate pixel width from Bars heuristic (simple fallback) int mainChartWidth = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS); int visibleBars = (int)ChartGetInteger(0, CHART_VISIBLE_BARS); int pixelWidth = 120; if(visibleBars > 0 && mainChartWidth > 0) pixelWidth = MathMax(80, CTM_TileWidthBars * mainChartWidth / visibleBars);
4.4. Configurar e posicionar o botão de alternância para manter os controles acessíveis
O botão de alternância permite ao usuário exibir ou ocultar os blocos de minigráficos. Ao posicioná-lo deliberadamente um pouco abaixo do painel de negociação, evitamos que se sobreponha a outros controles importantes da interface. Depois de calcular tradingPanelBottomY, o EA chama tiles.SetToggleButtonPos(toggleX, toggleY) para informar à classe onde o botão deve ser criado. Essa configuração é realizada antes da inicialização dos minigráficos, para que o botão seja criado na posição definida e seu posicionamento seja compatível com a lógica de reserva de espaço descrita a seguir.
// Place the CTM toggle button JUST BELOW the trading panel bottom int toggleX = 8; int toggleY = tradingPanelBottomY + 6; // +6 px margin so it doesn't touch trading controls tiles.SetToggleButtonPos(toggleX, toggleY);
4.5. Reservar a área superior da interface para os controles de negociação e evitar sobreposições
Para evitar que os blocos de minigráficos se sobreponham ao painel de negociação e ao botão de alternância, o EA calcula o valor de topReserve e chama tiles.SetTopReservedHeight(topReserve). A classe utiliza esse valor para limitar o número de linhas que podem ser distribuídas de baixo para cima, preservando a área superior do gráfico para botões, elementos Canvas e outros componentes da interface. Reservar esse espaço antes de chamar Init garante que a restrição seja considerada diretamente no cálculo do layout.
// Reserve the area above tiles so the trading UI remains free. We reserve up to the toggle bottom. int topReserve = toggleY + CMT_TOG_H + 4; // leave a few px extra tiles.SetTopReservedHeight(topReserve);
4.6. Inicializar os blocos de minigráficos para criar objetos OBJ_CHART para cada símbolo
Esta é a principal chamada de integração. O EA passa para tiles.Init(...) a lista de símbolos, a largura estimada em pixels, a altura dos blocos, os deslocamentos, os espaçamentos, o período gráfico e a escala. A classe resolve os nomes dos símbolos conforme as convenções da corretora, cria os objetos OBJ_CHART, configura suas propriedades (símbolo, período, escalas e dimensões) e cria o botão de alternância. O EA verifica o valor booleano retornado (ctm_ok) para tratar adequadamente eventuais falhas na inicialização, como quando nenhum dos símbolos solicitados é encontrado na corretora.
// Initialize tiles: (symbols, widthPx, heightPx, xOffset, bottomOffset, spacing, period, dateScale, priceScale, chartScale) bool ctm_ok = tiles.Init(ctmSymbols, pixelWidth, CTM_TileHeightPx, CTM_XOffset, CTM_BottomOffset, CTM_Spacing, PERIOD_M1, false, false, CTM_ChartScale); if(!ctm_ok) { Print("CTM: initialization failed (no matching symbols?); tiles disabled."); }
4.7. Manter o layout adaptativo chamando UpdateLayout quando o gráfico for alterado ou durante as atualizações do temporizador
Após a inicialização, o EA precisa manter os blocos de minigráficos nas posições corretas quando as dimensões ou o layout do gráfico mudarem. A integração contempla três situações:
- Encaminhar os eventos de alteração do gráfico para atualizar o posicionamento dos blocos, incluindo redimensionamentos e mudanças na área de trabalho realizados pelo usuário.
- Chamar tiles.UpdateLayout() periodicamente em OnTimer para acompanhar deslocamentos dinâmicos dos elementos da interface ou restabelecer o layout após alterações externas.
- Chamar tiles.UpdateLayout() ao final do ciclo principal de processamento de OnTimer, garantindo que o CTM seja atualizado depois dos demais componentes da interface, como elementos Canvas, notícias e dados analíticos de IA.
A seguir, apresentamos os trechos de código utilizados no EA para tratar essas situações.
Encaminhamento de eventos em OnChartEvent e resposta às alterações do gráfico:
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) { // Let CTM handle object clicks first (toggle button) if(tiles.HandleEvent(id, sparam)) return; // Forward to the TradingButtons header afterward buttonsEA.HandleChartEvent(id, sparam, majorPairs, pairSelected); // Also respond to chart change events for CTM layout if(id == CHARTEVENT_CHART_CHANGE) tiles.UpdateLayout(); }
Atualização ao final de OnTimer (sincroniza o CTM a cada acionamento do temporizador):
// Keep CTM updated every tick (timer-driven)
tiles.UpdateLayout();
}
4.8. Limpeza durante a desinicialização para remover os blocos de minigráficos e o botão de alternância
Quando o EA é interrompido ou removido do gráfico, todos os objetos criados por ele devem ser excluídos. A chamada tiles.Delete() remove cada objeto OBJ_CHART e o botão de alternância, libera a memória dos arrays e redesenha o gráfico. Essa é a última etapa da integração e evita que objetos residuais permaneçam no gráfico.
// delete CTM tiles and toggle button
tiles.Delete();Lista de verificação da integração (resumo)
- Adicione #include <ChartMiniTiles.mqh> no início.
- Declare uma instância global de CChartMiniTiles.
- Crie ctmSymbols e calcule pixelWidth antes de Init.
- Defina a posição do botão de alternância com tiles.SetToggleButtonPos(...).
- Reserve a área superior da interface com tiles.SetTopReservedHeight(...).
- Inicialize com tiles.Init(...) e verifique o valor retornado.
- Encaminhe OnChartEvent para tiles.HandleEvent(...) e chame tiles.UpdateLayout() após alterações no gráfico e durante as atualizações periódicas.
- Chame tiles.Delete() em OnDeinit.
Testes e resultados
Esta seção marca a etapa final de testes do News Headline EA após a integração das novas funcionalidades. Depois de compilar o programa no MetaEditor 5 sem erros, executamos o EA em um gráfico do terminal MetaTrader 5 para observar seu funcionamento. As capturas de tela abaixo mostram os resultados dos meus testes.

Figura 2: Utilização do News Headline EA no gráfico AUDUSD com minigráficos para negociação com múltiplos símbolos

Figura 3: Funcionamento do ChartMiniTiles no News Headline EA
Ao analisar os resultados apresentados acima, podemos confirmar que a solução desenvolvida foi integrada com sucesso, resolvendo o problema identificado anteriormente. Agora, os traders podem visualizar vários pares em um único gráfico, e os botões de controle funcionam corretamente. Outro avanço importante é que conseguimos implementar essa nova funcionalidade sem sobrepor elementos da interface nem interferir nos recursos existentes do News Headline EA, graças ao gerenciamento adequado do layout e aos recursos oferecidos pela linguagem MQL5. Na próxima seção, destacaremos os principais resultados deste desenvolvimento.
Conclusão
Integramos com sucesso ao News Headline EA uma classe capaz de gerenciar a exibição de vários minigráficos dentro de um único gráfico principal. Essa solução oferece aos traders uma ferramenta eficiente para monitorar e negociar diversos instrumentos simultaneamente, especialmente durante períodos de alta volatilidade, como a divulgação de notícias de grande impacto. Quando há várias posições abertas em diferentes pares, a ferramenta permite acompanhá-las e gerenciá-las em uma única interface, facilitando o controle das operações e a execução rápida de ordens.
Do ponto de vista educacional, este artigo apresenta conhecimentos valiosos sobre o desenvolvimento de classes personalizadas, estratégias de negociação com múltiplos instrumentos, execução rápida de ordens e seleção de pares, tudo isso sem precisar sair do gráfico atual.
Embora essa implementação demonstre a utilidade prática da negociação com múltiplos pares, ainda existem diversas oportunidades de aprimoramento. Uma das principais é aprimorar os métodos que permitam analisar os pares selecionados com maior flexibilidade. Nas próximas etapas, poderemos incorporar técnicas de análise automatizada ao algoritmo para ampliar as capacidades do sistema existente. Esses aprimoramentos serão abordados em publicações futuras.
Convidamos você a compartilhar suas ideias e contribuir para esta discussão. Abaixo, disponibilizamos o código-fonte e uma imagem que mostra o gráfico principal com as configurações do ChartMiniTiles.
Principais lições
| Principal lição | Descrição: |
|---|---|
| Gerenciamento de múltiplos instrumentos | Os traders podem selecionar e monitorar vários pares de negociação com eficiência, sem precisar alternar entre gráficos. |
| Classe específica para gerenciamento de múltiplos gráficos | A utilização de uma classe independente para gerenciar vários minigráficos simplifica a integração e preserva a modularidade do código. |
| Testes independentes antes da integração | Desenvolver e validar a funcionalidade em um EA de teste independente permite confirmar sua estabilidade antes de integrá-la ao EA principal. |
| Layouts configuráveis de minigráficos | Os minigráficos podem ser redimensionados e organizados de acordo com as preferências do usuário, melhorando a visibilidade e o fluxo de trabalho. |
| Visualização de múltiplos instrumentos em tempo real | Exibir vários instrumentos em um único gráfico permite que os traders reajam mais rapidamente às mudanças nas condições de mercado. |
| Programação modular | Dividir as funcionalidades em arquivos de cabeçalho e classes facilita a manutenção e a reutilização do código em diferentes projetos. |
| Desenvolvimento incremental de funcionalidades | Adicionar novas funcionalidades gradualmente reduz a ocorrência de erros e facilita sua integração aos sistemas existentes. |
| Tratamento de eventos nos minigráficos | Cada minigráfico pode responder às ações do usuário, permitindo análises interativas e dinâmicas. |
| Integração com o EA principal | Após os testes, a classe de minigráficos é integrada ao EA principal para permitir a negociação sem interrupções com múltiplos instrumentos. |
| Classes utilitárias reutilizáveis | Classes como CChartMiniTiles são componentes modulares que podem ser adaptados para outros projetos e EAs. |
| Práticas eficientes de desenvolvimento | Adotar um fluxo de desenvolvimento estruturado, que inclui prototipagem, testes e integração, acelera o desenvolvimento e reduz a ocorrência de erros. |
| Suporte à tomada rápida de decisões | Os minigráficos oferecem aos traders uma visão consolidada de diferentes mercados, ajudando-os a tomar decisões de negociação com maior rapidez. |
| Gerenciamento dinâmico de objetos | O código demonstra como criar, atualizar e excluir dinamicamente objetos gráficos para cada minigráfico, um recurso importante para desenvolver EAs escaláveis. |
| Uso eficiente da memória | Ao gerenciar os minigráficos como objetos independentes e atualizar apenas os elementos visíveis, o EA otimiza o consumo de memória e os recursos de processamento. |
| Encaminhamento eficiente de eventos | A classe de minigráficos demonstra como tratar eventos do gráfico de forma hierárquica, garantindo que sejam encaminhados à instância correta sem conflitos. |
Anexos
| Nome do arquivo | Versão | Descrição |
|---|---|---|
| ChartMiniTiles.mqh | 1.0 | Define a classe CChartMiniTiles, responsável por gerenciar e exibir diferentes visualizações de minigráficos dentro de um único gráfico principal. Oferece recursos modulares de visualização de múltiplos símbolos e interação com o usuário. |
| MiniChartsEA.mq5 | 1.0 | EA de teste desenvolvido para validar a classe CChartMiniTiles de forma independente antes de integrá-la ao News Headline EA principal. Verifica o layout, o redimensionamento e o tratamento de eventos dos minigráficos. |
| NewsHeadlineEA.mq5 | 1.14 | EA principal que reúne diversas funcionalidades, incluindo a visualização do feed de notícias, a negociação automatizada baseada em eventos do calendário econômico e a negociação com múltiplos símbolos por meio de minigráficos. |
| TradingButtons.mqh | 1.0 | Disponibiliza botões de controle para executar operações, selecionar pares e gerenciar ordens diretamente no gráfico. Permite negociar rapidamente com múltiplos símbolos por meio do EA. |
| terminal64_Dp0JGQhX5.png | Não se aplica | Captura de tela panorâmica do gráfico no terminal, ilustrando a funcionalidade ChartMiniTiles do News Headline EA, com negociação de múltiplos símbolos, monitoramento em tempo real e análise visual rápida. |
Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/19299
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.