Desenvolvendo um EA multimoeda (Parte 27): Componente para exibição de texto multilinha

MetaTrader 5 — Exemplos | 28 janeiro 2026, 07:43

Yuriy Bykov

Conteúdo

Introdução

Na parte anterior, criamos uma versão básica de um EA informador auxiliar, que exibe informações sobre os tamanhos médios das velas em pontos e os comprimentos das séries de velas consecutivas na mesma direção. Isso não está diretamente relacionado ao nosso projeto principal, a saber, um sistema de otimização automática e inicialização de EAs multimoeda que implementam diversas estratégias simples. No entanto, o desenvolvimento posterior do próprio EA informador, por enquanto, continuará no âmbito desta série, pois durante o trabalho já começamos a experimentar e a treinar a implementação de diversos componentes que, posteriormente, esperamos integrar com sucesso ao projeto principal.

Passamos para uma estrutura mais otimizada de organização do código, que abre a possibilidade de paralelizar o trabalho em várias direções de desenvolvimento da biblioteca Adwizard. Uma dessas direções é a criação de uma interface visual para o gerenciamento do funcionamento dos EAs finais. O projeto do EA informador, analisado também neste artigo, nos ajudará a explorar mais a fundo diferentes abordagens para a implementação de interfaces sem complexidade excessiva. Ao estudar suas vantagens e desvantagens, poderemos escolher a mais adequada e desenvolver o projeto principal de forma direcionada.

Da última vez, escrevemos a implementação da parte de cálculo, para a qual não foram impostas exigências rígidas de eficiência. Para a exibição dos resultados dos cálculos, utilizamos dois dos métodos mais simples disponíveis "de fábrica". O primeiro é o uso da função padrão Comment(), que exibe o texto transmitido diretamente no gráfico. O segundo é o uso de outra função padrão, Print(), para exibir texto no diário dos EAs. Isso é bastante conveniente para tarefas simples.

No entanto, esses métodos apresentam uma série de limitações. O principal problema do primeiro é a ausência de controle sobre o tamanho, o estilo e a cor da fonte, bem como a impossibilidade de rolar o texto quando há um grande volume de informações. Isso gera inconvenientes, especialmente ao exibir dados multilinha ou estruturados. O segundo método apresenta os mesmos problemas, com exceção da rolagem, além do inconveniente adicional de alimentar constantemente os registros no diário.

Por isso, no âmbito deste artigo, criaremos nosso próprio componente, uma janela de diálogo em tela cheia, capaz de exibir texto multilinha com configurações flexíveis de fonte e suporte a rolagem. Essa ferramenta tornará a visualização das informações mais conveniente e clara. Após o refinamento do uso desse componente, ele provavelmente passará a integrar a biblioteca Adwizard, como um meio de exibição de diversas informações sobre o funcionamento de EAs multimoeda.

Traçamos o caminho

Vamos listar os requisitos que gostaríamos de implementar:

Exibição de texto multilinha: ao componente é passado um texto totalmente formatado na forma de uma variável string, na qual podem aparecer caracteres de quebra de linha. Cada parte separada por caracteres de quebra de linha será exibida no gráfico em uma nova linha.
Rolagem de texto: se todo o texto não couber dentro da área disponível para exibição, será possível realizar rolagem vertical e horizontal, com a roda do mouse e com a tecla Shift pressionada no caso da rolagem horizontal. Por enquanto, não implementaremos a exibição de barras de rolagem, talvez as adicionemos posteriormente.
Alteração do tamanho da fonte: com a tecla Ctrl e a roda do mouse, será possível diminuir ou aumentar o tamanho da fonte utilizada para exibir o texto.
Suporte à alteração dos parâmetros da fonte, isto é, estilo, cor do texto e cor de fundo. A alteração desses parâmetros, por enquanto, será realizada apenas de forma programática. No futuro, pode-se adicionar uma interface para modificar esses parâmetros com o programa em execução.
Adaptação automática à alteração do tamanho do gráfico: se o usuário realizar quaisquer ações que levem à mudança do tamanho da janela do gráfico no qual o EA que utiliza este componente está em execução, o tamanho da área de exibição do texto também será alterado, continuando a ocupar toda a área disponível para exibição.
Minimização: possibilidade de minimizar e maximizar a área de exibição.

