Explorador de la biblioteca estándar de MQL5 (Parte 2): Conexión de componentes de la biblioteca
Índice
Introducción
Muchos desarrolladores que se incorporan al ecosistema MQL5 —desde principiantes entusiastas hasta programadores experimentados procedentes de otros lenguajes— se encuentran con un obstáculo común y frustrante: saben escribir código, pero les cuesta crear asesores expertos robustos y de nivel profesional. La biblioteca estándar de MQL5 es un potente conjunto de clases ya creadas, probadas y optimizadas, diseñadas para acabar con esas dificultades. Sin embargo, su propia riqueza puede resultar abrumadora. El verdadero reto no es la falta de componentes, sino la ausencia de una hoja de ruta clara: una guía práctica sobre cómo integrar estos sofisticados elementos básicos en un sistema de negociación coherente y funcional.
Los desarrolladores suelen encontrarse con una caja de herramientas llena de instrumentos de precisión, pero sin un plano que les permita ensamblarlos para crear una solución completa. Para simplificar esta complejidad, usaremos una analogía tomada de la vida real: al igual que el cuerpo humano depende de órganos especializados que funcionan bajo la coordinación del cerebro, un asesor experto depende de módulos especializados coordinados por su programa principal.
En esta analogía, el asesor experto (EA) actúa como el cerebro: el responsable central de la toma de decisiones. Las clases auxiliares de la biblioteca actúan como sus órganos y desempeñan funciones especializadas:
- La clase CTrade ejecuta operaciones, al igual que las manos realizan acciones.
- La clase CIndicators analiza los datos del mercado, al igual que los ojos perciben el entorno.
- La clase CAccountInfo supervisa el estado de la cuenta, al igual que el sistema nervioso, que recoge y transmite información.

Fig. 1. Sistema de software conceptual

Fig. 2. Sistema biológico conceptual
Esta analogía es solo un recurso conceptual para hacer más intuitiva la estructura abstracta de la programación orientada a objetos (POO) y ayudar a los lectores a visualizar cómo interactúa cada parte de la biblioteca para formar un sistema de negociación coordinado y eficiente.
Todas estas son ventajas de la programación orientada a objetos (POO) —modularidad, reutilización y abstracción—, pero en esta serie omitimos deliberadamente la explicación teórica en profundidad para centrarnos primero en la aplicación práctica. Muchos alumnos comprenden mejor los conceptos a través de la práctica, y una vez que empiece a crear e integrar clases por su cuenta, los principios subyacentes de la programación orientada a objetos empiezan a cobrar sentido de forma natural.
Para aquellos lectores que prefieran profundizar en la teoría de la programación orientada a objetos (POO) antes de continuar, existen numerosas referencias excelentes, tanto en la comunidad MQL5 como en otras fuentes, que explican en profundidad la encapsulación, la herencia y el polimorfismo. Sin embargo, nuestro enfoque aquí se basa en la práctica, con ejemplos reales, diagramas y analogías que harán que su experiencia con la Biblioteca Estándar de MQL5 resulte agradable y productiva.
Al final de esta exposición, iremos más allá de los ejemplos aislados para desvelar un plan maestro: la guía definitiva para entrelazar los potentes hilos de la Biblioteca Estándar de MQL5 en el sólido marco de un asesor experto profesional, al tiempo que descubrimos formas de ampliar la propia biblioteca.

Fig. 3. El EA como cerebro y las clases como órganos
Aunque el asesor experto se considera, con razón, el «cerebro» o el programa principal, también debemos entender que los propios módulos pueden crearse incluyendo otros módulos, lo que denominamos «dependencias». Del mismo modo que estamos aprendiendo a integrar bibliotecas completas en los programas de EA, necesitamos los mismos conocimientos a la hora de entrelazar módulos o de implementar un módulo dentro de otro.
La analogía anterior pone de manifiesto que las interrelaciones entre módulos se dan de dos formas principales: por lo general, a través de la coordinación del programa principal, pero también mediante dependencias directas. Por ejemplo, la clase CPanel no es independiente: incluye directamente WndObj.mqh y ChartObjectsTxtControls.mqh. Depende de ambos archivos.

Fig. 4. Comunicación entre clases
La buena noticia es que esta red de relaciones no resulta complicada una vez que se entiende. Al usar cualquier módulo en un EA, ya sea una clase sencilla o un módulo dependiente complejo, hay una serie de pasos coherentes y repetibles que garantizan una integración satisfactoria en todo momento. Consulte el fragmento de código parcial que aparece a continuación: en él se destacan las dependencias clave que utiliza Panel.mqh y dónde se incluyen.
//+------------------------------------------------------------------+ //| Panel.mqh | //| Copyright 2000-2025, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #include "WndObj.mqh" #include <ChartObjects\ChartObjectsTxtControls.mqh>
En la siguiente sección, voy a explicar los pasos que suelo seguir a la hora de integrar clases de bibliotecas en mis proyectos. Esto le ayudará a adquirir una base sólida antes de pasar a la fase de implementación, en la que analizaremos ejemplos prácticos con más detalle.
Cómo integrar cualquier clase en un asesor experto
En la mayoría de los casos, la elección de las clases que se van a utilizar se realiza una vez definida la estrategia o el objetivo general de su EA; no hay necesidad de sobrecargar su proyecto con componentes innecesarios. En esta sección, sin embargo, no nos centramos en el diseño de la estrategia, sino en comprender el proceso de integración en sí mismo.
Nuestro objetivo es compartir los conocimientos esenciales y los pasos prácticos que le permitirán integrar con confianza cualquier módulo de biblioteca en sus futuros proyectos siempre que sea necesario. En la siguiente sección se describen estos pasos, acompañados de un diagrama de flujo que ilustra el proceso.
Flujo del proceso:
- Analizar: estudiar el propósito de la clase y la cadena de herencia
- Incluir: añadir la directiva #include con la ruta correcta
- Declarar - crear una instancia de objeto en el EA
- Inicializar - llamar a Create() en OnInit() con los parámetros
- Tiempo de ejecución - actualizar en OnTick() y gestionar los eventos
- Limpiar - liberar recursos en OnDeinit()
Gestión de errores:
- Errores de compilación → Comprobar las dependencias
- Errores de creación → Comprobar los parámetros
- Problemas en tiempo de ejecución → Supervisar el estado del objeto

