Desarrollamos un asesor experto multidivisas (Parte 27): Componente para mostrar textos de varias líneas

MetaTrader 5 — Ejemplos | 30 marzo 2026, 14:07

Yuriy Bykov

Contenido

Introducción

En la sección anterior, creamos una versión básica de un asesor-informador auxiliar que muestra información sobre los tamaños promedio de las velas en puntos y las longitudes de series de velas en la misma dirección. Esto no se relaciona directamente con nuestro proyecto principal: un sistema para la optimización automática y el inicio de asesores multidivisa que implementan una variedad de estrategias simples. Sin embargo, el desarrollo futuro del asesor-informador permanecerá por ahora en el marco de esta serie, ya que hemos comenzado a experimentar y mejorar la implementación de varios componentes que esperamos integrar posteriormente con éxito en el proyecto principal.

Hemos pasado a una estructura de código más optimizada que abre la posibilidad de paralelizar el trabajo en múltiples áreas del desarrollo de la biblioteca Adwizard. Una de estas áreas es la creación de una interfaz visual para gestionar el trabajo de los asesores finales. El proyecto de asesor-informador analizado en este artículo nos ayudará a explorar más a fondo diferentes enfoques para implementar la interfaz sin complejidad innecesaria. Tras estudiar sus ventajas y desventajas, podremos elegir el más adecuado y desarrollar con criterio el proyecto principal.

La última vez escribimos una posible implementación de la parte de cálculo, que no tenía requisitos estrictos de eficiencia. Para mostrar los resultados del cálculo, usamos dos métodos simples disponibles "listos para usar". La primera consiste en usar la función estándar Comment(), que muestra el texto pasado directamente en el gráfico. La segunda consiste en utilizar otra función estándar Print(), para enviar texto al registro del asesor. Esto resulta bastante cómodo para tareas sencillas.

No obstante, estos métodos tienen una serie de limitaciones. El principal problema del primero es la falta de control sobre el tamaño, estilo y color de la fuente, así como la imposibilidad de desplazarse por el texto cuando existe una gran cantidad de información. Esto crea inconvenientes, especialmente cuando se generan datos estructurados o de varias líneas. El segundo método tiene los mismos problemas, salvo el desplazamiento, más el inconveniente añadido de tener que agregar constantemente entradas al diario.

Por ello, en este artículo, crearemos nuestro propio componente: un cuadro de diálogo de pantalla completa capaz de mostrar texto de varias líneas con configuraciones de fuente flexibles y soporte de desplazamiento. Esta herramienta hará que la visualización de la información resulte más cómoda y clara. Una vez que hayamos probado este componente, probablemente pasará a formar parte de la biblioteca Adwizard como un recurso para mostrar una amplia variedad de información sobre el funcionamiento de los asesores multidivisa.

Trazando el camino

Vamos a enumerar los deseos que querríamos implementar:

Muestra de texto de varias líneas: al componente se le transmite un texto completamente formado como variable de línea, que puede contener caracteres de avance de línea. Cada parte, separada por caracteres de avance de línea, se mostrará en la ventana del gráfico en una nueva línea.
Desplazamiento de texto: si el texto completo no cabe en el área de muestra disponible, podemos usar la rueda del ratón para desplazarnos vertical y horizontalmente (mientras mantenemos presionada la tecla Shift). Por ahora, no mostraremos barras de desplazamiento, pero podríamos agregarlas más adelante.
Cambio del tamaño de la fuente: utilizando la tecla Ctrl + la rueda del ratón, podemos disminuir o aumentar el tamaño de la fuente utilizada para mostrar el texto.
Soporte para cambiar parámetros de fuente: estilo, color de texto y color de fondo. Por ahora, el cambio de estos parámetros solo se realizará mediante programación. En el futuro, podemos agregar una interfaz para cambiar estos parámetros cuando el programa se esté ejecutando.
Adaptación automática al cambio de tamaño del gráfico: si realizamos alguna acción que resulte en un cambio en el tamaño de la ventana del gráfico en el que se ejecuta el asesor experto que utiliza este componente para la muestra, el tamaño del área de muestra de texto también cambiará, ocupando el área completa disponible para la muestra.
Minimización: es la capacidad de minimizar y maximizar el área de muestra.

Posiblemente necesitemos mejorar aún más algunos de los requisitos durante el proceso de implementación, pero en general, la lista anterior resulta suficiente.

Clase CConsoleDialog

Vamos a crear una nueva clase y a llamarla CConsoleDialog. La haremos descendiente de la clase de biblioteca estándar existente CAppDialog, ya que esta clase padre ya contiene bastante de lo que planeamos implementar. Por ejemplo, la visualización de la ventana con los botones para minimizar/maximizar y cerrar la aplicación del asesor ya está lista. Todo lo que debemos hacer es ocuparnos del contenido interno del área de cliente de la ventana: aquí es donde se mostrará el texto.