É possível que, durante a implementação, ajustemos adicionalmente alguns requisitos, mas, em geral, a lista acima é totalmente suficiente.

Classe CConsoleDialog

Vamos criar uma nova classe, chamando-a de CConsoleDialog. Faremos dela uma herdeira da classe existente da biblioteca padrão CAppDialog, pois nessa classe pai já existe uma quantidade considerável do que planejamos implementar. Por exemplo, a exibição da janela com botões de minimizar, maximizar e fechar o aplicativo do EA já está pronta. Resta-nos cuidar do conteúdo interno da área cliente da janela, é justamente ali que o texto será exibido.

Para a exibição do texto, utilizaremos um objeto da classe CCanvas para desenhar o texto, enquanto o suporte à rolagem e à alteração do tamanho da fonte será implementado por meio do processamento de eventos do gráfico.

É assim que ficará a descrição da nova classe:

//+------------------------------------------------------------------+
//| Класс диалогового окна на весь экран                             |
//| для вывода многострочного текста                                 |
//+------------------------------------------------------------------+
class CConsoleDialog : public CAppDialog {
protected:
   CCanvas           m_canvas;         // Объект холста для вывода текста

   string            m_lines[];        // Массив строк текста
   string            m_text;           // Текст для вывода в диалоговом окне

   int               m_startRow;       // Начальная строка видимого текста
   int               m_startCol;       // Начальный столбец (символ) видимого текста

   int               m_totalRows;      // Общее число строк текста
   int               m_totalCols;      // Общее число символов в самой длинной строке текста

   int               m_visibleRows;    // Максимальное количество видимых строк
   int               m_visibleCols;    // Максимальное количество видимых символов в строке

   string            m_fontName;          // Название шрифта для текста
   int               m_fontSize;          // Размер шрифта
   uint              m_fontColor;         // Цвет шрифта

   int               m_fontSymbolWidth;   // Ширина одного символа в пикселях
   int               m_fontSymbolHeight;  // Высота строки текста в пикселях

   uint              m_backgroundColor;   // Цвет фона

   bool              m_mouseWheel;        // Предыдущее состояние отслеживания событий прокрутки мышью

   bool              CreateCanvas();      // Создание холста
   void              UpdateCanvas();      // Вывод текста на холсте
   void              UpdateCanvasFont();  // Изменение шрифта холста

public:
                     CConsoleDialog();       // Конструктор
                    ~CConsoleDialog(void);   // Деструктор

   // Методы создания диалогового окна
   bool              Create(string name);
   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      ChartEvent(const int id, const long &lparam,
                                const double &dparam, const string &sparam);

   virtual void      Minimize();             // Минимизация диалогового окна
   virtual void      Maximize();             // Максимизация диалогового окна

   virtual void      Text(string text);      // Установка нового текста

   virtual void      FontName(string p_fontName);  // Установка названия шрифта
   virtual bool      FontSize(int p_fontSize);     // Установка размера шрифта
   virtual void      FontColor(uint p_fontColor);  // Установка цвета шрифта

   // Установка цвета фона
   virtual void      BackgroundColor(uint p_backgroundColor);
};

De todos os métodos públicos listados, por enquanto utilizaremos principalmente o método de definição de novo texto Text() e a primeira variante do método Create(), que permite criar a janela de diálogo informando apenas o seu nome. Esse mesmo nome será usado como legenda no título da janela.

Construtor e destrutor

Ao criar um objeto da classe CConsoleDialog, o construtor inicializa a fonte padrão, isto é, uma fonte monoespaçada "Consolas" com tamanho 13, com a cor do texto definida como preta e com uma leve transparência. Essa fonte foi escolhida para permitir a exibição de dados tabulares em forma de texto, de modo que eles realmente se pareçam com tabelas, com colunas alinhadas de maneira uniforme. Caso a fonte não seja monoespaçada, não será possível obter tabelas alinhadas corretamente.

