Criação de um painel administrativo de trading em MQL5 (Parte XI): Interface moderna de mensagens na plataforma (I)

Sumário:

• Introdução
• Visão geral
• Projeto e implementação do código
• Testes e resultados
• Conclusão

Introdução

O terminal MetaTrader 5 está evoluindo rapidamente e se transformando em um ambiente de trabalho mais eficiente e compacto para trading. O recurso de chats, adicionado há relativamente pouco tempo, permite que os traders conversem com amigos da comunidade MQL5, participem de grupos e sigam canais, tudo isso diretamente no terminal. Na minha opinião, esse é um avanço significativo para a comunidade MQL5.

Para acessar esse recurso, basta entrar no terminal com sua conta MQL5, adicionar amigos e participar de canais ou grupos ativos. Essas comunidades são uma fonte valiosa de insights de trading: especialistas compartilham regularmente ideias e capturas de tela, além de participarem de discussões em tempo real. E, como já mencionei, tudo isso está integrado de forma natural ao próprio terminal, sem a necessidade de sair do gráfico.

No entanto, ainda existe uma limitação: toda a comunicação fica restrita ao ecossistema MQL5. Falta a possibilidade de conectar o MetaTrader 5 a plataformas sociais externas. Felizmente, a API do terminal e os recursos de WebRequest permitem estabelecer conexão com servidores de terceiros para troca de mensagens, como Telegram, WhatsApp e outros.

É justamente esse tipo de funcionalidade, entre outras, que nosso painel administrativo pretende oferecer por meio de um painel de comunicação independente e moderno, com uma interface prática inspirada nos aplicativos de mensagens que usamos no dia a dia. Agora estamos deixando para trás o protótipo com aparência de calculadora e avançando para um design mais intuitivo e profissional. Embora a estrutura inicial tenha cumprido bem seu papel nos primeiros testes, a nova versão oferecerá comunicação bidirecional completa.

A partir de agora, não será apenas o administrador que enviará mensagens: os destinatários também poderão responder. Essa mudança exige a implementação de um sistema adequado de contatos, com identificadores exclusivos para gerenciar destinatários externos.

A figura abaixo mostra como acessar a MQL5 Community e os chats na plataforma de trading MetaTrader 5. O ícone da conta fica no canto superior direito da interface do terminal, como mostrado na imagem.

Acesso à MQL5 Community e aos chats no terminal MetaTrader 5

Se você já adicionou uma conta MQL5, normalmente o terminal exibirá uma notificação correspondente no log de inicialização, confirmando a ativação da conta da MQL5 Community e dos chats. Veja abaixo o log de inicialização do meu terminal em 16 de abril de 2025.

2025.04.16 08:44:10.343 Network '40538052': previous successful authorization performed from 197.221.254.8 on 2025.04.16 03:48:48
2025.04.16 08:44:10.461 Experts expert New_Admin_Panel- (Volatility 75 (1s) Index.0,M5) loaded successfully
2025.04.16 08:44:12.323 Experts expert New_Admin_Panel- (Volatility 10 (1s) Index.0,M1) loaded successfully
2025.04.16 08:44:12.324 Network '40538052': terminal synchronized with Deriv.com Limited: 0 positions, 0 orders, 150 symbols, 0 spreads
2025.04.16 08:44:12.324 Network '40538052': trading has been enabled - hedging mode
2025.04.16 08:44:14.354 Trades  use MetaTrader VPS Hosting Service to speed up the execution: 2.26 ms via 'MQL5 Frankfurt FRA8 01' instead of 212.79 ms
2025.04.16 08:44:14.776 MQL5.community  activated for 'Billionaire2024', balance: 
0.00 
2025.04.16 08:44:15.826 MQL5.chats      activated for 'Billionaire2024'

A seguir, nesta visão geral, analisaremos em detalhes o design atual e como pretendemos implementar a próxima etapa de evolução do nosso Painel de Comunicação.

Visão geral

Vale destacar que, graças às melhorias recentes na estrutura do código, ficou mais fácil adicionar novas funcionalidades ao programa. Agora podemos trabalhar no painel de comunicação de forma isolada, sem afetar os demais componentes do nosso projeto de grande porte. Essa abordagem modular nos permite explorar ao máximo novas possibilidades de design.

