EA para la apertura de operaciones según el riesgo con interfaz de usuario integrada en el gráfico (Parte 1): Diseño de la interfaz de usuario
Introducción
A muchos traders les cuesta calcular el tamaño del lote adecuado para cada operación y, al mismo tiempo, mantener un nivel de riesgo constante. Hacer estos cálculos manualmente antes de cada entrada es una tarea repetitiva y que requiere mucho tiempo; incluso un pequeño error puede provocar pérdidas indeseadas. Los traders necesitan una forma de agilizar este proceso y hacerlo más fiable, directamente desde el gráfico.
Este artículo presenta una solución práctica y muestra cómo diseñar un panel de control integrado en el gráfico para un asesor experto de apertura de operaciones en función del riesgo. La interfaz que vamos a desarrollar constituye la base de un sistema completo que, más adelante, automatizará el cálculo del tamaño del lote y la colocación de órdenes. En esta primera parte, nuestro objetivo es crear el diseño gráfico estático que constituirá el núcleo visual de la herramienta.
El objetivo de este proyecto va más allá de la simple creación de un diseño. El objetivo es crear algo que, con el tiempo, pueda utilizarse en condiciones reales de negociación. Los lectores también aprenderán a colocar los objetos del gráfico y darles estilo de forma adecuada, para que posteriormente puedan crear sus propias interfaces profesionales para asesores expertos personalizados.
Al principio, el lector tiene la necesidad de comprender cómo diseñar una interfaz gráfica de usuario (GUI) organizada y atractiva en MQL5. Al finalizar, dispondrá de los conocimientos y el código de ejemplo necesarios para crear un panel estático completo en el gráfico. Este artículo constituye el primer paso de una serie de dos partes que abarca desde el diseño visual hasta la funcionalidad completa.
Concepto y diseño
Antes de comenzar a programar, es importante tener una idea clara de lo que queremos crear. La interfaz gráfica de usuario de este asesor experto está diseñada para facilitar y agilizar el trabajo del trader. Esta reúne en un único panel integrado en el gráfico todos los datos de entrada esenciales para calcular el tamaño del lote y colocar una orden.