O tamanho da fonte de 13 pixels, por um lado, é pequeno o suficiente para exibir um grande volume de texto e, por outro, ainda não é tão pequeno a ponto de se tornar ilegível. Considerando a possibilidade planejada de alterar facilmente o tamanho, a escolha de um valor inicial específico não desempenha um papel fundamental. A cor de fundo é definida como transparente, portanto, através do canvas veremos a cor cinza padrão de fundo utilizada na classe CDialog.

Para a exibição correta, o método de definição do tamanho da fonte FontSize() é chamado imediatamente, pois ele determina os parâmetros básicos para o desenho do texto no canvas. Por sua vez, o destrutor é responsável pela remoção correta do recurso do canvas e pela restauração da configuração original de tratamento dos eventos de rolagem da roda do mouse no gráfico.

//+------------------------------------------------------------------+
//| Конструктор                                                      |
//+------------------------------------------------------------------+
CConsoleDialog::CConsoleDialog() :
   m_fontName("Consolas"),
   m_fontSize(13),
   m_fontColor(ColorToARGB(clrBlack, 240)),
   m_backgroundColor(ColorToARGB(clrBlack, 0)) {
   FontSize(m_fontSize);
}

//+------------------------------------------------------------------+
//| Деструктор                                                       |
//+------------------------------------------------------------------+
CConsoleDialog::~CConsoleDialog() {
// Удаляем холст
   m_canvas.Destroy();

// Возвращаем прежнюю настройку обработки событий прокрутки мышью
   ChartSetInteger(m_chart_id, CHART_EVENT_MOUSE_WHEEL, (long)m_mouseWheel);
}

Criação da janela de diálogo

Para a criação da janela, existem duas variantes do método Create(). A primeira aceita apenas o nome da janela e define automaticamente a posição e o tamanho da janela para ocupar praticamente toda a área do gráfico, com uma pequena margem superior. Esse método calcula as dimensões do gráfico e chama a segunda variante do Create() com coordenadas específicas.

O segundo método permite criar a janela de diálogo com parâmetros definidos, isto é, o número do gráfico, o nome, o número da subjanela e as coordenadas. Nesse método, primeiro é chamada a implementação da classe pai para criar a janela, em seguida são definidos os tamanhos para o estado minimizado, o canvas é criado, o rastreamento dos eventos de rolagem do mouse é ativado e as posições da área visível do texto são inicializadas, para que a exibição comece desde o início.

//+------------------------------------------------------------------+
//| Метод создания диалогового окна только по имени                  |
//+------------------------------------------------------------------+
bool CConsoleDialog::Create(string name) {
// Устанавливаем положение угла и размеры окна
   int x1 = 0;
   int y1 = DIALOG_VERTICAL_MARGIN;
   int y2 = (int) ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS, 0);
   int x2 = (int) ChartGetInteger(0, CHART_WIDTH_IN_PIXELS, 0);

// Вызываем метод создания по заданным размерам
   return Create(0, name, 0, x1, y1, x2, y2);
}

//+------------------------------------------------------------------+
//| Метод создания диалогового окна                                  |
//+------------------------------------------------------------------+
bool CConsoleDialog::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)) {
      return false;
   }

// Устновка размеров минимизированного окна диалога
   m_min_rect.SetBound(0, DIALOG_VERTICAL_MARGIN,
                       250, DIALOG_VERTICAL_MARGIN + CONTROLS_DIALOG_MINIMIZE_HEIGHT);

// Создание холста
   if(!CreateCanvas()) {
      return false;
   }

// Запоминаем прежнюю настройку обработки событий прокрутки мышью
   m_mouseWheel = ChartGetInteger(0, CHART_EVENT_MOUSE_WHEEL);