As alterações que faremos hoje no painel de comunicação serão semelhantes às que já aplicamos anteriormente ao painel principal. No estado atual, nosso painel de comunicação ainda não pode ser considerado atraente nem prático, portanto teremos bastante trabalho pela frente para aperfeiçoá-lo.

Continuaremos usando a biblioteca padrão do MQL5, mas esta versão também apresentará novas classes personalizadas, adaptadas às necessidades do projeto. Para entender a direção do desenvolvimento, começaremos pelo design conceitual da interface, identificaremos seus principais componentes e descreveremos a finalidade de cada um. Depois disso, passaremos à implementação do código.

Características da interface de mensagens com base em aplicativos populares

Antes de projetarmos nossa própria interface, vamos analisar as características comuns das interfaces de mensagens utilizadas pelos aplicativos modernos mais populares. Podemos aproveitar ideias de soluções já existentes e adaptá-las às nossas necessidades atuais, adicionando ou removendo funcionalidades conforme necessário.

A seguir, apresentamos dez características principais para análise. Primeiro vamos examiná-las e, em seguida, veremos algumas imagens para avaliar visualmente como esses elementos são implementados em aplicativos reais.

1. Design limpo e minimalista:

• Interface plana com uma paleta de cores moderna, com suporte a modo claro e escuro
• Espaçamentos e alinhamentos consistentes
• Balões de mensagem com cantos arredondados e transições suaves
• Ícones simples, como clipe, emoji e microfone, posicionados de forma intuitiva

2. Área da conversa, ou janela principal do chat:

• Área rolável com o histórico das mensagens
• Marcas de tempo nas mensagens
• Agrupamento das mensagens por remetente
• Indicações visuais de status: entregue, lida, editada e fixada
• Suporte a conteúdo multimídia, como imagens, vídeos, mensagens de voz e arquivos

3. Painel lateral: contatos ou canais

• Lista de usuários, grupos ou canais
• Indicadores de status online, como pontos verdes e horário do último acesso
• Prévia das mensagens mais recentes
• Pesquisa e filtros

4. Barra de navegação superior:

• Nome do chat ou do contato
• Avatares dos usuários ou ícones dos grupos
• Menu suspenso de configurações e opções, como silenciar, arquivar, excluir etc.
• Botão de informações para visualizar o perfil do usuário ou do grupo

5. Área de entrada da mensagem, na parte inferior:

• Campo de entrada de texto com a dica "Digite uma mensagem..."
• Botões disponíveis:
• Enviar, com ícone de avião de papel
• Anexar arquivo, com ícone de clipe
• Selecionar emoji, com ícone de rosto sorridente
• Entrada por voz, com ícone de microfone
• Atalhos de teclado: Enter para enviar e Shift+Enter para inserir uma nova linha

6. Pré-visualização de mídia e anexos:

• Visualização integrada de imagens, vídeos e arquivos
• Possibilidade de expandir e recolher a visualização
• Suporte ao envio de arquivos por arrastar e soltar

7. Notificações e alertas:

• Notificações internas e do sistema
• Ativação ou desativação de som e vibração
• Menções destacadas (@username)
• Mensagens pop-up ou badges com a contagem de mensagens não lidas

8. Sincronização entre dispositivos:

• Aplicativos web, móveis e desktop com sincronização em tempo real
• Histórico de chats persistente entre sessões
• Suporte ao modo offline, com sincronização automática ao restabelecer a conexão

9. Recursos de segurança e privacidade:

• Criptografia de ponta a ponta, como no WhatsApp
• Temporizador de mensagens e autodestruição, como no Telegram
• Autenticação de dois fatores e sessões de login protegidas

10. Extensibilidade e bots:

• Suporte a bots e automação
• Plugins e integrações com outras ferramentas, como calendário, gerenciador de tarefas e plataforma de trading
• APIs avançadas e suporte a WebSocket

Agora vamos observar algumas imagens para avaliar visualmente todos esses elementos. Vale lembrar que, quando implementamos o conceito de autenticação de dois fatores, mencionamos o recebimento do código de confirmação por meio de um bot dedicado do Telegram. Vamos destacar os principais componentes da interface de mensagens. Com base nas minhas observações e no layout do Telegram, identifiquei os seguintes elementos:

• A área de entrada da mensagem está destacada por uma moldura vermelha.
• O histórico do chat está destacado por uma moldura azul.
• A parte superior, destacada por uma moldura verde, inclui o nome do contato, o botão de pesquisa e o menu de três pontos.

Veja a imagem abaixo.