Al mostrar el texto, usaremos un objeto de clase CCanvas para dibujar el mismo, e implementaremos el soporte para desplazarse y cambiar el tamaño de fuente mediante el manejo de eventos gráficos.

Así es como se verá la descripción de la nueva clase:

//+------------------------------------------------------------------+
//| Класс диалогового окна на весь экран                             |
//| для вывода многострочного текста                                 |
//+------------------------------------------------------------------+
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 los métodos públicos enumerados, por ahora usaremos principalmente el método para configurar texto nuevo Text() y la primera versión del método Create(), que permite crear un cuadro de diálogo especificando solo su nombre. También la usaremos como título en la ventana.

Constructor y destructor

Al crear un objeto de la clase CConsoleDialog, el constructor inicializa la fuente predeterminada: se trata de una fuente monoespaciada "Consolas" de tamaño 13, con el color del texto establecido en negro con una ligera transparencia. Hemos elegido esta fuente para que los datos tabulares puedan mostrarse como texto y se vean exactamente como tablas con columnas pares. Si la fuente no es monoespaciada, ni siquiera serán posibles las tablas.

Un tamaño de fuente de 13 píxeles es, por una parte, lo suficientemente pequeño para mostrar una gran cantidad de texto, pero por otra, no tan pequeño como para resultar ilegible. Dada la posibilidad prevista de cambiar fácilmente el tamaño, la elección de un valor inicial concreto no juega un papel especial. El color de fondo se hace transparente, por lo que veremos a través del lienzo el color de fondo gris estándar usado en la clase CDialog.

Para una visualización correcta, se llama inmediatamente al método FontSize() para establecer el tamaño de la fuente, que determina los parámetros básicos para dibujar texto en el lienzo. A su vez, el destructor es responsable de eliminar correctamente el recurso canvas y restaurar la configuración original para procesar eventos de desplazamiento de la rueda del ratón en el 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);
}

Creando un cuadro de diálogo

Hay dos opciones para que el método Create() cree una ventana. La primera admite solo el nombre de la ventana y establece automáticamente la posición y el tamaño de la ventana en toda la pantalla del gráfico con un pequeño margen superior. Este método calcula las dimensiones del gráfico y llama al segundo método Create() con las coordenadas indicadas.

El segundo método permite crear un cuadro de diálogo con parámetros específicos: número de gráfico, nombre, número de subventana y coordenadas. Este método primero llama a la implementación principal para crear la ventana, luego establece las dimensiones para el estado minimizado, crea el lienzo, habilita el seguimiento de eventos de desplazamiento del ratón e inicializa las posiciones del área de texto visible para que la visualización empiece desde cero.

//+------------------------------------------------------------------+
//| Метод создания диалогового окна только по имени                  |
//+------------------------------------------------------------------+
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;
}

El valor del margen superior desde el borde de la ventana del gráfico se indica mediante la constante DIALOG_VERTICAL_MARGIN. Esta separación permite ver el nombre del símbolo y el periodo de tiempo en la parte superior del gráfico, así como el nombre del asesor en ejecución. Haciendo clic en el nombre del asesor podrás acceder rápidamente a sus parámetros. Si el cuadro de diálogo comenzara desde la parte superior del gráfico, esta opción no existiría. Sin embargo, si por algún motivo resulta innecesario, simplemente podemos establecer el valor de la constante mencionada anteriormente en 0, y luego el cuadro de diálogo ocupará toda el área disponible del gráfico.

Gestión de eventos

El método ChartEvent() es responsable de manejar varios eventos de gráficos. Básicamente, procesaremos los eventos de desplazamiento de la rueda del ratón (CHARTEVENT_MOUSE_WHEEL). Si la ventana no está minimizada, se verificarán las teclas presionadas: manteniendo presionada la tecla Shift desplazamos el texto horizontalmente si la anchura excede el rango visible; si no hay teclas adicionales, el texto se desplazará verticalmente cuando su altura supere el área visible; y manteniendo presionada la tecla Ctrl podremos cambiar el tamaño de fuente escalando el texto. Si el tamaño del gráfico cambia, el método adaptará automáticamente el tamaño de la ventana, expandiéndola para llenar toda el área disponible si es necesario. Todos los demás eventos se procesarán en la clase básica 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 no utilizamos componentes que sean descendientes de la clase CWndObj en este cuadro de diálogo, no podemos usar macros estándar para crear la función OnEvent(), que vincula los eventos de los componentes del cuadro de diálogo y sus funciones de controlador. El componente CCanvas que estamos usando nos obliga a usar el manejador de eventos de gráfico general ChartEvent().

Minimización