// Устанавливаем отслеживание событий прокрутки мышью
   ChartSetInteger(chart, CHART_EVENT_MOUSE_WHEEL, 1);

// Устанавливаем начальное положение текста в окне
   m_startRow = 0;
   m_startCol = 0;

   return true;
}

O valor da margem superior em relação à borda da janela do gráfico é definido pela constante DIALOG_VERTICAL_MARGIN. A presença dessa margem permite visualizar, na parte superior do gráfico, o nome do símbolo e o timeframe, bem como o nome do EA em execução. Ao clicar no nome do EA, é possível acessar rapidamente seus parâmetros. Se a janela de diálogo começasse a partir do topo absoluto do gráfico, essa possibilidade não existiria. Ainda assim, caso ela se mostre desnecessária, basta definir o valor da constante mencionada como 0, e então a janela de diálogo realmente passará a ocupar toda a área disponível do gráfico.

Processamento de eventos

O método ChartEvent() é responsável pelo processamento de diversos eventos do gráfico. Principalmente, trataremos os eventos de rolagem da roda do mouse (CHARTEVENT_MOUSE_WHEEL). Se a janela não estiver minimizada, ocorre a verificação das teclas pressionadas: com a tecla Shift pressionada, é realizada a rolagem horizontal do texto, caso ele exceda o intervalo visível em largura; sem teclas adicionais, ocorre a rolagem vertical quando há excesso em altura; e com a tecla Ctrl pressionada, é possível alterar o tamanho da fonte, escalonando o texto. No caso de alteração do tamanho do gráfico, o método adapta automaticamente as dimensões da janela, expandindo-a para toda a área disponível quando necessário. Todos os demais eventos são tratados na classe base CAppDialog.

//+------------------------------------------------------------------+
//| Обработка событий                                                |
//+------------------------------------------------------------------+
void CConsoleDialog::ChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) {
// Обработка события прокрутки колёсика мыши
   if(id == CHARTEVENT_MOUSE_WHEEL) {
      // Если окно диалога минимизировано, то не обрабатываем это событие
      if(m_minimized) {
         return;
      }

      // Разбираем состояние кнопок и колесика мышки для этого события
      int flg_keys = (int)(lparam >> 32);       // флаг состояний клавиш Ctrl, Shift и кнопок мышки
      int delta    = (int)dparam;               // суммарное значение прокрутки колесика, 
                                                // срабатывает при достижении +120 или -120

      // Если нажата клавиша SHIFT, то
      if((flg_keys & 0x0004) != 0) {
         // Если количество символов в строке больше количества видимых
         // символов в диалоге, то выполняем горизонтальное смещение
         if(m_totalCols > m_visibleCols) {
            // На одно событие прокрутки будем смещаться на 2 символа (120 / 60 = 2)
            delta /= 60;

            // Если новая начальная позиция попадает в допустимый диапазон, то
            if(m_startCol - delta >= 0
                  && m_startCol - delta <= m_totalCols - m_visibleCols + 2) {
               // Запоминаем новую начальную позицию
               m_startCol -= delta;

               // Обновляем холст
               UpdateCanvas();
            }
         }
      } else if (flg_keys == 0) {
         // Иначе если количество строк текста больше количества видимых
         // строк в диалоге, то выполняем вертикальное смещение
         if(m_totalRows > m_visibleRows) {
            // На одно событие прокрутки будем смещаться на 1 строку (120 / 120 = 1)
            delta /= 120;

            // Если новая начальная позиция попадает в допустимый диапазон, то
            if(m_startRow - delta >= 0
                  && m_startRow - delta <= m_totalRows - m_visibleRows + 1) {
               // Запоминаем новую начальную позицию
               m_startRow -= delta;

               // Обновляем холст
               UpdateCanvas();
            }
         }
      } else if((flg_keys & 0x0008) != 0) {
         // Иначе если нажата клавиша CTRL, то пробуем установить новый размер шрифта
         if(FontSize(m_fontSize + delta / 120)) {
            // Обновляем холст
            UpdateCanvas();
         }
      }

      return;
   }

// Обработка события изменения графика
   if(id == CHARTEVENT_CHART_CHANGE) {
      // Если размеры отображаемой области изменились
      if(m_chart.HeightInPixels(m_subwin) != Height() + DIALOG_VERTICAL_MARGIN
            || m_chart.WidthInPixels() != Width()) {
         // Установить для диалогового окна новые размеры
         m_norm_rect.SetBound(0, DIALOG_VERTICAL_MARGIN, m_chart.WidthInPixels(), m_chart.HeightInPixels(m_subwin));

         // Если окно диалога не минимизировано, то
         if(!m_minimized) {
            // Разворачивем его на полный экран графика с новыми размерами
            Maximize();
         }
         return;
      }
   }

// Обработка отсальных событий в вышестоящем классе
   CAppDialog::ChartEvent(id, lparam, dparam, sparam);
}

