Creare Pannelli Grafici è Diventato Facile in MQL5

Introduzione

MQL5 fornisce agli sviluppatori molti strumenti utili che possono essere utilizzati per facilitare il processo di codifica e fare le cose in modo efficace, risparmiando tempo e fatica. Un esempio di questi utili strumenti è che in MQL5 sono presenti molte librerie o classi che possono essere utilizzate per codificare molte applicazioni senza dover costruire il codice di queste applicazioni da zero. Da queste librerie o classi, ad esempio Pannelli e Finestre di Dialogo. In questo articolo impareremo come poter utilizzare queste classi e a creare un'applicazione che le utilizza, dopo aver chiarito quanto l'utilizzo delle classi mql5 possa essere utile per la creazione di un software MetaTrader5, in quanto presenteremo due metodi differenti per realizzare la stessa applicazione.

Inoltre, può essere un buon contenuto pratico per migliorare le vostre abilità di codifica come sviluppatori principianti, creando l'applicazione da zero per migliorare e perfezionare le abilità logiche di programmazione, codificando cose già pronte con il proprio codice. Può anche essere usato come semplice guida per creare qualcosa che possa salvarvi dalle distrazioni durante il trading, se siete trader. Se siete sviluppatori mql5 principianti, può essere utilizzata come una guida utile per imparare a creare pannelli grafici nel terminale MetaTrader 5. In questa semplice guida cercheremo di semplificare le cose per essere in grado di sviluppare il vostro semplice pannello grafico o per poter approfondire l'argomento per creare pannelli complessi come sviluppatore o addirittura come trader.

Cercheremo di trattare gli argomenti attraverso i seguenti punti:

• Identificazione Grafica del Pannello
• Classi di Pannelli e Finestre di Dialogo
• Semplice Applicazione di Pannello Grafico
• Pannello Grafico Senza Classi
• Pannello Grafico con le Classi
• Conclusioni

Vi consiglio di apprendere l'argomento della programmazione orientata agli oggetti in MQL5 perché vi aiuterà a capire l'argomento di questo articolo, se volete farlo potete leggere il mio articolo su Comprendere la programmazione orientata agli oggetti (OOP) in MQL5.

Avvertenza: Tutte le informazioni sono fornite "così come sono" solo a scopo didattico e non sono preparate per scopi commerciali o di consulenza. Le informazioni non garantiscono alcun tipo di risultato. Se scegliete di utilizzare questi materiali su uno qualsiasi dei vostri conti di trading, lo farete a vostro rischio e pericolo e sarete gli unici responsabili.

Identificazione Grafica del Pannello

In questa parte, identificheremo il significato del Pannello grafico e come ci può essere utile nel settore del trading. Il pannello può essere semplicemente un'interfaccia grafica con funzioni o informazioni utili, come ad esempio un pannello che può essere utilizzato per aprire e gestire le operazioni, fornire informazioni sul conto o sulla giornata di trading, ecc. Questi pannelli possono essere molto utili in quanto consentono di risparmiare tempo o di ottenere facilmente ciò di cui si ha bisogno senza doverlo fare nel modo consueto, permettendoci di concentrarci maggiormente sul trading e sull'analisi del mercato.

In base a ciò, possiamo creare o avere un pannello personalizzato a seconda degli oggetti presenti in questi pannelli e dei compiti o della natura dell'interazione tra l'utente e questo pannello; possiamo citare alcuni di questi oggetti come i seguenti:

• Numeri,
• Stringhe,
• Forme,
• Colori,
• Pulsanti,
• ecc.

Se mi chiedete come possiamo sviluppare o codificare questi tipi di pannelli da soli, posso rispondere che esistono due metodi per crearli e svilupparli. Il primo metodo è quello più difficile, in quanto si codifica tutto da zero e questo metodo richiede molto tempo e fatica, ma se siete sviluppatori dovete essere in grado di capire come farlo, perché questo migliorerà le vostre capacità di codifica, anche se non lo userete come metodo nel vostro lavoro, ma almeno sarete in grado di capire e svolgere questo compito da soli. L'altro metodo è il più semplice e agevole, in quanto si utilizzano classi o librerie già pronte per svolgere il lavoro in modo rapido ed efficace, senza dover impiegare molto tempo e fatica. Nel resto dell'articolo, verranno fornite ulteriori informazioni sulle classi che possono essere utilizzate per creare questi pannelli. Inoltre, creeremo una semplice applicazione utilizzando i due metodi citati per poter decidere e confermare che l'uso delle classi è una questione preziosa.

Classi dei Pannelli e Finestre di Dialogo