Al minimizar una ventana utilizando el método Minimize(), se eliminar el lienzo, lo cual liberará los recursos que este utiliza. Después de ello, se llamará a la implementación básica para cambiar el estado de la ventana. De forma similar, al maximizar con el método Maximize(),, primero se llama al método padre para maximizar la ventana, después de lo cual se crea el lienzo y se actualiza la visualización del texto para garantizar una muestra correcta dadas las nuevas dimensiones del área del cliente.

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

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

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

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

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

Tal vez nos resulte más cómodo en el futuro escribir una clase contenedora para el lienzo, convirtiéndolo en un descendiente de la clase CWndObj. Pero por ahora este enfoque nos bastará.

Trabajando con texto

Para establecer o cambiar el texto mostrado, utilizaremos el método Text(). Este comprueba si el nuevo texto es diferente del actual. De ser así, la línea original se dividirá en un array de líneas en el carácter de avance de línea '\n'. Después de esto, se guarda el número de líneas y se determina la longitud máxima de la línea más larga. Estos datos son necesarios para organizar correctamente el desplazamiento y la visualización. Luego, se actualiza el lienzo para mostrar el nuevo 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();
   }
}

Configuración de la fuente y el color

El método FontName() permite establecer el nombre de la fuente utilizada para mostrar texto y actualiza la configuración del lienzo en consecuencia.

El cambio del tamaño de fuente se implementa en el método FontSize(), que toma un nuevo valor y comprueba que esté dentro de límites razonables (de 8 a 72). Si el cambio se realiza con éxito, la posición de desplazamiento se restablecerá al inicio del texto y las propiedades de fuente del lienzo se actualizarán para reflejar el nuevo valor de tamaño. Además, para el nuevo tamaño, se calcularán y guardarán los valores de anchura y altura del carácter para calcular correctamente la parte visible del texto.

El método FontColor() permite establecer el color de la fuente.

//+------------------------------------------------------------------+
//| Установка названия шрифта                                        |
//+------------------------------------------------------------------+
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;
}

Trabajando con el lienzo

El método CreateCanvas() se encarga de crear el lienzo que inicializa el objeto CCanvas con las dimensiones del área de cliente del cuadro de diálogo y especificar un formato de color con un canal alfa. Cuando el lienzo se crea correctamente, los parámetros de fuente y carácter se establecen de inmediato. El método UpdateCanvas() se encarga de dibujar el texto en el lienzo: borra el fondo y luego muestra las líneas visibles, considerando las posiciones de desplazamiento actuales por líneas y caracteres. Para cada línea visible, el comienzo de la línea se recorta si es necesario y el texto se muestra con pequeñas separaciones desde los bordes. Una vez se completa la representación, se realiza una actualización del lienzo para que los cambios sean visibles para el usuario.

Finalmente, el método UpdateCanvasFont() actualiza la configuración de la fuente en el lienzo, calcula las dimensiones de un carácter según la letra "M" y calcula cuántas líneas y caracteres pueden caber en las dimensiones de la ventana actual, lo cual es necesario para desplazarse.

//+------------------------------------------------------------------+
//| Создание холста                                                  |
//+------------------------------------------------------------------+
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 a guardar el código resultante en el archivo ConsoleDialog.mqh en la carpeta del proyecto y veamos qué cambios deben realizarse en el archivo del asesor-informador para conectar el componente desarrollado.

Conectando el componente

Para mostrar texto en un gráfico utilizando el nuevo componente, abriremos el archivo asesor-informador. Primero, debemos incluir el archivo de biblioteca creado:

#include "ConsoleDialog.mqh"

A continuación, crearemos un objeto de creación e inicio del diálogo global:

CConsoleDialog *dialog;

En el método Init(), antes de iniciar el cálculo y la visualización, agregaremos los comandos para crear e iniciar el cuadro de diálogo:

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

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

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

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

   return(INIT_SUCCEEDED);
}

Y finalmente, en la función Show(), reemplazaremos la llamada a la función Comment() con la configuración del texto con los resultados de nuestro cuadro de diálogo:

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

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

Luego guardaremos los cambios realizados en el archivo SymbolsInformer.mq5 en la carpeta del proyecto.

Simulación

Iniciaremos el asesor-informador con los parámetros predeterminados. Como ahora funcionan tanto el desplazamiento como el cambio de tamaño del texto, podemos seleccionar fácilmente el tamaño más cómodo y el área de resultados visibles deseada.

Si nos interesan, por ejemplo, solo los datos sobre el tamaño medio de la vela del EURUSD M30, podemos crear la siguiente visualización aumentando el tamaño de la fuente:

Si queremos ver todos los valores de GBPUSD y EURGBP a la vez, podemos reducir nuevamente el tamaño de la fuente y desplazarnos hacia abajo por el texto:

Podemos adaptar fácilmente el componente desarrollado para su uso en asesores existentes, donde no se utiliza una interfaz gráfica y toda la información se muestra en el gráfico en forma de texto.