Como neste diálogo não utilizamos componentes que sejam herdeiros da classe CWndObj, não podemos recorrer aos macros padrão para criar a função OnEvent(), na qual ocorre a vinculação dos eventos dos componentes do diálogo com suas funções manipuladoras. O componente CCanvas que utilizamos nos obriga a usar exclusivamente o manipulador geral de eventos do gráfico ChartEvent().

Minimização

Ao minimizar a janela pelo método Minimize(), o canvas é destruído, liberando os recursos utilizados. Em seguida, é chamada a implementação base para alterar o estado da janela. De forma semelhante, ao maximizar pelo método Maximize(), primeiro é chamado o método da classe pai, que expande a janela, após o que o canvas é criado e a exibição do texto é atualizada, garantindo a renderização correta considerando os novos tamanhos da área cliente.

//+------------------------------------------------------------------+
//| Минмизация диалогового окна                                      |
//+------------------------------------------------------------------+
void CConsoleDialog::Minimize() {
// Удаляем холст
   m_canvas.Destroy();

// Вызываем родительский метод минимизации
   CAppDialog::Minimize();
}

//+------------------------------------------------------------------+
//| Максимизация диалогового окна                                    |
//+------------------------------------------------------------------+
void CConsoleDialog::Maximize() {
// Вызываем родительский метод максимизации
   CAppDialog::Maximize();

// Создаём холст
   CreateCanvas();

// Выводим текст на холсте
   UpdateCanvas();
}

É possível que, no futuro, seja mais conveniente escrever uma classe de encapsulamento para o canvas, transformando-o em um herdeiro da classe CWndObj. Mas, por enquanto, essa abordagem também é plenamente suficiente.

Trabalho com texto

Para definir ou alterar o texto exibido, utiliza-se o método Text(). Ele verifica se o novo texto é diferente do atual. Em caso afirmativo, a string original é dividida em um array de strings pelo caractere de quebra de linha '\n'. Em seguida, é armazenada a quantidade de linhas e determinada a maior extensão da linha mais longa. Esses dados são necessários para a organização correta da rolagem e da exibição. Depois disso, é chamada a atualização do canvas para exibir o novo texto.

//+------------------------------------------------------------------+
//| Установка текста                                                 |
//+------------------------------------------------------------------+
void CConsoleDialog::Text(string text) {
// Если текст изменяется, то
   if(text != m_text) {
      // Запомним новый тект
      m_text = text;

      // Делим текст на строки
      StringSplit(m_text, '\n', m_lines);

      // Запоминаем количество строк
      m_totalRows = ArraySize(m_lines);

      // Определяем максимальную длину строк
      m_totalCols = 0;
      FOREACH(m_lines) {
         m_totalCols = MathMax(m_totalCols, StringLen(m_lines[i]));
      }

      // Выводим текст на холсте
      UpdateCanvas();
   }
}

Configuração de fonte e cor

O método FontName() permite definir o nome da fonte utilizada para a exibição do texto e atualiza as configurações do canvas de acordo.