Exemplo de chat no Telegram

Outro exemplo bastante próximo é a interface de mensagens do MQL5, aqui representada por um canal criado anteriormente na plataforma. Observe o layout abaixo: é possível notar semelhanças e algumas diferenças em relação à imagem anterior do Telegram. Essa estrutura geral da interface nos fornece várias ideias úteis.

Exemplo de chat no MQL5 Chats

A quantidade de referências possíveis é praticamente ilimitada. Muitas delas seguem uma estrutura semelhante, como sistemas de e-mail com botões de resposta e recursos adicionais, interfaces de chatbots e outras soluções. Todas oferecem boas referências sobre os elementos que normalmente são necessários em uma interface de comunicação. Com base nesses exemplos, podemos avançar para a escolha do design mais adequado ao nosso painel de comunicação para trading, levando em conta suas limitações e as particularidades do uso previsto.

Projeto e implementação do código

É aqui que começa a transição do painel atual para a nova versão. Antes disso, porém, precisamos definir as principais necessidades de um administrador de trading ao se comunicar com outros traders. Em geral, elas incluem:

1. Instruções específicas para os traders

Anteriormente, já implementamos a ideia de botões de mensagens rápidas para reduzir o tempo entre a elaboração e o envio de uma mensagem. Isso permite transmitir informações importantes com agilidade. No entanto, o administrador também precisa ter a possibilidade de enviar mensagens personalizadas, e é justamente para isso que serve a área de entrada da mensagem. Também aprimoraremos o mecanismo de acesso às mensagens rápidas.

2. Comunicação unidirecional e bidirecional

Normalmente, apenas o administrador tem permissão para enviar mensagens, o que torna a comunicação unidirecional. No entanto, existem situações em que a comunidade de traders precisa poder responder. Nas novas versões do painel, devemos incorporar esse recurso.

3. Compartilhamento de capturas de tela e análise visual

É importante adicionarmos a possibilidade de compartilhar imagens, especialmente gráficos ou capturas de tela com legendas. O terminal MQL5 já inclui uma ferramenta para criar capturas de tela e enviá-las para a seção de gráficos da comunidade MQL5. Precisamos adicionar um botão que crie uma captura de tela e a anexe à mensagem para envio rápido. Isso permitirá comunicar ideias de trading visualmente de forma mais eficiente.

4. Gerenciamento de contatos

Como o Telegram oferece diferentes formas de comunicação, como conversas privadas, canais e grupos, podemos usar chat IDs exclusivos para diferenciar os contatos e organizá-los em categorias, como contatos individuais e de grupo. Isso também exige um mecanismo eficiente para armazenar e recuperar os contatos em nosso aplicativo.

Abaixo está o nosso design conceitual. Em seguida, passaremos à implementação do código.

Novo design: Painel de Comunicação

Neste momento, nossa prioridade é aperfeiçoar o design da interface. Nas próximas seções do artigo, continuaremos desenvolvendo essa base, adicionando novos recursos e aprimorando a experiência do usuário.

Usaremos diretivas #include da biblioteca padrão do MQL5 para incluir os componentes necessários à implementação da interface. A tabela abaixo apresenta os arquivos utilizados e sua finalidade no projeto.

Arquivo de cabeçalho	Finalidade
Dialog.mqh	Fornece a classe base para janelas de diálogo, além do gerenciamento dos componentes da interface, tratamento de eventos e renderização.
Panel.mqh	Usado para agrupar e posicionar visualmente os controles, formando as diferentes seções do layout, como a área principal e o painel de entrada.
Label.mqh	Exibe textos não editáveis, como rótulos de campos de entrada e títulos de seções (Username, Chat ID).
Edit.mqh	Fornece campos de texto editáveis para entrada de dados pelo usuário, incluindo a composição de mensagens e as credenciais do Telegram.
Button.mqh	Permite criar botões clicáveis para as ações do usuário (Send, Attach File, Screenshot, Theme Toggle).
VirtualKeys.mqh	Define constantes usadas no tratamento de eventos do teclado, como a detecção da tecla Enter no campo de mensagem.
Telegram.mqh	Implementa a lógica de envio de mensagens por meio da Telegram Bot API, incluindo a montagem das URLs das requisições e a comunicação via HTTP.

Arquivo de cabeçalho da classe CommunicationsDialog (CommunicationsDialog.mqh)