La interfaz permite al trader elegir el tipo de orden que desea colocar. El trader puede introducir un precio de entrada para las órdenes pendientes y especificar los niveles de stop-loss y take-profit. También incluye un campo para establecer el porcentaje de riesgo por operación. Hay dos botones principales disponibles. Un botón calcula el tamaño del lote adecuado en función de los datos introducidos por el usuario, mientras que el otro calcula y envía al instante la operación al servidor.
El panel también incluye una pequeña sección en la que se muestra el tamaño del lote calculado, de modo que el usuario pueda ver el resultado antes de enviar la operación. Para mejorar la facilidad de uso, hay un botón para cerrar el panel cuando no se necesita y otro para volver a abrirlo. Esto garantiza que la interfaz se mantenga despejada y no interfiera con la visualización del gráfico durante la negociación.
El diseño presenta una estructura sencilla y moderna. Todos los elementos están dispuestos de forma ordenada en una línea recta para facilitar la lectura y la interacción con el panel. La paleta de colores usa un fondo claro y suave con toques de color mínimos para que la atención se centre en la información. El título aparece en letra más grande y resaltado en un color diferente para que el usuario pueda identificar de inmediato la finalidad de la herramienta. Los botones de acción utilizan colores vivos que llaman la atención y guían al trader hacia el siguiente paso.
Con solo echar un vistazo rápido, el usuario puede entender para qué sirve el panel y cómo interactuar con él. El diseño transmite claramente una sensación de estructura y finalidad, lo que hace que la herramienta resulte a la vez profesional y agradable de usar.
Preparación de la estructura del EA
Empezaremos por crear nuestro archivo de trabajo. Para crear un archivo EA vacío, hay que abrir MetaEditor y seleccionar Archivo --> Nuevo --> Asesor experto (plantilla). El archivo debe llamarse SmartRiskTrader. Elegimos este nombre porque refleja claramente la finalidad de nuestra herramienta. Se trata de un asistente de negociación inteligente que gestiona la apertura de operaciones en función del riesgo.
Una vez creado el archivo, se debe eliminar todo el código generado automáticamente que contenga y, a continuación, pegar el siguiente código fuente:
//+------------------------------------------------------------------+ //| SmartRiskTrader.mq5 | //| Copyright 2025, MetaQuotes Ltd. Developer is Chacha Ian | //| https://www.mql5.com/en/users/chachaian | //+------------------------------------------------------------------+ #property copyright "Copyright 2025, MetaQuotes Ltd. Developer is Chacha Ian" #property link "https://www.mql5.com/en/users/chachaian" #property version "1.00" //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- create timer EventSetTimer(60); return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- destroy timer EventKillTimer(); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { } //+------------------------------------------------------------------+ //| Timer function | //+------------------------------------------------------------------+ void OnTimer() { } //+------------------------------------------------------------------+ //| TradeTransaction function | //+------------------------------------------------------------------+ void OnTradeTransaction(const MqlTradeTransaction &trans, const MqlTradeRequest &request, const MqlTradeResult &result) { } //+------------------------------------------------------------------+ //| ChartEvent function | //+------------------------------------------------------------------+ void OnChartEvent(const int32_t id, const long &lparam, const double &dparam, const string &sparam) { } //+------------------------------------------------------------------+
Este código sirve como plantilla. Supone una base limpia sobre la que construiremos toda la funcionalidad de nuestro EA. Vamos a repasar brevemente las partes principales:
- OnInit: esta función se ejecuta cuando el EA se carga por primera vez en un gráfico. En su interior, configuramos un evento de temporizador que se activa tras un intervalo de tiempo determinado. En este caso, cada 60 segundos. Normalmente, es dentro de esta función donde se se realizan las operaciones de inicialización del EA.
- OnDeinit: esta función se ejecuta cuando el EA se retira del gráfico o cuando se cierra el terminal. Desactiva los temporizadores y libera los recursos creados por el EA.
- OnTick: esta función se ejecuta cada vez que llega un nuevo tick de precio. Más adelante, la usaremos para gestionar la lógica de negociación.
- OnTimer: esta función se ejecuta periódicamente según el temporizador que hemos configurado en OnInit. Resulta ideal para tareas en segundo plano, como actualizar paneles o comprobar las condiciones de negociación.
- OnTradeTransaction: esta función se ejecuta cada vez que se produce una operación de negociación, como la apertura, la modificación o el cierre de una posición. Podemos utilizarla para supervisar la actividad de negociación y reaccionar ante ella.
- OnChartEvent: esta función gestiona las interacciones del usuario en el gráfico, como los clics en los botones. Es imprescindible para crear nuestro panel de control integrado en el gráfico.
Una vez preparada esta estructura, ya disponemos de todos los "puntos de enganche" necesarios en los que podemos ir incorporando nuestra lógica paso a paso. Pasemos ahora a definir algunas funciones de utilidad que nos facilitarán la creación y gestión de objetos gráficos en nuestro gráfico. Justo debajo de nuestro código fuente actual se deben añadir las siguientes funciones. Servirán como elementos básicos reutilizables a la hora de crear nuestra interfaz de usuario.
//--- UTILITY FUNCTIONS //+------------------------------------------------------------------+ //| Function to generate a unique object name with a given prefix | //+------------------------------------------------------------------+ string GenerateUniqueName(string prefix){ int attempt = 0; string uniqueName; while(true) { uniqueName = prefix + IntegerToString(MathRand() + attempt); if(ObjectFind(0, uniqueName) < 0){ break; } attempt++; } return uniqueName; } //--- Reusable GUI elements //+------------------------------------------------------------------+ //| 1. To create a Rectangular panel | //+------------------------------------------------------------------+ bool CREATE_OBJ_RECTANGLE_LABEL( string objName, int xDistance, int yDistance, int width, int height, color clrBackground, int borderWidth, color borderColor = clrNONE, ENUM_BORDER_TYPE borderType = BORDER_FLAT, ENUM_LINE_STYLE borderStyle = STYLE_SOLID ){ ResetLastError(); //--- Create a rectangular panel if(!ObjectCreate(0, objName, OBJ_RECTANGLE_LABEL, 0, 0, 0)){ Print("Error while creating a rectangular panel: ", GetLastError()); return false; } //--- Set values for corresponding object properties ObjectSetInteger(0, objName, OBJPROP_XDISTANCE, xDistance); ObjectSetInteger(0, objName, OBJPROP_YDISTANCE, yDistance); ObjectSetInteger(0, objName, OBJPROP_XSIZE, width); ObjectSetInteger(0, objName, OBJPROP_YSIZE, height); ObjectSetInteger(0, objName, OBJPROP_CORNER, CORNER_LEFT_UPPER); ObjectSetInteger(0, objName, OBJPROP_BGCOLOR, clrBackground); ObjectSetInteger(0, objName, OBJPROP_BORDER_TYPE, borderType); ObjectSetInteger(0, objName, OBJPROP_STYLE, borderStyle); ObjectSetInteger(0, objName, OBJPROP_WIDTH, borderWidth); ObjectSetInteger(0, objName, OBJPROP_COLOR, borderColor); ObjectSetInteger(0, objName, OBJPROP_BACK, false); ObjectSetInteger(0, objName, OBJPROP_STATE, false); ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false); ObjectSetInteger(0, objName, OBJPROP_SELECTED, false); ChartRedraw(); return true; } //+------------------------------------------------------------------+ //| 2. To create a Button Object | //+------------------------------------------------------------------+ bool CREATE_OBJ_BUTTON( string objName, int xDistance, int yDistance, int width, int height, string text = "Activate", color textColor = clrDarkGray, int fontSize = 12, int borderWidth = 0, color backgroundColor = clrWhiteSmoke, color borderColor = clrBlack, string font = "Tahoma" ){ ResetLastError(); //--- Create a button object if(!ObjectCreate(0, objName, OBJ_BUTTON, 0, 0, 0)){ Print("Error while creating a button: ", GetLastError()); return false; } //--- Set values for corresponding object properties ObjectSetInteger(0, objName, OBJPROP_XDISTANCE, xDistance); ObjectSetInteger(0, objName, OBJPROP_YDISTANCE, yDistance); ObjectSetInteger(0, objName, OBJPROP_XSIZE, width); ObjectSetInteger(0, objName, OBJPROP_YSIZE, height); ObjectSetInteger(0, objName, OBJPROP_CORNER, CORNER_LEFT_UPPER); ObjectSetString (0, objName, OBJPROP_TEXT, text); ObjectSetInteger(0, objName, OBJPROP_COLOR, textColor); ObjectSetInteger(0, objName, OBJPROP_FONTSIZE, fontSize); ObjectSetString (0, objName, OBJPROP_FONT, font); ObjectSetInteger(0, objName, OBJPROP_BGCOLOR, backgroundColor); ObjectSetInteger(0, objName, OBJPROP_BORDER_TYPE, BORDER_FLAT); ObjectSetInteger(0, objName, OBJPROP_WIDTH, borderWidth); ObjectSetInteger(0, objName, OBJPROP_BORDER_COLOR, borderColor); ObjectSetInteger(0, objName, OBJPROP_BACK, false); ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false); ObjectSetInteger(0, objName, OBJPROP_SELECTED, false); ChartRedraw(); return true; } //+------------------------------------------------------------------+ //| 3. To create an Input field | //+------------------------------------------------------------------+ bool CREATE_OBJ_EDIT( string objName, int xDistance, int yDistance, int width, int height, string text = "Say sth'...", color textColor = clrGray, int fontSize = 12, color backgroundColor = clrWhite, color borderColor = clrBlack, string font = "Tahoma" ){ ResetLastError(); //--- Create an input field if(!ObjectCreate(0, objName, OBJ_EDIT, 0, 0, 0)){ Print("Error while creating a text input: ", GetLastError()); return false; } //--- Set values for corresponding object properties ObjectSetInteger(0, objName, OBJPROP_XDISTANCE, xDistance); ObjectSetInteger(0, objName, OBJPROP_YDISTANCE, yDistance); ObjectSetInteger(0, objName, OBJPROP_XSIZE, width); ObjectSetInteger(0, objName, OBJPROP_YSIZE, height); ObjectSetInteger(0, objName, OBJPROP_CORNER, CORNER_LEFT_UPPER); ObjectSetString (0, objName, OBJPROP_TEXT, text); ObjectSetInteger(0, objName, OBJPROP_COLOR, textColor); ObjectSetInteger(0, objName, OBJPROP_FONTSIZE, fontSize); ObjectSetString (0, objName, OBJPROP_FONT, font); ObjectSetInteger(0, objName, OBJPROP_BGCOLOR, backgroundColor); ObjectSetInteger(0, objName, OBJPROP_BORDER_COLOR, borderColor); ObjectSetInteger(0, objName, OBJPROP_ALIGN, ALIGN_LEFT); ObjectSetInteger(0, objName, OBJPROP_READONLY, false); ObjectSetInteger(0, objName, OBJPROP_BACK, false); ObjectSetInteger(0, objName, OBJPROP_STATE, false); ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false); ObjectSetInteger(0, objName, OBJPROP_SELECTED, false); ChartRedraw(); return true; } //+------------------------------------------------------------------+ //| 4. To create a Text label | //+------------------------------------------------------------------+ bool CREATE_OBJ_LABEL( string objName, int xDistance, int yDistance, string text = "Name sth'...", color textColor = clrDarkGray, int fontSize = 12, string font = "Tahoma" ){ ResetLastError(); //--- Create a text label if(!ObjectCreate(0, objName, OBJ_LABEL, 0, 0, 0)){ Print("Error while creating a text label: ", GetLastError()); return false; } //--- Set values for corresponding object properties ObjectSetInteger(0, objName, OBJPROP_XDISTANCE, xDistance); ObjectSetInteger(0, objName, OBJPROP_YDISTANCE, yDistance); ObjectSetInteger(0, objName, OBJPROP_CORNER, CORNER_LEFT_UPPER); ObjectSetString (0, objName, OBJPROP_TEXT, text); ObjectSetInteger(0, objName, OBJPROP_COLOR, textColor); ObjectSetInteger(0, objName, OBJPROP_FONTSIZE, fontSize); ObjectSetString (0, objName, OBJPROP_FONT, font); ObjectSetInteger(0, objName, OBJPROP_BACK, false); ObjectSetInteger(0, objName, OBJPROP_STATE, false); ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false); ObjectSetInteger(0, objName, OBJPROP_SELECTED, false); ChartRedraw(); return true; }
Ahora, veamos qué hace cada una de estas funciones.
1. GenerateUniqueName
Cada objeto gráfico de un gráfico debe tener un nombre único. Dicha función crea un nombre único utilizando un prefijo y un número aleatorio. Esta ayuda a evitar conflictos de nombres cuando se crean varios objetos de forma dinámica.
2. CREATE_OBJ_RECTANGLE_LABEL
La función crea un panel rectangular. Lo utilizaremos como fondo o contenedor para albergar otros elementos de la interfaz gráfica de usuario, como etiquetas y botones.
3. CREATE_OBJ_BUTTON
Esta función crea un botón en el que se puede hacer clic y cuyo texto, tamaño y color se pueden personalizar. Los botones son fundamentales para las acciones del usuario, como realizar operaciones o calcular el tamaño del lote.
4. CREATE_OBJ_EDIT
Esta función crea un cuadro de texto editable en el que el usuario puede introducir valores. Más adelante utilizaremos estos cuadros para recoger datos de entrada como el precio de entrada y el porcentaje de riesgo.
5. CREATE_OBJ_LABEL
La función crea una etiqueta de texto sencilla que muestra información o descripciones junto a los campos de entrada y los botones.
En conjunto, estas cinco funciones constituyen la base de nuestra interfaz gráfica integrada en el gráfico. Simplifican la creación de objetos y hacen que nuestro código sea más organizado y legible. En la siguiente sección, las utilizaremos para crear el diseño principal de nuestra interfaz gráfica de usuario.
Paso a paso: montaje de la interfaz de usuario
Ahora que ya tenemos todas nuestras funciones auxiliares listas, es hora de empezar a montar la interfaz de usuario propiamente dicha. Para mantener nuestro código limpio y organizado, crearemos una única función que se encargue de todo el proceso de visualización de la interfaz gráfica de usuario. Llamaremos a esta función CREATE_GUI. Hacer que la interfaz sea modular de esta forma resulta muy útil, ya que más adelante quizá queramos eliminar y volver a crear el panel cuando un usuario haga clic en el botón de cierre de la interfaz de usuario. El hecho de que haya una única función encargada de crear todos los elementos visuales hace que este proceso sea sencillo y fácil de gestionar. Por ahora, vamos a declarar esta función justo debajo de las que ya tenemos.
... //+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ } //+------------------------------------------------------------------+
También la llamaremos dentro de la función OnInit para poder ver al instante el efecto de nuestro código a medida que vamos creando la interfaz paso a paso.
... //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- create timer EventSetTimer(60); //--- render the graphical user interface CREATE_GUI(); return(INIT_SUCCEEDED); } ...
Antes de continuar, hay un paso importante que debemos dar para asegurarnos de que nuestra interfaz se muestre correctamente en el gráfico. Por defecto, los gráficos de MetaTrader muestran botones para operar con un solo clic en la esquina superior izquierda. Estos botones pueden solaparse con nuestra interfaz personalizada y dificultar su visualización. Para solucionar esto, configuraremos el aspecto del gráfico desactivando los botones para operar con un solo clic cuando se inicie nuestro EA.
Lo conseguiremos usando una función sencilla llamada ConfigureChartAppearance, que definiremos justo debajo de nuestras funciones auxiliares existentes. Dicha función configura la propiedad del gráfico para ocultar los botones para operar con un solo clic.
//+------------------------------------------------------------------+ //| 4. This function configures the chart's appearance. | | //+------------------------------------------------------------------+ bool ConfigureChartAppearance() { if(!ChartSetInteger(0, CHART_SHOW_ONE_CLICK, false)){ Print("Error while setting one click buttons, ", GetLastError()); return false; } return true; }
Una vez definida esta función, la llamaremos dentro de la función OnInit para que se ejecute automáticamente al cargar el asesor experto. De este modo se garantiza que el diseño del gráfico se ajuste antes de que se muestre la interfaz gráfica de usuario.
//+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { ... //--- Configure chart appearance if(!ConfigureChartAppearance()){ Print("Error while customizing the chart's appearance"); return(INIT_FAILED); } return(INIT_SUCCEEDED); }
Es una buena práctica asegurarse de que todos los objetos gráficos creados por nuestro EA se eliminen correctamente cuando el programa se retire del gráfico. Esto evita el desorden y que queden objetos de sesiones anteriores.
Para ello, añadiremos una sencilla línea de código dentro de la función OnDeinit que borre todos los objetos gráficos cuando se retire el EA del gráfico. La función ObjectsDeleteAll elimina todos los objetos del gráfico actual, dejándolo limpio y listo para su uso futuro.
//+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { ... //--- delete all graphical objects ObjectsDeleteAll(0); }
Antes de empezar a crear los objetos individuales para nuestro panel, debemos asegurarnos de que cada objeto tenga un nombre único. Esto nos ayuda a identificarlos y gestionarlos fácilmente en el gráfico. Para ello, utilizaremos macros para almacenar los nombres de nuestros objetos. En el caso de los objetos a los que no necesitemos acceder con frecuencia ni modificarlos a menudo, nos limitaremos a definir un prefijo corto que se utilizará para generar sus nombres. Vamos a añadir el siguiente fragmento de código justo debajo de la sección que define las directivas de propiedades del EA.
... //+------------------------------------------------------------------+ //| Macros | //+------------------------------------------------------------------+ #define SmartRiskTrader "SmartRiskTrader" ...
Comenzaremos a crear nuestra interfaz con el panel de fondo, que servirá de contenedor base para el resto de elementos de nuestra interfaz gráfica de usuario. Puede concebirse como el lienzo sobre el que se colocarán todos los botones, etiquetas y controles. Para ello, llamamos a nuestra función personalizada CREATE_OBJ_RECTANGLE_LABEL, que dibuja un objeto de etiqueta rectangular en el gráfico.
... //+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ //--- Background panel CREATE_OBJ_RECTANGLE_LABEL(GenerateUniqueName(SmartRiskTrader), 20, 20, 320, 380, clrWhiteSmoke, 1, clrDarkBlue, BORDER_FLAT, STYLE_DASHDOTDOT); } ...
Luego utilizamos GenerateUniqueName(SmartRiskTrader) para garantizar que el nombre del objeto sea único, y le aplicamos un fondo de aspecto limpio en color blanco humo con un borde azul oscuro.
Llegados a este punto, se puede compilar el código fuente. Una vez compilado correctamente el código, se puede pasar al gráfico y ejecutar el EA. Ahora debería aparecer un panel rectangular de aspecto cuidado justo en la posición definida.

