Wie man ein interaktives MQL5 Dashboard/Panel mit Hilfe der Controls-Klasse erstellt (Teil 1): Einrichten des Panels

Einführung

In diesem Artikel wird ein interaktives Dashboard unter Verwendung der Klasse Controls der MetaQuotes Language 5 (MQL5) erstellt. Die Layout-Struktur verleiht dem Dashboard ein Aussehen und eine Grundfunktionalität, die als Grundgerüst für komplexere Operationen des Panels dienen wird. Bei diesem Design geht es im Wesentlichen darum, zu überlegen, was die Handelserfahrung für den Händler sauberer, schneller und intuitiver machen würde. Am Ende dieses Artikels sollten Sie über ein grundlegendes Dashboard in Ihrem MetaTrader 5-Chart verfügen, das einen Titel, Schaltflächen für die Navigation und Schaltflächen für die jeweiligen Aktionen enthält - das heißt, Sie können das Dashboard für sich arbeiten lassen.

Das Hauptnavigationsfeld wird drei Schaltflächen haben: Trade, Close und Information. Jeder Bereich verfügt über spezielle Bedienelemente für verschiedene Befehle. Der Handelsbereich enthält beispielsweise Schaltflächen für Handelsvolumen, Preis, Stop-Loss (SL), Take-Profit (TP) und Handelsbefehle wie Buy, Sell und Buy Stop. Im Bereich Schließen (Close) finden Sie Schaltflächen, mit denen Sie das Panel mit Optionen wie „Close All Profit“ (Alle im Gewinn schließen) und „Close All Pending Orders“ (Alle schwebenden Aufträge schließen) auflösen können. Im Bereich Informationen werden wichtige Handelsdaten und Statusaktualisierungen angezeigt. Wir gliedern den Artikel in drei Hauptteile:

1. Illustration der Elemente
2. Zusammenstellung des GUI-Panels in MQL5
3. Schlussfolgerung

Auf dieser Reise werden wir MetaQuotes Language 5 (MQL5) ausgiebig als primäre Programmiersprache für die integrierte Entwicklungsumgebung (IDE) in MetaEditor verwenden, um anspruchsvolle Handelsanwendungen und Schnittstellen zu erstellen. Wir werden unser Programm direkt im MetaTrader 5-Handelsterminal ausführen, wo wir Echtzeit-Marktdaten überwachen und nahtlos mit unserem Handelsprogramm interagieren können. Daher ist es wichtig, dass Sie die neuesten Versionen von MQL5 und MetaTrader 5 installiert haben, um die Kompatibilität und den Zugang zu allen verfügbaren Funktionen zu gewährleisten. Wenn Sie alles vorbereitet haben, können Sie mit der Erstellung Ihres interaktiven Handelspanels beginnen!

Illustration der Elemente

Im Folgenden werden wir die wichtigsten Komponenten unseres interaktiven GUI-Panels/Dashboards für Händler erläutern. Das Panel wird aus mehreren wesentlichen Elementen bestehen, die jeweils einen bestimmten Zweck erfüllen, um die Effizienz des Handels zu steigern. Wir werden uns auf drei Hauptnavigationsschaltflächen konzentrieren: Trade, Close, und Information (Handeln, Schließen und Information), die jeweils mit entsprechenden Aktionsschaltflächen ausgestattet sind.

Der Handelsbereich enthält Schaltflächen für Handelsvolumen, Preis, Stop-Loss (SL) und Take-Profit (TP) sowie Ausführungsschaltflächen für Buy (Kaufen), Sell (Verkaufen) und Buy-Stop und viele andere. Der Abschnitt „Schließen“ enthält unter anderem Funktionen wie „Alle im Gewinn schließen“ und „Alle schwebenden Aufträge schließen“, die einen schnellen Zugriff auf wichtige Handelsmanagement-Tools gewährleisten. Im Bereich Informationen schließlich werden wichtige Handelsdaten wie Kontostand, Margenhöhe und Marktaktualisierungen in Echtzeit angezeigt.

Um diese Elemente visuell darzustellen, stellen wir ein Chart-Layout zur Verfügung, das zeigt, wie diese Komponenten innerhalb des Panels angeordnet werden. Diese Illustration wird in den folgenden Abschnitten des Artikels als Fahrplan für den Aufbau unserer Nutzeroberfläche dienen und uns dabei helfen, diese Elemente in eine zusammenhängende und nutzerfreundliche Oberfläche zu integrieren. Hier ist die vollständige Illustration:

Zusammenstellung des GUI-Panels in MQL5

Um das Panel zu erstellen, werden wir es auf einen Expertenberater stützen. Um einen Expert Advisor (EA) zu erstellen, klicken Sie auf Ihrem MetaTrader 5-Terminal auf die Registerkarte Tools und aktivieren Sie MetaQuotes Language Editor oder drücken Sie einfach F4 auf Ihrer Tastatur. Alternativ können Sie auch auf das IDE-Symbol (Integrated Development Environment) in der Symbolleiste klicken. Dadurch wird die MetaQuotes-Spracheditor-Umgebung geöffnet, die das Schreiben von Handelsrobotern, technischen Indikatoren, Skripten und Funktionsbibliotheken ermöglicht.

Sobald der MetaEditor geöffnet ist, navigieren Sie in der Symbolleiste zur Registerkarte „Datei“ und wählen Sie „Neue Datei“, oder drücken Sie einfach die Tastenkombination STRG + N, um ein neues Dokument zu erstellen. Alternativ könnten wir auch auf das Symbol New auf der Registerkarte Werkzeuge klicken. Daraufhin erscheint ein Popup-Fenster des MQL-Assistenten.

Markieren Sie in dem sich öffnenden Assistenten die Option Expert Advisor (Vorlage) und klicken Sie auf Weiter.

Geben Sie in den allgemeinen Eigenschaften des Expertenberaters unter dem Abschnitt Name den Dateinamen Ihres Experten an. Nicht vergessen, den Backslash vor dem Namen des EA verwenden, um einen Ordner anzugeben oder zu erstellen, wenn er nicht existiert. Hier haben wir zum Beispiel standardmäßig „Experts\“. Das bedeutet, dass unser EA im Ordner Experts erstellt wird und wir ihn dort finden können. Die anderen Abschnitte sind ziemlich einfach, aber Sie können dem Link am Ende des Assistenten folgen, um zu erfahren, wie der Prozess genau abläuft.

Nachdem Sie den gewünschten Namen des Expert Advisors eingegeben haben, klicken Sie auf Weiter, dann auf Weiter und schließlich auf Fertig stellen. Nachdem wir all dies getan haben, sind wir bereit, unser GUI-Panel zu codieren und zu programmieren.

Im Datensatz des neuen Programms, der standardmäßig erscheint, werden die Metadaten angezeigt, die die mit der Datei verbundenen notwendigen Eigenschaften enthalten. Bei der Anpassung haben wir die folgenden Metadaten.

//+------------------------------------------------------------------+
//|                                         CONTROL PANEL PART 1.mq5 |
//|                           Copyright 2024, Allan Munene Mutiiria. |
//|                                     https://forexalgo-trader.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, Allan Munene Mutiiria." //--- Set copyright information
#property link      "https://forexalgo-trader.com"            //--- Link to the author's website
#property version   "1.00"                                    //--- Version of the script

Von hier aus müssen wir als Erstes Zugriff auf die standardmäßige nutzerdefinierte MQL5-Bibliothek erhalten, mit der wir das Panel oder Dashboard erstellen können. Sie ist bereits in Klassen organisiert und wird die Erstellung unserer Panels erleichtern. Die Dateien, die wir verwenden werden, sind im Ordner „Include“ und im Unterordner „Controls“ untergebracht. Um auf sie zuzugreifen, navigieren Sie einfach zu den angegebenen Ordnern und öffnen Sie sie. Sie werden im Folgenden näher erläutert.

Nachdem wir die Dateien angezeigt haben, müssen wir sie zunächst in das Programm einbinden, damit wir auf ihre Eigenschaften und andere Hilfsmittel zugreifen können. Als erstes werden die Schaltflächendateien eingebunden. Wir erreichen dies durch die folgende Logik.

#include <Controls/Button.mqh>                                 //--- Include button control library

In diesem Abschnitt verwenden wir die Bibliothek „Button.mqh“, die Teil der MQL5-Standardbibliotheken für grafische Nutzeroberflächen (GUI) ist. Mit der Bibliothek „Button.mqh“ haben wir Zugriff auf die Klasse „CButton“, die wir zum Erstellen, Konfigurieren und Verwalten der Schaltflächenelemente unseres Handelsbereichs verwenden können. Mit Hilfe der Bibliothek „Button.mqh“ können wir Schaltflächen für verschiedene Interaktionszwecke implementieren, z. B. Navigationsschaltflächen, Schaltflächen für Handelsaktionen (z. B. für die Ausführung von Kauf- und Verkaufsaufträgen) und andere Schaltflächenkomponenten, die von der Verwendung von Schaltflächen als GUI-Elemente profitieren. Wenn wir das Programm kompilieren, sollten wir einige zusätzliche Dateierweiterungen im Programm erkennen, die wie unten gezeigt aufgerufen werden.

Wir können bestätigen, dass die Dateien korrekt hinzugefügt wurden. Auf dieser Grundlage können wir nun ein Objekt erstellen, das uns Zugriff auf die Klassenmitglieder gewährt und den Rahmen des Haupthintergrundhalters des Panels erstellt. Wir erreichen dies durch die folgende Logik.

CButton obj_Btn_MAIN;                                       //--- Main button object

Hier deklarieren wir die Variable „obj_Btn_MAIN“ als eine Instanz der Klasse „CButton“. Das bedeutet, dass „obj_Btn_MAIN“ in unserem Programm als Schaltflächenobjekt fungieren wird. Indem wir dieses Schaltflächenobjekt erstellen, reservieren wir im Wesentlichen Speicherplatz, um ein Hauptschaltflächenelement in unserer Schnittstelle darzustellen und zu bearbeiten. Die Klasse „CButton“ bietet verschiedene Methoden und Eigenschaften zum Erstellen, Anpassen und Verwalten von Schaltflächensteuerelementen, z. B. zum Einstellen der Beschriftung, Größe und Farbe der Schaltfläche und zum Behandeln von Klickereignissen. Damit können wir nun die Schaltfläche erstellen, wenn der Experte initialisiert wird, d. h. im OnInit-Ereignishandler.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit() {
   //--- Start of the initialization function

   //--- MAIN BUTTON
   obj_Btn_MAIN.Create(0, Btn_MAIN, 0, 30, 30, 0, 0); //--- Create the main button at specified coordinates
   

   //--- End of initialization function
   return(INIT_SUCCEEDED); //--- Return initialization success status
}

Hier, in der Ereignisbehandlung von OnInit, einer Funktion, die automatisch aufgerufen wird, wenn der EA zum ersten Mal an ein Chart angehängt oder reinitialisiert wird, erstellen wir die Hauptschaltfläche des Dashboards. Wir nennen das Objekt „obj_Btn_MAIN“ und verwenden den Punktoperator, um Zugriff auf alle Klassenmitglieder zu erhalten. Mit dem Punkt-Operator sollten Sie etwa so etwas realisieren:

Create ist die Mitgliedsfunktion, die wir auswählen und deren notwendige Parameter wir angeben. Um zu verstehen, was das alles bedeutet, sollten wir die Parameter aufschlüsseln:

• Der erste Parameter (0) gibt die Chart-ID an. Ein Wert von 0 bezieht sich auf das aktuelle Chart, auf dem der EA läuft.
• Der zweite Parameter („Btn_MAIN“) ist eine vordefinierte String-Konstante, die den Namen dieser Schaltfläche darstellt. Dieser Name wird verwendet, um in anderen Teilen des Programms auf die Schaltfläche zu verweisen. Um die Referenzierung zu erleichtern, haben wir sie im globalen Bereich wie folgt definiert:

//--- Define button names for easier reference
#define Btn_MAIN "Btn_MAIN"                                   //--- Button name for the main button

• Der dritte Parameter (0) bezieht sich auf den Index des Unterfensters. Hier gibt 0 an, dass die Schaltfläche im Fenster des Haupt-Charts platziert werden soll.
• Der vierte (30) und der fünfte (30) Parameter legen die X- bzw. Y-Koordinaten der Schaltfläche fest. Diese bestimmen die Position der Schaltfläche im Chart.
• Die letzten beiden Parameter (0 und 0) definieren die Breite und Höhe der Schaltfläche. In diesem Fall bedeutet ein Wert von 0, dass die Schaltfläche die Standardabmessungen verwendet. Dies wird im Folgenden veranschaulicht:

Wenn wir das Programm ausführen, erhalten wir die folgende Ausgabe.

Aus dem Bild können wir ersehen, dass unsere ersten Koordinaten als 30 und 30 Pixel eingestellt sind, aber die zweiten Koordinaten werden als 0 angezeigt, da wir sie auf 0 belassen. Unsere zweiten Koordinaten werden also auf den Ursprung (0,0) abgebildet. Um die zweiten Koordinaten festzulegen, gibt es mehrere Möglichkeiten. Die erste besteht darin, sie direkt in der Mitgliedsfunktion zu definieren. 

   //--- MAIN BUTTON
   obj_Btn_MAIN.Create(0, Btn_MAIN, 0, 30, 30, 310, 300); //--- Create the main button at specified coordinates

Hier legen wir die zweiten Koordinaten der Schaltfläche fest. Wir haben sie als 310 und 300 Pixel für die x- bzw. y-Achse festgelegt. Wir haben sie zur besseren Übersichtlichkeit ebenfalls gelb hervorgehoben. Nach der Ausführung erhalten wir die folgende Ausgabe.

