Dans l’univers du trading algorithmique, la différence entre un Expert Advisor (EA) performant et un outil frustrant réside souvent dans son interface utilisateur. Un panel de trading MT5 en MQL5 transforme votre robot en un véritable tableau de bord interactif, vous permettant de surveiller les positions, ajuster les paramètres et visualiser les performances sans quitter MetaTrader 5. Cet article vous guide pas à pas dans la création d’une interface graphique complète pour votre EA, en utilisant les classes standards de MQL5 comme CAppDialog, CButton et CLabel. Que vous soyez développeur débutant ou trader expérimenté souhaitant améliorer vos outils, vous apprendrez à concevoir un panel trading MT5 mql5 interface graphique fonctionnel, responsive et facile à maintenir. Préparez-vous à passer de simples lignes de code à un EA professionnel digne des meilleurs prop firms.

1. Préparer l’environnement de développement pour votre panel MT5

Avant de coder la moindre ligne, il est crucial de bien configurer votre environnement MetaEditor. La création d’un panel de trading MT5 en MQL5 repose sur l’utilisation de la bibliothèque standard <Controls> qui fournit tous les composants graphiques de base. Ouvrez MetaEditor (F4 dans MT5) et créez un nouvel Expert Advisor. Assurez-vous d’inclure les fichiers d’en-tête nécessaires : Dialog.mqh, Button.mqh et Label.mqh.

Voici la structure initiale de votre code :

//+------------------------------------------------------------------+
//|                                              PanelTradingEA.mq5  |
//|                                                 Votre Nom         |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024"
#property link      "https://www.votresite.com"
#property version   "1.00"

#include <Controls\Dialog.mqh>
#include <Controls\Button.mqh>
#include <Controls\Label.mqh>

//--- Déclaration de la classe du panel
class CPanelTrading : public CAppDialog
  {
private:
   //--- Composants du panel
   CButton         m_buttonBuy;
   CButton         m_buttonSell;
   CLabel          m_labelBalance;
   CLabel          m_labelProfit;
   //--- Méthodes
   bool            Create(const long chart, const string name, const int subwin, const int x1, const int y1, const int x2, const int y2);
   bool            CreateButtonBuy(void);
   bool            CreateButtonSell(void);
   bool            CreateLabels(void);
public:
                    CPanelTrading(void);
                   ~CPanelTrading(void);
   //--- Event handlers
   virtual bool    OnEvent(const int id, const long &lparam, const double &dparam, const string &sparam);
  };

Cette structure de base définit les éléments essentiels de votre interface graphique MQL5. La classe CPanelTrading hérite de CAppDialog, ce qui vous donne accès à toutes les fonctionnalités de fenêtre, de gestion d’événements et de rendu. Les méthodes CreateButtonBuy et CreateButtonSell seront implémentées dans les étapes suivantes pour ajouter des boutons d’action.

2. Concevoir les contrôles interactifs : boutons et labels

L’étape suivante consiste à créer les éléments visuels de votre panel trading MT5 mql5 interface graphique. Commencez par implémenter la méthode de création des boutons d’achat et de vente. Ces contrôles permettront à l’utilisateur d’interagir directement avec le marché depuis le panel.

Exemple de code pour créer un bouton d’achat :

bool CPanelTrading::CreateButtonBuy(void)
  {
//--- Coordonnées et taille du bouton
   int x = 10;
   int y = 50;
   int width = 100;
   int height = 30;

//--- Création du bouton
   if(!m_buttonBuy.Create(0, "ButtonBuy", 0, x, y, x+width, y+height))
     {
      Print("Erreur lors de la création du bouton BUY");
      return(false);
     }
//--- Propriétés du bouton
   m_buttonBuy.Text("ACHETER");
   m_buttonBuy.FontSize(10);
   m_buttonBuy.Color(clrWhite);
   m_buttonBuy.BackColor(clrGreen);
   m_buttonBuy.BorderColor(clrDarkGreen);
//--- Ajout au dialogue
   if(!Add(m_buttonBuy))
     {
      Print("Erreur lors de l'ajout du bouton au dialogue");
      return(false);
     }
   return(true);
  }

Pour les labels, créez des affichages dynamiques qui se mettront à jour en temps réel :