Esto confirma que nuestra función de creación de interfaces gráficas de usuario funciona correctamente. Siempre supone una buena idea probar el código de forma incremental, como se ha hecho aquí, para poder detectar y resolver cualquier problema en una fase temprana, antes de que la interfaz se vuelva más compleja.
A continuación, añadiremos otro panel rectangular encima de nuestro panel de fondo original. Este panel secundario no tiene ninguna función práctica; su único objetivo es aportar un atractivo visual, ya que contribuye a que la interfaz tenga un aspecto más limpio y con diferentes capas. Simplemente lo superpondremos sobre el primer rectángulo utilizando unas coordenadas ligeramente más pequeñas, para que quede bien encajado dentro del borde del panel principal.
Una vez añadido, el código debería tener este aspecto:
... //+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ //--- Background panel CREATE_OBJ_RECTANGLE_LABEL(GenerateUniqueName(SmartRiskTrader), 20, 20, 320, 380, clrWhiteSmoke, 1, clrDarkBlue, BORDER_FLAT, STYLE_DASHDOTDOT); CREATE_OBJ_RECTANGLE_LABEL(GenerateUniqueName(SmartRiskTrader), 30, 30, 300, 360, clrWhite, 1, clrDarkBlue, BORDER_FLAT, STYLE_SOLID); } ...
Esta sencilla incorporación confiere a nuestra interfaz un aspecto más refinado y con mayor profundidad. Ahora podemos compilar y ejecutar el programa para apreciar el diseño actualizado.