Nesta seção, veremos como o código funciona. Também analisaremos as vantagens de estruturar o código em componentes isolados e reutilizáveis. Ao manter a lógica de cada painel em um arquivo separado, com as definições, enumerações, declarações de classes e implementações de métodos necessárias, deixamos o código principal mais simples, fácil de manter e reutilizável em diferentes EAs. Ao incluir esse arquivo, não é necessário conhecer todos os detalhes internos da interface; basta invocar a interface. Vamos analisar todas as alterações passo a passo.

Estrutura do arquivo de cabeçalho da classe

No início do arquivo, foi adicionada uma proteção contra inclusões múltiplas, juntamente com as dependências necessárias:

• Includes: elementos padrão da interface do MQL5 (Dialog, Panel, Edit, Button e Label), VirtualKeys para os códigos das teclas e nosso arquivo personalizado Telegram.mqh.

• Constantes e enumerações: macros que definem a geometria do painel e os espaçamentos da interface, além de duas enumerações para os tipos de mensagem (OUTGOING, INCOMING, SYSTEM) e seus status (SENT, FAILED).

• Definição da classe: CCommunicationDialog herda de CAppDialog e declara:

1. Membros privados para painéis, botões, rótulos, campos de entrada e o flag de modo escuro.
2. Métodos públicos: construtor, InitCredentials, CreatePanel, manipulador de eventos OnEvent e métodos de ação, como OnSendMessage.
3. Métodos auxiliares privados para construir as seções da interface, aplicar o tema, gerenciar o histórico e formatar as mensagens.

#ifndef COMMUNICATIONS_MQH
#define COMMUNICATIONS_MQH

#include <Controls\Dialog.mqh>
#include <Controls\Panel.mqh>
#include <Controls\Edit.mqh>
#include <Controls\Button.mqh>
#include <Controls\Label.mqh>
#include <VirtualKeys.mqh>
#include "Telegram.mqh"

#define COMM_PANEL_LEFT    80
… 
enum ENUM_UI_CONSTANTS { UI_INDENT=10, UI_GAP=5, … };
enum ENUM_MESSAGE_TYPE   { MSG_OUTGOING, MSG_INCOMING, MSG_SYSTEM };
enum ENUM_MESSAGE_STATUS { STATUS_SENT,   STATUS_FAILED };

class CCommunicationDialog : public CAppDialog
{
private:
   CPanel  m_mainPanel, m_composePanel;
   CButton m_toggleSidebar, m_sendButton, m_attachButton, m_screenshotButton;
   CLabel  m_usernameLabel, m_chatIdLabel, m_tokenLabel, m_mainUserLabel;
   CEdit   m_usernameInput, m_chatIdInput, m_tokenInput, m_messageThread, m_messageInput;
   bool    m_isDarkMode;

public:
   CCommunicationDialog():m_isDarkMode(false){}
   bool CreatePanel(...);
   virtual bool OnEvent(...);
   void OnSendMessage();
   …  
private:
   bool CreateSidebar();
   bool CreateMainContent();
   bool CreateComposeArea();
   void ApplyTheme();
   void LoadChatHistory(string);
   void SaveMessageToHistory(...);
   string FormatMessage(...);
   void AddMessageToHistory(...);
};
#endif // COMMUNICATIONS_MQH

1. CreatePanel - montagem da janela de diálogo

Esse método coordena a criação de toda a janela de diálogo. Primeiro, é chamada a rotina da classe base responsável por criar a janela. Em seguida, são construídos, em sequência, o painel lateral, a área principal de mensagens e a área de entrada. Cada etapa é validada e, se ocorrer algum erro, a execução é encerrada imediatamente. Depois que todas as áreas são criadas, o tema atual é aplicado, o histórico salvo é carregado e o gráfico é redesenhado para exibir toda a interface.

bool CCommunicationDialog::CreatePanel(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)) return(false);
   if(!CreateSidebar())     { Destroy(); return(false); }
   if(!CreateMainContent()) { Destroy(); return(false); }

   Add(m_mainPanel);
   Add(m_messageThread);
   Add(m_mainUserLabel);

   if(!CreateComposeArea()){ Destroy(); return(false); }
   Add(m_composePanel);
   Add(m_messageInput);
   Add(m_screenshotButton);
   Add(m_attachButton);
   Add(m_sendButton);

   ApplyTheme();
   LoadChatHistory(m_chatIdInput.Text());
   ChartRedraw();
   return(true);
}