In questa parte, parleremo delle classi che possono aiutarci a creare facilmente il pannello grafico; ci riferiremo alle classi Panels e Dialogs e potete consultare il riferimento MQL5 per ulteriori informazioni, poiché in questo articolo faremo riferimento solo ad alcune di esse.

Ora identifichiamo le classi per la creazione di pannelli di controllo e finestre di dialogo; possiamo dire che si tratta di una libreria che dispone di codice già pronto per creare o sviluppare pannelli o applicazioni interattive, compresi indicatori ed expert advisor. Si trova nella cartella dei dati del terminale, nella cartella Controls della cartella include. Esistono classi ausiliarie, di base, semplici e complesse che possono essere utilizzate per diverse operazioni. Esempi di queste classi:

Classe	Nome del File Include (cartella Controls)	Descrizione
CLabel	Label.mqh	È una semplice classe di controllo per creare semplici etichette di testo non modificabili.
CButton	Button.mqh	È una semplice classe di controllo per creare semplici pulsanti.
CEdit	Edit.mqh	Si tratta di una semplice classe di controllo che consente all'utente di inserire un testo
CPanel	Panel.mqh	Si tratta di una semplice classe di controllo per combinare controlli con altre funzioni simili in un gruppo
CCheckBox	CheckBox.mqh	È una classe di controllo complessa che visualizza una casella di controllo e consente all'utente di scegliere se è vera o falsa.
CSpinEdit	SpinEdit.mqh	Si tratta di una classe di controllo complessa che consente di modificare un valore intero tramite campi di incremento e decremento.
CDialog	Dialog.mqh	È una classe di controllo complessa per combinare i controlli con altre funzioni differenti in un gruppo.

Come possiamo vedere, le classi citate e altre possono essere utilizzate per svolgere molti compiti che potrebbero richiedere molto tempo e sforzo se provassimo a svolgerli attraverso il codice normale o senza utilizzare le classi; inoltre, possiamo estendere la stessa visione ad altre classi che possono aiutare a svolgere altri compiti oltre ai pannelli. Se vogliamo vedere la differenza attraverso un semplice esempio o un'applicazione, lo faremo nella prossima parte.

Semplice Applicazione di Pannello Grafico

In questa parte impareremo come creare un semplice pannello di trading che può essere utilizzato per aprire ordini di acquisto e di vendita dopo aver determinato la dimensione del lotto. Creeremo questo pannello utilizzando due metodi: il primo per creare il nostro codice senza utilizzare le classi e il secondo metodo utilizzando le classi per assicurarci e confrontare quanto l'utilizzo delle classi ci aiuterà a raggiungere il nostro obiettivo in modo semplice e agevole e per imparare a creare il pannello attraverso il nostro codice senza utilizzare le classi, in quanto ciò migliorerà la nostra logica di programmazione e la nostra abilità di codifica.

Pannello Grafico Senza Classi

I seguenti passaggi consentono di creare un semplice pannello di ordini per aprire ordini di acquisto e di vendita dopo aver determinato la dimensione del lotto senza utilizzare le classi, ad eccezione della classe "Trade", in quanto l'obiettivo di questo articolo è quello di imparare a creare pannelli:

Utilizzando #include per includere il file include Trade e creare un oggetto con il nome trade da utilizzare per gli ordini aperti.

#include <Trade\Trade.mqh>
CTrade trade;

Creare una funzione booleana di apertura dei trade per impostare la variabile ENUM_ORDER_TYPE e la variabile double per la dimensione del lotto del trade. Questi sono i parametri della funzione che creeremo e il corpo della funzione sarà:

• Creazione di una variabile double per il prezzo
• Impostare una condizione per determinare il tipo di prezzo (ask o bid) in base al tipo di ordine utilizzando la condizione if:
• Se il tipo di ordine è buy, il prezzo che verrà utilizzato per aprire l'ordine è l'ask.
• Se il tipo di ordine è sell, il prezzo sarà il bid.
• Il risultato sarà l'apertura della posizione con il simbolo corrente, il tipo di ordine, la dimensione del lotto, il tipo di prezzo, il valore zero per lo stop loss e il take profit e il commento vuoto.

bool openTrade(ENUM_ORDER_TYPE type, double vol)
  {
   double price;
   if(type==ORDER_TYPE_BUY)
   {
      price=SymbolInfoDouble(Symbol(),SYMBOL_ASK);
   }
   else price=SymbolInfoDouble(Symbol(),SYMBOL_BID);

   return trade.PositionOpen(Symbol(),type,vol,price,0,0,"");
  }