Ahora que ya tenemos listo el fondo, pasaremos a crear la sección de cabecera de nuestra interfaz gráfica de usuario. En esta zona aparecerá el título de nuestra herramienta y habrá un pequeño botón que permitirá al usuario cerrar el panel. También añadiremos una línea separadora fina para distinguir visualmente la cabecera del resto de la interfaz.
La construiremos paso a paso, añadiendo un componente cada vez y compilando después de cada adición para observar los cambios en tiempo real.
Empezaremos creando un pequeño rectángulo que albergará nuestro botón de cierre:
... //+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ //--- Background panel ... CREATE_OBJ_RECTANGLE_LABEL(GenerateUniqueName(SmartRiskTrader), 30, 30, 300, 360, clrWhite, 1, clrDarkBlue, BORDER_FLAT, STYLE_SOLID); //--- Header Section Components CREATE_OBJ_RECTANGLE_LABEL(GenerateUniqueName(SmartRiskTrader), 300, 40, 20, 20, clrWhiteSmoke, 1, clrDarkBlue, BORDER_FLAT, STYLE_SOLID); } ...
Una vez añadida esta línea, se puede compilar el código y ejecutar el EA para ver cómo aparece el pequeño recuadro de la cabecera en la zona superior derecha del panel.

A continuación, colocamos el botón de cierre ("X") justo dentro de ese recuadro: a diferencia de los elementos decorativos que hemos ido creando hasta ahora, este botón responderá realmente a la interacción del usuario; al hacer clic en él, se cerrará nuestra interfaz. Por eso, es importante asignarle un nombre único y fácilmente reconocible al que podamos hacer referencia más adelante en nuestro código.
... //+------------------------------------------------------------------+ //| Macros | //+------------------------------------------------------------------+ #define SmartRiskTrader "SmartRiskTrader" #define BTN_CLOSE_GUI "BTN_CLOSE_GUI" ...
Ahora vamos a añadir el código que muestra el botón.
... //+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ ... //--- Header Section Components CREATE_OBJ_RECTANGLE_LABEL(GenerateUniqueName(SmartRiskTrader), 300, 40, 20, 20, clrWhiteSmoke, 1, clrDarkBlue, BORDER_FLAT, STYLE_SOLID); CREATE_OBJ_LABEL(BTN_CLOSE_GUI, 305, 40, "X", clrDarkBlue, 12); }
Al compilar el EA, debería aparecer el símbolo "X" en la parte superior derecha del panel.