Wir haben die erwarteten Ergebnisse. Bei dieser Methode muss man jedoch bei der Definition der Pixel vorsichtig sein, da die zweiten Koordinaten in keiner Weise mit den ersten Koordinaten zusammenhängen. Es muss also tiefgreifende Mathematik betrieben werden, da alle Pixel vom Ursprung aus betrachtet werden. Wenn unsere zweiten Koordinaten beispielsweise 10 und 10 sind, hat die Schaltfläche zweite Koordinaten auf der y- und x-Achse, die 10 Pixel vom Ursprung entfernt sind. Unsere Schaltfläche wird also rückwärts gemappt, wobei die Größe (30-10 = 20) 20 Pixel beträgt. Hier ist eine Illustration.

Um den mathematischen Aufwand der ersten Methode zu vermeiden, können wir die zweite Methode verwenden, bei der wir die Höhe und Breite der Schaltfläche definieren, die direkt aus den ersten Koordinaten berechnet wird. Dabei wird die folgende Logik verwendet.

   //--- MAIN BUTTON
   obj_Btn_MAIN.Create(0, Btn_MAIN, 0, 30, 30, 0, 0); //--- Create the main button at specified coordinates
   obj_Btn_MAIN.Width(20); //---  Set width of the main button
   obj_Btn_MAIN.Height(20); //---  Set height of the main button

Hier verwenden wir die Mitgliedsfunktionen „width“ und „height“, um die Größe der Schaltfläche festzulegen. Wir haben eine einheitliche Größe von 20 Pixeln verwendet, damit wir den Unterschied sehen können. Nach der Kompilierung des Programms erhalten wir die folgenden Ergebnisse.

Aus der Abbildung geht hervor, dass die Schaltfläche in Vorwärtsrichtung zugeordnet ist, was bedeutet, dass wir die zweiten Koordinaten bei der Definition des Startpunkts nicht betonen müssen. Es gibt noch eine dritte Möglichkeit, die Punkte direkt zu definieren, die durch die Kombination der Parameter Breite und Höhe Platz spart. Das Codeschnipsel sieht wie folgt aus:

   //--- MAIN BUTTON
   obj_Btn_MAIN.Create(0, Btn_MAIN, 0, 30, 30, 0, 0); //--- Create the main button at specified coordinates
   //obj_Btn_MAIN.Width(310); //--- (Commented out) Set width of the main button
   //obj_Btn_MAIN.Height(300); //--- (Commented out) Set height of the main button
   obj_Btn_MAIN.Size(310, 300); //--- Set size of the main button

Hier legen wir die Größe der Schaltfläche direkt fest. Wir müssen jedoch die Hintergrundfarbe der Schaltfläche und ihre Rahmenfarbe festlegen. 

   obj_Btn_MAIN.ColorBackground(C'070,070,070'); //--- Set background color of the main button
   obj_Btn_MAIN.ColorBorder(clrBlack); //--- Set border color of the main button

Hier konfigurieren wir das visuelle Erscheinungsbild unserer „obj_Btn_MAIN“-Schaltfläche, indem wir ihre Hintergrund- und Rahmenfarben festlegen. Zunächst rufen wir die Methode „ColorBackground“ für das Objekt „obj_Btn_MAIN“ auf und übergeben die RGB-Werte „C'070,070,070'“ als Parameter. RGB steht für Red (Rot), Green (Grün) und Blue (Blau) - die drei Grundfarben, die zur Erzeugung eines breiten Spektrums von Farben auf digitalen Bildschirmen verwendet werden.

Das RGB-Format nimmt drei Werte an, die die Intensität von Rot, Grün und Blau in einem Bereich von 0 bis 255 darstellen, wobei „0“ keine Intensität bedeutet und „255“ die maximale Intensität ist. Zum Beispiel bedeutet „C'070,070,070'“:

• Wir setzen die rote Komponente auf „70“ (von 255)
• Wir setzen die grüne Komponente auf „70“.
• Wir setzen die blaue Komponente auf „70“.

Wenn wir alle drei RGB-Werte gleich einstellen, ergibt sich ein Grauton. Da wir moderate Werte von 70 für alle drei verwenden, wird der Hintergrund der Schaltfläche zu einem mitteldunklen Grau. Diese Farbe ist visuell neutral und sorgt dafür, dass andere bunte Elemente, die wir entwerfen werden, auf der Tafel hervorstechen.

Als Nächstes rufen wir die Methode „ColorBorder“ auf und legen die Farbe mit der Konstante „clrBlack“ fest, die für reines Schwarz steht. Hier ist jeder RGB-Wert 0 (“C'000.000.000'“), was bedeutet, dass keine Rot-, Grün- oder Blaukomponenten vorhanden sind. Durch die Verwendung von Schwarz für die Umrandung schaffen wir eine starke visuelle Kontur, die die Grenzen der Schaltfläche klar vor dem dunkleren grauen Hintergrund abgrenzt und sie klarer und strukturierter aussehen lässt. Dieser Ansatz gewährleistet, dass die Schaltfläche leicht zu erkennen ist, und verleiht der gesamten grafischen Oberfläche ein ansprechendes Aussehen. Nach dem Kompilieren erhalten wir die folgende Ausgabe.

Dort befindet sich unsere Hauptschaltfläche. Schließlich müssen wir das Chart aktualisieren, damit die Änderungen automatisch wirksam werden und nicht auf ein manuelles Chart-Ereignis warten müssen, das die Aktualisierung beeinflusst. Die Logik ist wie folgt.

   ChartRedraw(0); //--- Redraw the chart to update the panel

Hier rufen wir die Funktion ChartRedraw auf, um die Chart-Oberfläche zu aktualisieren und visuell darzustellen. Auf diese Weise stellen wir sicher, dass alle neu hinzugefügten grafischen Elemente — Schaltflächen, Beschriftungen usw. — richtig angezeigt werden. Die Funktion ChartRedraw ist immer dann unverzichtbar, wenn wir Chart-Elemente hinzufügen, ändern oder entfernen, da sie das Terminal zwingt, das aktuelle Chart neu darzustellen. Das ist besonders wichtig, wenn wir interaktive Bedienfelder erstellen und sicherstellen wollen, dass das Bedienfeld dem Nutzer den aktuellsten Zustand anzeigt, den es anzeigen kann.

Der Parameter 0 wird beim Aufruf der Funktion verwendet. Es ist die Chart-ID. Jeder Chart in MetaTrader 5 hat eine eindeutige ID, und 0 bezieht sich auf den aktuellen Chart, an den der Expert Advisor angehängt ist. Um ein Chart neu zu zeichnen, müssen wir die richtige ID übergeben. Wir stellen sicher, dass der Vorgang des Neuzeichnens für dieses spezielle Chart gilt. Wenn wir die Funktion ChartRedraw nicht aufrufen, kann es zu einem grafischen Problem kommen. Bei neu erstellten grafischen Objekten kann es vorkommen, dass sie nicht angezeigt werden, oder dass bei geänderten grafischen Objekten die von uns vorgenommenen Änderungen nicht angezeigt werden; sie zeigen weiterhin ihre veralteten Eigenschaften an. Wir können also sicherstellen, dass unser Panel und sein Inhalt korrekt angezeigt werden, indem wir die Funktion ChartRedraw für dieses Panel aufrufen. Der endgültige Initialisierungscode, der für die Erstellung der Hauptschaltfläche verantwortlich ist, lautet wie folgt.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit() {
   //--- Start of the initialization function

   //--- MAIN BUTTON
   obj_Btn_MAIN.Create(0, Btn_MAIN, 0, 30, 30, 0, 0); //--- Create the main button at specified coordinates
   //obj_Btn_MAIN.Width(310); //--- (Commented out) Set width of the main button
   //obj_Btn_MAIN.Height(300); //--- (Commented out) Set height of the main button
   obj_Btn_MAIN.Size(310, 300); //--- Set size of the main button
   obj_Btn_MAIN.ColorBackground(C'070,070,070'); //--- Set background color of the main button
   obj_Btn_MAIN.ColorBorder(clrBlack); //--- Set border color of the main button


   ChartRedraw(0); //--- Redraw the chart to update the panel

   //--- End of initialization function
   return(INIT_SUCCEEDED); //--- Return initialization success status
}

Bis zu diesem Punkt haben wir nun einige Hintergrundinformationen über das, was wir tun werden, und die notwendigen Dinge, die wir tun müssen. So können wir die Objekte für alle Schaltflächen definieren, die wir für die anfängliche Schnittstelle benötigen.

#include <Controls/Button.mqh>                                 //--- Include button control library
CButton obj_Btn_MAIN;                                       //--- Main button object
CButton obj_Btn_HEADER;                                     //--- Header button object
CButton obj_Btn_X;                                          //--- Close button (X) object
CButton obj_Btn_TRADE;                                     //--- Trade button object
CButton obj_Btn_CLOSE;                                      //--- Close button object
CButton obj_Btn_INFO;                                       //--- Information button object
CButton obj_Btn_RISK;                                       //--- Risk button object
CButton obj_Btn_POINTS;                                     //--- Points button object
CButton obj_Btn_SELL;                                       //--- Sell button object
CButton obj_Btn_ENTRY;                                      //--- Entry button object
CButton obj_Btn_BUY;                                        //--- Buy button object
CButton obj_Btn_SELLSTOP;                                   //--- Sell Stop button object
CButton obj_Btn_BUYSTOP;                                    //--- Buy Stop button object
CButton obj_Btn_SELLLIMIT;                                  //--- Sell Limit button object
CButton obj_Btn_BUYLIMIT;                                   //--- Buy Limit button object
CButton obj_Btn_FOOTER;                                     //--- Footer button object

Hier definieren wir mehrere der übrigen Button-Objekte mit der Klasse „CButton“, um verschiedene interaktive Elemente des Panels darzustellen. Jede Zeile instanziiert ein eindeutiges Schaltflächenobjekt, wodurch eine grundlegende Struktur für die verschiedenen Abschnitte des Dashboards geschaffen wird, die wir erstellen müssen. Schauen wir uns den Zweck und die Rolle der einzelnen Schaltflächen an:

• „obj_Btn_HEADER“: Dieses Objekt stellt die Kopfschaltfläche des Panels dar. Wir könnten sie für die Anzeige eines Titels oder eines Symbols verwenden oder als visuelle Trennlinie für den oberen Bereich des Panels dienen.
• „obj_Btn_X“: Diese Schaltfläche dient zum Schließen (oft als „X“ dargestellt), mit der die Nutzer das Panel verlassen oder ausblenden können.
• „obj_Btn_TRADE“: Stellt die Schaltfläche „Handeln“ dar, die ein zentrales Steuerelement ist. Wenn Sie diese Taste drücken, werden die Handelsfunktionen aktiviert, die Handelsoptionen aufgerufen und die Untermenüs für die Handelsaktionen geöffnet.
• „obj_Btn_CLOSE“: Die Schaltfläche „Close“ hier ist eine spezielle Schaltfläche, die für die Verwaltung der Schließung von Handelsgeschäften verwendet wird. Er dient als Schalter für den Übergang zwischen dem Handelsbereich und einem abschließenden Bereich des Panels.
• „obj_Btn_INFO“: Diese Schaltfläche wird verwendet, um dem Nutzer Informationsinhalte zu präsentieren, wie z. B. Handelskennzahlen, Kontodetails und Panel-Beschreibungen.

Bei den Schaltflächen für die Handelsfunktionalität dienen die Objekte bestimmten Zwecken im Handelskontext:

• „obj_Btn_RISK“: Dient als Schaltfläche zur Risikokontrolle. Sie ermöglicht es dem Nutzer, Risikoparameter wie den prozentualen Anteil des Risikos pro Handel zu konfigurieren oder anzupassen.
• „obj_Btn_POINTS“: Diese Schaltfläche wird verwendet, um punktbasierte Handelsoptionen festzulegen oder zu ihnen zu wechseln, bei denen bestimmte Niveaus, wie Stop-Loss oder Take-Profit, in Punkten und nicht in Kursniveaus definiert werden.
• „obj_Btn_SELL“, „obj_Btn_ENTRY“ und „obj_Btn_BUY“: obj_Btn_SELL“ löst einen Verkauf aus, „obj_Btn_BUY“ leitet einen Kauf ein und „obj_Btn_ENTRY“ dient als Platzhalter für Markteröffnung.

Bei schwebenden Aufträgen definieren diese Schaltflächen die Aktionen:

• „obj_Btn_SELLSTOP“ und „obj_Btn_BUYSTOP“: Steuern Sie die Platzierung von schwebenden Verkaufsstopp- und Kaufstopp-Aufträgen, die unterhalb bzw. oberhalb des aktuellen Kurses platziert werden.
• „obj_Btn_SELLLIMIT“ und „obj_Btn_BUYLIMIT“: Abwicklung von schwebenden Sell Limit- und Buy Limit-Aufträgen, die es den Nutzern ermöglichen, Aufträge auf bestimmten Niveaus in Erwartung von Preisrückgängen zu platzieren.

Schließlich gibt es noch die Schaltfläche „obj_Btn_FOOTER“, mit der wir die Schaltfläche der Fußzeile des Panels definieren. Diese Schaltfläche könnte als dekoratives Element, als Reset-Steuerelement oder als Navigationsschaltfläche für den Wechsel zu einer Übersichtsansicht dienen, aber in unserem Fall werden wir sie nur zur Anzeige der Dashboard-Zusammenfassung verwenden.