2. CreateSidebar - credenciais e alternância de tema

O painel lateral contém, na parte superior, o botão de alternância de tema, seguido por três campos de entrada rotulados: username, chat ID e bot token. Esses campos permitem inserir manualmente as credenciais do Telegram. Essa estrutura servirá de base para um futuro sistema de gerenciamento de contatos, no qual os usuários poderão salvar e selecionar chat IDs sem precisar digitá-los novamente.

bool CCommunicationDialog::CreateSidebar()
{
   int x=UI_INDENT, y=UI_INDENT, w=UI_SIDEBAR_WIDTH-2*UI_INDENT, h=16;

   m_toggleSidebar.Create(m_chart_id,m_name+"_Toggle",m_subwin,x,y,x+h,y+h);
   m_toggleSidebar.Text("🌙"); Add(m_toggleSidebar);
   y+=h+UI_GAP;

   m_usernameLabel.Create(...); m_usernameLabel.Text("Username:");
   m_usernameInput.Create(...); Add(m_usernameLabel); Add(m_usernameInput);
   y+=h+UI_GAP;

   m_chatIdLabel.Create(...); m_chatIdLabel.Text("Chat ID:");
   m_chatIdInput.Create(...); Add(m_chatIdLabel); Add(m_chatIdInput);
   y+=h+UI_GAP;

   m_tokenLabel.Create(...); m_tokenLabel.Text("Bot Token:");
   m_tokenInput.Create(...); Add(m_tokenLabel); Add(m_tokenInput);

   return(true);
}

3. CreateMainContent - exibição do histórico de mensagens

Aqui é inicializado o painel central, juntamente com um elemento Edit configurado como somente leitura, responsável por exibir a conversa. O rótulo na parte superior mostra o nome do usuário atual. O usuário não pode editar diretamente as mensagens anteriores: novas mensagens são adicionadas programaticamente para manter uma visualização limpa e linear do histórico.

bool CCommunicationDialog::CreateMainContent()
{
   int x1=UI_SIDEBAR_WIDTH, y1=0;
   int x2=ClientAreaWidth(), y2=ClientAreaHeight()-UI_COMPOSE_HEIGHT;

   m_mainPanel.Create(...);
   m_messageThread.Create(...);
   m_messageThread.ReadOnly(true);
   m_messageThread.FontSize(9);
   m_messageThread.TextAlign(ALIGN_LEFT);

   m_mainUserLabel.Create(...);
   m_mainUserLabel.Text(m_usernameInput.Text());
   return(true);
}

4. CreateComposeArea - entrada de texto e botões de ação

Aqui é criada a área inferior de composição de mensagens. Ela inclui um campo de texto com um placeholder e três botões: captura de tela, anexar arquivo e enviar. O campo é inicializado com o texto do placeholder em uma cor mais suave. Antes de usar os botões de ação, o usuário deve inserir uma mensagem.

bool CCommunicationDialog::CreateComposeArea()
{
   int caW=ClientAreaWidth(), caH=ClientAreaHeight();
   int y1=caH-UI_COMPOSE_HEIGHT, y2=caH;
   int x1=UI_SIDEBAR_WIDTH, x2=caW;

   m_composePanel.Create(...);

   m_screenshotButton.Create(...); m_screenshotButton.Text(StringFormat("%c",58));
   m_attachButton.    Create(...); m_attachButton.   Text(StringFormat("%c",49));
   m_sendButton.      Create(...); m_sendButton.     Text(StringFormat("%c",216));

   m_messageInput.Create(...);
   m_messageInput.Text("Type here...");
   m_messageInput.Color(clrGray);

   return(true);
}

5. OnCaptureScreenshot - criação de uma captura de tela em GIF

Ao pressionar o botão, o método faz uma captura de tela do gráfico atual em formato GIF, usando um nome de arquivo baseado em uma marca de tempo. O arquivo é salvo na pasta MQL5\Files, e uma mensagem de sistema é adicionada para informar se a operação foi concluída com sucesso ou não. Esse recurso é útil para enviar rapidamente capturas de gráficos pelo Telegram.

void CCommunicationDialog::OnCaptureScreenshot()
{
   datetime ts=TimeCurrent();
   string tstr=TimeToString(ts, TIME_DATE|TIME_MINUTES|TIME_SECONDS);
   StringReplace(tstr,":","");  

   string path=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\Files\\";
   string fn=path+"shot_"+tstr+".gif";

   bool ok=ChartScreenShot(m_chart_id,fn,0,0);
   m_messageThread.Text(
      FormatMessage(ok ? "Screenshot saved: "+fn : "Screenshot failed",
                    MSG_SYSTEM, ok ? STATUS_SENT : STATUS_FAILED, ts));
   ChartRedraw();
}