Impostazione della posizione del pannello scegliendo l'angolo superiore sinistro dopo aver creato una variabile const ENUM_BASE_CORNER panelLoc

const ENUM_BASE_CORNER panelLoc=CORNER_LEFT_UPPER;

Impostazione del margine di x e y dopo la creazione di una variabile const intera per x e y

const int xMargin=20;
const int yMargin=20;

Impostazione dello spazio tra gli elementi per x e y dopo la creazione di un'altra variabile const intera

const int xSpace=10;
const int ySpace=10;

Impostazione delle dimensioni degli elementi che sono pulsanti e testo dopo aver creato quattro variabili const int btnWidth per la larghezza del pulsante, btnHeight per l'altezza del pulsante, txtWidth per la larghezza del testo e txtHeight per l'altezza del testo

const int btnWidth=50;
const int btnHeight=20;
const int txtWidth=(btnWidth*2)+xSpace;
const int txtHeight=20;

Impostando le posizioni di testo e pulsanti, abbiamo il testo x, il testo y, il pulsante buy x, il pulsante buy y, il pulsante sell x e il pulsante sell y. Dichiareremo variabili const integer per tutti loro e assegneremo valori per ognuno.

const int txtX=3;
const int txtY=yMargin+txtHeight;
const int buyX=3;
const int buyY=txtY+ySpace+btnHeight;
const int sellX=buyX+xSpace+btnWidth;
const int sellY=txtY+ySpace+btnHeight;

Assegnazione del nome degli elementi testo, pulsante buy e pulsante sell dopo la creazione delle variabili const string per loro

const string txtName="txttVol";
const string buyName="buyBtn";
const string sellName="sellBtn";

Creazione di una variabile double per la dimensione del lotto con un valore iniziale

double lotSize=0.01;

Nella parte OnInit(), chiameremo la funzione createPanel() che creeremo in seguito

   createPanel();

Nella parte OnDeinit, cancelleremo gli oggetti utilizzando i loro nomi

   ObjectDelete(0,txtName);
   ObjectDelete(0,buyName);
   ObjectDelete(0,sellName);

Nell'ambito globale, creeremo la funzione che abilita l'interazione con il pannello seguendo i seguenti passaggi

Si utilizza la funzione OnChartEvent e i suoi parametri sono:

• const int id: per l'ID dell'evento
• const long &lparam: per il parametro di tipo long dell'evento
• const double &dparam: per il parametro di tipo double dell'evento
• const string &sparam: per il parametro di tipo stringa dell'evento

Impostazione delle condizioni di interazione con il testo degli oggetti (dimensione del lotto), pulsante di acquisto e pulsante di vendita

//+------------------------------------------------------------------+
//| Interaction function                                             |
//+------------------------------------------------------------------+
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
  {
//--- If the event id is equal to the end of text editing in the panel and the string type event is equal to the text name
   if(id==CHARTEVENT_OBJECT_ENDEDIT && sparam==txtName)
     {
      //--- lotTxt string variable will be equal to the returned property value by using the ObjectGetString function
      string lotTxt=ObjectGetString(0, txtName, OBJPROP_TEXT);
      //--- call setLot function that we will create later with the lotTxt value
      setLot(lotTxt);
      //Setting the property value by using the ObjectSetString
      ObjectSetString(0, txtName, OBJPROP_TEXT, string(lotSize));
      //--- Use return
      return;
     }
//--- If the event id is equal to the object click to check if we click the buy button
   else
      if(id==CHARTEVENT_OBJECT_CLICK)
        {
         //We will check if the string param is equal to buyname
         if(sparam==buyName)
           {
            //--- Setting the value of the property by using the ObjectSetInteger
            ObjectSetInteger(0, buyName, OBJPROP_STATE, false);
            //Calling the created openTrade to open a buy order.
            openTrade(ORDER_TYPE_BUY, lotSize);
            //--- Use return
            return;
           }
         //--- If the event id is equal to the object click to check if we click the sell button
         //--- We will check if the string param is equal to sellname
         else
            if(sparam==sellName)
              {
               //--- Setting the value of the property by using the ObjectSetInteger
               ObjectSetInteger(0, sellName, OBJPROP_STATE, false);
               //Calling the created openTrade to open a sell order
               openTrade(ORDER_TYPE_SELL, lotSize);
               //--- Use return
               return;
              }
        }
  }

Creare la funzione void createPanel che abbiamo chiamato prima nella parte OnInit() attraverso i seguenti passaggi:

• Eliminare gli oggetti txtName, buyName e sellName
• Chiamata della funzione EditCreate.
• Chiamata della funzione ButtonCreate per il pulsante buy.
• Chiamata della funzione ButtonCreate per il pulsante sell.