In ähnlicher Weise müssen wir die Felder „Bearbeiten“ und „Beschriften“ definieren. Es gilt die folgende Logik.

#include <Controls/Edit.mqh>                                   //--- Include edit control library
CEdit obj_Edit_RISK;                                        //--- Risk edit field object
CEdit obj_Edit_PRICE;                                       //--- Price edit field object
CEdit obj_Edit_LOTS;                                        //--- Lots edit field object
CEdit obj_Edit_SL;                                          //--- Stop Loss edit field object
CEdit obj_Edit_TP;                                          //--- Take Profit edit field object

#include <Controls/Label.mqh>                                  //--- Include label control library
CLabel obj_Lbl_HEADER;                                      //--- Header label object
CLabel obj_Lbl_PRICE;                                       //--- Price label object
CLabel obj_Lbl_LOTS;                                        //--- Lots label object
CLabel obj_Lbl_SL;                                          //--- Stop Loss label object
CLabel obj_Lbl_TP;                                          //--- Take Profit label object

Hier finden Sie die wichtigsten Steuerbibliotheken, um Nutzereingaben zu steuern und Text auf dem Dashboard anzuzeigen. Zunächst wird die Bibliothek „Edit.mqh“ eingebunden, die Funktionalitäten für editierbare Eingabefelder bereitstellt. Es sind mehrere Objekte der Klasse „CEdit“ definiert, darunter „obj_Edit_RISK“ als Risikobearbeitungsfeld. Das Objekt „obj_Edit_PRICE“ stellt das Preis-Editierfeld dar, in dem der Nutzer den Preis angeben kann, zu dem er Geschäfte abschließen möchte. Ein Objekt mit dem Namen „obj_Edit_LOTS“ ist für die Losgröße bestimmt, die der Nutzer anpassen kann, um die Anzahl der Lots anzugeben, die er handeln möchte. „obj_Edit_SL“ ist das Feld für die Bearbeitung des Stop-Loss. Und schließlich dient „obj_Edit_TP“ als Editierfeld für den Take-Profit.

Als Nächstes integrieren wir die Bibliothek „Label.mqh“. Diese Bibliothek vereinfacht die Erstellung von statischen Textbeschriftungen auf dem Bedienfeld, was besonders für die Bereitstellung einer nutzerfreundlichen Schnittstelle nützlich ist. Die Bibliothek wurde speziell für unsere Arbeitsumgebung entwickelt und enthält eine Klasse, „CLabel“, die wir mehrmals instanziiert haben, um die verschiedenen Beschriftungen zu erstellen, die wir für unser Panel benötigen. Das erste Label, das wir instanziieren, heißt „obj_Lbl_HEADER“ und wird verwendet, um den Titel oder die wichtigsten Informationen ganz oben im Panel anzuzeigen. Die nächste Beschriftung heißt „obj_Lbl_PRICE“ und wird verwendet, um den aktuellen Preis des Vermögenswerts anzugeben, mit dem wir arbeiten. Neben dem Eingabefeld für die Losgröße befindet sich eine Beschriftung mit der Bezeichnung „obj_Lbl_LOTS“, die zur Angabe der Losgröße dient. Anschließend können wir die entsprechenden Felder des Panels wie unten beschrieben definieren:

//--- Define button names for easier reference
#define Btn_MAIN "Btn_MAIN"                                   //--- Button name for the main button
#define Btn_HEADER "Btn_HEADER"                               //--- Button name for the header button
#define Btn_X "Btn_X"                                        //--- Button name for the close button
#define Btn_TRADE "Btn_TRADE"                               //--- Button name for the trade button
#define Btn_CLOSE "Btn_CLOSE"                                //--- Button name for the close button
#define Btn_INFO "Btn_INFO"                                  //--- Button name for the info button

#define Btn_RISK "Btn_RISK"                                  //--- Button name for the risk button
#define Btn_POINTS "Btn_POINTS"                              //--- Button name for the points button
#define Btn_SELL "Btn_SELL"                                  //--- Button name for the sell button
#define Btn_ENTRY "Btn_ENTRY"                                //--- Button name for the entry button
#define Btn_BUY "Btn_BUY"                                    //--- Button name for the buy button
#define Btn_SELLSTOP "Btn_SELLSTOP"                          //--- Button name for the sell stop button
#define Btn_BUYSTOP "Btn_BUYSTOP"                            //--- Button name for the buy stop button
#define Btn_SELLLIMIT "Btn_SELLLIMIT"                        //--- Button name for the sell limit button
#define Btn_BUYLIMIT "Btn_BUYLIMIT"                          //--- Button name for the buy limit button
#define Btn_FOOTER "Btn_FOOTER"                              //--- Button name for the footer button

//---
//--- Define edit field names for easier reference
#define Edit_RISK "Edit_RISK"                                //--- Edit field name for risk input
#define Edit_PRICE "Edit_PRICE"                              //--- Edit field name for price input
#define Edit_LOTS "Edit_LOTS"                                //--- Edit field name for lots input
#define Edit_SL "Edit_SL"                                    //--- Edit field name for stop loss input
#define Edit_TP "Edit_TP"                                    //--- Edit field name for take profit input

//--- Define label names for easier reference
#define Lbl_HEADER "Lbl_HEADER"                              //--- Label name for the header
#define Lbl_PRICE "Lbl_PRICE"                                //--- Label name for the price
#define Lbl_LOTS "Lbl_LOTS"                                  //--- Label name for the lots
#define Lbl_SL "Lbl_SL"                                      //--- Label name for the stop loss
#define Lbl_TP "Lbl_TP"                                      //--- Label name for the take profit

Nachdem wir die Schlüsselelemente definiert haben, die wir für unsere Initialisierungsschnittstelle benötigen, können wir unserem Panel eine Kopfzeile geben, indem wir die bereits definierten Dienstprogramme verwenden. Die übernommene Kopflogik ist in dem nachstehenden Codeausschnitt dargestellt:

   //--- HEADER BUTTON 
   obj_Btn_HEADER.Create(0, Btn_HEADER, 0, 30, 30, 0, 0); //--- Create the header button at specified coordinates
   obj_Btn_HEADER.Size(310, 25); //--- Set size of the header button
   obj_Btn_HEADER.ColorBackground(clrLightBlue); //--- Set background color of the header button
   obj_Btn_HEADER.ColorBorder(clrBlack); //--- Set border color of the header button

Hier wird die Schaltfläche der Kopfzeile des Dashboard-Panels erstellt und angepasst. Wir beginnen mit der Methode „Create“ für das Objekt „obj_Btn_HEADER“, um die Schaltfläche mit Parametern zu initialisieren, die ihre Chart-ID, ihren Namen („Btn_HEADER“), ihre ersten Koordinaten (30, 30) und ihre zweiten Koordinaten (0, 0) angeben. Als Nächstes legen wir die Größe der Schaltfläche mit der Methode „Größe“ auf 310 Pixel Breite und 25 Pixel Höhe fest, damit sie gut in das Panel-Layout passt.

Anschließend passen wir die Hintergrundfarbe der Kopfzeilen-Schaltfläche mit der Methode „ColorBackground“ an und setzen sie auf „clrLightBlue“, um sie optisch ansprechend zu gestalten. Zusätzlich legen wir die Farbe des Rahmens mit der Methode „ColorBorder“ fest und setzen sie auf „clrBlack“, was die Sichtbarkeit und die Definition der Schaltfläche vor dem Hintergrund des Panels verbessert. Nach dem Kompilieren erhalten wir die folgende Ausgabe.

Das war ein Erfolg. Jetzt können wir die Kopfzeile noch lebendiger gestalten, indem wir sie mit einer Beschriftung und einer Schaltfläche zum Schließen der Seite versehen. Fügen wir zunächst die Schaltfläche zum Schließen hinzu. Die Logik ist wie unten dargestellt.

   //--- X BUTTON
   obj_Btn_X.Create(0, Btn_X, 0, 30 + 280, 30 + 1, 0, 0); //--- Create the close button (X) at specified coordinates
   obj_Btn_X.Size(30 - 1, 25 - 1 - 1); //--- Set size of the close button
   obj_Btn_X.ColorBackground(clrLightBlue); //--- Set background color of the close button
   obj_Btn_X.ColorBorder(clrLightBlue); //--- Set border color of the close button
   obj_Btn_X.Text(CharToString(255)); //--- Set the close button text to an "X" character
   obj_Btn_X.Color(clrBlack); //--- Set text color of the close button
   obj_Btn_X.Font("Wingdings"); //--- Set font of the close button to Wingdings
   obj_Btn_X.FontSize(17); //--- Set font size of the close button

Hier erstellen und konfigurieren wir die Schaltfläche „Schließen“ (X) für das Dashboard-Panel. Wir beginnen mit der Initialisierung der Schaltfläche mit der Methode „Create“ für das Objekt „obj_Btn_X“. Die Parameter, die wir angeben, spezifizieren die Chart-ID, den Namen („Btn_X“) und die Position im Chart, die so berechnet wird, dass die x-Koordinate bei (30 + 280) und die y-Koordinate bei (30 + 1) liegt, wodurch sichergestellt wird, dass das Chart im Layout des Panels richtig ausgerichtet ist.

Als Nächstes legen wir die Größe der Schaltfläche „Schließen“ mit der Methode „Größe“ auf 29 (30 - 1) Pixel in der Breite und 23 (25 - 1 - 1) Pixel in der Höhe fest, wobei wir die Standardgröße leicht reduzieren, um sicherzustellen, dass sie gut in die Nutzeroberfläche passt. Wir spielen mit 1 Pixel, um für den Rand zu sorgen, sodass er nicht den Rand der Kopfzeile überschreibt, sondern innerhalb der Kopfzeile liegt. Anschließend passen wir die Hintergrundfarbe der Schaltfläche mit der Methode „ColorBackground“ auf hellblau an und schaffen so ein einheitliches Erscheinungsbild mit der Kopfzeilenschaltfläche, die sich vollständig in die Kopfzeile einfügt. Die Farbe des Rahmens wird mit der Methode „ColorBorder“ ebenfalls auf hellblau gesetzt, was der Schaltfläche ein sauberes Aussehen ohne kontrastierenden Rahmen verleiht.

Der Text der Schaltfläche wird mit der Funktion CharToString und dem Parameter 255 in ein Symbolzeichen umgewandelt, sodass die Schaltfläche ihre Funktion als Schließen-Schaltfläche visuell anzeigt. In MQL5 steht das Zeichen für ein Windows-Symbol, kann aber auch etwas anderes sein. Die Textfarbe wird mit der Methode „Color“ auf Schwarz gesetzt, damit sie sich von dem hellen Hintergrund abhebt. Schließlich haben wir mit der Methode „Font“ als Schriftart für die Schließen-Schaltfläche Wingdings gewählt, die für die Darstellung des Fenstersymbols geeignet ist, und mit der Methode „FontSize“ die Schriftgröße auf 17 gesetzt, um die Lesbarkeit zu verbessern. Hier ist eine Darstellung der möglichen Symbolcodes in MQL5.

Wie wir sehen können, gibt es eine Vielzahl von Optionen, aber wir beschränken uns auf den ursprünglichen Code 255. Wir müssen nur noch den Titel der Kopfzeile festlegen, und schon sind wir mit dem Kopfzeilenabschnitt fertig.

   //--- HEADER LABEL
   obj_Lbl_HEADER.Create(0, Lbl_HEADER, 0, 40, 30, 0, 0); //--- Create the header label at specified coordinates
   obj_Lbl_HEADER.Text("Control Panel"); //--- Set text of the header label
   obj_Lbl_HEADER.Color(clrRed); //--- Set text color of the header label
   obj_Lbl_HEADER.Font("Cooper black"); //--- Set font of the header label to Cooper Black
   obj_Lbl_HEADER.FontSize(14); //--- Set font size of the header label

Hier erstellen und konfigurieren wir die Kopfzeilenbeschriftung für das Handels-Dashboard. Zunächst wird das Etikett mit der Methode „Create“ für das Objekt „obj_Lbl_HEADER“ initialisiert, wobei die ID des Charts, der Name des Etiketts („Lbl_HEADER“) und seine Position im Chart (40) für die x-Koordinate und (30) für die y-Koordinate angegeben werden. Durch diese Positionierung wird sichergestellt, dass die Kopfzeile im Layout des Bedienfelds angemessen erscheint.

Als Nächstes setzen wir den Text der Kopfzeile mit der Methode „Text“ auf „Control Panel“, um den Zweck des Dashboards klar zu kennzeichnen. Das alles kann natürlich so sein, wie Sie es wollen. Sie können sie gerne ändern. Anschließend passen wir die Textfarbe mit der Methode „Color“ auf Rot an, sodass sie sich vom Hintergrund abhebt und besser sichtbar ist. Die Schriftart der Kopfzeile ist mit der Methode „Font“ auf „Cooper black“ eingestellt, was dem Text ein klares und professionelles Aussehen verleiht. Schließlich legen wir mit der Methode „FontSize“ die Schriftgröße auf 14 fest, damit der Kopfzeilentext gut lesbar ist. Nach dem Kompilieren erhalten wir die folgende Ausgabe.