Ahora, vamos a añadir la etiqueta del título para nuestra interfaz gráfica de usuario. De este modo, el panel tendrá un aspecto más profesional e informativo.
... //+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ ... CREATE_OBJ_LABEL(GenerateUniqueName(SmartRiskTrader), 40, 37, "Smart Risk Trader", clrDarkBlue, 14, "Comic Sans Ms"); CREATE_OBJ_LABEL(GenerateUniqueName(SmartRiskTrader), 40, 37, "Smart Risk Trader", clrDarkBlue, 14, "Comic Sans Ms"); } ...
El siguiente paso es compilar y ejecutar de nuevo el código. Ahora debería verse el título en la parte superior del panel, con una tipografía agradable y fácil de leer.

Por último, vamos a crear una línea horizontal para separar la cabecera del resto de los componentes que hay debajo:
... //+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ ... CREATE_OBJ_LABEL(GenerateUniqueName(SmartRiskTrader), 40, 37, "Smart Risk Trader", clrDarkBlue, 14, "Comic Sans Ms"); CREATE_OBJ_RECTANGLE_LABEL(GenerateUniqueName(SmartRiskTrader), 30, 70, 300, 1, clrDarkBlue, 1, clrDarkBlue, BORDER_FLAT); } ...
Se debe compilar de nuevo para comprobar que todo está en su sitio.