//+------------------------------------------------------------------+
//|createPanel function                                              |
//+------------------------------------------------------------------+
void createPanel()
  {
//--- Delete objects of txtName, buyName, and sellName
   ObjectDelete(0, txtName);
   ObjectDelete(0, buyName);
   ObjectDelete(0, sellName);
//--- calling the EditCreate function
   EditCreate(             // Parameters:
      0,                   // const long (chart_ID): to specify the chart's ID, we will use (0).
      txtName,             // const string (name): to specify the button name,  we will use (txtName)
      0,                   // const int (sub_window): to specify the subwindow index, we will use (0) for the main window
      txtX,                // const int (x): to specify the X coordinate, we will use (txtX)
      txtY,                // const int (y): to specify the Y coordinate, we will use (txtY)
      txtWidth,            // const int (width):to specify the button width, we will use (txtWidth)
      txtHeight,           // const int (height): to specify the button height, we will use (txtHeight)
      string(lotSize),     // const string (text): to specify the text, we will use (lotSize)
      "Arial",             // const string (font): to specify the font, we will use "Arial"
      10,                  // const int (font_size): to specify the font size, we will use (10)
      ALIGN_LEFT,          // const ENUM_ALIGN_MODE (align_mode): to specify the position of text, we will use (ALIGN_LEFT)
      false,               // const bool (read_only=false): to specify the ability to edit, we will be (false)
      panelLoc,            // const ENUM_BASE_CORNER (corner): to specify the chart corner for anchoring, we will call panelLoc function
      clrBlack,            // const color (clr): to specify the text color, we will specify clrBlack
      clrWhite,            // const color (back_clr): to specify the background color, we will specify clrWhite
      clrBlack,            // const color (border_clr): to specify the border color, we will specify clrBlack
      false,               // const bool (back=false): in the background, we will set false
      false,               // const bool (selection=false): highlight to move, we will set false
      false,               // const bool (hidden): hidden in the object list, we will set false
      0);                  // const long (z_order=0): priority for a mouse click, we will use (0)
//--- calling the ButtonCreate function for the buy
   ButtonCreate(           // Parameters:
      0,                   // const long (chart_ID): to specify the chart's ID, we will use (0)
      buyName,             // const string (name): to specify the button name, we will use (buyName) for the buy button
      0,                   // const int (sub_window): to specify the subwindow index, we will use (0) for the main window
      buyX,                // const int (x): to specify the X coordinate, we will use (buyX) for buy
      buyY,                // const int (y): to specify the Y coordinate, we will use (buyY) for buy
      btnWidth,            // const int (width): to specify the button width, we will use (btnWidth) for buy
      btnHeight,           // const int (height): to specify the button height, we will use (btnHeight) for buy
      panelLoc,            // const ENUM_BASE_CORNER (corner): to specify the chart corner for anchoring, we will call panelLoc function for buy button
      "Buy",               // const string (text): to specify the text, we will use ("Buy") for the buy button
      "Arial",             // const string (font): to specify the font, we will use "Arial"
      10,                  // const int (font_size): to specify the font size, we will use (10)
      clrBlack,            // const color (clr): to specify the text color, we will specify clrBlack
      clrGreen,            // const color (back_clr): to specify the background color, we will specify clrGreen for the buy button
      clrBlack,            // const color (border_clr): to specify the border color, we will specify clrBlack
      false,               // const bool (state): to specify if the object is pressed or released, we will specify false
      false,               // const bool (back=false): in the background, we will set false
      false,               // const bool (selection=false): highlight to move, we will set false
      false,               // const bool (hidden): hidden in the object list, we will set false
      0);                  // const long (z_order=0): priority for mouse click, we will use (0) for buy button
//--- calling the ButtonCreate function for the sell
   ButtonCreate(          //Parameters:
      0,                   //const long (chart_ID): to specify the chart's ID, we will use (0)
      sellName,            //const string (name): to specify the button name, we will use (sellName) for the sell button
      0,                   //const int (sub_window): to specify the subwindow index, we will use (0) for the main window
      sellX,               //const int (x): to specify the X coordinate, we will use (sellX) for sell
      sellY,               //const int (y): to specify the Y coordinate, we will use (sellY)
      btnWidth,            //const int (width): to specify the button width, we will use (btnWidth) for sell
      btnHeight,           //const int (height): to specify the button height, we will use (btnHeight) for sell
      panelLoc,            //const ENUM_BASE_CORNER (corner): to specify the chart corner for anchoring, we will call panelLoc function for sell button
      "Sell",              //const string (text): to specify the text, we will use ("Sell") for the sell button
      "Arial",             //const string (font): to specify the font, we will use "Arial"
      10,                  //const int (font_size): to specify the font size, we will use (10)
      clrBlack,            //const color (clr): to specify the text color, we will specify clrBlack
      clrRed,              //const color (back_clr): to specify the background color, we will specify clrRed for the sell button
      clrBlack,            //const color (border_clr): to specify the border color, we will specify clrBlack
      false,               //const bool (state): to specify if the object is pressed or released, we will specify false
      false,               //const bool (back=false): in the background, we will set false
      false,               //const bool (selection=false): highlight to move, we will set false
      false,               //const bool (hidden): hidden in the object list, we will set false
      0);                  //const long (z_order=0): priority for mouse click, we will use (0) for sell button
  }