Das war ein Erfolg. In einem ähnlichen Format können wir die Navigationsschaltflächen erstellen. Wir werden zunächst die Schaltfläche für die Ansicht der Handelsvorgänge mit der folgenden Logik erstellen. 

   //--- TRADE BUTTON
   obj_Btn_TRADE.Create(0, Btn_TRADE, 0, 40, 60, 0, 0); //--- Create the trade button at specified coordinates
   obj_Btn_TRADE.Size(90, 30); //--- Set size of the trade button
   obj_Btn_TRADE.ColorBackground(clrYellow); //--- Set background color of the trade button
   obj_Btn_TRADE.ColorBorder(clrYellow); //--- Set border color of the trade button
   obj_Btn_TRADE.Text("Trade"); //--- Set text of the trade button
   obj_Btn_TRADE.Color(clrBlack); //--- Set text color of the trade button
   obj_Btn_TRADE.Font("Arial Black"); //--- Set font of the trade button to Arial Black
   obj_Btn_TRADE.FontSize(13); //--- Set font size of the trade button

Hier ändern wir nur die Größe der Schaltfläche und die Hintergrundfarbe auf gelb. Nach dem Kompilieren erhalten wir die folgende Ausgabe.

Das war ein Erfolg. Wir setzen die Farbe der Schaltfläche auf gelb, um zu verdeutlichen, dass die Schaltfläche aktiv ist. Wenn wir also die anderen Navigationsschaltflächen definieren, wird eine ähnliche Logik beibehalten, aber die Farbe wird in eine inaktive Farbe geändert. Hier ist die vollständige Logik.

   //--- CLOSE BUTTON
   obj_Btn_CLOSE.Create(0, Btn_CLOSE, 0, 40 + obj_Btn_TRADE.Width() + 10, 60, 0, 0); //--- Create the close button at specified coordinates
   obj_Btn_CLOSE.Size(90, 30); //--- Set size of the close button
   obj_Btn_CLOSE.ColorBackground(clrSilver); //--- Set background color of the close button
   obj_Btn_CLOSE.ColorBorder(clrSilver); //--- Set border color of the close button
   obj_Btn_CLOSE.Text("Close"); //--- Set text of the close button
   obj_Btn_CLOSE.Color(clrBlack); //--- Set text color of the close button
   obj_Btn_CLOSE.Font("Arial Black"); //--- Set font of the close button to Arial Black
   obj_Btn_CLOSE.FontSize(13); //--- Set font size of the close button

   //--- INFO BUTTON
   obj_Btn_INFO.Create(0, Btn_INFO, 0, 40 + obj_Btn_TRADE.Width() + 10 + obj_Btn_CLOSE.Width() + 10, 60, 0, 0); //--- Create the info button at specified coordinates
   obj_Btn_INFO.Size(90, 30); //--- Set size of the info button
   obj_Btn_INFO.ColorBackground(clrSilver); //--- Set background color of the info button
   obj_Btn_INFO.ColorBorder(clrSilver); //--- Set border color of the info button
   obj_Btn_INFO.Text("Inform'n"); //--- Set text of the info button
   obj_Btn_INFO.Color(clrBlack); //--- Set text color of the info button
   obj_Btn_INFO.Font("Arial Black"); //--- Set font of the info button to Arial Black
   obj_Btn_INFO.FontSize(13); //--- Set font size of the info button

Hier erstellen wir die Schaltflächen „Close“ und „Information“ und setzen ihre Hintergrundfarbe auf Silber, damit sie ihren anfänglichen inaktiven Zustand anzeigen. Hier sind die Ergebnisse.

Nachdem wir die Navigationsschaltflächen definiert haben, können wir den Fußzeilenbereich definieren, bevor wir die Initialisierung des Handelskörpers abschließen. Die Logik wird wie im folgenden Codeausschnitt dargestellt sein.

   //--- FOOTER BUTTON
   obj_Btn_FOOTER.Create(0, Btn_FOOTER, 0, 30 + 1, 305 - 1, 0, 0); //--- Create the footer button at specified coordinates
   obj_Btn_FOOTER.Size(310 - 1 - 1, 25); //--- Set size of the footer button
   obj_Btn_FOOTER.ColorBackground(C'070,070,070'); //--- Set background color of the footer button
   obj_Btn_FOOTER.ColorBorder(C'070,070,070'); //--- Set border color of the footer button
   obj_Btn_FOOTER.Text(ShortToString(0x23F0) + "https://t.me/Forex_Algo_Trader"); //--- Set text of the footer button with a link
   obj_Btn_FOOTER.Color(clrWhite); //--- Set text color of the footer button
   obj_Btn_FOOTER.Font("Calibri bold italic"); //--- Set font of the footer button to Calibri bold italic
   obj_Btn_FOOTER.FontSize(12); //--- Set font size of the footer button

Hier erstellen und konfigurieren wir die Fußzeilenschaltfläche für das Handels-Dashboard, indem wir die normalen Parameter übergeben und sie am unteren Rand des Panels platzieren. Als Nächstes definieren wir die Größe der Fußzeilen-Schaltfläche mit der Methode „Größe“, indem wir die Abmessungen auf 310 - 1 - 1 für die Breite und 25 für die Höhe festlegen. Dadurch wird sichergestellt, dass die Schaltfläche gut in den Fußbereich des Bedienfelds passt. Anschließend passen wir die Hintergrundfarbe der Schaltfläche mit der Methode „ColorBackground“ mit den RGB-Werten „C'070,070,070'“ auf ein dunkles Grau an, um sicherzustellen, dass sie optisch ansprechend ist und mit dem Gesamtdesign übereinstimmt, sodass sie im Grunde mit der Hauptschaltfläche verschmilzt.

Die Farbe des Rahmens wird mit der Methode „ColorBorder“ ebenfalls auf das gleiche Dunkelgrau gesetzt, wodurch die Schaltfläche ein nahtloses Aussehen erhält. Für den Text der Schaltfläche verwenden wir die „Text“-Methode, um ihn auf eine Kombination aus einem Symbol (dargestellt durch das Unicode-Zeichen 0x23F0, das als Uhr erscheint) und dem Link „https://t.me/Forex_Algo_Trader“ zu setzen, der die Nutzer zum Zugriff auf zusätzliche Ressourcen auffordert. Wir haben die Unicode Zeichen mit Hilfe der Funktion ShortToString in ein Symbol umgewandelt. Die Zeichen sind in hexadezimaler Form, wie unten gezeigt, und das ist der Grund, warum wir die Funktion benötigen.

Wir setzen die Textfarbe mit der Methode „Color“ auf Weiß, um die Sichtbarkeit vor dem dunklen Hintergrund zu verbessern. Schließlich konfigurieren wir die Schriftart der Fußzeilen-Schaltfläche mit der Methode „Font“ auf „Calibri bold italic“, was einen Hauch von Professionalität verleiht, und setzen die Schriftgröße mit der Methode „FontSize“ auf 12, damit der Text lesbar bleibt. Nach der Kompilierung erhalten wir den folgenden Meilenstein.

Das war ein Erfolg. Jetzt müssen wir nur noch den Hauptteil fertigstellen, dann ist alles in Ordnung. Da wir die Body-Ansicht bei jeder Aktivierung der Navigationsschaltfläche ständig ändern müssen, können wir die Body-Logik in einer Funktion unterbringen und sie nur bei Bedarf aufrufen. 

   // BODY OF THE PANEL
   createSection_Trade(); //--- Call function to create the trade section

Hier erstellen wir eine Funktion namens „createSection_Trade“ im Body des Panels, um den Abschnitt „Trade“ des Dashboards einzurichten. Dies ist in der Regel der Aufruf der Funktion, wie wir sie definiert haben. Mit dieser Funktion können Sie die interaktiven Elemente für den Handel erstellen und konfigurieren, z. B. die Schaltflächen für Kauf, Verkauf und Auftragsart. Durch die Verwendung der Funktion stellen wir sicher, dass der Code modular und organisiert ist, sodass alle Elemente im Zusammenhang mit dem Handel innerhalb einer separaten Funktion behandelt werden können. Dadurch bleibt das Hauptpanel übersichtlicher, und das Dashboard-System lässt sich leichter warten und bei Bedarf erweitern.

Dann müssen wir die Funktion definieren. Da es sich um eine einfache Funktion handelt, definieren wir sie als void-Funktion und übergeben ihr keine Parameter. 

void createSection_Trade(){

//---

}

Um die Funktionen zu erstellen, verwenden wir eine ähnliche Logik wie im gesamten Code. Der vollständige Funktionscode wird wie folgt aussehen.