Tras seguir estos pasos, la interfaz gráfica de usuario cuenta ahora con una sección de cabecera sencilla pero elegante que le aporta estructura e identidad: un pequeño botón de cierre, un título de diseño limpio y una línea de separación clara justo debajo.
Ahora añadiremos nuestro primer campo de entrada y su etiqueta. Este campo de entrada permite al usuario seleccionar un tipo de orden, como "Buy", "Sell", "Buy Limit" u otros. Al igual que antes, empezamos mostrando una etiqueta de texto para describir qué representa el campo.
A continuación, creamos el botón propiamente dicho que hará las veces de nuestro campo de entrada. Como queremos acceder a este botón más adelante mediante código —por ejemplo, para detectar cuándo se pulsa—, debemos asignarle un nombre fijo en lugar de generar uno de forma dinámica. Para ello, primero definimos una macro de la siguiente manera:
... //+------------------------------------------------------------------+ //| Macros | //+------------------------------------------------------------------+ ... #define BTN_ORDER_TYPES "BTN_ORDER_TYPES" ...
Una vez definida la macro, podemos pasar a crear la etiqueta y el campo de entrada (que en este caso está representado por un botón). La etiqueta servirá como título del campo, mientras que el botón permitirá al usuario interactuar con la interfaz y seleccionar el tipo de orden deseado.
... //+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ ... //--- Order Types CREATE_OBJ_LABEL(GenerateUniqueName(SmartRiskTrader), 40, 90, "Order Type: ", C'20, 20, 20'); CREATE_OBJ_BUTTON(BTN_ORDER_TYPES, 140, 90, 140, 25, "Select Order Type", C'20, 20, 20', 12, 1, clrWhiteSmoke, clrDarkBlue); } ...
Una vez añadido este código, se puede compilar y ejecutar para ver el nuevo campo de entrada en el gráfico.