Creare la funzione void setLot con un parametro che è lotTxt utilizzato per lotSize e il corpo della funzione è uguale al seguente:

• Creare una variabile double newLot e assegnarla a lotTxt dopo averla convertita in double da una stringa utilizzando la funzione StringToDouble.
• Se la variabile newLot è inferiore a 0, occorre stampare il messaggio "Invalid Volume Specified", quindi utilizzare return.
• Restituzione del valore newLot uguale a lotSize

void setLot(string lotTxt)
  {
   double newLot=StringToDouble(lotTxt);
   if(newLot<0)
     {
      Print("Invaid Volume Specified");
      return;
     }
   lotSize=newLot;
  }

Creazione della funzione EditCreate attraverso i seguenti passaggi:

//+------------------------------------------------------------------+
//|EditCreate function                                               |
//+------------------------------------------------------------------+
bool EditCreate(const long             chart_ID=0,
                const string           name="Edit",
                const int              sub_window=0,
                const int              x=0,
                const int              y=0,
                const int              width=50,
                const int              height=18,
                const string           text="Text",
                const string           font="Arial",
                const int              font_size=10,
                const ENUM_ALIGN_MODE  align=ALIGN_CENTER,
                const bool             read_only=false,
                const ENUM_BASE_CORNER corner=CORNER_LEFT_UPPER,
                const color            clr=clrBlack,
                const color            back_clr=clrWhite,
                const color            border_clr=clrNONE,
                const bool             back=false,
                const bool             selection=false,
                const bool             hidden=true,
                const long             z_order=0)
  {
//--- Reset the error value by using ResetLastError()
   ResetLastError();
//--- Create an edit field
   if(!ObjectCreate(chart_ID, name, OBJ_EDIT, sub_window, 0, 0))
     {
      Print(__FUNCTION__,
            ": failed to create \"Edit\" object! Error code = ", GetLastError());
      return(false);
     }
//--- Setting the object coordinates x and y by using the ObjectSetInteger
   ObjectSetInteger(chart_ID, name, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(chart_ID, name, OBJPROP_YDISTANCE, y);
//--- Setting the object size by using the ObjectSetInteger function also
   ObjectSetInteger(chart_ID, name, OBJPROP_XSIZE, width);
   ObjectSetInteger(chart_ID, name, OBJPROP_YSIZE, height);
//--- Setting the text by using ObjectSetString function
   ObjectSetString(chart_ID, name, OBJPROP_TEXT, text);
//--- Setting the text font by using the ObjectSetString function also
   ObjectSetString(chart_ID, name, OBJPROP_FONT, font);
//--- Setting the font size by using the ObjectSetInteger function
   ObjectSetInteger(chart_ID, name, OBJPROP_FONTSIZE, font_size);
//--- Setting the type of text alignment in the object
   ObjectSetInteger(chart_ID, name, OBJPROP_ALIGN, align);
//--- Setting the ability to edit, enable if it is (true) or cancel (false) if you need a read-only mode
   ObjectSetInteger(chart_ID, name, OBJPROP_READONLY, read_only);
//--- Setting the chart's corner, relative to which object coordinates are defined to set the location of the object.
   ObjectSetInteger(chart_ID, name, OBJPROP_CORNER, corner);
//--- Setting the text color
   ObjectSetInteger(chart_ID, name, OBJPROP_COLOR, clr);
//--- Setting the background color
   ObjectSetInteger(chart_ID, name, OBJPROP_BGCOLOR, back_clr);
//--- Setting the border color of the object
   ObjectSetInteger(chart_ID, name, OBJPROP_BORDER_COLOR, border_clr);
//--- Displaying in the foreground by (false) or in the background by (true)
   ObjectSetInteger(chart_ID, name, OBJPROP_BACK, back);
//--- Setting (true) to enable or (false) to disable the mode of moving the label by mouse
   ObjectSetInteger(chart_ID, name, OBJPROP_SELECTABLE, selection);
   ObjectSetInteger(chart_ID, name, OBJPROP_SELECTED, selection);
//--- Setting (true) if you need hiding or (false) if you need the display of graphical object name in the object list
   ObjectSetInteger(chart_ID, name, OBJPROP_HIDDEN, hidden);
//--- Setting the priority for receiving the event of a mouse click in the chart
   ObjectSetInteger(chart_ID, name, OBJPROP_ZORDER, z_order);
//--- Returning (true) if successful execution
   return(true);
  }

La creazione della funzione ButtonCreate avviene attraverso gli stessi parametri della funzione EditCreate, eccetto che per una piccola differenza

bool ButtonCreate(const long              chart_ID=0,               
                  const string            name="Button",            
                  const int               sub_window=0,             
                  const int               x=0,                      
                  const int               y=0,                      
                  const int               width=50,                 
                  const int               height=18,                
                  const ENUM_BASE_CORNER  corner=CORNER_LEFT_UPPER, 
                  const string            text="Button",            
                  const string            font="Arial",             
                  const int               font_size=10,             
                  const color             clr=clrBlack,             
                  const color             back_clr=C'236,233,216',  
                  const color             border_clr=clrNONE,       
                  const bool              state=false,              
                  const bool              back=false,               
                  const bool              selection=false,          
                  const bool              hidden=true,              
                  const long              z_order=0)                
  {
   ResetLastError();
   if(!ObjectCreate(chart_ID,name,OBJ_BUTTON,sub_window,0,0))
     {
      Print(__FUNCTION__,
            ": failed to create the button! Error code = ",GetLastError());
      return(false);
     }
   ObjectSetInteger(chart_ID,name,OBJPROP_XDISTANCE,x);
   ObjectSetInteger(chart_ID,name,OBJPROP_YDISTANCE,y);
   ObjectSetInteger(chart_ID,name,OBJPROP_XSIZE,width);
   ObjectSetInteger(chart_ID,name,OBJPROP_YSIZE,height);
   ObjectSetInteger(chart_ID,name,OBJPROP_CORNER,corner);
   ObjectSetString(chart_ID,name,OBJPROP_TEXT,text);
   ObjectSetString(chart_ID,name,OBJPROP_FONT,font);
   ObjectSetInteger(chart_ID,name,OBJPROP_FONTSIZE,font_size);
   ObjectSetInteger(chart_ID,name,OBJPROP_COLOR,clr);
   ObjectSetInteger(chart_ID,name,OBJPROP_BGCOLOR,back_clr);
   ObjectSetInteger(chart_ID,name,OBJPROP_BORDER_COLOR,border_clr);
   ObjectSetInteger(chart_ID,name,OBJPROP_BACK,back);
   ObjectSetInteger(chart_ID,name,OBJPROP_STATE,state);
   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTABLE,selection);
   ObjectSetInteger(chart_ID,name,OBJPROP_SELECTED,selection);
   ObjectSetInteger(chart_ID,name,OBJPROP_HIDDEN,hidden);
   ObjectSetInteger(chart_ID,name,OBJPROP_ZORDER,z_order);
   return(true);
  }