Fig. 5. Hoja de ruta para la integración de la biblioteca MQL5
Flujo de integración entre módulos
Análisis de dependencias
- Relaciones padre-hijo: p. ej., CPanel → WndObj → ChartObjectsTxtControls
- Contratos de interfaz: qué métodos deben implementarse
- Flujo de datos: cómo se transmite la información entre módulos

Fig. 6. Jerarquía de herencia de módulos
Pasos para la implementación
- Cadena de inclusión: cada módulo incluye sus dependencias directas
- Configuración de la herencia: jerarquías de clases establecidas mediante «extends»
- Implementación de métodos: sobrescribir los métodos virtuales según sea necesario
- Pruebas aisladas: probar los módulos de forma independiente antes de integrarlos en el EA
Patrones habituales
- Arquitectura por capas: los módulos de nivel superior dependen de los de nivel inferior
- Segregación de interfaces: los módulos ofrecen API claras y específicas
- Inyección de dependencias: pasar los objetos necesarios en lugar de codificarlos de forma fija

Fig. 7. Flujo de integración entre módulos
Ahora que contamos con una base arquitectónica sólidamente establecida y una hoja de ruta de integración claramente definida, pasaremos a la fase de implementación, en la que la teoría se convierte en práctica. Aquí es donde aplicamos el proceso de integración estructurado a un proyecto real, transformando los conocimientos conceptuales en un asesor experto funcional.
Nuestro plan de implementación consiste en crear un EA InfoPanel, un panel de control informativo que muestre cómo poner en práctica la clase CPanel y sus dependencias en un entorno de negociación. Este ejemplo mostrará exactamente cómo aplicar cada paso de nuestra metodología de integración para crear un sistema limpio, profesional y ampliable.
Implementación
Al abordar cualquier clase de biblioteca en MQL5, la integración comienza por comprender qué es realmente esa clase: su finalidad, su jerarquía de herencia y cómo encaja en el ecosistema de los controles del gráfico. CPanel es más que una simple zona rectangular; es una capa de interfaz autónoma que hereda de CWndObj y gestiona su propio ciclo de vida en el gráfico. Sirve de estructura arquitectónica para componentes complejos de la interfaz de usuario. Antes de escribir código en un asesor experto, esta comprensión establece el marco conceptual para una integración fluida.
Análisis de la clase CPanel en Panel.mqh
El primer contacto con una clase siempre debe tener un carácter exploratorio. Al leer el archivo de encabezado Panel.mqh se pueden descubrir relaciones clave y puntos de extensión. La clase hereda de CWndObj, lo que significa que hereda la capacidad de gestionar eventos y ventanas en el gráfico. En su interior, encapsula CChartObjectRectLabel, el rectángulo gráfico que define el marco visible del panel.
Al identificar sus puntos de acceso públicos —en particular, Create() y BorderType()—, podrá localizar los puntos de control con los que interactuará su EA. Esta inspección sustituye el método de prueba y error por un diseño fundamentado.
//+------------------------------------------------------------------+ //| Panel.mqh | //| Copyright 2000-2025, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #include "WndObj.mqh" #include <ChartObjects\ChartObjectsTxtControls.mqh> //+------------------------------------------------------------------+ //| Class CPanel | //| Usage: control that is displayed by | //| the CChartObjectRectLabel object | //+------------------------------------------------------------------+ class CPanel : public CWndObj { private: CChartObjectRectLabel m_rectangle; // chart object //--- parameters of the chart object ENUM_BORDER_TYPE m_border; // border type public: CPanel(void); ~CPanel(void); //--- create virtual bool Create(const long chart,const string name,const int subwin,const int x1,const int y1,const int x2,const int y2); //--- parameters of the chart object ENUM_BORDER_TYPE BorderType(void) const { return(m_border); } bool BorderType(const ENUM_BORDER_TYPE type); protected: //--- handlers of object settings virtual bool OnSetText(void) { return(m_rectangle.Description(m_text)); } virtual bool OnSetColorBackground(void) { return(m_rectangle.BackColor(m_color_background)); } virtual bool OnSetColorBorder(void) { return(m_rectangle.Color(m_color_border)); } //--- internal event handlers virtual bool OnCreate(void); virtual bool OnShow(void); virtual bool OnHide(void); virtual bool OnMove(void); virtual bool OnResize(void); virtual bool OnChange(void); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CPanel::CPanel(void) : m_border(BORDER_FLAT) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CPanel::~CPanel(void) { } //+------------------------------------------------------------------+ //| Create a control | //+------------------------------------------------------------------+ bool CPanel::Create(const long chart,const string name,const int subwin,const int x1,const int y1,const int x2,const int y2) { //--- call method of the parent class if(!CWndObj::Create(chart,name,subwin,x1,y1,x2,y2)) return(false); //--- create the chart object if(!m_rectangle.Create(chart,name,subwin,x1,y1,Width(),Height())) return(false); //--- call the settings handler return(OnChange()); } //+------------------------------------------------------------------+ //| Set border type | //+------------------------------------------------------------------+ bool CPanel::BorderType(const ENUM_BORDER_TYPE type) { //--- save new value of parameter m_border=type; //--- set up the chart object return(m_rectangle.BorderType(type)); } //+------------------------------------------------------------------+ //| Create object on chart | //+------------------------------------------------------------------+ bool CPanel::OnCreate(void) { //--- create the chart object by previously set parameters return(m_rectangle.Create(m_chart_id,m_name,m_subwin,m_rect.left,m_rect.top,m_rect.Width(),m_rect.Height())); } //+------------------------------------------------------------------+ //| Display object on chart | //+------------------------------------------------------------------+ bool CPanel::OnShow(void) { return(m_rectangle.Timeframes(OBJ_ALL_PERIODS)); } //+------------------------------------------------------------------+ //| Hide object from chart | //+------------------------------------------------------------------+ bool CPanel::OnHide(void) { return(m_rectangle.Timeframes(OBJ_NO_PERIODS)); } //+------------------------------------------------------------------+ //| Absolute movement of the chart object | //+------------------------------------------------------------------+ bool CPanel::OnMove(void) { //--- position the chart object return(m_rectangle.X_Distance(m_rect.left) && m_rectangle.Y_Distance(m_rect.top)); } //+------------------------------------------------------------------+ //| Resize the chart object | //+------------------------------------------------------------------+ bool CPanel::OnResize(void) { //--- resize the chart object return(m_rectangle.X_Size(m_rect.Width()) && m_rectangle.Y_Size(m_rect.Height())); } //+------------------------------------------------------------------+ //| Set up the chart object | //+------------------------------------------------------------------+ bool CPanel::OnChange(void) { //--- set up the chart object return(CWndObj::OnChange() && m_rectangle.BorderType(m_border)); } //+------------------------------------------------------------------+
Cada una de estas líneas se traducirá después directamente en un paso de inicialización dentro de su EA.
Pasos para la integración
Paso 1. Inclusión del archivo de encabezado y las dependencias
Una vez que la intención queda clara, el siguiente paso es la inclusión. El EA debe poder acceder a CPanel y a sus clases base mediante las directivas #include adecuadas. La estructura de archivos de MQL5 es muy estricta en cuanto a las rutas de inclusión, por lo que debe comprobar siempre que su archivo Panel.mqh y sus archivos de encabezado auxiliares (WndObj.mqh, ChartObjectsTxtControls.mqh, etc.) sean accesibles desde el proyecto o desde el directorio global «Include».
#include <Controls\Panel.mqh> // gives access to CPanel and its internals
En este punto, el EA «sabe» que la clase del panel existe y ya puede crear una instancia de ella.
Paso 2. Declaración del objeto
La declaración define dónde se encuentra el panel dentro del ámbito de memoria del EA. La mayoría de los desarrolladores optan por declarar CPanel como un puntero a nivel global para garantizar que persista entre las llamadas a eventos y que pueda eliminarse de forma segura durante la limpieza.
CPanel *mainPanel = NULL; Esto hace que el objeto sea accesible en todos los controladores de eventos (OnInit, OnTick, OnDeinit, etc.), lo que garantiza un ciclo de vida coherente.
Paso 3. Inicialización: cómo dar vida al panel
La creación tiene lugar dentro de OnInit(), y es aquí donde el diseño del archivo de encabezado se materializa en la ejecución. El método Create() requiere seis argumentos: el ID del gráfico, un nombre único, la subventana de destino y cuatro coordenadas que definen el rectángulo del panel. Compruebe siempre que la llamada devuelva «true»; un resultado «false» suele indicar un problema con un parámetro o una dependencia.
int OnInit() { mainPanel = new CPanel(); if(!mainPanel.Create(ChartID(), "InfoPanel", 0, 10, 10, 400, 120)) { Print("Panel creation failed."); delete mainPanel; mainPanel = NULL; return(INIT_FAILED); } mainPanel.BorderType(BORDER_RAISED); mainPanel.Text("Information Panel"); return(INIT_SUCCEEDED); }
Este fragmento de código muestra una inicialización mínima pero completa. El panel ya aparece en el gráfico, ocupando el rectángulo especificado.
Paso 4. Gestión en tiempo de ejecución
Es posible que el panel en sí no necesite actualizaciones continuas si es estático, pero es aquí donde se amplía su lógica de integración. Quizá quiera incorporar controles secundarios, como etiquetas o botones, o actualizar el contenido del panel periódicamente.
Para las actualizaciones dinámicas, un evento OnTimer() ofrece un mecanismo de actualización estable sin sobrecargar el bucle OnTick().
void OnTimer() { // Placeholder for runtime UI updates }
En cada actualización se pueden refrescar los datos que se muestran en el panel sin necesidad de volver a dibujar el objeto.
Paso 5. Limpieza y gestión de errores
Todo objeto creado dinámicamente debe destruirse para evitar fugas de memoria. En OnDeinit(), llame a «delete» y establezca el puntero en NULL. Esto garantiza una desasignación correcta y evita que queden objetos de gráfico huérfanos.
void OnDeinit(const int reason) { if(mainPanel) { mainPanel.OnHide(); delete mainPanel; mainPanel = NULL; } }
Si falla la compilación, compruebe si faltan archivos de inclusión o si hay referencias sin definir. Los errores de creación suelen estar relacionados con coordenadas incorrectas o conflictos de nombres, mientras que el parpadeo durante la ejecución o los problemas con los eventos suelen deberse a la superposición de objetos del gráfico.
Análisis de CChartObjectText en ChartObjectsTxtControls.mqh
En esta sección, nos centramos en la capa de interfaz del archivo de encabezado ChartObjectsTxtControls.mqh. Para mayor claridad y concisión, solo hemos extraído la parte pública y de nivel superior de la clase, que define cómo interactuamos con ella. El código fuente completo es mucho más extenso, pero para nuestro análisis solo necesitamos la interfaz pública, que constituye la «puerta de entrada» de la clase.
Esta visión selectiva es intencionada. La esencia de la programación orientada a objetos (POO) es la abstracción: no necesitamos saber cómo funciona internamente, siempre y cuando entendamos la interfaz y sepamos cómo utilizarla correctamente. La interfaz define los métodos disponibles, sus parámetros y su comportamiento esperado; eso es todo lo que necesitamos para crear integraciones de forma eficaz.
Nuestro objetivo aquí es analizar el archivo de encabezado para comprender su finalidad e identificar los puntos de acceso: los métodos clave a los que llamaremos desde nuestro EA principal para describir o manipular texto en el gráfico. En este caso, hemos incluido este archivo de encabezado no para construir el panel (como cuando se utilizaba como dependencia de CPanel), sino únicamente para definir el texto dentro de nuestro asesor experto.
Cuando se usaba como dependencia, no teníamos que prestar mucha atención a su lógica interna, ya que CPanel se encargaba de ello. Sin embargo, en este contexto educativo, lo estudiamos deliberadamente para comprender cómo se estructura cada clase y cómo utilizarla de forma autónoma.
El fragmento que se muestra a continuación presenta la interfaz de CChartObjectText, que proporciona todos los métodos esenciales para trabajar con objetos de texto directamente en el gráfico. Entre ellos se encuentran Create(), FontSize() y Anchor(), que son nuestros principales puntos de acceso a la hora de integrar elementos de texto en un panel o en un EA. Estos son los métodos que nos permiten definir posiciones en píxeles, establecer estilos de fuente, controlar la alineación y gestionar la visibilidad: todo lo necesario para crear la capa de descripción textual de nuestro InfoPanel.
//+------------------------------------------------------------------+ //| ChartObjectsTxtControls.mqh | //| Copyright 2000-2025, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ //| All text objects. | //+------------------------------------------------------------------+ #include "ChartObject.mqh" //+------------------------------------------------------------------+ //| Class CChartObjectText. | //| Purpose: Class of the "Text" object of chart. | //| Derives from class CChartObject. | //+------------------------------------------------------------------+ class CChartObjectText : public CChartObject { public: CChartObjectText(void); ~CChartObjectText(void); //--- method of creating the object bool Create(long chart_id,const string name,const int window,const datetime time,const double price); //--- method of identifying the object virtual int Type(void) const override { return(OBJ_TEXT); } //--- methods of access to properties of the object double Angle(void) const; bool Angle(const double angle) const; string Font(void) const; bool Font(const string font) const; int FontSize(void) const; bool FontSize(const int size) const; ENUM_ANCHOR_POINT Anchor(void) const; bool Anchor(const ENUM_ANCHOR_POINT anchor) const; //--- methods for working with files virtual bool Save(const int file_handle) override; virtual bool Load(const int file_handle) override; };
Pasos para la integración de CChartObjectText en el EA
Paso 1. Incluir
Incluimos el archivo ChartObjectsTxtControls.mqh cerca del principio del EA para que las definiciones de las clases sean visibles. Utilizamos la misma ruta que la biblioteca.Si ya ha incluido Panel.mqh, este archivo de encabezado suele incorporarse automáticamente, pero incluirlo explícitamente en el EA deja claras la intención y las dependencias.
#include <ChartObjects\ChartObjectsTxtControls.mqh> // provides CChartObjectLabel et al.
Paso 2. Declarar
Declaramos los objetos de etiqueta en un ámbito en el que las funciones del ciclo de vida del EA puedan acceder a ellos: el ámbito global. Utilice objetos en la pila para las clases de texto del gráfico (gestionan la vinculación internamente) o punteros si prefiere la semántica de «new» y «delete». Asigne nombres a las etiquetas con cuidado (deben ser únicos dentro de cada gráfico). Si prevé que habrá varias etiquetas, utilice patrones de nombre claros: «InfoPanel_123_txt1».
// global declarations CChartObjectLabel txtDesc; // pixel-based label (good for panel body)
Paso 3. Inicializar (OnInit)
A continuación, creamos la etiqueta dentro de OnInit() utilizando la firma que aparece en el archivo de encabezado ChartObjectsTxtControls.mqh: Create(long chart_id, const string name, const int window, const int X, const int Y). Colóquela en relación con el rectángulo del panel para mantener la coherencia del diseño.
Si no se consigue crear la etiqueta, registre información útil (ID del gráfico, nombre, coordenadas) y cancele la inicialización.
int OnInit() { string txt_name = panel_name + "_txtDesc"; int left = PANEL_X1 + PADDING; int top = PANEL_Y1 + PADDING + 18; if(!txtDesc.Create(ChartID(), txt_name, 0, left, top)) { Print("txtDesc.Create failed"); return(INIT_FAILED); } txtDesc.Description("Hello trader! I am InfoPanel EA"); txtDesc.FontSize(11); // txtDesc.Anchor(ANCHOR_LEFT_UPPER); // if API available return(INIT_SUCCEEDED); }
Paso 4. Tiempo de ejecución (OnTick/OnTimer/OnChartEvent)
Reduzca al mínimo el trabajo en tiempo de ejecución para el texto estático. Si necesita campos dinámicos, actualice Description() desde OnTimer() (configure EventSetTimer() en OnInit()), no en cada tick. Si añade interactividad (botones o campos de edición del mismo archivo de encabezado), reenvíe OnChartEvent() y compruebe sparam para detectar clics en los objetos.
Si hay varias líneas, utilice varias instancias de CChartObjectLabel apiladas verticalmente o genere \n y compruebe si el método Description() admite saltos de línea; si no es así, es mejor utilizar etiquetas separadas.
void OnTimer() { // e.g., update price line inside the panel txtDesc.Description("Bid: " + DoubleToString(SymbolInfoDouble(_Symbol, SYMBOL_BID), _Digits)); }
Paso 5. Limpieza (OnDeinit)
Elimine el objeto gráfico cuando se cierre el EA. Utilice el método Delete() de la clase (o ObjectDelete() como alternativa). No llame a métodos internos protegidos de otras clases; simplemente elimine su etiqueta y libere cualquier puntero a un panel.
void OnDeinit(const int reason) { txtDesc.Delete(); // removes the chart object // delete panel pointer here if allocated EventKillTimer(); // if used }
Uniendo las piezas para formar un EA
La integración final de la clase CPanel en nuestro EA InfoPanel completa la etapa fundacional de nuestro estudio de la biblioteca estándar. Este panel no es un cuadro de mando interactivo ni un controlador de operaciones, sino un panel de información estático, un elemento sencillo pero profesional en el gráfico que describe de forma explícita el producto que se está utilizando. Es posible que muchos desarrolladores opten por un diseño similar para mostrar la identidad y los detalles de su EA directamente en el gráfico, evitando así la limitación que supone el nombre predeterminado del gráfico o la necesidad de rebuscar entre las propiedades. Actúa como un sello sutil pero práctico: un elemento visual que aporta claridad al entorno.
Aunque el concepto pueda parecer modesto, su importancia radica en el método, no en la magnitud. Aquí hemos puesto en práctica el ciclo completo de integración de clases: desde la inclusión del archivo de encabezado de la biblioteca estándar hasta la creación y personalización de una instancia de CPanel y su combinación con elementos de texto del gráfico para mostrar información significativa. Este proceso refleja la esencia misma de cómo se estructuran y gestionan los componentes profesionales de MQL5. Se trata de comprender el ritmo arquitectónico —incluir, declarar, crear y controlar— que más adelante reutilizará en sistemas mucho más avanzados.
Este primer proyecto es sencillo a propósito, ya que sienta las bases para su ampliación. Una vez que se haya familiarizado con CPanel, le resultará natural añadir otros elementos, como CChartObjectLabel para ofrecer una presentación de texto más completa o incluso CPicture para incorporar la identidad visual de la marca. En conjunto, estos elementos estáticos conforman un ecosistema de visualización de la información pequeño pero completo, preparado para ir aumentando en complejidad a medida que avance nuestro estudio.
El objetivo general es entrenar la mente para pensar de forma modular, para ver la biblioteca estándar no como un marco rígido, sino como una base flexible que puede ampliarse indefinidamente. Cada clase —CPanel, CChartObjectLabel, CPicture y otras— es un elemento básico. Lo que hoy en día empieza siendo un simple panel de visualización puede convertirse más adelante en un espacio de trabajo completo con visualización de datos, controles personalizados y diseños adaptables.
Por lo tanto, nuestra andadura con CPanel supone algo más que la creación de un panel de información estático; es el comienzo del dominio de la lógica y la destreza necesarias para construir sistemas completos a partir de la biblioteca estándar, paso a paso, capa a capa.
//+------------------------------------------------------------------+ //| InfoPanel_EA.mq5 | //| Minimal example: creating a CPanel and a label text showing | //| a short EA description with panel background & border. We will | //| also add a logo to explore CPicture. | //+------------------------------------------------------------------+ #property copyright "Clemence Benjamin" #property version "1.0" #include <Controls/Panel.mqh> // Panel header (correct path) #include <ChartObjects\ChartObjectsTxtControls.mqh> // for CChartObjectLabel //---- Globals -------------------------------------------------------- CPanel *infoPanel = NULL; // pointer to panel (allocate/free) CChartObjectLabel txtDesc; // label text inside the panel // layout (pixels) int PANEL_X1 = 10; int PANEL_Y1 = 30; int PANEL_X2 = 300; // widened to give text room int PANEL_Y2 = 100; int PADDING = 10; // short description that fits comfortably on one line string EA_DESCRIPTION = "Hello trader! I am InfoPanel EA"; //+------------------------------------------------------------------+ //| Expert initialization | //+------------------------------------------------------------------+ int OnInit() { // allocate the panel object infoPanel = new CPanel(); if(infoPanel == NULL) { Print("InfoPanel: allocation failed"); return(INIT_FAILED); } // unique panel name string panel_name = "InfoPanel_" + IntegerToString((int)ChartID()); // create the panel on the current chart (subwindow 0 = main) if(!infoPanel.Create(ChartID(), panel_name, 0, PANEL_X1, PANEL_Y1, PANEL_X2, PANEL_Y2)) { Print("InfoPanel: Create() failed"); delete infoPanel; infoPanel = NULL; return(INIT_FAILED); } // appearance: border type, header text, background and border colors infoPanel.BorderType(BORDER_RAISED); infoPanel.Text("InfoPanel"); // Set a visible background and border color. // Use standard color constants; change them if you prefer another palette. // If your library expects ARGB or different color encoding, adapt accordingly. infoPanel.ColorBackground(clrSilver); // panel background infoPanel.ColorBorder(clrBlack); // panel border // compute child label position inside panel (some padding below header) int left = PANEL_X1 + PADDING; int top = PANEL_Y1 + PADDING + 18; // leave header area // create a CChartObjectLabel as panel body (unique name) string txt_name = panel_name + "_txtDesc"; if(!txtDesc.Create(ChartID(), txt_name, 0, left, top)) { Print("InfoPanel: txtDesc.Create() failed"); delete infoPanel; infoPanel = NULL; return(INIT_FAILED); } // set the short description and font size using the correct API txtDesc.Description(EA_DESCRIPTION); txtDesc.FontSize(11); return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Expert deinitialization | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { // remove the label object txtDesc.Delete(); // free the panel (do NOT call protected methods) if(infoPanel != NULL) { delete infoPanel; infoPanel = NULL; } // safe kill of timer if later added EventKillTimer(); } //+------------------------------------------------------------------+ //| Expert tick function (kept intentionally light) | //+------------------------------------------------------------------+ void OnTick() { // static info panel — no per-tick UI updates } //+------------------------------------------------------------------+ //| Chart event handler (optional extension point) | //+------------------------------------------------------------------+ void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) { // placeholder for future interactive controls }

Fig. 8. Pruebas iniciales
Ahora, dando un paso más, añadiremos un logotipo en formato BMP al panel para dotarlo de una identidad clara. Siempre he preferido utilizar herramientas de código abierto para crear imágenes; GIMP es una opción excelente, ya que permite exportar imágenes en formato BMP de forma rápida y sencilla. Por supuesto, puede utilizar cualquier otro programa con el que se sienta cómodo. Una vez creado el logotipo y guardado en la carpeta Images de su terminal para poder acceder a él fácilmente, podemos pasar a explorar la clase CPicture y planificar cómo integrarla en nuestro panel.
A continuación se muestran dos imágenes. La figura 9 ilustra dónde se colocará el logotipo en nuestro panel, mientras que la figura 10 muestra el logotipo que he creado con GIMP. Al exportar la imagen en formato BMP, asegúrese de que tenga una profundidad de color de 24 bits y una sola capa, y de que no incluya canal alfa. Estos ajustes funcionaron a la perfección durante las pruebas; otras configuraciones de exportación generaron imágenes que no se mostraban correctamente en el panel. La imagen del logotipo que se muestra aquí no está en el formato BMP correcto, por lo que no funcionará correctamente. He utilizado una versión en formato PNG, que es un formato admitido para la publicación. Puede encontrar el logotipo adjunto al final del artículo.

Fig. 9. Espacio para el logotipo del EA

Fig. 10. Logotipo de 56 x 59 píxeles
Comprensión y preparación de la clase CPicture para su integración
La clase CPicture amplía las bases que ya hemos sentado con CPanel y CChartObjectLabel. Al igual que el panel nos proporcionó un contenedor y la etiqueta nos ofreció texto, esta clase nos presenta una forma sencilla de mostrar imágenes de mapa de bits en el gráfico, lo cual resulta ideal para nuestra próxima mejora, en la que queremos añadir una miniatura del logotipo al panel de información.
En esencia, CPicture actúa como una pequeña clase contenedora del objeto de gráfico CChartObjectBmpLabel. Hereda de CWndObj, lo que significa que sigue los mismos métodos del ciclo de vida (Create, OnShow, OnHide, etc.) que hemos visto anteriormente. Este diseño garantiza que podamos integrarlo en nuestro EA siguiendo los mismos pasos que utilizamos con las clases anteriores: asignar memoria, crear, configurar y liberar recursos.
Si lo analizamos con detenimiento, hay algunos puntos clave que llaman la atención. El método principal de creación, Create(chart, name, subwin, x1, y1, x2, y2), define el área del objeto en el gráfico en coordenadas de píxeles, al igual que CPanel. Una vez creado el objeto, podemos asignarle la imagen propiamente dicha mediante BmpName(name), que apunta a un archivo .bmp ubicado en la carpeta Images del terminal. El método Border(value) ajusta el ancho visible o el grosor del borde del área de la imagen, aunque, para lograr una presentación limpia del logotipo, probablemente estableceremos este valor en cero. Internamente, estos dos métodos actualizan el objeto de gráfico subyacente a través del controlador OnChange().
Nuestros puntos de acceso para la integración
Para nuestros fines, solo necesitamos centrarnos en unos pocos puntos de acceso prácticos:
- Create() – inicializa el objeto en el gráfico utilizando un nombre único y unas coordenadas en píxeles.
- BmpName() – asigna el archivo de mapa de bits que se va a mostrar, como el logotipo de nuestro EA.
- Border() – define los valores del borde o del ancho si es necesario (opcional para los logotipos).
- Destructor o delete: libera memoria de forma segura cuando se elimina el EA.
//+------------------------------------------------------------------+ //| Picture.mqh | //| Copyright 2000-2025, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #include "WndObj.mqh" #include <ChartObjects\ChartObjectsBmpControls.mqh> //+------------------------------------------------------------------+ //| Class CPicture | //| Note: image displayed by | //| the CChartObjectBmpLabel object | //+------------------------------------------------------------------+ class CPicture : public CWndObj { private: CChartObjectBmpLabel m_picture; // chart object //--- parameters of the chart object int m_border; // border width string m_bmp_name; // filename public: CPicture(void); ~CPicture(void); //--- create virtual bool Create(const long chart,const string name,const int subwin,const int x1,const int y1,const int x2,const int y2); //--- parameters of the chart object int Border(void) const { return(m_border); } bool Border(const int value); string BmpName(void) const { return(m_bmp_name); } bool BmpName(const string name); protected: //--- internal event handlers virtual bool OnCreate(void); virtual bool OnShow(void); virtual bool OnHide(void); virtual bool OnMove(void); virtual bool OnChange(void); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CPicture::CPicture(void) : m_border(0), m_bmp_name(NULL) { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CPicture::~CPicture(void) { } //+------------------------------------------------------------------+ //| Create a control | //+------------------------------------------------------------------+ bool CPicture::Create(const long chart,const string name,const int subwin,const int x1,const int y1,const int x2,const int y2) { //--- call method of the parent class if(!CWndObj::Create(chart,name,subwin,x1,y1,x2,y2)) return(false); //--- create the chart object if(!m_picture.Create(chart,name,subwin,x1,y1)) return(false); //--- call the settings handler return(OnChange()); } //+------------------------------------------------------------------+ //| Set border width | //+------------------------------------------------------------------+ bool CPicture::Border(const int value) { //--- save new value of parameter m_border=value; //--- set up the chart object return(m_picture.Width(value)); } //+------------------------------------------------------------------+ //| Set image | //+------------------------------------------------------------------+ bool CPicture::BmpName(const string name) { //--- save new value of parameter m_bmp_name=name; //--- set up the chart object return(m_picture.BmpFileOn(name)); } //+------------------------------------------------------------------+ //| Create object on chart | //+------------------------------------------------------------------+ bool CPicture::OnCreate(void) { //--- create the chart object by previously set parameters return(m_picture.Create(m_chart_id,m_name,m_subwin,m_rect.left,m_rect.top)); } //+------------------------------------------------------------------+ //| Display object on chart | //+------------------------------------------------------------------+ bool CPicture::OnShow(void) { return(m_picture.Timeframes(OBJ_ALL_PERIODS)); } //+------------------------------------------------------------------+ //| Hide object from chart | //+------------------------------------------------------------------+ bool CPicture::OnHide(void) { return(m_picture.Timeframes(OBJ_NO_PERIODS)); } //+------------------------------------------------------------------+ //| Absolute movement of the chart object | //+------------------------------------------------------------------+ bool CPicture::OnMove(void) { //--- position the chart object return(m_picture.X_Distance(m_rect.left) && m_picture.Y_Distance(m_rect.top)); } //+------------------------------------------------------------------+ //| Set up the chart object | //+------------------------------------------------------------------+ bool CPicture::OnChange(void) { //--- set up the chart object return(m_picture.Width(m_border) && m_picture.BmpFileOn(m_bmp_name)); } //+------------------------------------------------------------------+
Con estos sencillos métodos, ya tenemos todo lo necesario para integrar un componente de imagen en nuestro panel.
Planificación de la integración
Ahora que ya sabemos cómo funciona CPicture, podemos planificar cómo incorporarlo a nuestro InfoPanel_EA. El archivo de imagen —nuestro logotipo— debe prepararse primero en formato BMP. Como ya se ha mencionado, herramientas como GIMP facilitan la exportación a formato BMP. Una vez que tengamos el archivo, lo colocamos en la carpeta Images del terminal (MQL5/Images/) para que el EA pueda acceder fácilmente a él por su nombre.
En nuestro código, haremos lo siguiente:
- Incluir el archivo de encabezado Picture.mqh.
- Declarar un puntero global para nuestra instancia de CPicture, igual que hicimos con el panel.
- Crear el objeto en OnInit(), colocándolo de forma ordenada dentro del panel o justo encima de él.
- Establecer el nombre de la imagen con BmpName("logo.bmp") para cargar el archivo que hayamos elegido.
- Liberar los recursos en OnDeinit() para garantizar un cierre correcto.
De este modo, nuestro panel pasará de ser una simple pantalla de texto a convertirse en un espacio informativo con la imagen de marca, un paso sutil pero significativo que hará que la presentación del EA sea más profesional y reconocible.
Justificación de este paso
Aunque esta novedad pueda parecer insignificante, nos permite comprender mejor cómo se puede combinar en la práctica cualquier clase visual de la biblioteca estándar. Cada integración refuerza un patrón: crear, configurar y gestionar el ciclo de vida de forma segura. Para cuando hayamos terminado de integrar el logotipo, habremos conectado tres clases estándar diferentes —CPanel, CChartObjectLabel y CPicture— en una única interfaz cohesionada.
Esto nos prepara para la siguiente sección, en la que pondremos en marcha la integración completa e insertaremos el logotipo de nuestro EA en el propio panel. Con esto habremos completado nuestro panel informativo estático, que nos servirá como repaso visual de todo lo que hemos aprendido hasta ahora. En la siguiente sección se mostrará cómo estas clases pueden coexistir armoniosamente, haciendo que nuestro EA sea a la vez informativo y visualmente distintivo.
//+------------------------------------------------------------------+ //| InfoPanel_EA.mq5 | //| Info panel with logo placed inside the panel and on foreground | //+------------------------------------------------------------------+ #property copyright "Clemence Benjamin" #property version "1.0" #include <Controls\Panel.mqh> #include <ChartObjects\ChartObjectsTxtControls.mqh> #include <Controls\Picture.mqh> //---- Globals -------------------------------------------------------- CPanel *infoPanel = NULL; CChartObjectLabel txtDesc; CPicture *logo = NULL; // layout (pixels) int PANEL_X1 = 10; int PANEL_Y1 = 30; int PANEL_X2 = 300; int PANEL_Y2 = 100; int PADDING = 10; // logo size and filename int LOGO_SIZE = 56; string LOGO_FILE = "Logo.bmp"; // short description string EA_DESCRIPTION = "Hello trader! I am InfoPanel EA"; //+------------------------------------------------------------------+ //| Expert initialization | //+------------------------------------------------------------------+ int OnInit() { // 1. Create panel infoPanel = new CPanel(); if(infoPanel == NULL) { Print("InfoPanel: allocation failed"); return(INIT_FAILED); } string panel_name = "InfoPanel_" + IntegerToString((int)ChartID()); if(!infoPanel.Create(ChartID(), panel_name, 0, PANEL_X1, PANEL_Y1, PANEL_X2, PANEL_Y2)) { Print("InfoPanel: Create() failed"); delete infoPanel; infoPanel = NULL; return(INIT_FAILED); } infoPanel.BorderType(BORDER_RAISED); infoPanel.Text("InfoPanel"); infoPanel.ColorBackground(clrSilver); infoPanel.ColorBorder(clrBlack); // 2. Create label inside panel int label_left = PANEL_X1 + PADDING; int label_top = PANEL_Y1 + PADDING + 18; string txt_name = panel_name + "_txtDesc"; if(!txtDesc.Create(ChartID(), txt_name, 0, label_left, label_top)) { Print("InfoPanel: txtDesc.Create() failed"); delete infoPanel; infoPanel = NULL; return(INIT_FAILED); } txtDesc.Description(EA_DESCRIPTION); txtDesc.FontSize(11); // 3. Set panel as background if(!ObjectSetInteger(ChartID(), panel_name, OBJPROP_BACK, true)) PrintFormat("InfoPanel: unable to set OBJPROP_BACK for '%s' (non-fatal).", panel_name); // 4. Compute logo coordinates int logo_right = PANEL_X2 - PADDING; int logo_left = logo_right - LOGO_SIZE; int logo_top = PANEL_Y1 + PADDING; int logo_bottom = logo_top + LOGO_SIZE; string logo_name = panel_name + "_logo"; // 5. Create logo logo = new CPicture(); if(logo == NULL) { Print("InfoPanel: logo allocation failed (continuing without logo)"); } else { if(!logo.Create(ChartID(), logo_name, 0, logo_left, logo_top, logo_right, logo_bottom)) { Print("InfoPanel: logo.Create() failed (continuing without logo)"); delete logo; logo = NULL; } else { // Ensure logo is in foreground if(!ObjectSetInteger(ChartID(), logo_name, OBJPROP_BACK, false)) Print("InfoPanel: Failed to set OBJPROP_BACK=false for logo (non-fatal)."); // Log coordinates PrintFormat("InfoPanel: Logo coords: left=%d, top=%d, right=%d, bottom=%d", logo_left, logo_top, logo_right, logo_bottom); // Load built-in logo.bmp with correct relative path (no fullpath needed).You can use custom logo names as long you update the code. string bmp_path = "\\Images\\Logo.bmp"; bool ok = logo.BmpName(bmp_path); PrintFormat("InfoPanel: logo.BmpName('%s') returned %s", bmp_path, ok ? "true" : "false"); if(!ok) { Print("InfoPanel: LOGO load failed. Verify MT5 installation has MQL5\\Images\\dollar.bmp."); } else { Print("InfoPanel: Logo loaded successfully!"); } logo.Border(LOGO_SIZE); ChartRedraw(ChartID()); // Force redraw } } return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Expert deinitialization | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { if(logo != NULL) { delete logo; logo = NULL; } txtDesc.Delete(); if(infoPanel != NULL) { delete infoPanel; infoPanel = NULL; } EventKillTimer(); } //+------------------------------------------------------------------+ //| OnTick | //+------------------------------------------------------------------+ void OnTick() { } //+------------------------------------------------------------------+ //| Chart events | //+------------------------------------------------------------------+ void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) { }
Al colocar el logotipo mostrado con CPicture dentro del rectángulo de CPanel y hacer que se muestre en primer plano, hemos llevado a cabo una demostración breve pero eficaz: la combinación de tres clases independientes de la biblioteca estándar —CPanel, CChartObjectLabel y CPicture— en un único elemento coherente de la interfaz de usuario. Primero creamos el panel, luego añadimos la etiqueta descriptiva y, por último, calculamos las coordenadas exactas en píxeles para insertar el logotipo de modo que quedara perfectamente alineado en el lado derecho del panel. Llamando a ObjectSetInteger(..., OBJPROP_BACK, true) para el panel y estableciendo OBJPROP_BACK = false para el logotipo, conseguimos controlar el orden de dibujo, de modo que la imagen aparece por encima del fondo, pero detrás de otros posibles objetos interactivos. También utilizamos ChartRedraw() para garantizar que el terminal se actualizara inmediatamente después de cargar el mapa de bits. Todos estos pasos seguían el mismo ritmo de integración: incluir, declarar, crear, configurar, comprobar los valores de retorno y limpiar.
De este ejercicio se extrajeron varias conclusiones concretas sobre la integración de clases. En primer lugar, el cálculo de coordenadas y el rigor en la nomenclatura son importantes: calcule las posiciones en relación con el rectángulo del panel y utilice nombres de objetos únicos y predecibles (nosotros utilizamos panel_name + "_logo") para evitar colisiones y simplificar la depuración. En segundo lugar, los recursos externos deben gestionarse con cuidado: hemos guardado el mapa de bits en MQL5\Images, hemos pasado su ruta relativa («\Images\Logo.bmp») a la función BmpName() y hemos registrado si la operación se ha realizado con éxito o ha fallado, para que el EA siga funcionando correctamente en caso de que falte el archivo. En tercer lugar, respete el contrato del ciclo de vida de cada clase: creamos los objetos con «new», validamos cada llamada a «Create()» y «BmpName()», y eliminamos siempre los objetos en «OnDeinit()» para evitar dejar objetos huérfanos en el gráfico o provocar fugas de memoria. En cuarto lugar, la gestión de las capas y el control del redibujado son habilidades prácticas: OBJPROP_BACK y ChartRedraw() nos permiten gestionar la visibilidad y la actualización de forma determinista.
Por último, este trabajo refuerza un patrón repetible que se aplica a cualquier clase de la biblioteca estándar: identificar los puntos de acceso públicos (creación y configuración mediante métodos como Border()/BmpName() o Text()), integrarlos en el ciclo de vida del EA (OnInit → tiempo de ejecución → OnDeinit), validar cada paso con mensajes de registro claros y calcular la geometría en relación con los elementos existentes para que el diseño siga siendo fácil de mantener. Lo que parece una funcionalidad mínima —un logotipo dentro de un panel— es, en realidad, un pequeño campo de prácticas para el conjunto de habilidades más amplio que estamos desarrollando: combinar módulos pequeños que funcionan correctamente para crear interfaces más grandes y profesionales. A partir de aquí, podemos ampliar el panel con total confianza (diseño adaptativo, líneas adicionales de metadatos estáticos o iconos opcionales no interactivos), sabiendo que cualquier clase de la biblioteca estándar se puede integrar siguiendo exactamente el mismo enfoque riguroso.
Pruebas
Tras compilar el código en MetaEditor 5, lo añadimos a un gráfico para observar nuestro pequeño panel de información, con su descripción y su logotipo, tal y como se muestra en la imagen siguiente. Este panel y sus componentes pueden considerarse como la identidad visual de un asesor experto. Esta misma idea se puede aplicar para dotar a sus futuros productos de una presencia única y reconocible en el gráfico. Por ahora, podemos sentirnos orgullosos de haber demostrado con éxito el concepto y de haber profundizado en nuestra comprensión del proceso de integración.

Fig. 11. Prueba de InfoPanel_EA en el gráfico
Conclusión
Gracias a este ejercicio, hemos logrado establecer una rutina repetible para integrar clases de la biblioteca estándar en un asesor experto. Desde la creación de un CPanel hasta la incorporación de una etiqueta descriptiva y un logotipo mediante CChartObjectLabel y CPicture, hemos analizado cómo se pueden combinar y controlar los distintos componentes de la interfaz de usuario para obtener un resultado pulido y funcional. Esta demostración, aunque breve, es completa y refleja la misma disciplina arquitectónica que se requiere para sistemas más grandes y complejos.
El objetivo no era solo crear un panel de información estático, sino interiorizar un patrón de trabajo —incluir, declarar, inicializar, configurar y limpiar— que se aplica de forma universal en todo el ecosistema de clases de MQL5. A medida que avancemos en la serie «Explorador de la biblioteca estándar de MQL5», este ejercicio básico nos facilitará el trabajo futuro con controles más avanzados y módulos compuestos.
Aunque aún quedan por pulir algunos detalles y se pueden introducir variaciones creativas, se ha logrado el objetivo fundamental: comprender cómo interactúan las clases modulares y cómo los pequeños componentes reutilizables pueden convertirse en aplicaciones completas. Se recomienda encarecidamente repetir el ejercicio: reproduzca este ejemplo, experimente con colores personalizados, diseños alternativos o nuevas clases como CButton, CDialog o CCheckBox. Cada iteración le permite comprender mejor cómo funciona el modelo de objetos de MQL5.
Recuerde que la modularización es la clave del progreso. La biblioteca estándar ya cuenta con numerosos componentes básicos muy potentes; nuestra tarea como desarrolladores consiste en combinarlos para crear sistemas inteligentes. Si aspira a dominar este oficio, dedice tiempo a estudiar la programación orientada a objetos (POO): le proporcionará los conocimientos necesarios para diseñar, ampliar y mantener sus propios marcos de trabajo escalables.
Este ejercicio puede parecer sencillo a primera vista, pero es un paso fundamental en su trayectoria hacia el desarrollo profesional en MQL5. Hemos hablado de muchas cosas, pero aún nos queda mucho por contar. El archivo adjunto contiene la implementación completa; no dude en probarla, perfeccionarla y compartir sus opiniones. Hagamos que este debate sea aún más enriquecedor con sus comentarios y ampliaciones creativas a continuación.
| Nombre del archivo | Descripción |
|---|---|
| InfoPanel_EA.mq5 | Muestra cómo integrar varias clases de la biblioteca estándar en un asesor experto. El EA crea un panel de información en el gráfico mediante CPanel, añade una etiqueta de texto descriptiva con CChartObjectLabel e incorpora una imagen de logotipo a través de la clase CPicture. Este ejemplo sirve de base para comprender la construcción de interfaces de usuario modulares y la interacción entre clases en MQL5. |
| Logo.zip | Contiene un logotipo en formato BMP, que es compatible y que puede extraer a la carpeta Images del terminal. No obstante, le animamos a que personalice su propia versión utilizando herramientas de código abierto como GIMP para disfrutar de una experiencia de desarrollo más personalizada. |
Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/19834
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.