A alteração do tamanho da fonte é implementada no método FontSize(), que recebe um novo valor e verifica se ele está dentro de limites razoáveis, de 8 a 72. Em caso de alteração bem-sucedida, a posição de rolagem é redefinida para o início do texto, e os parâmetros da fonte do canvas são atualizados conforme o novo tamanho. Além disso, para o novo tamanho são calculados e armazenados os valores de largura e altura de um único caractere, necessários para o cálculo correto da parte visível do texto.

O método FontColor() permite definir a cor da fonte.

//+------------------------------------------------------------------+
//| Установка названия шрифта                                        |
//+------------------------------------------------------------------+
void CConsoleDialog::FontName(string p_fontName) {
// Запоминаем новое имя шрифта
   m_fontName = p_fontName;

// Обновляем шрифт холста
   UpdateCanvasFont();
}

//+------------------------------------------------------------------+
//| Установка размера шрифта                                         |
//+------------------------------------------------------------------+
bool CConsoleDialog::FontSize(int p_fontSize) {
// Если размер находится в разумных пределах, то
   if (p_fontSize >= 8 && p_fontSize <= 72) {
      // Запоминаем новый размер шрифта
      m_fontSize = p_fontSize;

      // Сбрасываем начальную строку и столбец
      m_startRow = 0;
      m_startCol = 0;

      // Обновляем шрифт холста
      UpdateCanvasFont();

      return true;
   }

   return false;
}

//+------------------------------------------------------------------+
//| Установка цвета шрифта                                           |
//+------------------------------------------------------------------+
void CConsoleDialog::FontColor(uint p_fontColor) {
   m_fontColor = p_fontColor;
}

Trabalho com canvas

A criação do canvas é responsabilidade do método CreateCanvas(), que inicializa o objeto CCanvas com os tamanhos da área cliente da janela de diálogo e define o formato de cor com canal alfa. Em caso de criação bem-sucedida do canvas, a fonte e os parâmetros dos caracteres são definidos imediatamente. O método UpdateCanvas() é responsável pela renderização direta do texto no canvas: ele limpa o fundo e, em seguida, exibe as linhas visíveis, levando em conta as posições atuais de rolagem por linhas e por caracteres. Para cada linha visível, o início da string é truncado quando necessário, e o texto é exibido com pequenos recuos em relação às bordas. Após a conclusão da renderização, é chamada a atualização do canvas para que as alterações se tornem visíveis ao usuário.

Por fim, o método UpdateCanvasFont() atualiza os parâmetros da fonte no canvas, calcula as dimensões de um único caractere com base na letra "M" e determina quantas linhas e quantos caracteres podem ser acomodados nos tamanhos atuais da janela, o que é necessário para a organização da rolagem.

//+------------------------------------------------------------------+
//| Создание холста                                                  |
//+------------------------------------------------------------------+
bool CConsoleDialog::CreateCanvas() {
// Получаем размеры клиентской области диалогового окна
   int height = ClientAreaHeight();
   int width = ClientAreaWidth();

// Если размеры ненулевые
   if(height > 0 && width > 0) {
      // Если при создании холста возникла ошибка, то выходим
      if(!m_canvas.CreateBitmapLabel("display",
                                     ClientAreaLeft(),
                                     ClientAreaTop(),
                                     ClientAreaWidth(),
                                     ClientAreaHeight(),
                                     COLOR_FORMAT_ARGB_NORMALIZE)) {
         PrintFormat(__FUNCTION__" | ERROR: Creating canvas %d", GetLastError());
         return false;
      }

      UpdateCanvasFont();
   }

   return true;
}

//+------------------------------------------------------------------+
//| Вывод текста на холсте                                           |
//+------------------------------------------------------------------+
void CConsoleDialog::UpdateCanvas() {
// Стираем холст цветом фона
   m_canvas.Erase(m_backgroundColor);

// Для каждой строки, попадающей в видимый диапазон
   for (int i = m_startRow; i < MathMin(m_totalRows, m_startRow + m_visibleRows); i++) {
      // Берём очередную строку текста
      string line = m_lines[i];

      // Если её надо показывать не с первого символа, то
      if (m_startCol > 0) {
         // Вырезаем начальные символы
         line = StringSubstr(line, m_startCol);
      }

      // Выводим строку на холст
      m_canvas.TextOut(5, 5 + (i - m_startRow) * m_fontSymbolHeight, line, m_fontColor, TA_LEFT | TA_TOP);
   }

// Вызываем метод отрисовки холста на экране
   m_canvas.Update(true);
}