Antes de crear el menú desplegable para nuestros tipos de órdenes, primero tenemos que definir algunas macros. Estas macros almacenarán los identificadores únicos de cada elemento del menú desplegable, de modo que podamos identificarlos e interactuar con ellos fácilmente más adelante. Dado que estos elementos responderán a acciones del usuario, como los clics, el uso de nombres fijos en lugar de nombres generados dinámicamente facilita la gestión de los eventos. A continuación se muestran las macros que definen el grupo del menú desplegable y cada una de las opciones de tipo de orden.
#define ORDER_TYPE_GROUP "ORDER_TYPE_GROUP" #define MARKET_BUY "ORDER_TYPE_GROUP_MARKET_BUY" #define MARKET_SELL "ORDER_TYPE_GROUP_MARKET_SELL" #define BUY_LIMIT "ORDER_TYPE_GROUP_BUY_LIMIT" #define SELL_LIMIT "ORDER_TYPE_GROUP_SELL_LIMIT" #define BUY_STOP "ORDER_TYPE_GROUP_BUY_STOP" #define SELL_STOP "ORDER_TYPE_GROUP_SELL_STOP"
Ahora que hemos definido las macros, podemos crear una función que genere el menú desplegable. Esta función, denominada CREATE_ORDER_TYPE_DROPDOWN, mostrará todos los elementos del menú desplegable, incluidos el panel de fondo y las etiquetas individuales de los tipos de órdenes. El menú desplegable ofrecerá a los usuarios una forma clara y organizada de seleccionar un tipo de orden directamente desde la interfaz.
... //+------------------------------------------------------------------+ //| Function to create the order types dropdown | //+------------------------------------------------------------------+ void CREATE_ORDER_TYPE_DROPDOWN(){ CREATE_OBJ_RECTANGLE_LABEL(GenerateUniqueName(ORDER_TYPE_GROUP), 140, 116, 140, 151, clrWhiteSmoke, 1, clrDarkBlue, BORDER_FLAT); CREATE_OBJ_LABEL(MARKET_BUY , 150, 120, "Market Buy ", C'20, 20, 20'); CREATE_OBJ_LABEL(MARKET_SELL, 150, 145, "Market Sell", C'20, 20, 20'); CREATE_OBJ_LABEL(BUY_LIMIT , 150, 170, "Buy Limit ", C'20, 20, 20'); CREATE_OBJ_LABEL(SELL_LIMIT , 150, 195, "Sell Limit ", C'20, 20, 20'); CREATE_OBJ_LABEL(BUY_STOP , 150, 220, "Buy Stop ", C'20, 20, 20'); CREATE_OBJ_LABEL(SELL_STOP , 150, 245, "Sell Stop ", C'20, 20, 20'); }
Para probar esta función, podemos llamarla temporalmente desde la función OnInit. Esto nos permitirá ver cómo aparece el menú desplegable en el gráfico al iniciar el EA.
... //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- create timer EventSetTimer(60); //--- render the graphical user interface CREATE_GUI(); CREATE_ORDER_TYPE_DROPDOWN(); return(INIT_SUCCEEDED); } ...
Ahora, al compilar el código fuente y observar el gráfico, debería aparecer un menú desplegable ordenado y bien presentado en la interfaz.
Una vez comprobado que funciona correctamente, es importante comentar la llamada a la función, ya que más adelante mostraremos el menú desplegable únicamente cuando el usuario haga clic en el botón “Select Order Type” (“Seleccionar tipo de orden”). Esto garantiza que el menú desplegable se comporte de forma dinámica, tal y como debe hacerlo en una interfaz profesional.
... //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- create timer EventSetTimer(60); //--- render the graphical user interface CREATE_GUI(); //CREATE_ORDER_TYPE_DROPDOWN(); return(INIT_SUCCEEDED); } ...
A continuación, vamos a crear el campo del precio de entrada junto con su etiqueta. Como tendremos que acceder a este campo más adelante en nuestro código, deberíamos asignarle un nombre fijo para poder referirnos a él con facilidad. Definiremos este nombre como una macro tal y como se muestra a continuación:
... //+------------------------------------------------------------------+ //| Macros | //+------------------------------------------------------------------+ ... #define FIELD_ENTRY_PRICE "FIELD_ENTRY_PRICE" ...
Una vez definida la macro, ya podemos añadir la etiqueta y el campo de entrada a nuestra función CREATE_GUI. Estas dos líneas de código mostrarán la etiqueta “Entry Price:” (“Precio de entrada”) y un campo editable en el que los usuarios podrán introducir un valor.
... //+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ ... //--- Entry Price CREATE_OBJ_LABEL(GenerateUniqueName(SmartRiskTrader), 40, 125, "Entry Price: ", C'20, 20, 20'); CREATE_OBJ_EDIT(FIELD_ENTRY_PRICE, 140, 125, 100, 25, "1.14030", C'20, 20, 20', 12, clrWhiteSmoke, clrDarkBlue); }
Ahora se debe compilar el código fuente y, a continuación, ejecutar el EA en el gráfico. Debería aparecer un campo de precio de entrada de aspecto cuidado y bien alineado, junto con su etiqueta, listo para que el usuario introduzca datos.

Ahora que hemos añadido el campo del precio de entrada, repetiremos el mismo procedimiento con el resto de campos de entrada. Estos campos permitirán al usuario introducir el nivel de stop-loss, el nivel de take-profit y el porcentaje de riesgo. Al igual que antes, definiremos macros para cada uno de estos campos para que resulte más fácil hacer referencia a ellos más adelante en nuestro código.
... //+------------------------------------------------------------------+ //| Macros | //+------------------------------------------------------------------+ ... #define FIELD_STOP_LOSS "FIELD_STOP_LOSS" #define FIELD_TAKE_PROFIT "FIELD_TAKE_PROFIT" #define RISK "RISK"
Una vez definidas estas macros, podemos volver a nuestra función CREATE_GUI y añadir el código que crea las etiquetas y los campos de entrada correspondientes.
//+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ ... //--- Stop Loss CREATE_OBJ_LABEL(GenerateUniqueName(SmartRiskTrader), 40, 160, "Stop Loss: ", C'20, 20, 20'); CREATE_OBJ_EDIT(FIELD_STOP_LOSS, 140, 160, 100, 25, "1.13302", C'20, 20, 20', 12, clrWhiteSmoke, clrDarkBlue); //--- Take Profit CREATE_OBJ_LABEL(GenerateUniqueName(SmartRiskTrader), 40, 195, "Take Profit: ", C'20, 20, 20'); CREATE_OBJ_EDIT(FIELD_TAKE_PROFIT, 140, 195, 100, 25, "1.16302", C'20, 20, 20', 12, clrWhiteSmoke, clrDarkBlue); //--- Risk CREATE_OBJ_LABEL(GenerateUniqueName(SmartRiskTrader), 40, 230, "Risk %: ", C'20, 20, 20'); CREATE_OBJ_EDIT(RISK, 140, 230, 100, 25, "2.0", C'20, 20, 20', 12, clrWhiteSmoke, clrDarkBlue); }
Tras añadir estas líneas, se debe compilar el código fuente y ejecutar el EA en el gráfico. Ahora debería verse un diseño limpio y organizado que contiene los tres nuevos campos de entrada, cada uno de ellos debidamente etiquetado y alineado con el resto de la interfaz.