Dopo aver compilato ed eseguito il codice, il pannello appare come il seguente:

Come si può vedere nell'immagine precedente, nell'angolo in alto a sinistra abbiamo il pannello con un punto in cui sono presenti la dimensione del lotto e due pulsanti per l'acquisto (Buy) e la vendita (Sell); in questo modo possiamo specificare la dimensione del lotto di cui abbiamo bisogno ed effettuare un ordine premendo buy o sell in base al tipo di ordine di cui abbiamo bisogno. Questo è il primo metodo che abbiamo detto che useremo per creare questo pannello senza usare le classi Panels o Dialogs e vediamo che questo metodo richiede molte righe di codice. Ora dobbiamo creare lo stesso pannello usando le classi Panels e Dialogs per valutare e verificare la complessità o la lunghezza del codice confrontando questi due metodi.

Pannello Grafico con le Classi

Ecco il secondo metodo per creare lo stesso pannello utilizzando le classi necessarie. I passaggi seguenti sono per creare lo stesso pannello.

Includere i file o le classi di cui abbiamo bisogno per utilizzare i suoi componenti nel nostro programma: Dialog, Button, Edit e Trade. Questo può essere fatto, come sappiamo, utilizzando il comando #include.

#include <Controls\Dialog.mqh>
#include <Controls\Button.mqh>
#include <Controls\Edit.mqh>
#include <Trade\Trade.mqh>