6. OnSendMessage - envio e histórico

Esse manipulador verifica se a mensagem não está vazia e se as credenciais foram preenchidas. Em seguida, chama a função de envio pelo Telegram, registra o resultado no arquivo de histórico e adiciona a nova mensagem à conversa, acompanhada de um ícone de confirmação ou de erro. Depois disso, o campo de entrada retorna ao estado inicial.

void CCommunicationDialog::OnSendMessage()
{
   string txt=m_messageInput.Text();
   if(txt==""||txt=="Type here...") { /* show error */ return; }

   string chatId=m_chatIdInput.Text(), token=m_tokenInput.Text();
   if(chatId==""||token=="")        { /* show error */ return; }

   datetime ts=TimeCurrent();
   bool sent = SendMessageToTelegram(txt, chatId, token);
   SaveMessageToHistory(chatId, ts, MSG_OUTGOING,
                        sent ? STATUS_SENT : STATUS_FAILED, txt);

   m_messageThread.Text(FormatMessage(txt, MSG_OUTGOING,
                                     sent ? STATUS_SENT : STATUS_FAILED, ts));

   m_messageInput.Text("Type here...");
   m_messageInput.Color(clrGray);
   ChartRedraw();
}

7. Métodos auxiliares para temas e formatação

Esses métodos permitem alternar dinamicamente entre os temas e formatar as mensagens. ApplyTheme altera as cores do plano de fundo e do texto de acordo com o modo claro ou escuro. FormatMessage monta as linhas com marcas de tempo, prefixos do usuário ou do sistema e ícones indicando o status do envio. Os métodos responsáveis pelo histórico salvam e carregam as conversas em arquivos de dados específicos para cada chat, evitando que sejam perdidas entre as sessões.

void CCommunicationDialog::ApplyTheme()
{
   color bg = m_isDarkMode ? (color)0x2E2E35 : clrWhite;
   color txt= m_isDarkMode ? clrWhite       : clrBlack;
   m_mainPanel.ColorBackground(bg);
   m_composePanel.ColorBackground(bg);
   m_messageThread.Color(txt);
   m_messageInput.Color(txt);
   …
}

string CCommunicationDialog::FormatMessage(const string message,
                                           ENUM_MESSAGE_TYPE type,
                                           ENUM_MESSAGE_STATUS status,
                                           datetime ts)
{
   string user = (type==MSG_OUTGOING ? m_mainUserLabel.Text()
                                     : type==MSG_INCOMING ? "Them" : "System");
   string ico = (status==STATUS_SENT ? ShortToString(0x2713)
                                     : ShortToString(0x2717));
   return StringFormat("[%s] %s: %s %s",
                       TimeToString(ts,TIME_MINUTES), user, message,
                       (type==MSG_SYSTEM ? "" : ico));
}

Integração da classe CommunicationsDialog ao EA

No arquivo principal do EA (New_Admin_Pane.mq5), o arquivo Communications.mqh é integrado ao método HandleCommunications. Quando o usuário pressiona o botão Communications, o código alterna a visibilidade de uma instância existente de CCommunicationDialog ou, no primeiro uso, cria uma nova instância, inicializa-a com os valores salvos de chat ID e bot token e constrói a interface por meio de CreatePanel. Em seguida, show() é chamado para exibir o painel no gráfico. A criação sob demanda no primeiro clique, combinada com a lógica posterior de exibição e ocultação do painel, reduz o consumo de recursos e mantém uma separação clara entre a interface CommunicationsDialog e o restante do EA.

// handle showing/hiding communications panel
void HandleCommunications()
{
   if(g_commPanel)
   {
      // toggle visibility if already created
      if(g_commPanel.IsVisible()) g_commPanel.Hide();
      else                        g_commPanel.Show();
      ChartRedraw();
      return;
   }

   // first‐time creation
   g_commPanel = new CCommunicationDialog();

   // build the UI
   if(!g_commPanel.CreatePanel(g_chart_id,
                               "CommunicationsPanel",
                               g_subwin,
                               80, 100, 430, 500))
   {
      delete g_commPanel;
      g_commPanel = NULL;
      Print("CommPanel creation failed: ", GetLastError());
      return;
   }

   // pre‐fill credentials and display
   g_commPanel.InitCredentials(TwoFactorChatID, TwoFactorBotToken);
   g_commPanel.Show();
   ChartRedraw();
}