//+------------------------------------------------------------------+
//|     FUNCTION TO CREATE THE TRADE SECTION                         |
//+------------------------------------------------------------------+
void createSection_Trade(){
   //--- RISK BUTTON
   obj_Btn_RISK.Create(0,Btn_RISK,0,40,100,0,0); //--- Create the risk button
   obj_Btn_RISK.Size(210,25); //--- Set the button size
   obj_Btn_RISK.ColorBackground(clrTurquoise); //--- Set the background color
   obj_Btn_RISK.ColorBorder(clrTurquoise); //--- Set the border color
   obj_Btn_RISK.Text("Risk based on Equity (%)"); //--- Set the button text
   obj_Btn_RISK.Color(clrBlack); //--- Set the text color
   obj_Btn_RISK.Font("Arial Black"); //--- Set the font style
   obj_Btn_RISK.FontSize(11); //--- Set the font size
   
   //--- RISK EDIT
   obj_Edit_RISK.Create(0,Edit_RISK,0,40+220,100,0,0); //--- Create the risk edit field
   obj_Edit_RISK.Size(70,25); //--- Set the edit field size
   obj_Edit_RISK.ColorBackground(clrWhite); //--- Set the background color
   obj_Edit_RISK.ColorBorder(clrBlack); //--- Set the border color
   obj_Edit_RISK.Text("78"); //--- Set the default text
   obj_Edit_RISK.Color(clrBlack); //--- Set the text color
   obj_Edit_RISK.Font("Times new roman bold"); //--- Set the font style
   obj_Edit_RISK.FontSize(15); //--- Set the font size
   
   //--- PRICE LABEL
   obj_Lbl_PRICE.Create(0,Lbl_PRICE,0,40,130,0,0); //--- Create the price label
   obj_Lbl_PRICE.Text("Price"); //--- Set the label text
   obj_Lbl_PRICE.Color(clrWhite); //--- Set the text color
   obj_Lbl_PRICE.Font("Arial black"); //--- Set the font style
   obj_Lbl_PRICE.FontSize(13); //--- Set the font size   
   
   //--- PRICE EDIT
   obj_Edit_PRICE.Create(0,Edit_PRICE,0,40+60,130,0,0); //--- Create the price edit field
   obj_Edit_PRICE.Size(90,25); //--- Set the edit field size
   obj_Edit_PRICE.ColorBackground(clrWhite); //--- Set the background color
   obj_Edit_PRICE.ColorBorder(clrBlack); //--- Set the border color
   obj_Edit_PRICE.Text(DoubleToString(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits)); //--- Set the default text to current ask price
   obj_Edit_PRICE.Color(clrBlack); //--- Set the text color
   obj_Edit_PRICE.Font("Times new roman bold"); //--- Set the font style
   obj_Edit_PRICE.FontSize(13); //--- Set the font size
   
   //--- LOTS LABEL
   obj_Lbl_LOTS.Create(0,Lbl_LOTS,0,40+160,130,0,0); //--- Create the lot size label
   obj_Lbl_LOTS.Text("Lot size"); //--- Set the label text
   obj_Lbl_LOTS.Color(clrWhite); //--- Set the text color
   obj_Lbl_LOTS.Font("Arial black"); //--- Set the font style
   obj_Lbl_LOTS.FontSize(13); //--- Set the font size   
   
   //--- LOTS EDIT
   obj_Edit_LOTS.Create(0,Edit_LOTS,0,40+60+180,130,0,0); //--- Create the lot size edit field
   obj_Edit_LOTS.Size(50,25); //--- Set the edit field size
   obj_Edit_LOTS.ColorBackground(clrWhite); //--- Set the background color
   obj_Edit_LOTS.ColorBorder(clrBlack); //--- Set the border color
   obj_Edit_LOTS.Text("0.01"); //--- Set the default text
   obj_Edit_LOTS.Color(clrBlack); //--- Set the text color
   obj_Edit_LOTS.Font("Times new roman bold"); //--- Set the font style
   obj_Edit_LOTS.FontSize(13); //--- Set the font size
   
   //--- SL LABEL
   obj_Lbl_SL.Create(0,Lbl_SL,0,40,160,0,0); //--- Create the stop loss label
   obj_Lbl_SL.Text("SL"); //--- Set the label text
   obj_Lbl_SL.Color(clrWhite); //--- Set the text color
   obj_Lbl_SL.Font("Arial black"); //--- Set the font style
   obj_Lbl_SL.FontSize(13); //--- Set the font size   
   
   //--- SL EDIT
   obj_Edit_SL.Create(0,Edit_SL,0,40+30,160,0,0); //--- Create the stop loss edit field
   obj_Edit_SL.Size(70,25); //--- Set the edit field size
   obj_Edit_SL.ColorBackground(clrWhite); //--- Set the background color
   obj_Edit_SL.ColorBorder(clrBlack); //--- Set the border color
   obj_Edit_SL.Text("300"); //--- Set the default text
   obj_Edit_SL.Color(clrBlack); //--- Set the text color
   obj_Edit_SL.Font("Times new roman bold"); //--- Set the font style
   obj_Edit_SL.FontSize(13); //--- Set the font size
   
   //--- TP LABEL
   obj_Lbl_TP.Create(0,Lbl_TP,0,40+190,160,0,0); //--- Create the take profit label
   obj_Lbl_TP.Text("TP"); //--- Set the label text
   obj_Lbl_TP.Color(clrWhite); //--- Set the text color
   obj_Lbl_TP.Font("Arial black"); //--- Set the font style
   obj_Lbl_TP.FontSize(13); //--- Set the font size   
   
   //--- TP EDIT
   obj_Edit_TP.Create(0,Edit_TP,0,40+30+190,160,0,0); //--- Create the take profit edit field
   obj_Edit_TP.Size(70,25); //--- Set the edit field size
   obj_Edit_TP.ColorBackground(clrWhite); //--- Set the background color
   obj_Edit_TP.ColorBorder(clrBlack); //--- Set the border color
   obj_Edit_TP.Text("750"); //--- Set the default text
   obj_Edit_TP.Color(clrBlack); //--- Set the text color
   obj_Edit_TP.Font("Times new roman bold"); //--- Set the font style
   obj_Edit_TP.FontSize(13); //--- Set the font size
    
   //--- POINTS BUTTON
   obj_Btn_POINTS.Create(0,Btn_POINTS,0,40+110,160,0,0); //--- Create the points button
   obj_Btn_POINTS.Size(70,25); //--- Set the button size
   obj_Btn_POINTS.ColorBackground(clrGoldenrod); //--- Set the background color
   obj_Btn_POINTS.ColorBorder(clrGoldenrod); //--- Set the border color
   obj_Btn_POINTS.Text("Points"); //--- Set the button text
   obj_Btn_POINTS.Color(clrBlack); //--- Set the text color
   obj_Btn_POINTS.Font("Calibri bold"); //--- Set the font style
   obj_Btn_POINTS.FontSize(14); //--- Set the font size
   
   //--- SELL BUTTON
   obj_Btn_SELL.Create(0,Btn_SELL,0,40,210,0,0); //--- Create the sell button
   obj_Btn_SELL.Size(100,25); //--- Set the button size
   obj_Btn_SELL.ColorBackground(clrOrangeRed); //--- Set the background color
   obj_Btn_SELL.ColorBorder(clrOrangeRed); //--- Set the border color
   obj_Btn_SELL.Text("Sell"); //--- Set the button text
   obj_Btn_SELL.Color(clrWhite); //--- Set the text color
   obj_Btn_SELL.Font("Calibri bold"); //--- Set the font style
   obj_Btn_SELL.FontSize(14); //--- Set the font size
   
   //--- ENTRY BUTTON
   obj_Btn_ENTRY.Create(0,Btn_ENTRY,0,150,210,0,0); //--- Create the entry button
   obj_Btn_ENTRY.Size(70,25); //--- Set the button size
   obj_Btn_ENTRY.ColorBackground(clrGoldenrod); //--- Set the background color
   obj_Btn_ENTRY.ColorBorder(clrGoldenrod); //--- Set the border color
   obj_Btn_ENTRY.Text("Entry"); //--- Set the button text
   obj_Btn_ENTRY.Color(clrBlack); //--- Set the text color
   obj_Btn_ENTRY.Font("Calibri bold"); //--- Set the font style
   obj_Btn_ENTRY.FontSize(14); //--- Set the font size
   
   //--- BUY BUTTON
   obj_Btn_BUY.Create(0,Btn_BUY,0,40+190,210,0,0); //--- Create the buy button
   obj_Btn_BUY.Size(100,25); //--- Set the button size
   obj_Btn_BUY.ColorBackground(clrLimeGreen); //--- Set the background color
   obj_Btn_BUY.ColorBorder(clrLimeGreen); //--- Set the border color
   obj_Btn_BUY.Text("Buy"); //--- Set the button text
   obj_Btn_BUY.Color(clrWhite); //--- Set the text color
   obj_Btn_BUY.Font("Calibri bold"); //--- Set the font style
   obj_Btn_BUY.FontSize(14); //--- Set the font size
   
   //--- SELL STOP BUTTON
   obj_Btn_SELLSTOP.Create(0,Btn_SELLSTOP,0,40,240,0,0); //--- Create the sell stop button
   obj_Btn_SELLSTOP.Size(140,25); //--- Set the button size
   obj_Btn_SELLSTOP.ColorBackground(clrOrangeRed); //--- Set the background color
   obj_Btn_SELLSTOP.ColorBorder(clrOrangeRed); //--- Set the border color
   obj_Btn_SELLSTOP.Text("Sell Stop"); //--- Set the button text
   obj_Btn_SELLSTOP.Color(clrWhite); //--- Set the text color
   obj_Btn_SELLSTOP.Font("Calibri bold"); //--- Set the font style
   obj_Btn_SELLSTOP.FontSize(14); //--- Set the font size
   
   //--- BUY STOP BUTTON
   obj_Btn_BUYSTOP.Create(0,Btn_BUYSTOP,0,40+190-40,240,0,0); //--- Create the buy stop button
   obj_Btn_BUYSTOP.Size(140,25); //--- Set the button size
   obj_Btn_BUYSTOP.ColorBackground(clrLimeGreen); //--- Set the background color
   obj_Btn_BUYSTOP.ColorBorder(clrLimeGreen); //--- Set the border color
   obj_Btn_BUYSTOP.Text("Buy Stop"); //--- Set the button text
   obj_Btn_BUYSTOP.Color(clrWhite); //--- Set the text color
   obj_Btn_BUYSTOP.Font("Calibri bold"); //--- Set the font style
   obj_Btn_BUYSTOP.FontSize(14); //--- Set the font size
   
   //--- SELL LIMIT BUTTON
   obj_Btn_SELLLIMIT.Create(0,Btn_SELLLIMIT,0,40,270,0,0); //--- Create the sell limit button
   obj_Btn_SELLLIMIT.Size(140,25); //--- Set the button size
   obj_Btn_SELLLIMIT.ColorBackground(clrOrangeRed); //--- Set the background color
   obj_Btn_SELLLIMIT.ColorBorder(clrOrangeRed); //--- Set the border color
   obj_Btn_SELLLIMIT.Text("Sell Limit"); //--- Set the button text
   obj_Btn_SELLLIMIT.Color(clrWhite); //--- Set the text color
   obj_Btn_SELLLIMIT.Font("Calibri bold"); //--- Set the font style
   obj_Btn_SELLLIMIT.FontSize(14); //--- Set the font size
   
   //--- BUY LIMIT BUTTON
   obj_Btn_BUYLIMIT.Create(0,Btn_BUYLIMIT,0,40+190-40,270,0,0); //--- Create the buy limit button
   obj_Btn_BUYLIMIT.Size(140,25); //--- Set the button size
   obj_Btn_BUYLIMIT.ColorBackground(clrLimeGreen); //--- Set the background color
   obj_Btn_BUYLIMIT.ColorBorder(clrLimeGreen); //--- Set the border color
   obj_Btn_BUYLIMIT.Text("Buy Limit"); //--- Set the button text
   obj_Btn_BUYLIMIT.Color(clrWhite); //--- Set the text color
   obj_Btn_BUYLIMIT.Font("Calibri bold"); //--- Set the font style
   obj_Btn_BUYLIMIT.FontSize(14); //--- Set the font size
}

Nach dem Kompilieren erhalten wir die folgende Ausgabe.

Das war ein Erfolg. Wir haben jetzt die notwendige ansprechende Handelsschnittstelle, die wir wollten. Wir müssen nur noch die anderen Ansichten des Navigationsbereichs erstellen und das war's. Zunächst werden wir die abschließende Schnittstelle erstellen und ihre Logik ebenfalls in einer Funktion organisieren. Bevor wir jedoch die Funktionshilfsmittel definieren, müssen wir neben den Objektdeklarationen auch die jeweiligen Namen der Schaltflächen festlegen. Hier ist die Logik der Objektdeklaration.

CButton obj_Btn_CLOSE_ALL;                                  //--- Close All button object
CButton obj_Btn_CLOSE_ALL_SELL;                             //--- Close All Sell button object
CButton obj_Btn_CLOSE_ALL_BUY;                              //--- Close All Buy button object
CButton obj_Btn_CLOSE_LOSS_SELL;                            //--- Close Loss Sell button object
CButton obj_Btn_CLOSE_LOSS_BUY;                             //--- Close Loss Buy button object
CButton obj_Btn_CLOSE_PROFIT_SELL;                          //--- Close Profit Sell button object
CButton obj_Btn_CLOSE_PROFIT_BUY;                           //--- Close Profit Buy button object
CButton obj_Btn_CLOSE_ALL_LOSS;                             //--- Close All Loss button object
CButton obj_Btn_CLOSE_ALL_PROFIT;                           //--- Close All Profit button object
CButton obj_Btn_CLOSE_PENDING;                              //--- Close Pending button object

//--- 

CButton obj_Btn_ACC_NUMBER;                                 //--- Account Number button object
CButton obj_Btn_ACC_NAME;                                   //--- Account Name button object
CButton obj_Btn_ACC_TYPE;                                   //--- Account Type button object
CButton obj_Btn_ACC_LEVERAGE;                               //--- Account Leverage button object

CButton obj_Btn_ACC_EQUITY;                                 //--- Account Equity button object
CButton obj_Btn_ACC_BALANCE;                                //--- Account Balance button object
CButton obj_Btn_TIME;                                       //--- Time button object


//---
CLabel obj_Lbl_ACC_NUMBER;                                  //--- Account Number label object
CLabel obj_Lbl_ACC_NAME;                                    //--- Account Name label object
CLabel obj_Lbl_ACC_TYPE;                                    //--- Account Type label object
CLabel obj_Lbl_ACC_LEVERAGE;                                //--- Account Leverage label object

CLabel obj_Lbl_ACC_EQUITY;                                  //--- Account Equity label object
CLabel obj_Lbl_ACC_BALANCE;                                 //--- Account Balance label object
CLabel obj_Lbl_TIME;                                        //--- Time label object

Hier ist die Logik der Objektdefinition.

#define Btn_CLOSE_ALL "Btn_CLOSE_ALL"                        //--- Button name for closing all trades
#define Btn_CLOSE_ALL_SELL "Btn_CLOSE_ALL_SELL"              //--- Button name for closing all sell trades
#define Btn_CLOSE_ALL_BUY "Btn_CLOSE_ALL_BUY"                //--- Button name for closing all buy trades
#define Btn_CLOSE_LOSS_SELL "Btn_CLOSE_LOSS_SELL"            //--- Button name for closing all loss sell trades
#define Btn_CLOSE_LOSS_BUY "Btn_CLOSE_LOSS_BUY"              //--- Button name for closing all loss buy trades
#define Btn_CLOSE_PROFIT_SELL "Btn_CLOSE_PROFIT_SELL"        //--- Button name for closing all profit sell trades
#define Btn_CLOSE_PROFIT_BUY "Btn_CLOSE_PROFIT_BUY"          //--- Button name for closing all profit buy trades
#define Btn_CLOSE_ALL_LOSS "Btn_CLOSE_ALL_LOSS"              //--- Button name for closing all loss trades
#define Btn_CLOSE_ALL_PROFIT "Btn_CLOSE_ALL_PROFIT"          //--- Button name for closing all profit trades
#define Btn_CLOSE_PENDING "Btn_CLOSE_PENDING"                //--- Button name for closing all pending trades

#define Btn_ACC_NUMBER "Btn_ACC_NUMBER"                      //--- Button name for the account number
#define Btn_ACC_NAME "Btn_ACC_NAME"                          //--- Button name for the account name
#define Btn_ACC_TYPE "Btn_ACC_TYPE"                          //--- Button name for the account type
#define Btn_ACC_LEVERAGE "Btn_ACC_LEVERAGE"                  //--- Button name for the account leverage

#define Btn_ACC_EQUITY "Btn_ACC_EQUITY"                      //--- Button name for the account equity
#define Btn_ACC_BALANCE "Btn_ACC_BALANCE"                    //--- Button name for the account balance
#define Btn_TIME "Btn_TIME"                                  //--- Button name for the time

//---
#define Lbl_ACC_NUMBER "Lbl_ACC_NUMBER"                      //--- Label name for the account number
#define Lbl_ACC_NAME "Lbl_ACC_NAME"                          //--- Label name for the account name
#define Lbl_ACC_TYPE "Lbl_ACC_TYPE"                          //--- Label name for the account type
#define Lbl_ACC_LEVERAGE "Lbl_ACC_LEVERAGE"                  //--- Label name for the account leverage

#define Lbl_ACC_EQUITY "Lbl_ACC_EQUITY"                      //--- Label name for the account equity
#define Lbl_ACC_BALANCE "Lbl_ACC_BALANCE"                    //--- Label name for the account balance
#define Lbl_TIME "Lbl_TIME"                                  //--- Label name for the time

Nachdem wir alle notwendigen Parameter definiert haben, erstellen wir die Schließfunktion wie folgt.