Utilizzando la sostituzione macro #define, che è la direttiva del preprocessore per assegnare nomi mnemonici alle costanti, queste sono uguali alle seguenti:

• PANEL_NAME "Order Panel"
• PANEL_WIDTH 116
• PANEL_HIEIGHT 100
• ROW_HEIGHT 20
• BUY_BTN_NAME "Buy BTN"
• SELL_BTN_NAME "Sell BTN"
• CLOSE_BTN_NAME "Close BTN"
• EDIT_NAME "Lot Size"

#define PANEL_NAME "Order Panel"
#define PANEL_WIDTH 116
#define PANEL_HIEIGHT 100
#define ROW_HEIGHT 20
#define BUY_BTN_NAME "Buy BTN"
#define SELL_BTN_NAME "Sell BTN"
#define CLOSE_BTN_NAME "Close BTN"
#define EDIT_NAME "Lot Size"

La creazione degli oggetti dalle classi è uguale alla seguente

CAppDialog panel;
CButton buyBtn;
CButton sellBtn;
CButton closeBtn;
CEdit lotSize;
CTrade trade;

Nella parte OnInit(), dobbiamo creare il nostro oggetto pannello utilizzando il nostro oggetto panel.Create e i suoi parametri sono:

• const long chart, utilizzeremo 0 per far apparire il pannello sul grafico principale.
• const string name, utilizzeremo PANEL_NAME
• const int subwin, useremo 0
• const int x1, useremo 10
• const int y1, useremo 20
• const int x2, useremo 10+PANEL_WIDTH+8
• const int y2, useremo 20+PANEL_HIEIGHT

panel.Create(0,PANEL_NAME,0,10,20,10+PANEL_WIDTH+8,20+PANEL_HIEIGHT);

Creare e impostare i pulsanti buy e sell come nei passaggi seguenti:

• Creare gli oggetti utilizzando oggetto.Create.
• Impostazione della larghezza degli oggetti buy e sell utilizzando oggetto.Width
• Impostazione dell'altezza degli oggetti buy e sell utilizzando il parametro oggetto.Height.
• Impostazione del colore di sfondo degli oggetti utilizzando oggetto.ColorBackground.
• Impostazione del testo degli oggettitramite oggetto.Text.
• Impostazione del carattere degli oggetti tramite oggetto.Font.
• Impostazione della dimensione dei caratteri degli oggetti utilizzando oggetto.FontSize.
• Impostazione del colore degli oggetti utilizzando oggetto.Color.
• Impostazione del colore del bordo degli oggetti mediante oggetto.ColorBorder.
• Posizionamento dell'oggetto o degli oggetti sul pannello.
• Quindi eseguire il pannello

int OnInit()
  {
   //buy button
   panel.Create(0,PANEL_NAME,0,10,20,10+PANEL_WIDTH+8,20+PANEL_HIEIGHT);
   buyBtn.Create(0,BUY_BTN_NAME,0,3,40,0,0);
   buyBtn.Width(50);
   buyBtn.Height(ROW_HEIGHT);
   buyBtn.ColorBackground(clrGreen);
   buyBtn.Text("Buy");
   buyBtn.Font("Arial");
   buyBtn.FontSize(10);
   buyBtn.Color(clrBlack);
   buyBtn.ColorBorder(clrBlack);   
   panel.Add(buyBtn);
   //sell button
   sellBtn.Create(0,SELL_BTN_NAME,0,63,40,0,0);
   sellBtn.Width(50);
   sellBtn.Height(ROW_HEIGHT);
   sellBtn.ColorBackground(clrRed);
   sellBtn.Text("Sell");
   sellBtn.Font("Arial");
   sellBtn.FontSize(10);
   sellBtn.Color(clrBlack);
   sellBtn.ColorBorder(clrBlack);
   panel.Add(sellBtn);
   //lotSize
   lotSize.Create(0,EDIT_NAME,0,4,10,0,0);
   lotSize.Width(108);
   lotSize.Height(ROW_HEIGHT);
   lotSize.Text("0.01");
   lotSize.Font("Arial");
   lotSize.FontSize(10);
   lotSize.ColorBackground(clrWhite);
   lotSize.Color(clrBlack);
   lotSize.ColorBorder(clrBlack);
   panel.Add(lotSize);
   //run the panel
   panel.Run();
   return(INIT_SUCCEEDED);
  }

Nella parte OnDeinit(const int reason), utilizziamo Destroy come segue come funzione di deinizializzazione

void OnDeinit(const int reason)
  {
   panel.Destroy();
  }