bool CPanelTrading::CreateLabels(void)
  {
//--- Label du solde
   if(!m_labelBalance.Create(0, "LabelBalance", 0, 10, 10, 200, 30))
     {
      Print("Erreur création label balance");
      return(false);
     }
   m_labelBalance.Text("Solde : 0.00");
   m_labelBalance.FontSize(12);
   m_labelBalance.Color(clrWhite);
   if(!Add(m_labelBalance))
      return(false);

//--- Label du profit
   if(!m_labelProfit.Create(0, "LabelProfit", 0, 10, 90, 200, 120))
     {
      Print("Erreur création label profit");
      return(false);
     }
   m_labelProfit.Text("Profit : 0.00");
   m_labelProfit.FontSize(12);
   m_labelProfit.Color(clrLime);
   if(!Add(m_labelProfit))
      return(false);

   return(true);
  }

Ces composants forment le cœur de votre interface graphique pour EA. Les boutons déclencheront des ordres, tandis que les labels afficheront les informations de compte en direct. N’oubliez pas d’appeler ces méthodes dans votre fonction Create principale.

3. Gérer les événements utilisateur et les interactions

Un panel de trading MT5 en MQL5 ne serait rien sans une gestion d’événements robuste. La classe CAppDialog fournit une méthode virtuelle OnEvent que vous devez surcharger pour capturer les clics sur vos boutons. Voici comment implémenter cette gestion :

bool CPanelTrading::OnEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
  {
//--- Appel de la méthode parente
   if(!CAppDialog::OnEvent(id, lparam, dparam, sparam))
      return(false);

//--- Gestion des clics sur les boutons
   if(id == CHARTEVENT_OBJECT_CLICK)
     {
      //--- Bouton ACHETER
      if(sparam == "ButtonBuy")
        {
         Print("Clic sur ACHETER détecté");
         //--- Logique d'ordre d'achat
         double price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
         MqlTradeRequest request = {};
         MqlTradeResult result = {};
         request.action = TRADE_ACTION_DEAL;
         request.symbol = _Symbol;
         request.volume = 0.1;
         request.type = ORDER_TYPE_BUY;
         request.price = price;
         request.deviation = 10;
         request.magic = 123456;
         OrderSend(request, result);
         return(true);
        }
      //--- Bouton VENDRE
      if(sparam == "ButtonSell")
        {
         Print("Clic sur VENDRE détecté");
         //--- Logique d'ordre de vente
         double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
         MqlTradeRequest request = {};
         MqlTradeResult result = {};
         request.action = TRADE_ACTION_DEAL;
         request.symbol = _Symbol;
         request.volume = 0.1;
         request.type = ORDER_TYPE_SELL;
         request.price = price;
         request.deviation = 10;
         request.magic = 123456;
         OrderSend(request, result);
         return(true);
        }
     }
   return(true);
  }

Cette gestion d’événements permet à votre panel trading MT5 mql5 interface graphique de réagir instantanément aux actions de l’utilisateur. Vous pouvez étendre cette logique pour inclure des confirmations, des messages d’erreur ou des limites de risque. Les traders des prop firms apprécieront particulièrement cette réactivité.

4. Intégrer le panel dans l’EA principal et le déployer

L’étape finale consiste à intégrer votre interface graphique MQL5 dans l’Expert Advisor principal. Utilisez les événements OnInit, OnDeinit et OnChartEvent pour gérer le cycle de vie du panel. Voici un exemple complet :

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
CPanelTrading *panel;

int OnInit()
  {
//--- Création du panel
   panel = new CPanelTrading();
   if(panel == NULL)
     {
      Print("Erreur d'allocation mémoire pour le panel");
      return(INIT_FAILED);
     }
//--- Configuration du panel
   if(!panel.Create(0, "PanelTrading", 0, 20, 20, 250, 200))
     {
      Print("Erreur lors de la création du panel");
      delete panel;
      return(INIT_FAILED);
     }
//--- Affichage du panel
   panel.Run();
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Destruction du panel
   if(panel != NULL)
     {
      delete panel;
      panel = NULL;
     }
   Comment("");
  }

//+------------------------------------------------------------------+
//| ChartEvent function                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//--- Délégation des événements au panel
   if(panel != NULL)
      panel.OnEvent(id, lparam, dparam, sparam);
  }

Ce code assure que votre panel de trading MT5 en MQL5 s’affiche correctement au chargement de l’EA et se désalloue proprement lors de sa suppression. Pour enrichir l’expérience utilisateur, vous pouvez ajouter des fonctionnalités comme un affichage du nombre de positions ouvertes, un compteur de trades quotidiens ou un indicateur de risque en temps réel. Ces éléments feront de votre interface un outil indispensable pour tout trader algorithmique.

Besoin d’un EA sur-mesure ? Demander un devis gratuit