//+------------------------------------------------------------------+
//|      FUNCTION TO CREATE THE CLOSE SECTION                        |
//+------------------------------------------------------------------+
void createSection_Close(){
   //--- CLOSE ALL BUTTON
   obj_Btn_CLOSE_ALL.Create(0, Btn_CLOSE_ALL, 0, 80, 120, 0, 0); //--- Create the close all button
   obj_Btn_CLOSE_ALL.Size(210, 25); //--- Set the button size
   obj_Btn_CLOSE_ALL.ColorBackground(clrPeru); //--- Set the background color
   obj_Btn_CLOSE_ALL.ColorBorder(clrWhite); //--- Set the border color
   obj_Btn_CLOSE_ALL.Text("Close All"); //--- Set the button text
   obj_Btn_CLOSE_ALL.Color(clrBlack); //--- Set the text color
   obj_Btn_CLOSE_ALL.Font("Calibri bold"); //--- Set the font style
   obj_Btn_CLOSE_ALL.FontSize(14); //--- Set the font size
   
   //--- CLOSE ALL SELL BUTTON
   obj_Btn_CLOSE_ALL_SELL.Create(0, Btn_CLOSE_ALL_SELL, 0, 40, 150, 0, 0); //--- Create the close all sell button
   obj_Btn_CLOSE_ALL_SELL.Size(140, 25); //--- Set the button size
   obj_Btn_CLOSE_ALL_SELL.ColorBackground(clrSalmon); //--- Set the background color
   obj_Btn_CLOSE_ALL_SELL.ColorBorder(clrWhite); //--- Set the border color
   obj_Btn_CLOSE_ALL_SELL.Text("Close All Sell"); //--- Set the button text
   obj_Btn_CLOSE_ALL_SELL.Color(clrBlack); //--- Set the text color
   obj_Btn_CLOSE_ALL_SELL.Font("Calibri bold"); //--- Set the font style
   obj_Btn_CLOSE_ALL_SELL.FontSize(14); //--- Set the font size
   
   //--- CLOSE ALL BUY BUTTON
   obj_Btn_CLOSE_ALL_BUY.Create(0, Btn_CLOSE_ALL_BUY, 0, 190, 150, 0, 0); //--- Create the close all buy button
   obj_Btn_CLOSE_ALL_BUY.Size(140, 25); //--- Set the button size
   obj_Btn_CLOSE_ALL_BUY.ColorBackground(clrMediumSeaGreen); //--- Set the background color
   obj_Btn_CLOSE_ALL_BUY.ColorBorder(clrWhite); //--- Set the border color
   obj_Btn_CLOSE_ALL_BUY.Text("Close All Buy"); //--- Set the button text
   obj_Btn_CLOSE_ALL_BUY.Color(clrBlack); //--- Set the text color
   obj_Btn_CLOSE_ALL_BUY.Font("Calibri bold"); //--- Set the font style
   obj_Btn_CLOSE_ALL_BUY.FontSize(14); //--- Set the font size
   
   //--- CLOSE LOSS SELL BUTTON
   obj_Btn_CLOSE_LOSS_SELL.Create(0, Btn_CLOSE_LOSS_SELL, 0, 40, 180, 0, 0); //--- Create the close loss sell button
   obj_Btn_CLOSE_LOSS_SELL.Size(140, 25); //--- Set the button size
   obj_Btn_CLOSE_LOSS_SELL.ColorBackground(clrSalmon); //--- Set the background color
   obj_Btn_CLOSE_LOSS_SELL.ColorBorder(clrWhite); //--- Set the border color
   obj_Btn_CLOSE_LOSS_SELL.Text("Close Loss Sell"); //--- Set the button text
   obj_Btn_CLOSE_LOSS_SELL.Color(clrBlack); //--- Set the text color
   obj_Btn_CLOSE_LOSS_SELL.Font("Calibri bold"); //--- Set the font style
   obj_Btn_CLOSE_LOSS_SELL.FontSize(14); //--- Set the font size
   
   //--- CLOSE LOSS BUY BUTTON
   obj_Btn_CLOSE_LOSS_BUY.Create(0, Btn_CLOSE_LOSS_BUY, 0, 190, 180, 0, 0); //--- Create the close loss buy button
   obj_Btn_CLOSE_LOSS_BUY.Size(140, 25); //--- Set the button size
   obj_Btn_CLOSE_LOSS_BUY.ColorBackground(clrMediumSeaGreen); //--- Set the background color
   obj_Btn_CLOSE_LOSS_BUY.ColorBorder(clrWhite); //--- Set the border color
   obj_Btn_CLOSE_LOSS_BUY.Text("Close Loss Buy"); //--- Set the button text
   obj_Btn_CLOSE_LOSS_BUY.Color(clrBlack); //--- Set the text color
   obj_Btn_CLOSE_LOSS_BUY.Font("Calibri bold"); //--- Set the font style
   obj_Btn_CLOSE_LOSS_BUY.FontSize(14); //--- Set the font size
   
   //--- CLOSE PROFIT SELL BUTTON
   obj_Btn_CLOSE_PROFIT_SELL.Create(0, Btn_CLOSE_PROFIT_SELL, 0, 40, 210, 0, 0); //--- Create the close profit sell button
   obj_Btn_CLOSE_PROFIT_SELL.Size(140, 25); //--- Set the button size
   obj_Btn_CLOSE_PROFIT_SELL.ColorBackground(clrSalmon); //--- Set the background color
   obj_Btn_CLOSE_PROFIT_SELL.ColorBorder(clrWhite); //--- Set the border color
   obj_Btn_CLOSE_PROFIT_SELL.Text("Close Profit Sell"); //--- Set the button text
   obj_Btn_CLOSE_PROFIT_SELL.Color(clrBlack); //--- Set the text color
   obj_Btn_CLOSE_PROFIT_SELL.Font("Calibri bold"); //--- Set the font style
   obj_Btn_CLOSE_PROFIT_SELL.FontSize(14); //--- Set the font size
   
   //--- CLOSE PROFIT BUY BUTTON
   obj_Btn_CLOSE_PROFIT_BUY.Create(0, Btn_CLOSE_PROFIT_BUY, 0, 190, 210, 0, 0); //--- Create the close profit buy button
   obj_Btn_CLOSE_PROFIT_BUY.Size(140, 25); //--- Set the button size
   obj_Btn_CLOSE_PROFIT_BUY.ColorBackground(clrMediumSeaGreen); //--- Set the background color
   obj_Btn_CLOSE_PROFIT_BUY.ColorBorder(clrWhite); //--- Set the border color
   obj_Btn_CLOSE_PROFIT_BUY.Text("Close Profit Buy"); //--- Set the button text
   obj_Btn_CLOSE_PROFIT_BUY.Color(clrBlack); //--- Set the text color
   obj_Btn_CLOSE_PROFIT_BUY.Font("Calibri bold"); //--- Set the font style
   obj_Btn_CLOSE_PROFIT_BUY.FontSize(14); //--- Set the font size
   
   //--- CLOSE ALL LOSS BUTTON
   obj_Btn_CLOSE_ALL_LOSS.Create(0, Btn_CLOSE_ALL_LOSS, 0, 40, 240, 0, 0); //--- Create the close all loss button
   obj_Btn_CLOSE_ALL_LOSS.Size(140, 25); //--- Set the button size
   obj_Btn_CLOSE_ALL_LOSS.ColorBackground(clrSalmon); //--- Set the background color
   obj_Btn_CLOSE_ALL_LOSS.ColorBorder(clrWhite); //--- Set the border color
   obj_Btn_CLOSE_ALL_LOSS.Text("CLOSE LOSS"); //--- Set the button text
   obj_Btn_CLOSE_ALL_LOSS.Color(clrBlack); //--- Set the text color
   obj_Btn_CLOSE_ALL_LOSS.Font("Calibri bold"); //--- Set the font style
   obj_Btn_CLOSE_ALL_LOSS.FontSize(14); //--- Set the font size
   
   //--- CLOSE ALL PROFIT BUTTON
   obj_Btn_CLOSE_ALL_PROFIT.Create(0, Btn_CLOSE_ALL_PROFIT, 0, 190, 240, 0, 0); //--- Create the close all profit button
   obj_Btn_CLOSE_ALL_PROFIT.Size(140, 25); //--- Set the button size
   obj_Btn_CLOSE_ALL_PROFIT.ColorBackground(clrMediumSeaGreen); //--- Set the background color
   obj_Btn_CLOSE_ALL_PROFIT.ColorBorder(clrWhite); //--- Set the border color
   obj_Btn_CLOSE_ALL_PROFIT.Text("CLOSE PROFIT"); //--- Set the button text
   obj_Btn_CLOSE_ALL_PROFIT.Color(clrBlack); //--- Set the text color
   obj_Btn_CLOSE_ALL_PROFIT.Font("Calibri bold"); //--- Set the font style
   obj_Btn_CLOSE_ALL_PROFIT.FontSize(14); //--- Set the font size
   
   //--- CLOSE ALL PENDING BUTTON
   obj_Btn_CLOSE_PENDING.Create(0, Btn_CLOSE_PENDING, 0, 80, 270, 0, 0); //--- Create the close all pending button
   obj_Btn_CLOSE_PENDING.Size(210, 25); //--- Set the button size
   obj_Btn_CLOSE_PENDING.ColorBackground(clrPeru); //--- Set the background color
   obj_Btn_CLOSE_PENDING.ColorBorder(clrWhite); //--- Set the border color
   obj_Btn_CLOSE_PENDING.Text("Close All Pending"); //--- Set the button text
   obj_Btn_CLOSE_PENDING.Color(clrBlack); //--- Set the text color
   obj_Btn_CLOSE_PENDING.Font("Calibri bold"); //--- Set the font style
   obj_Btn_CLOSE_PENDING.FontSize(14); //--- Set the font size
}

In der Ereignisbehandlung der Initialisierung können wir die Logik des Funktionsaufrufs für den Handelsabschnitt auskommentieren und den Abschlussabschnitt über den Funktionsaufruf ausführen. Wir erreichen dies, indem wir die Funktion auskommentieren, anstatt sie zu löschen, da wir sie später wieder verwenden müssen.

   // BODY OF THE PANEL
   //createSection_Trade(); //--- Call function to create the trade section
   createSection_Close(); //--- Call function to create the close section

Nach der Ausführung des Programms erhalten wir die folgende Ausgabe.

Das war ein Erfolg. Nun können wir mit der Erstellung des letzten Abschnitts fortfahren, in dem die Informationen über das Handelskonto angezeigt werden. Hierfür verwenden wir ebenfalls eine Funktion. 

//+------------------------------------------------------------------+
//|        FUNCTION TO CREATE THE INFO SECTION                       |
//+------------------------------------------------------------------+
void createSection_Information() {
   //--- Create Account Number Label
   obj_Lbl_ACC_NUMBER.Create(0, Lbl_ACC_NUMBER, 0, 40, 100, 0, 0); //--- Initialize label for Account Number
   obj_Lbl_ACC_NUMBER.Text("Account Number"); //--- Set label text to "Account Number"
   obj_Lbl_ACC_NUMBER.Color(clrWhite); //--- Set label color to white
   obj_Lbl_ACC_NUMBER.Font("Calibri bold"); //--- Set label font to Calibri bold
   obj_Lbl_ACC_NUMBER.FontSize(14); //--- Set label font size to 14

   //--- Create Account Number Button
   obj_Btn_ACC_NUMBER.Create(0, Btn_ACC_NUMBER, 0, 40 + 140, 100 + 2, 0, 0); //--- Initialize button for Account Number
   obj_Btn_ACC_NUMBER.Size(150, 20); //--- Set button size to 150x20
   obj_Btn_ACC_NUMBER.ColorBackground(clrGainsboro); //--- Set button background color to Gainsboro
   obj_Btn_ACC_NUMBER.ColorBorder(clrWhite); //--- Set button border color to white
   obj_Btn_ACC_NUMBER.Text(IntegerToString(AccountInfoInteger(ACCOUNT_LOGIN))); //--- Set button text with account number
   obj_Btn_ACC_NUMBER.Color(clrBlack); //--- Set button text color to black
   obj_Btn_ACC_NUMBER.Font("Calibri bold"); //--- Set button font to Calibri bold
   obj_Btn_ACC_NUMBER.FontSize(13); //--- Set button font size to 13

}

Auch bei der Erstellung des Informationsteils verwenden wir ein ähnliches Format. Beim Einstellen des Textes verwenden wir jedoch einige zusätzliche Funktionen, deren Wesen wir hier erläutern möchten. Die Linie ist zur besseren Übersichtlichkeit gelb hervorgehoben. Wir verwenden eine Kombination aus den Funktionen AccountInfoInteger und IntegerToString, um den Text der Schaltfläche „obj_Btn_ACC_NUMBER“ so einzustellen, dass die Kontonummer angezeigt wird.

Wir verwenden die Funktion AccountInfoInteger, um die spezifischen Kontoinformationen auf der Grundlage des angegebenen Parameters abzurufen. In diesem Fall ist der Parameter „ACCOUNT_LOGIN“, der die Funktion anweist, die Login-Nummer des Kontos vom MetaTrader-Terminal zu erhalten. Diese Anmeldenummer wird als Ganzzahlwert zurückgegeben.