//+------------------------------------------------------------------+
//| Изменение шрифта холста                                          |
//+------------------------------------------------------------------+
void CConsoleDialog::UpdateCanvasFont() {
// Установка параметров шрифта для вывода текста на холст
   m_canvas.FontSet(m_fontName, m_fontSize);

// Установка новых размеров одного символа
   m_canvas.TextSize("M", m_fontSymbolWidth, m_fontSymbolHeight);

// Определяем количество видимых строк и символов в строке (столбцов)
   m_visibleRows = ClientAreaHeight() / m_fontSymbolHeight;
   m_visibleCols = ClientAreaWidth() / m_fontSymbolWidth;
}

Vamos salvar o código obtido no arquivo ConsoleDialog.mqh na pasta do projeto e verificar quais alterações precisam ser feitas no arquivo do EA informador para conectar o componente desenvolvido.

Conectamos o componente

Para exibir texto no gráfico utilizando o novo componente, abrimos o arquivo do EA informador. Antes de tudo, conectamos o arquivo de biblioteca criado:

#include "ConsoleDialog.mqh"

Em seguida, criamos um objeto global do diálogo:

CConsoleDialog *dialog;

No método Init(), antes do início dos cálculos e da exibição, adicionamos os comandos de criação e inicialização do diálogo:

//+------------------------------------------------------------------+
//| Инициализация советника                                          |
//+------------------------------------------------------------------+
int OnInit(void) {
// ...

// Создаём и запускаем диалог для вывода результатов
   dialog = new CConsoleDialog();
   dialog.Create("Symbols Informer");
   dialog.Run();

// Выполняем принудительный перерасчёт
   Calculate(true);

// Показываем результаты
   Show();

   return(INIT_SUCCEEDED);
}

E, por fim, na função Show() substituímos a chamada da função Comment() pela definição do texto com os resultados para o nosso diálogo:

//+------------------------------------------------------------------+
//| Показ результатов                                                |
//+------------------------------------------------------------------+
void Show() {
// Получаем результаты в виде текста
   string text = TextComment();

// Показываем его на графике в диалоговом окне
   dialog.Text(text);
}

Salvamos as alterações realizadas no arquivo SymbolsInformer.mq5 na pasta do projeto.

Teste

Executamos o EA informador com os parâmetros padrão. Como agora tanto a rolagem quanto a alteração do tamanho do texto funcionam, é possível escolher com tranquilidade o tamanho mais confortável e a área visível desejada dos resultados.

Se nos interessarem, por exemplo, apenas os dados sobre o tamanho médio das velas para EURUSD M30, podemos configurar essa exibição aumentando o tamanho da fonte:

Se, por outro lado, quisermos ver imediatamente todos os valores para GBPUSD e EURGBP, podemos reduzir novamente o tamanho da fonte e rolar o texto para baixo:

O componente desenvolvido pode ser facilmente adaptado para uso em EAs já prontos, nos quais não é utilizada uma interface gráfica, e todas as informações são exibidas no gráfico na forma de texto.

Por exemplo, em um artigo recente, Arbitragem Forex: sistema de negociação matricial para retorno ao valor justo com limitação de risco, o autor apresenta justamente um exemplo desse tipo de EA:

Ao introduzir pequenas alterações em seu código-fonte, descritas na seção sobre a conexão do componente, obtemos o seguinte resultado:

Dessa forma, a percepção das informações torna-se muito mais conveniente e agradável.

Conclusão