Testes e resultados

Primeiro, compilei o EA e não houve erros nem avisos. Depois de iniciá-lo, a interface principal foi exibida corretamente, com os botões Toggle, Trade, Communications, Analytics e Show All/Hide All em seus respectivos lugares.

1. Abertura do Painel de Comunicação

Ao pressionar o botão Communications, foi criada uma instância de CCommunicationDialog. A janela de diálogo apareceu na área reservada do gráfico, confirmando que CreatePanel funciona corretamente e que o painel lateral, a área de mensagens e a área de entrada foram construídos como esperado.

2. Entrada dos dados de autenticação

Testei as duas formas de entrada: pelos parâmetros de entrada do EA, TwoFactorChatID e TwoFactorBotToken, e pelos campos Chat ID e Bot Token do painel lateral. Nos dois casos, InitCredentials preencheu corretamente os campos e atualizou o rótulo You.

3. Envio de mensagem

Depois de informar os dados necessários, digitei uma mensagem de teste e pressionei Enter ou o botão Send. A mensagem apareceu na conversa com o ícone ✓ e também foi recebida no chat do Telegram. Isso confirma o funcionamento correto do WebRequest e do escape de caracteres no JSON.

4. Alternância de tema

Ao pressionar o botão com o ícone de lua/sol, a interface alterna entre os modos claro e escuro. As cores do plano de fundo e do texto foram atualizadas, e uma mensagem de sistema apareceu na conversa, como Dark mode enabled ou Light mode enabled.

5. Botões Screenshot e Attach

Ao pressionar o botão de captura de tela, um arquivo GIF é criado e salvo na pasta MQL5\Files, e uma mensagem correspondente também é registrada no log. Por enquanto, o botão de anexar arquivo apenas exibe uma mensagem de sistema provisória (Attachment TBD), indicando que ainda precisamos implementar o suporte completo ao envio de arquivos.

Teste da atualização do Painel de Comunicação

Conclusão

A criação de um painel moderno de mensagens totalmente integrado ao EA é perfeitamente viável, embora os controles da biblioteca padrão imponham algumas limitações. Em particular, o CEdit integrado aceita apenas uma única linha e um número limitado de caracteres. Nesta primeira etapa, implementamos a arquitetura básica, incluindo entrada de credenciais, disposição das mensagens, suporte a temas e integração com o Telegram. Durante a elaboração deste artigo, também encontrei extensões desenvolvidas pela comunidade que contornam essas limitações. Incluirei os links na próxima atualização.

Objetivos para o próximo artigo:

1. Histórico de chat com várias linhas

• Alinhamento das mensagens recebidas à esquerda e das enviadas à direita
• Quebra automática de linha e rolagem quando o conteúdo ultrapassar a área visível

2. Sistema de gerenciamento de contatos

• Uma agenda simples, com armazenamento persistente e acesso por username ou chat ID

3. Suporte a capturas de tela e anexos

• Criação e upload de arquivos
• Isso permitirá que os traders compartilhem instantaneamente análises de gráficos em tempo real. Esse recurso é essencial para o trabalho em equipe e a análise das operações.

4. Recursos avançados de atalhos de teclado

• Envio rápido de mensagens e comandos predefinidos

Essas são apenas algumas das melhorias planejadas. Seus comentários e sugestões são muito bem-vindos e nos ajudam a continuar aprimorando o projeto. Acredito que, em breve, poderemos comemorar a integração completa de uma API externa para troca de mensagens diretamente no MetaTrader 5. Espero que este artigo inspire os leitores a desenvolver novas ideias.

Boas operações e até o próximo artigo!

Arquivo	Descrição
New_Admin_Panel.mq5	EA com um sistema integrado de painéis para gerenciamento avançado de trading no MetaTrader 5.
CommunicationsDialog.mqh	Módulo do painel de comunicação: interface moderna de mensagens, baseada no Telegram, para EAs do MetaTrader 5. Coloque o arquivo na pasta Include do terminal.
All Modules.zip	Todos os arquivos de cabeçalho necessários. Salve-os na pasta MQL5/Include.

Voltar à introdução