Anschließend wird die Funktion IntegerToString angewendet, um diesen Integer-Wert in eine Zeichenkette umzuwandeln. Dies ist notwendig, weil die „Text“-Methode der Schaltfläche erfordert, dass der Wert in einem String-Format für die ordnungsgemäße Anzeige sein. Ohne diese Umwandlung würde die Schaltfläche die Kontonummer nicht korrekt wiedergeben können. In einem ähnlichen Format legen wir die Schaltflächen für den Kontonamen und den Typ fest.

   //--- Create Account Name Label
   obj_Lbl_ACC_NAME.Create(0, Lbl_ACC_NAME, 0, 40, 125, 0, 0); //--- Initialize label for Account Name
   obj_Lbl_ACC_NAME.Text("Account Name"); //--- Set label text to "Account Name"
   obj_Lbl_ACC_NAME.Color(clrWhite); //--- Set label color to white
   obj_Lbl_ACC_NAME.Font("Calibri bold"); //--- Set label font to Calibri bold
   obj_Lbl_ACC_NAME.FontSize(14); //--- Set label font size to 14

   //--- Create Account Name Button
   obj_Btn_ACC_NAME.Create(0, Btn_ACC_NAME, 0, 40 + 120, 125 + 2, 0, 0); //--- Initialize button for Account Name
   obj_Btn_ACC_NAME.Size(170, 20); //--- Set button size to 170x20
   obj_Btn_ACC_NAME.ColorBackground(clrGainsboro); //--- Set button background color to Gainsboro
   obj_Btn_ACC_NAME.ColorBorder(clrWhite); //--- Set button border color to white
   obj_Btn_ACC_NAME.Text(AccountInfoString(ACCOUNT_SERVER)); //--- Set button text with account server name
   obj_Btn_ACC_NAME.Color(clrBlack); //--- Set button text color to black
   obj_Btn_ACC_NAME.Font("Calibri bold"); //--- Set button font to Calibri bold
   obj_Btn_ACC_NAME.FontSize(13); //--- Set button font size to 13

   //--- Create Account Type Label
   obj_Lbl_ACC_TYPE.Create(0, Lbl_ACC_TYPE, 0, 40, 150, 0, 0); //--- Initialize label for Account Type
   obj_Lbl_ACC_TYPE.Text("Account Type"); //--- Set label text to "Account Type"
   obj_Lbl_ACC_TYPE.Color(clrWhite); //--- Set label color to white
   obj_Lbl_ACC_TYPE.Font("Calibri bold"); //--- Set label font to Calibri bold
   obj_Lbl_ACC_TYPE.FontSize(14); //--- Set label font size to 14

   //--- Create Account Type Button
   obj_Btn_ACC_TYPE.Create(0, Btn_ACC_TYPE, 0, 40 + 110, 150 + 2, 0, 0); //--- Initialize button for Account Type
   obj_Btn_ACC_TYPE.Size(180, 20); //--- Set button size to 180x20
   obj_Btn_ACC_TYPE.ColorBackground(clrGainsboro); //--- Set button background color to Gainsboro
   obj_Btn_ACC_TYPE.ColorBorder(clrWhite); //--- Set button border color to white
   ENUM_ACCOUNT_TRADE_MODE account_type = (ENUM_ACCOUNT_TRADE_MODE)AccountInfoInteger(ACCOUNT_TRADE_MODE); //--- Retrieve account type
   string trade_mode; //--- Initialize variable for trade mode description
   switch (account_type) { //--- Determine account type
      case ACCOUNT_TRADE_MODE_DEMO: trade_mode = "Demo Account"; break; //--- Set trade_mode for Demo account
      case ACCOUNT_TRADE_MODE_CONTEST: trade_mode = "Contest Account"; break; //--- Set trade_mode for Contest account
      default: trade_mode = "Real Account"; break; //--- Set trade_mode for Real account
   }
   obj_Btn_ACC_TYPE.Text(trade_mode); //--- Set button text to account type description
   obj_Btn_ACC_TYPE.Color(clrBlack); //--- Set button text color to black
   obj_Btn_ACC_TYPE.Font("Calibri bold"); //--- Set button font to Calibri bold
   obj_Btn_ACC_TYPE.FontSize(13); //--- Set button font size to 13

Hier legen wir die Schaltflächen für den Kontonamen und den Typ fest. Wir verwenden jedoch eine etwas komplexere Logik, um die Kontoart zu ermitteln, da es keine direkte Methode gibt, die Kontoart direkt zu ermitteln. Die Logik ist zur Verdeutlichung nochmals gelb hervorgehoben. Wir beginnen mit der Definition einer Variablen namens „account_type“ vom Aufzählungstyp ENUM_ACCOUNT_TRADE_MODE. Hierbei handelt es sich um einen enumerierten Datentyp, der speziell dafür entwickelt wurde, verschiedene Kontomodi, wie z. B. Demo-, Wettbewerbs- oder Realkonto, zu speichern. Anschließend weisen wir ihm mit der Funktion „AccountInfoInteger“ einen Wert zu, und zwar mit dem Parameter ACCOUNT_TRADE_MODE. Diese Funktion ruft den aktuellen Handelsmodus des Kontos als Enumerationswert ab.

Als Nächstes deklarieren wir eine String-Variable mit dem Namen „trade_mode“, die eine beschreibende Bezeichnung für die Art des Kontos enthält. Dann verwenden wir eine switch-Anweisung, um den Kontotyp zu bestimmen, indem wir den Wert von „account_type“ überprüfen. Diese switch-Anweisung hat drei Fälle:

• „ACCOUNT_TRADE_MODE_DEMO“ (Demo): Wenn das Konto ein Demokonto ist, wird „trade_mode“ auf „Demo Account“ gesetzt.
• „ACCOUNT_TRADE_MODE_CONTEST“ (Wettbewerb): Wenn das Konto in einem Wettbewerb verwendet wird, wird „trade_mode“ auf „Contest Account“ gesetzt.
• Standardfall: Für jeden anderen Typ (in der Regel ein Real-Konto) wird „trade_mode“ auf „Real Account“ gesetzt.

Schließlich rufen wir die Methode „Text“ für die Schaltfläche „obj_Btn_ACC_TYPE“ auf und übergeben die Zeichenfolge „trade_mode“. Dadurch wird der Text der Schaltfläche so aktualisiert, dass der beschreibende Kontotyp angezeigt wird. Von hier aus werden die übrigen Dienstprogramme in einem ähnlichen Format wie folgt definiert.

   //--- Create Account Leverage Label
   obj_Lbl_ACC_LEVERAGE.Create(0, Lbl_ACC_LEVERAGE, 0, 40, 175, 0, 0); //--- Initialize label for Account Leverage
   obj_Lbl_ACC_LEVERAGE.Text("Account Leverage"); //--- Set label text to "Account Leverage"
   obj_Lbl_ACC_LEVERAGE.Color(clrWhite); //--- Set label color to white
   obj_Lbl_ACC_LEVERAGE.Font("Calibri bold"); //--- Set label font to Calibri bold
   obj_Lbl_ACC_LEVERAGE.FontSize(14); //--- Set label font size to 14

   //--- Create Account Leverage Button
   obj_Btn_ACC_LEVERAGE.Create(0, Btn_ACC_LEVERAGE, 0, 40 + 150, 175 + 2, 0, 0); //--- Initialize button for Account Leverage
   obj_Btn_ACC_LEVERAGE.Size(140, 20); //--- Set button size to 140x20
   obj_Btn_ACC_LEVERAGE.ColorBackground(clrGainsboro); //--- Set button background color to Gainsboro
   obj_Btn_ACC_LEVERAGE.ColorBorder(clrWhite); //--- Set button border color to white
   obj_Btn_ACC_LEVERAGE.Text(IntegerToString(AccountInfoInteger(ACCOUNT_LEVERAGE))); //--- Set button text with account leverage
   obj_Btn_ACC_LEVERAGE.Color(clrBlack); //--- Set button text color to black
   obj_Btn_ACC_LEVERAGE.Font("Calibri bold"); //--- Set button font to Calibri bold
   obj_Btn_ACC_LEVERAGE.FontSize(13); //--- Set button font size to 13

   //--- Create Account Equity Label
   obj_Lbl_ACC_EQUITY.Create(0, Lbl_ACC_EQUITY, 0, 40, 220, 0, 0); //--- Initialize label for Account Equity
   obj_Lbl_ACC_EQUITY.Text("Account Equity"); //--- Set label text to "Account Equity"
   obj_Lbl_ACC_EQUITY.Color(clrAqua); //--- Set label color to Aqua
   obj_Lbl_ACC_EQUITY.Font("Cooper Black"); //--- Set label font to Cooper Black
   obj_Lbl_ACC_EQUITY.FontSize(14); //--- Set label font size to 14

   //--- Create Account Equity Button
   obj_Btn_ACC_EQUITY.Create(0, Btn_ACC_EQUITY, 0, 40 + 170, 220 + 2, 0, 0); //--- Initialize button for Account Equity
   obj_Btn_ACC_EQUITY.Size(120, 20); //--- Set button size to 120x20
   obj_Btn_ACC_EQUITY.ColorBackground(clrBlack); //--- Set button background color to black
   obj_Btn_ACC_EQUITY.ColorBorder(clrBlanchedAlmond); //--- Set button border color to Blanched Almond
   obj_Btn_ACC_EQUITY.Text(DoubleToString(AccountInfoDouble(ACCOUNT_EQUITY), 2)); //--- Set button text with account equity
   obj_Btn_ACC_EQUITY.Color(clrWhite); //--- Set button text color to white
   obj_Btn_ACC_EQUITY.Font("Times new roman bold"); //--- Set button font to Times New Roman bold
   obj_Btn_ACC_EQUITY.FontSize(13); //--- Set button font size to 13

   //--- Create Account Balance Label
   obj_Lbl_ACC_BALANCE.Create(0, Lbl_ACC_BALANCE, 0, 40, 245, 0, 0); //--- Initialize label for Account Balance
   obj_Lbl_ACC_BALANCE.Text("Account Balance"); //--- Set label text to "Account Balance"
   obj_Lbl_ACC_BALANCE.Color(clrAqua); //--- Set label color to Aqua
   obj_Lbl_ACC_BALANCE.Font("Cooper Black"); //--- Set label font to Cooper Black
   obj_Lbl_ACC_BALANCE.FontSize(14); //--- Set label font size to 14

   //--- Create Account Balance Button
   obj_Btn_ACC_BALANCE.Create(0, Btn_ACC_BALANCE, 0, 40 + 170, 245 + 2, 0, 0); //--- Initialize button for Account Balance
   obj_Btn_ACC_BALANCE.Size(120, 20); //--- Set button size to 120x20
   obj_Btn_ACC_BALANCE.ColorBackground(clrBlack); //--- Set button background color to black
   obj_Btn_ACC_BALANCE.ColorBorder(clrBlanchedAlmond); //--- Set button border color to Blanched Almond
   obj_Btn_ACC_BALANCE.Text(DoubleToString(AccountInfoDouble(ACCOUNT_BALANCE), 2)); //--- Set button text with account balance
   obj_Btn_ACC_BALANCE.Color(clrWhite); //--- Set button text color to white
   obj_Btn_ACC_BALANCE.Font("Times new roman bold"); //--- Set button font to Times New Roman bold
   obj_Btn_ACC_BALANCE.FontSize(13); //--- Set button font size to 13

   //--- Create Server Time Label
   obj_Lbl_TIME.Create(0, Lbl_TIME, 0, 40, 270, 0, 0); //--- Initialize label for Server Time
   obj_Lbl_TIME.Text("Server Time"); //--- Set label text to "Server Time"
   obj_Lbl_TIME.Color(clrLime); //--- Set label color to Lime
   obj_Lbl_TIME.Font("Cooper Black"); //--- Set label font to Cooper Black
   obj_Lbl_TIME.FontSize(14); //--- Set label font size to 14

   //--- Create Server Time Button
   obj_Btn_TIME.Create(0, Btn_TIME, 0, 40 + 120, 270 + 2, 0, 0); //--- Initialize button for Server Time
   obj_Btn_TIME.Size(170, 20); //--- Set button size to 170x20
   obj_Btn_TIME.ColorBackground(clrBlack); //--- Set button background color to black
   obj_Btn_TIME.ColorBorder(clrBlanchedAlmond); //--- Set button border color to Blanched Almond
   obj_Btn_TIME.Text(TimeToString(TimeTradeServer(), TIME_DATE | TIME_SECONDS)); //--- Set button text with server time
   obj_Btn_TIME.Color(clrWhite); //--- Set button text color to white
   obj_Btn_TIME.Font("Times new roman bold"); //--- Set button font to Times New Roman bold
   obj_Btn_TIME.FontSize(13); //--- Set button font size to 13

Das ist alles. Um die Auswirkungen der Änderung zu überprüfen, müssen wir die Funktion in der Initialisierungsphase aufrufen und die anderen Aufrufe der Navigationsfunktion auskommentieren. Dies ist wie unten dargestellt.

   // BODY OF THE PANEL
   //createSection_Trade(); //--- Call function to create the trade section
   //createSection_Close(); //--- Call function to create the close section
   createSection_Information(); //--- Call function to create the information section

Nach dem Kompilieren und Ausführen des Programms erhalten wir die folgende Ausgabe.