Por ejemplo, en el reciente artículo Trading de arbitraje en Forex: sistema comercial matricial para retornar al valor justo con limitación del riesgo, su autor ofrece un ejemplo de este tipo de asesor:

Realizando algunos cambios menores en su código fuente, como se describe en el apartado de conexión del componente, obtendremos la siguiente imagen:

De esta forma resulta mucho más cómodo y agradable percibir la información.

Conclusión

Hoy hemos mejorado ligeramente la primera versión del asesor-informador auxiliar, que muestra información sobre los tamaños promedio de las velas en puntos y las longitudes de las series de velas unidireccionales. De paso, hemos desarrollado un componente que podría ser útil en muchos otros asesores.

Pero por ahora tenemos un asesor responsable de la parte de los cálculos y de mostrar los resultados. La próxima vez intentaremos separar estas dos partes para ofrecer más flexibilidad. Planeamos transferir este enfoque a un asesor comercial multidivisa.

Gracias por su atención, ¡hasta pronto!

Advertencia importante

Todos los resultados expuestos en este artículo y en todos los artículos anteriores de la serie se basan únicamente en datos de pruebas históricas y no ofrecen ninguna garantía de lograr beneficios en el futuro. El trabajo de este proyecto es de carácter exploratorio. Todos los resultados publicados pueden ser usados por cualquiera bajo su propia responsabilidad.

Contenido del archivo

#	Nombre	Versión	Descripción	Cambios recientes
	SymbolsInformer		Carpeta de trabajo del proyecto
1	SymbolsInformer.mq5	1.01	Asesor experto mostrar información sobre las longitudes de las series de velas unidireccionales	Parte 27
2	CConsoleDialog.mqh	1.00		Parte 27
3	AbbyCross.mq5	—	Ejemplo de un archivo de asesor de terceros con la clase CConsoleDialog incluida
	SymbolsInformer/Include/Adwizard/Utils		Utilidades auxiliares, macros para la reducción del código
4	Macros.mqh	1.07	Macros útiles para operaciones con arrays	Parte 26
5	NewBarEvent.mqh	1.00	Clase de definición de una nueva barra para un símbolo específico	Parte 8

El código fuente también está disponible en los repositorios públicos SymbolsInformer y Adwizard.

Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/17883

Archivos adjuntos |

Descargar ZIP

MQL5.zip (19.76 KB)

Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.

Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.

Otros artículos del autor

Pasar a la discusión en el foro de los operadores

Creación de un Panel de administración de operaciones en MQL5 (Parte X): Interfaz basada en recursos externos

Actualmente estamos aprovechando las capacidades de MQL5 para utilizar recursos externos, como imágenes en formato BMP, para crear una interfaz de inicio con un estilo único para el Panel de Administración de Operaciones. La estrategia que se muestra aquí resulta especialmente útil al empaquetar múltiples recursos, incluyendo imágenes, sonidos y más, para una distribución más eficiente. En este artículo exploramos cómo se implementan estas características para ofrecer una interfaz moderna y visualmente atractiva para nuestro New_Admin_Panel EA.

Indicador del modelo CAPM en el mercado Forex

Adaptación del modelo CAPM clásico para el mercado de divisas Forex en MQL5. El indicador calcula el retorno esperado y la prima de riesgo según la volatilidad histórica. Los indicadores suben en los picos y valles, lo que refleja los principios fundamentales de fijación de precios. Aplicación práctica de estrategias de contra-tendencia y seguimiento de tendencia, considerando la dinámica de la relación riesgo-retorno en tiempo real. Incluye aparato matemático e implementación técnica.

Minería de datos de los balances de los bancos centrales y obtención de un panorama de la liquidez global

La minería de datos del balance de los bancos centrales ofrece una imagen de la liquidez global en el mercado Forex y en las divisas clave. Hoy combinaremos datos de la Fed, el BCE, el BOJ y el PBoC en un índice compuesto y utilizaremos el aprendizaje automático para descubrir patrones ocultos. Este enfoque convierte los datos sin procesar en señales comerciales reales combinando el análisis fundamental y técnico.

Reimaginando las estrategias clásicas (Parte 14): Configuraciones de alta probabilidad

Las configuraciones de alta probabilidad son bien conocidas en nuestra comunidad de trading, pero lamentablemente no están bien definidas. En este artículo, nuestro objetivo será encontrar una forma empírica y algorítmica de definir con precisión qué constituye una configuración de alta probabilidad, identificándolas y explotándolas. Mediante el uso de árboles de potenciación de gradiente, demostramos cómo el lector puede mejorar el rendimiento de una estrategia de negociación arbitraria y comunicar mejor la tarea exacta que debe realizarse a nuestro ordenador de una manera más significativa y explícita.