Assim, aprimoramos um pouco a primeira versão do EA informador auxiliar, que exibe informações sobre os tamanhos médios das velas em pontos e os comprimentos das séries de velas consecutivas na mesma direção. Paralelamente, desenvolvemos um componente que pode ser útil em muitos outros EAs.

No entanto, por enquanto, tanto a parte de cálculo quanto a exibição dos resultados ficam a cargo de um único EA. Na próxima vez, tentaremos separar essas duas partes para garantir maior flexibilidade. Esse mesmo enfoque planejamos aplicar posteriormente também ao EA multimoeda de negociação.

Obrigado pela atenção e até a próxima!

Aviso importante

Todos os resultados apresentados neste artigo e em todos os artigos anteriores deste ciclo baseiam-se exclusivamente em dados de testes em histórico e não constituem garantia de qualquer tipo de rentabilidade futura. O trabalho realizado no âmbito deste projeto tem caráter de pesquisa. Todos os resultados publicados podem ser utilizados livremente por qualquer interessado, por sua própria conta e risco.

Conteúdo do arquivo compactado

#	Nome	Versão	Descrição	Últimas alterações
	SymbolsInformer		Pasta de trabalho do projeto
1	SymbolsInformer.mq5	1.01	EA para exibir informações sobre os comprimentos de séries de velas consecutivas na mesma direção	Parte 27
2	CConsoleDialog.mqh	1.00		Parte 27
3	AbbyCross.mq5	–	Exemplo de arquivo de EA de terceiros com a classe CConsoleDialog conectada
	SymbolsInformer/Include/Adwizard/Utils		Utilitários auxiliares e macros para redução de código
4	Macros.mqh	1.07	Macros úteis para operações com arrays	Parte 26
5	NewBarEvent.mqh	1.00	Classe para detecção de novo candle para um símbolo específico	Parte 8

Além disso, o código-fonte também está disponível nos repositórios públicos SymbolsInformer e Adwizard.

Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/17883

Arquivos anexados |

Baixar como ZIP

MQL5.zip (19.76 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

Caminhe em novos trilhos: Personalize indicadores no MQL5

Vou agora listar todas as possibilidades novas e recursos do novo terminal e linguagem. Elas são várias, e algumas novidades valem a discussão em um artigo separado. Além disso, não há códigos aqui escritos com programação orientada ao objeto, é um tópico muito importante para ser simplesmente mencionado em um contexto como vantagens adicionais para os desenvolvedores. Neste artigo vamos considerar os indicadores, sua estrutura, desenho, tipos e seus detalhes de programação em comparação com o MQL4. Espero que este artigo seja útil tanto para desenvolvedores iniciantes quanto para experientes, talvez alguns deles encontrem algo novo.

Indicador do modelo CAPM no mercado Forex

Adaptação do modelo clássico CAPM para o mercado cambial Forex em MQL5. O indicador calcula a rentabilidade esperada e o prêmio de risco com base na volatilidade histórica. Os indicadores aumentam nos picos e nas depressões, refletindo os princípios fundamentais de precificação. Aplicação prática para estratégias contra a tendência e de seguimento de tendência, levando em conta a dinâmica da relação entre risco e rentabilidade em tempo real. Inclui o aparato matemático e a implementação técnica.

Está chegando o novo MetaTrader 5 e MQL5

Esta é apenas uma breve resenha do MetaTrader 5. Eu não posso descrever todos os novos recursos do sistema por um período tão curto de tempo - os testes começaram em 09.09.2009. Esta é uma data simbólica, e tenho certeza que será um número de sorte. Alguns dias passaram-se desde que eu obtive a versão beta do terminal MetaTrader 5 e MQL5. Eu ainda não consegui testar todos os seus recursos, mas já estou impressionado.

Redes neurais em trading: Extração eficiente de características para classificação precisa (Construção de objetos)

Mantis é uma ferramenta universal para análise profunda de séries temporais, escalável de forma flexível para quaisquer cenários financeiros. Saiba como a combinação de patching, convoluções locais e atenção cruzada permite obter uma interpretação de alta precisão dos padrões de mercado.