Wir haben jetzt alle Komponenten, die wir für die Schalttafel benötigen. Wir können nun wieder auf die ursprüngliche Schnittstelle für Handelsaktivitäten zurückgreifen, da sie diejenige ist, deren Schaltfläche aktiv ist. Wir werden daher die Funktionen für die Abschnitte „Close“ und „Information“ auskommentieren, aber wir werden sie später bei Bedarf benötigen, nämlich dann, wenn ihre jeweiligen Ansichtsfelder benötigt werden. Der endgültige Initialisierungscode, der für die Erstellung der Panel-Oberfläche verantwortlich ist, lautet also wie folgt:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit() {
   //--- Start of the initialization function

   //--- MAIN BUTTON
   obj_Btn_MAIN.Create(0, Btn_MAIN, 0, 30, 30, 0, 0); //--- Create the main button at specified coordinates
   //obj_Btn_MAIN.Width(310); //--- (Commented out) Set width of the main button
   //obj_Btn_MAIN.Height(300); //--- (Commented out) Set height of the main button
   obj_Btn_MAIN.Size(310, 300); //--- Set size of the main button
   obj_Btn_MAIN.ColorBackground(C'070,070,070'); //--- Set background color of the main button
   obj_Btn_MAIN.ColorBorder(clrBlack); //--- Set border color of the main button

   //--- HEADER BUTTON 
   obj_Btn_HEADER.Create(0, Btn_HEADER, 0, 30, 30, 0, 0); //--- Create the header button at specified coordinates
   obj_Btn_HEADER.Size(310, 25); //--- Set size of the header button
   obj_Btn_HEADER.ColorBackground(clrLightBlue); //--- Set background color of the header button
   obj_Btn_HEADER.ColorBorder(clrBlack); //--- Set border color of the header button

   //--- X BUTTON
   obj_Btn_X.Create(0, Btn_X, 0, 30 + 280, 30 + 1, 0, 0); //--- Create the close button (X) at specified coordinates
   obj_Btn_X.Size(30 - 1, 25 - 1 - 1); //--- Set size of the close button
   obj_Btn_X.ColorBackground(clrLightBlue); //--- Set background color of the close button
   obj_Btn_X.ColorBorder(clrLightBlue); //--- Set border color of the close button
   obj_Btn_X.Text(CharToString(255)); //--- Set the close button text to an "X" character
   obj_Btn_X.Color(clrBlack); //--- Set text color of the close button
   obj_Btn_X.Font("Wingdings"); //--- Set font of the close button to Wingdings
   obj_Btn_X.FontSize(17); //--- Set font size of the close button

   //--- HEADER LABEL
   obj_Lbl_HEADER.Create(0, Lbl_HEADER, 0, 40, 30, 0, 0); //--- Create the header label at specified coordinates
   obj_Lbl_HEADER.Text("Control Panel"); //--- Set text of the header label
   obj_Lbl_HEADER.Color(clrRed); //--- Set text color of the header label
   obj_Lbl_HEADER.Font("Cooper black"); //--- Set font of the header label to Cooper Black
   obj_Lbl_HEADER.FontSize(14); //--- Set font size of the header label
   
   //--- TRADE BUTTON
   obj_Btn_TRADE.Create(0, Btn_TRADE, 0, 40, 60, 0, 0); //--- Create the trade button at specified coordinates
   obj_Btn_TRADE.Size(90, 30); //--- Set size of the trade button
   obj_Btn_TRADE.ColorBackground(clrYellow); //--- Set background color of the trade button
   obj_Btn_TRADE.ColorBorder(clrYellow); //--- Set border color of the trade button
   obj_Btn_TRADE.Text("Trade"); //--- Set text of the trade button
   obj_Btn_TRADE.Color(clrBlack); //--- Set text color of the trade button
   obj_Btn_TRADE.Font("Arial Black"); //--- Set font of the trade button to Arial Black
   obj_Btn_TRADE.FontSize(13); //--- Set font size of the trade button
   
   //--- CLOSE BUTTON
   obj_Btn_CLOSE.Create(0, Btn_CLOSE, 0, 40 + obj_Btn_TRADE.Width() + 10, 60, 0, 0); //--- Create the close button at specified coordinates
   obj_Btn_CLOSE.Size(90, 30); //--- Set size of the close button
   obj_Btn_CLOSE.ColorBackground(clrSilver); //--- Set background color of the close button
   obj_Btn_CLOSE.ColorBorder(clrSilver); //--- Set border color of the close button
   obj_Btn_CLOSE.Text("Close"); //--- Set text of the close button
   obj_Btn_CLOSE.Color(clrBlack); //--- Set text color of the close button
   obj_Btn_CLOSE.Font("Arial Black"); //--- Set font of the close button to Arial Black
   obj_Btn_CLOSE.FontSize(13); //--- Set font size of the close button

   //--- INFO BUTTON
   obj_Btn_INFO.Create(0, Btn_INFO, 0, 40 + obj_Btn_TRADE.Width() + 10 + obj_Btn_CLOSE.Width() + 10, 60, 0, 0); //--- Create the info button at specified coordinates
   obj_Btn_INFO.Size(90, 30); //--- Set size of the info button
   obj_Btn_INFO.ColorBackground(clrSilver); //--- Set background color of the info button
   obj_Btn_INFO.ColorBorder(clrSilver); //--- Set border color of the info button
   obj_Btn_INFO.Text("Inform'n"); //--- Set text of the info button
   obj_Btn_INFO.Color(clrBlack); //--- Set text color of the info button
   obj_Btn_INFO.Font("Arial Black"); //--- Set font of the info button to Arial Black
   obj_Btn_INFO.FontSize(13); //--- Set font size of the info button
   
   // BODY OF THE PANEL
   createSection_Trade(); //--- Call function to create the trade section
   //createSection_Close(); //--- (Commented out) Call function to create the close section
   //createSection_Information(); //--- (Commented out) Call function to create the information section

   //--- FOOTER BUTTON
   obj_Btn_FOOTER.Create(0, Btn_FOOTER, 0, 30 + 1, 305 - 1, 0, 0); //--- Create the footer button at specified coordinates
   obj_Btn_FOOTER.Size(310 - 1 - 1, 25); //--- Set size of the footer button
   obj_Btn_FOOTER.ColorBackground(C'070,070,070'); //--- Set background color of the footer button
   obj_Btn_FOOTER.ColorBorder(C'070,070,070'); //--- Set border color of the footer button
   obj_Btn_FOOTER.Text(ShortToString(0x23F0) + "https://t.me/Forex_Algo_Trader"); //--- Set text of the footer button with a link
   obj_Btn_FOOTER.Color(clrWhite); //--- Set text color of the footer button
   obj_Btn_FOOTER.Font("Calibri bold italic"); //--- Set font of the footer button to Calibri bold italic
   obj_Btn_FOOTER.FontSize(12); //--- Set font size of the footer button

   ChartRedraw(0); //--- Redraw the chart to update the panel

   //--- End of initialization function
   return(INIT_SUCCEEDED); //--- Return initialization success status
}

Die endgültige Ausgabe des Meilensteins lautet wie folgt:

Obwohl wir die notwendigen Komponenten erstellt haben, müssen wir jede Komponente, die wir erstellt haben, wieder loswerden, sobald wir das Programm aus dem Chart entfernen. Das geht am besten, indem wir für jeden Abschnitt, den wir erstellt haben, Funktionen erstellen, mit denen die Abschnitte gleichzeitig entfernt und wiederverwendet werden können. Wir wollen ordentlich sein. Nehmen wir das Beispiel eines Gebäudeabbruchs: Es ist sinnvoll, zuerst die Fassade zu entfernen, dann die Zwischenwände und dann die oberen Stockwerke, bevor man sich dem Fundament zuwendet. Ja, jeder könnte damit anfangen, aber es ist professioneller, Dinge professionell zu tun. Wetten, dass Sie zustimmen. Die Funktionen sind wie folgt:

//--- Function to destroy main panel objects
void destroySection_Main_Panel() {
   obj_Btn_MAIN.Destroy(); //--- Destroy the main button
   obj_Btn_HEADER.Destroy(); //--- Destroy the header button
   obj_Btn_X.Destroy(); //--- Destroy the close (X) button
   obj_Lbl_HEADER.Destroy(); //--- Destroy the header label
   obj_Btn_TRADE.Destroy(); //--- Destroy the trade section button
   obj_Btn_CLOSE.Destroy(); //--- Destroy the close section button
   obj_Btn_INFO.Destroy(); //--- Destroy the information section button
   obj_Btn_FOOTER.Destroy(); //--- Destroy the footer button
}

//--- Function to destroy trade section objects
void destroySection_Trade() {
   obj_Btn_RISK.Destroy(); //--- Destroy the risk button
   obj_Edit_RISK.Destroy(); //--- Destroy the risk input field
   obj_Lbl_PRICE.Destroy(); //--- Destroy the price label
   obj_Edit_PRICE.Destroy(); //--- Destroy the price input field
   obj_Lbl_LOTS.Destroy(); //--- Destroy the lot size label
   obj_Edit_LOTS.Destroy(); //--- Destroy the lot size input field
   obj_Lbl_SL.Destroy(); //--- Destroy the stop loss label
   obj_Edit_SL.Destroy(); //--- Destroy the stop loss input field
   obj_Lbl_TP.Destroy(); //--- Destroy the take profit label
   obj_Edit_TP.Destroy(); //--- Destroy the take profit input field
   obj_Btn_POINTS.Destroy(); //--- Destroy the points button
   obj_Btn_SELL.Destroy(); //--- Destroy the sell button
   obj_Btn_ENTRY.Destroy(); //--- Destroy the entry button
   obj_Btn_BUY.Destroy(); //--- Destroy the buy button
   obj_Btn_SELLSTOP.Destroy(); //--- Destroy the sell stop button
   obj_Btn_BUYSTOP.Destroy(); //--- Destroy the buy stop button
   obj_Btn_SELLLIMIT.Destroy(); //--- Destroy the sell limit button
   obj_Btn_BUYLIMIT.Destroy(); //--- Destroy the buy limit button
}

//--- Function to destroy close section objects
void destroySection_Close() {
   obj_Btn_CLOSE_ALL.Destroy(); //--- Destroy the button to close all positions
   obj_Btn_CLOSE_ALL_SELL.Destroy(); //--- Destroy the button to close all sell positions
   obj_Btn_CLOSE_ALL_BUY.Destroy(); //--- Destroy the button to close all buy positions
   obj_Btn_CLOSE_LOSS_SELL.Destroy(); //--- Destroy the button to close losing sell positions
   obj_Btn_CLOSE_LOSS_BUY.Destroy(); //--- Destroy the button to close losing buy positions
   obj_Btn_CLOSE_PROFIT_SELL.Destroy(); //--- Destroy the button to close profitable sell positions
   obj_Btn_CLOSE_PROFIT_BUY.Destroy(); //--- Destroy the button to close profitable buy positions
   obj_Btn_CLOSE_ALL_LOSS.Destroy(); //--- Destroy the button to close all losing positions
   obj_Btn_CLOSE_ALL_PROFIT.Destroy(); //--- Destroy the button to close all profitable positions
   obj_Btn_CLOSE_PENDING.Destroy(); //--- Destroy the button to close pending orders
}

//--- Function to destroy information section objects
void destroySection_Information() {
   obj_Lbl_ACC_NUMBER.Destroy(); //--- Destroy the account number label
   obj_Btn_ACC_NUMBER.Destroy(); //--- Destroy the account number button
   obj_Lbl_ACC_NAME.Destroy(); //--- Destroy the account name label
   obj_Btn_ACC_NAME.Destroy(); //--- Destroy the account name button
   obj_Lbl_ACC_TYPE.Destroy(); //--- Destroy the account type label
   obj_Btn_ACC_TYPE.Destroy(); //--- Destroy the account type button
   obj_Lbl_ACC_LEVERAGE.Destroy(); //--- Destroy the account leverage label
   obj_Btn_ACC_LEVERAGE.Destroy(); //--- Destroy the account leverage button
   obj_Lbl_ACC_EQUITY.Destroy(); //--- Destroy the account equity label
   obj_Btn_ACC_EQUITY.Destroy(); //--- Destroy the account equity button
   obj_Lbl_ACC_BALANCE.Destroy(); //--- Destroy the account balance label
   obj_Btn_ACC_BALANCE.Destroy(); //--- Destroy the account balance button
   obj_Lbl_TIME.Destroy(); //--- Destroy the server time label
   obj_Btn_TIME.Destroy(); //--- Destroy the server time button
}

Hier verwenden wir einfach die entsprechenden Objekte und rufen die „Destroy“-Methode auf, um die spezifischen Elemente loszuwerden. Danach rufen wir die Funktionen von OnDeinit auf.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
   //--- Start of the deinitialization function

   destroySection_Main_Panel(); //--- Call function to destroy the main panel section
   destroySection_Trade(); //--- Call function to destroy the trade section
   destroySection_Close(); //--- Call function to destroy the close section
   destroySection_Information(); //--- Call function to destroy the information section
   
   ChartRedraw(0);
   
   //--- End of deinitialization function
}

Das war ein Erfolg. Wir haben das gewünschte Panel mit den entsprechenden Navigationsschaltflächen und Hauptteil-Komponenten erstellt. Damit ist das Ziel dieses ersten Teils der Artikelserie erreicht. Jetzt müssen wir dafür sorgen, dass die Schaltflächen lebendig sind und auf Klicks und automatische Aktualisierungen reagieren, wenn dies erforderlich ist, was in den folgenden Abschnitten geschehen wird.

Schlussfolgerung

In diesem Artikel haben wir uns auf die Einrichtung der grundlegenden Struktur für die Erstellung eines interaktiven MetaQuotes Language 5 (MQL5) Dashboard-Panels unter Verwendung der Klasse „Controls“ konzentriert. Wir haben die schrittweise Erstellung wesentlicher Komponenten wie Schaltflächen, Beschriftungen und Bearbeitungsfelder behandelt und dabei sichergestellt, dass jedes Element klar definiert und visuell gestaltet ist. Außerdem haben wir hervorgehoben, wie Sie Text, Farben und Größen anpassen können, um ein professionelles und kohärentes Erscheinungsbild für das Panel zu schaffen. Durch diesen strukturierten Ansatz haben wir den Kern einer voll funktionsfähigen Schnittstelle geschaffen, die je nach den spezifischen Handelsanforderungen erweitert und angepasst werden kann.

Im nächsten Teil werden wir dieses Panel durch das Hinzufügen von Reaktionsfähigkeit und Interaktivität verbessern, sodass es in der Lage ist, dynamisch auf Nutzereingaben und Handelsaktionen in MetaTrader 5 zu reagieren. Wir werden untersuchen, wie man Schaltflächenklick-Ereignisse programmiert, Echtzeit-Datenaktualisierungen verwaltet und Feedback-Mechanismen implementiert, um die Nutzerfreundlichkeit des Panels zu verbessern. Dieses Upgrade wird die derzeitige statische Schnittstelle in einen leistungsstarken Echtzeit-Handelsassistenten verwandeln, der ein nahtloses Handelserlebnis bietet. Bleiben Sie am Ball.