Abilitazione dell'interazione con il pannello mediante la funzione OnChartEvent e impostando le condizioni di comportamento dei pulsanti buy e sell come segue:

• Creazione della funzione OnChartEvent
• Il corpo della funzione
• Utilizzo di oggetto.ChartEvent con i parametri id per l'evento, lparam per il tipo di evento long, dparam per il tipo double e sparam per il tipo stringa.
• Verifica se l'id è uguale a Chart Click
• Verifica se sparam è uguale a buyBtn o sellBtn come nome
• Creare una variabile double per il lotto e assegnarla a StringToDouble(valore della dimensione del lotto)
• Aprire un ordine di acquisto o di vendita in base al tipo di evento utilizzando il valore del lotto.

void  OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
  {
   panel.ChartEvent(id,lparam,dparam,sparam);
   if(id==CHARTEVENT_OBJECT_CLICK)
     {
      if(sparam==buyBtn.Name())
        {
         double lot=StringToDouble(lotSize.Text());
         trade.Buy(lot);
        }
      else
         if(sparam==sellBtn.Name())
           {
            double lot=StringToDouble(lotSize.Text());
            trade.Sell(lot);
           }
     }
  }

Dopo aver compilato il codice ed eseguito il file eseguibile, il pannello è allegato al grafico come nella figura seguente:

Come si può vedere nell'immagine precedente, nell'angolo in alto a sinistra si trova il pannello con le dimensioni del lotto, gli oggetti buy e sell e possiamo modificare le dimensioni del lotto e gli ordini aperti.

Dopo aver imparato e creato lo stesso pannello con due metodi diversi, possiamo dire e notare che abbiamo creato il pannello usando le classi in modo più semplice e scorrevole rispetto a quello che abbiamo creato senza usare le classi. Quindi, le classi sono molto utili e ci permettono di codificare facilmente e di risparmiare molto tempo, ma il mio consiglio per voi, se siete sviluppatori, è di cercare di imparare e capire come creare cose già pronte come queste classi o funzioni incorporate, in qualsiasi linguaggio di programmazione, perché questo è un ottimo modo per migliorare le vostre capacità logiche, di codifica e di programmazione e quando codificate potete usare le classi, che vi aiuteranno a codificare in modo più semplice e scorrevole, oltre a farvi risparmiare tempo per svolgere compiti ripetuti.

Dopo aver appreso come creare questo tipo di pannello, è bene ricordare che si tratta di una semplice applicazione, come abbiamo detto, che è possibile svilupparla sempre di più utilizzando altre funzioni. Perché il pannello può essere semplice come quello che abbiamo menzionato o molto complesso e dotato di molti strumenti e funzionalità. L'obiettivo è capire come utilizzare queste classi dopo averne identificato l'importanza e il valore.

Conclusioni

Alla fine di questo articolo, possiamo concludere che l'uso delle classi è una cosa preziosa e utile in generale e in particolare per la creazione di pannelli che possono essere utilizzati in MetaTrader 5 e che possono essere utili per i trader in quanto li aiutano in molte cose che consentono loro di concentrarsi sul trading stesso e sul mercato senza svolgere molte attività essenziali lontano dall'uso di questi pannelli. Abbiamo anche imparato cosa sono i pannelli e gli esempi dei loro tipi, abbiamo imparato a conoscere le classi dei pannelli e delle finestre di dialogo che possono essere usate per creare facilmente questi pannelli e abbiamo confermato quanto queste classi possano essere utili creando un semplice pannello come applicazione tramite due metodi diversi, con codice normale senza usare le classi dei pannelli e delle finestre di dialogo e usandole per vedere quanto tempo e fatica possono essere consumati quando non le si usano.

Spero che questo articolo vi sia utile e che le informazioni fornite siano di facile comprensione e realizzazione. Spero anche che abbiate ottenuto maggiori conoscenze su come sviluppare più applicazioni o su come sviluppare e approfondire la creazione di pannelli utili per il vostro trading o se siete sviluppatori mql5 principianti, spero che abbiate imparato qualcosa di nuovo e abbiate ottenuto maggiori approfondimenti su come fare con questo importante argomento che è l'uso delle classi.

Se volete capire e imparare di più su classi e oggetti, vi consiglio di leggere il mio precedente articolo Comprendere la Programmazione Orientata agli Oggetti (OOP) in MQL5, che può aiutarvi a iniziare a padroneggiare questo argomento. Se volete leggere su come creare sistemi di trading utilizzando gli indicatori tecnici più popolari, potete leggere i miei articoli precedenti nella sezione dedicata alle pubblicazioni, sperando che vi siano utili.