A continuación, vamos a añadir los botones de ejecución que se encargarán de acciones como calcular el tamaño del lote y enviar órdenes de negociación. Dado que más adelante tendremos que detectar cuándo un usuario hace clic en estos botones, es importante asignar a cada uno de ellos un nombre único y fácilmente reconocible. Para ello, definiremos macros para los botones tal y como se muestra a continuación:
//+------------------------------------------------------------------+ //| Macros | //+------------------------------------------------------------------+ ... #define BTN_SEND_ORDER "BTN_SEND_ORDER" #define RESULTS_TEXT "RESULTS_TEXT" #define BTN_GUI_OPEN "BTN_GUI_OPEN"
Una vez definidas estas macros, podemos pasar a crear los elementos de los botones propiamente dichos dentro de nuestra función CREATE_GUI. El código que aparece a continuación añade dos botones: uno para calcular el tamaño del lote y otro para enviar órdenes de negociación.
//+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ ... //--- Execution Buttons CREATE_OBJ_BUTTON(BTN_CALC_LOT, 40, 270, 140, 40, "CALCULATE LOT", clrWhite, 12, 1, clrDarkBlue, clrBlack); CREATE_OBJ_BUTTON(BTN_SEND_ORDER, 190, 270, 120, 40, "SEND ORDER", clrWhite, 12, 1, clrDarkGreen, clrBlack); }
Ahora hay que compilar el código fuente y, a continuación, adjuntar el EA a un gráfico. Deberían verse dos botones perfectamente alineados que, más adelante, permitirán al usuario calcular el tamaño del lote y enviar órdenes directamente desde la interfaz.

Para completar el diseño estático de nuestra interfaz de usuario, vamos a crear ahora una pequeña zona de visualización en la que aparecerá el tamaño del lote calculado una vez que el usuario haya realizado el cálculo. Esta zona de visualización estará formada por un panel rectangular de fondo y una etiqueta de texto situada en su interior. Como más adelante tendremos que actualizar el valor que aparece en esta etiqueta mediante código, le daremos un nombre único definido como macro para facilitar las referencias a ella.
//+------------------------------------------------------------------+ //| Macros | //+------------------------------------------------------------------+ ... #define RESULTS_TEXT "RESULTS_TEXT"
Una vez definida la macro, podemos pasar a crear los elementos visuales propiamente dichos. Dentro de nuestra función CREATE_GUI, añadiremos las siguientes líneas de código para dibujar el contenedor rectangular y colocar la etiqueta de texto en su interior:
//+------------------------------------------------------------------+ //| Function to render the main GUI | //+------------------------------------------------------------------+ void CREATE_GUI(){ ... //--- Execution Results CREATE_OBJ_RECTANGLE_LABEL(GenerateUniqueName(SmartRiskTrader), 40, 320, 270, 50, clrWhiteSmoke, 1, clrDarkBlue, BORDER_FLAT); CREATE_OBJ_LABEL(RESULTS_TEXT, 60, 333, "Result: Lot Size = 0.23", clrDarkGreen, 14); }
Hay que compilar el código y, a continuación, adjuntar el EA a un gráfico. Ahora debería verse una zona limpia y sencilla en la parte inferior de la interfaz, en la que aparece un texto de ejemplo que representa el tamaño del lote calculado.

Con esta incorporación, hemos completado el diseño estático de nuestra interfaz "Smart Risk Trader". Para facilitar el seguimiento del proceso, hemos adjuntado el código fuente completo correspondiente a la fase actual del proyecto. Puede abrirlo en MetaEditor, examinar las funciones que hemos comentado y comprobar que todo se compila correctamente. En la siguiente sección, centraremos nuestra atención en hacer que la interfaz gráfica de usuario sea interactiva y responda a las acciones del usuario, dándole así vida.
Conclusión
A estas alturas, hemos creado con éxito una interfaz gráfica limpia y funcional integrada en el gráfico para nuestro asesor experto Smart Risk Trader. Ahora ya se comprende cómo utilizar los objetos gráficos de MQL5 para crear paneles, etiquetas, botones y campos de entrada, y cómo estructurar el código de forma modular para facilitar su mantenimiento y su futura ampliación. Lo que comenzó como una plantilla en blanco de EA se ha convertido en una base visualmente atractiva y bien organizada para una herramienta de trading profesional.
Siguiendo este tutorial paso a paso, no solo habrá aprendido a crear una interfaz gráfica de usuario (GUI) en MQL5, sino que también habrá adquirido conocimientos valiosos sobre cómo interactúan estos elementos dentro del entorno de MetaTrader 5. Con estos conocimientos, ahora podrá diseñar y crear interfaces aún más avanzadas, elegantes y dinámicas para sus propios asesores expertos e indicadores.
En la parte 2, daremos vida a esta interfaz conectando cada componente a una funcionalidad real. Aprenderá a detectar las acciones del usuario —como los clics en botones y las selecciones en menús desplegables— y a responder a ellas, así como a hacer que Smart Risk Trader sea totalmente interactivo.
Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/19932
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.