Einführung in MQL5 (Teil 34): Beherrschung der API- und WebRequest-Funktion in MQL5 (VIII)

Einführung

Willkommen zurück zu Teil 34 der Serie „Einführung in MQL5!“ Im vorherigen Artikel haben wir uns mit den Grundlagen des Sendens von API-Anfragen von MetaTrader 5 an Google Generative AI beschäftigt. Wir haben uns die Struktur von Anfragen, den Empfang von Antworten und die Funktionsweise der WebRequest-Funktion angesehen. Zu diesem Zeitpunkt gab es keinen direkten Kontakt mit dem Chart selbst; die gesamte Kommunikation mit der KI erfolgte über einen Code. 

In diesem Artikel werden wir ein interaktives Kontrollpanel direkt auf dem MetaTrader 5-Chart entwickeln, was einen praktischen Fortschritt darstellt. Dieses Panel ermöglicht es den Nutzern, eine Anfrage einzugeben, sie an die KI zu senden und das Ergebnis im Terminal anzuzeigen. Da wir uns in dieser Serie noch nicht mit grafischen Panels in MQL5 befasst haben, werden wir die grundlegenden Konzepte vorstellen, die zur Erstellung und Verwaltung dieser Panels erforderlich sind. Wir werden uns jedoch nicht eingehend mit der Entwicklung von grafischen Oberflächen befassen. Wir werden nur die für dieses Projekt erforderlichen Panel-Funktionen besprechen, da sich dieser Artikel in erster Linie auf APIs und die WebRequest-Funktion in MQL5 konzentriert.

In diesem Artikel verfolgen wir einen projektbezogenen Ansatz. Anstatt die Konzepte der Schalttafeln isoliert zu lernen, werden Sie sehen, wie jedes Teil für einen echten Zweck eingesetzt wird. Wir werden uns ansehen, wie man Schaltflächen, Eingabefelder und ein einfaches Panel erstellt. Im nächsten Artikel werden wir die Backend-Logik im Detail erläutern, u. a. wie die Schaltfläche „Senden“ über Chartereignisse behandelt wird, wie Nutzereingaben aufgezeichnet werden und wie die Serverantwort verarbeitet und dargestellt wird.

Erstellen eines Kontrollpanels in MQL5

Wir werden in diesem Teil nicht auf jeden Aspekt der grafischen Nutzeroberflächen von MQL5 eingehen. Ziel dieses Artikels ist es nicht, Sie zu einem Experten für die Erstellung von Nutzeroberflächen zu machen, sondern er konzentriert sich auf APIs und die WebRequest-Funktion. Da diese Reihe jedoch projektbasiert ist und wir bisher noch keine grafischen Tafeln verwendet haben, ist es wichtig, die grundlegenden Ideen darzulegen, die zur Durchführung dieses Projekts erforderlich sind. Wir werden uns nur auf die besonderen Elemente konzentrieren, die erforderlich sind, um ein einfaches und nützliches Kontrollpanel zu erstellen, anstatt die gesamte Palette der grafischen Steuerelemente in MQL5 zu erörtern. Dazu müssen Sie ein Panel auf dem Chart erstellen, grundlegende Komponenten wie Schaltflächen, Eingabefelder und Textbeschriftungen positionieren und verstehen, wie diese Komponenten mit Ihrem Code funktionieren. Sie können vermeiden, dass Sie sich in sinnlosen Kleinigkeiten verzetteln, indem Sie den Umfang klein halten.

In MQL5 ist ein Kontrollpanel eine grafische Nutzeroberfläche, die unmittelbar auf dem MetaTrader 5-Chart erscheint und es dem Nutzer ermöglicht, visuell mit einem Expert Advisor zu kommunizieren. Ein Kontrollpanel ermöglicht es Ihnen, Befehle zu übermitteln, Text einzugeben und Rückmeldungen in Echtzeit zu erhalten, anstatt nur von Eingabeparametern abhängig zu sein. Ihr Tool wird interaktiver und nutzerfreundlicher, da jede Interaktion auf dem Panel Ereignisse erzeugt, auf die Ihr Programm reagieren kann. Das Kontrollpanel dient in diesem Projekt als Bindeglied zwischen dem Nutzer und der API-Logik. In demselben Panel können Sie eine Nachricht eingeben, sie mit einer Schaltfläche senden und die Antwort sehen. Während der Schwerpunkt dieses Artikels beibehalten wird, können Sie dieses Konzept in späteren Projekten erweitern, indem Sie nur die notwendigen Komponenten der Panelgestaltung und der Textverarbeitung lernen.

Beispiel:

#include  <Controls\Dialog.mqh>
CAppDialog panel;

Erläuterung:

Die Dialog-Steuerungsbibliothek muss enthalten sein, bevor wir irgendeine Art von Kontrollpanel in MetaTrader 5 entwickeln können. Dies erreichen wir, indem wir die Dialog-Include-Datei in unser Programm einfügen. Diese Zeile weist den Compiler im Wesentlichen an, das MQL5-Verzeichnis zu durchsuchen, dann zum Ordner Include zu navigieren, den Ordner Controls zu öffnen und die Datei Dialog zu laden. Diese Datei enthält die vordefinierten Klassen und Funktionen, die für die Erzeugung von dialogbasierten UI-Elementen wie Panels, Fenstern und Containern auf dem Chart benötigt werden. Ohne diese Datei würde das Programm keine dialogbezogenen Klassen erkennen, sodass es unmöglich wäre, ein Kontrollpanel zu erstellen.

Wir verwenden die Klasse CAppDialog, um ein Dialogobjekt zu deklarieren, nachdem die Datei Dialog eingebunden wurde. Unser Kontrollpanel wird eine Instanz eines Dialogs sein, der durch diese Erklärung erstellt wird. Einfach ausgedrückt ist dieses Objekt eine Darstellung des Panels, das der primäre Container im Chart sein wird. Das Layout, die Interaktion und die künftigen Steuerelemente der Nutzeroberfläche werden alle von diesem einen Objekt verwaltet. Da das Panel im globalen Bereich definiert ist, kann es während der Initialisierung gebildet und entsprechend zerstört werden, wenn der Expert Advisor aus dem Chart entfernt wird, sodass es für die Dauer des Lebenszyklus des Expert Advisors verfügbar bleibt.

Analogie:

Betrachten Sie das Include-System von MQL5 als eine umfangreiche Bibliothek. MQL5 ist die wichtigste Bibliothek in MetaTrader 5. Diese Bibliothek hat einen speziellen Abschnitt namens Include, der vorgefertigte Hilfsprogramme enthält, die Programmierer verwenden können, anstatt alles von Grund auf neu zu erstellen. Ein Buch mit dem Namen Dialog befindet sich im Regal „Controls“, einem weiteren Regal innerhalb des Abschnitts „Include“. Wenn wir die Include-Zeile für die Dialog-Datei schreiben, weisen wir unser Programm in Wirklichkeit an, die MQL5-Bibliothek zu betreten, zum Abschnitt Include zu navigieren, das Regal Controls zu finden und das Buch Dialog zu öffnen, um dessen Anweisungen zu lesen und zu verwenden.

Detaillierte Anweisungen zum Erstellen von Fenstern, Panels und interaktiven Komponenten auf dem Chart sind in diesem Dialogbuch enthalten. Ähnlich wie ein Leser keine Informationen aus einem Buch nutzen kann, das noch nie geöffnet wurde, hat unser Programm keine Vorstellung davon, wie Dialogfelder funktionieren, ohne das Buch zu öffnen. Das Deklarieren des Dialogobjekts ähnelt nun dem Aufstellen eines leeren Bücherregals in unserem Büro. Wir fügen dem Regal noch nichts hinzu, wenn wir ein CAppDialog-Objekt deklarieren. „Ich möchte ein Bücherregal, das alle meine Interface-Elemente aufnimmt“, ist alles, was wir sagen.

Später wird dieses Bücherregal im Raum positioniert, mit einer bestimmten Größe versehen und für Dinge wie Eingabefelder, Schaltflächen und Textanzeigen verwendet. Alles, was mit dem Kontrollpanel zu tun hat, wird im Dialogobjekt gespeichert und angeordnet, das als primärer Container dient. Wir bestücken das Bücherregal nicht mit allen möglichen Gegenständen, die im Rahmen dieser projektbezogenen Arbeit möglich sind. Wir richten das Regal einfach so ein, dass es genau die Elemente aufnimmt, die wir für dieses spezielle Projekt benötigen, nämlich ein einfaches interaktives Panel, das KI-Antworten verarbeiten und anzeigen kann, ohne den Leser mit einer übermäßigen Menge an Informationen zu überfrachten.

Als Nächstes können wir mit der Erstellung des Kontrollpanels selbst beginnen, da wir nun Zugriff auf die Dialogwerkzeuge haben. Inzwischen weiß das Programm genau, wo es nach Anweisungen für die Konstruktion von Schalttafeln suchen muss und wie diese auf dem Chart erscheinen. Das bedeutet, dass wir nicht mehr blindlings agieren, weil wir über die nötigen Instrumente verfügen.

Beispiel:

#include  <Controls\Dialog.mqh>
CAppDialog panel;

int panel_x = 32;
int panel_y = 82;
int panel_w = 600;
int panel_h = 200;

ulong chart_ID = ChartID();
string panel_name = "Google Generative AI";

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   panel.Create(chart_ID,panel_name,0,panel_x,panel_y,panel_w,panel_h);
   panel.Run();
//---
   return(INIT_SUCCEEDED);
  }

Ausgabe:

Erläuterung:

Erinnern Sie sich, dass wir eine einzigartige Funktion verwendet haben, die speziell für die Erstellung von Chartelementen wie Trendlinien, Beschriftungen und Rechtecken entwickelt wurde? Für grundlegende grafische Elemente ist diese Methode wirksam. In diesem Fall haben wir es jedoch nicht mehr mit einfachen Chartobjekten zu tun. Wir haben es hier mit Schalttafeln zu tun. MetaTrader 5 geht mit Panels anders um, auch wenn ein Kontrollpanel hinter den Kulissen immer noch aus grafischen Komponenten aufgebaut ist. Das Dialog- und Steuersystem, das einen übergeordneten Rahmen für die Erstellung interaktiver Schnittstellen bietet, umfasst Panels. Wir verlassen uns daher nicht mehr auf die Strategie der Objekterzeugung. Vielmehr nutzen wir den in das Panel eingebauten Konstruktionsprozess, der Layout, Interaktion und Ereignisse automatisch verwalten soll.

Um zu bestimmen, wie und wo das Panel erscheinen soll, benötigt MetaTrader 5 eine Reihe von Informationen. Die Chart-ID ist eine der wichtigsten. Dieser Wert gibt das genaue Chart an, dem das Panel auf der Plattform zugeordnet werden soll. Das Panel wird auf dem richtigen Chart angezeigt, wenn die Chart-ID explizit angegeben wird, da ein Expert Advisor technisch mit vielen Charts interagieren kann. Der Name des Panels, der als unverwechselbares Erkennungszeichen für das Panel dient, ist ein weiterer wichtiger Aspekt. Dieser Name wird von MetaTrader 5 verwendet, um das Panel zu identifizieren, zu steuern und von anderen grafischen Elementen im Chart zu unterscheiden. Ein weiterer Vorteil der Verwendung eines eindeutigen und aussagekräftigen Namens ist, dass Ihr Code übersichtlich bleibt und einfacher zu pflegen ist.

Außerdem muss dem Panel bekannt sein, in welchem Chartfenster es angezeigt werden soll. Die beliebteste und nützlichste Wahl für interaktive Tools wie dieses ist die standardmäßige Platzierung von Panels im Hauptchartfenster. Die Positionierung ist ein weiterer wichtiger Faktor. Die Position des Feldes auf dem Chart wird durch die horizontalen und vertikalen Werte angegeben, die in Pixeln in Bezug auf die obere linke Ecke angegeben werden. Dies garantiert, dass das Panel sauber sitzt und eine genaue Anpassung des Layouts ermöglicht, ohne wichtige Preisinformationen zu beeinträchtigen.

Die Breite und Höhe eines Panels bestimmen seine Größe. Der Platz, der für Komponenten wie Texteingaben, Schaltflächen und Beschriftungen vorgesehen ist, wird durch diese Zahlen bestimmt. Die Größenwerte werden in separaten Variablen gespeichert, sodass sie strukturiert und einfach im Code zu ändern sind. Größenvariablen bestimmen die Skalierung, sodass Sie das Layout später ändern können, ohne die Logik für die Erstellung des Bereichs zu ändern. Positionsvariablen sind für die Platzierung verantwortlich. Das Panel muss auch nach der Erstellung noch eingeschaltet sein. Wenn Sie das Panel starten, kann es auf Nutzereingaben wie Texteingaben, Schaltflächenklicks und Ereignisauslöser reagieren. Ohne diesen Schritt wäre das Panel zwar sichtbar, würde aber nicht auf Nutzereingaben reagieren.

Analogie:

Stellen Sie sich Ihr Chart als eine Wand in einem Raum vor, an der Sie eine Tafel oder ein Plakat mit Informationen anbringen möchten. Zu diesem Zweck rufen Sie das Panel auf. Die Anweisung zum Aufhängen des Plakats ist ähnlich wie bei panel.Create(). Der Name des Panels und das Chart, auf dem es erscheinen soll, sind die ersten beiden Dinge, die Sie festlegen. Während der Name des Panels so etwas wie ein Titel auf dem Plakat ist, damit Sie sie später schnell identifizieren können, gibt die Tabelle dem Panel vor, an welcher Wand sie angebracht werden soll.

Anschließend werden die horizontalen und vertikalen Offsets des Panels festgelegt, um seine Position auf dem Chart zu bestimmen. Die eine bestimmt den Abstand von links, die andere den Abstand von oben. Dies ist vergleichbar mit der Wahl des idealen Standorts für ein Poster an der Wand, damit es sowohl gut sichtbar als auch gut positioniert ist. Als Nächstes geben Sie die Breite und Höhe des Panels an, um ihre Größe zu bestimmen. Die Größe des horizontalen und vertikalen Platzes, den das Panel einnimmt, wird durch diese Parameter bestimmt. Dies ist vergleichbar mit der Wahl der Größe eines Posters, das alle gewünschten Informationen anzeigt, ohne zu viel Platz an der Wand einzunehmen.

panel.Run() ist vergleichbar mit dem Aktivieren eines Smartposters, sodass Schaltflächen, Eingabeformulare, Lauftext und Informationen angezeigt werden. Das Panel würde auf keine Interaktionen reagieren, wenn es nicht in Betrieb wäre, ähnlich wie ein funktionsloses Poster an der Wand. Wenn Sie das Programm ausführen, werden Sie feststellen, dass das Panel aus dem Chart verschwindet, sobald Sie den EA kompilieren oder den Zeitrahmen ändern. In bestimmten Situationen kann sich das Chart sogar schließen. Dies ist darauf zurückzuführen, dass MetaTrader 5 automatisch alle Objekte und Steuerelemente entfernt, die von der vorherigen Instanz des EA eingerichtet wurden, wenn der EA aufgrund einer Neukompilierung oder einer Chartänderung neu geladen wird. Der Grund dafür ist, dass das Panel standardmäßig mit dem Lebenszyklus des EA verknüpft ist. Wenn Sie es nicht ausdrücklich anweisen, die Deinitialisierung korrekt durchzuführen, wird das Panel im Wesentlichen zusammen mit dem EA gelöscht. 

Die Antwort ist der Aufruf der Funktion panel.Destroy() mit dem Grund für die Deinitialisierung als Argument über den OnDeinit-Eventhandler. Dies verhindert Abstürze, da sichergestellt wird, dass das Panel gründlich bereinigt wird, wenn der EA pausiert oder neu geladen wird. MetaTrader 5 kann das Entfernen des Panels sicher handhaben, indem es die Ursache an die Destruktionsmethode übergibt. Dadurch bleibt Ihr Chart stabil und es wird ein unerwartetes Verhalten verhindert.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   panel.Destroy(reason);
  }

Hinzufügen von Nutzereingaben zu Ihrem Panel

Bei dem Projekt, das wir in diesem Artikel entwickeln, muss der Nutzer eine Eingabeaufforderung eingeben, die dann direkt vom Panel an die KI übertragen wird. Ich werde Sie durch die Erstellung eines Eingabefeldes innerhalb des Panels führen, damit der Nutzer seine Nachricht in diesem Teil eingeben kann. Dadurch kann das Panel den Text aufzeichnen, den Ihre MQL5-Software zur Interaktion mit der KI verwenden kann. Da der Schwerpunkt dieses Artikels immer noch auf API-Anfragen und WebRequest-Fähigkeiten liegt, werden wir nicht auf jeden Aspekt der Eingabekontrollen in MQL5 eingehen. Vielmehr werden wir uns nur auf die Elemente konzentrieren, die erforderlich sind, um Nutzereingaben effektiv zu erfassen und in das Panel zu integrieren.

Beispiel:

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

CAppDialog panel;
CEdit input_box;

int panel_x = 32;
int panel_y = 82;
int panel_w = 600;
int panel_h = 200;

ulong chart_ID = ChartID();
string panel_name = "Google Generative AI";
string input_box_name = "INPUT BOX";
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   panel.Create(chart_ID,panel_name,0,panel_x,panel_y,panel_w,panel_h);

   input_box.Create(chart_ID,input_box_name,0,5,55,0,0);
   input_box.Width(500);
   input_box.Height(30);
   panel.Add(input_box);

   panel.Run();

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   panel.Destroy(reason);
  }

Ausgabe:

Erläuterung:

Die erste Zeile weist Ihre MQL5-Software an, die Datei zu laden, die alle Definitionen für editierbare Textfelder innerhalb eines Panels enthält, indem Sie zuerst zum Ordner Include und dann zum Unterverzeichnis Controls navigieren. Ohne den in dieser Datei enthaltenen Code wüsste das Programm nicht, wie es mit Eingabefeldern umgehen soll. Man könnte es damit vergleichen, Ihrer Anwendung Anweisungen zur Erstellung und Verwaltung von Texteingabefeldern zu geben.

In der zweiten Zeile wird eine Variable für Ihr editierbares Textfeld deklariert. Dieses spezielle Textfeld wird durch den Variablennamen identifiziert, und der Datentyp weist das Programm an, sich wie ein editierbares Eingabefeld zu verhalten. Das Eingabefeld ist derzeit lediglich eine Definition im Code, die noch erstellt und dem Panel hinzugefügt werden muss; es ist im Chart nicht sichtbar. Die Deklaration der Variablen ist gleichbedeutend mit der Angabe, dass Sie beabsichtigen, einen einzelnen Container namens input_box zu konstruieren, den Sie dann in ein Regal stellen und verwenden können, und die Einbindung der Datei ist gleichbedeutend mit dem Besuch einer Bibliothek, um den Bauplan für eine bestimmte Art von Container zu erhalten.

Sie können dem Textfeld eine Identität geben, die das Programm intern verwenden kann, indem Sie eine String-Variable für den Namen des Eingabefeldes definieren. Wenn sich mehrere Bedienelemente auf einem einzigen Panel befinden, wird eine solche Verwechslung vermieden. Es funktioniert ähnlich wie bei der Beschriftung von Lagerbehältern, bei der jede Box einen Namen hat, der es erleichtert, die richtige Box zu identifizieren und zu nutzen. Dank des Codes, der das Eingabefeld generiert, erscheint das bearbeitbare Textfeld in Ihrem Panel dann tatsächlich. Bei der Erstellung geben Sie eine Reihe von Parametern an, u. a. das Chart, in dem es angezeigt werden soll, den soeben definierten Namen, eine übergeordnete Identifikation (häufig das Panel) und die anfänglichen x-y-Koordinaten. Die Breite und die Höhe werden in der Konstruktionsfunktion zunächst auf Null gesetzt, können aber mit verschiedenen Befehlen schnell geändert werden, um die visuellen Abmessungen des Eingabefeldes festzulegen, sodass es ausreichend hoch und breit ist, damit der Nutzer bequem tippen kann.

Schließlich wird das Eingabefeld dem Panel hinzugefügt; dies ist vergleichbar mit der Platzierung des Containers in einem größeren Anzeigebereich. Das Eingabefeld ist im Speicher vorhanden, kann aber erst angezeigt oder verwendet werden, wenn es dem Panel hinzugefügt wird. Das ist so, als würde man einen Behälter benennen, seine Maße angeben, ihn auf einen Tisch stellen und dann jedem erlauben, Objekte darin zu platzieren.

Analogie:

Betrachten Sie die erste Zeile als Anweisung an Ihre Anwendung, eine große Bibliothek zu betreten, ein spezielles Regal mit der Bezeichnung „Include“ zu öffnen, einen kleineren Bereich mit der Bezeichnung „Controls“ aufzusuchen und die Anweisungen zur Erstellung editierbarer Container abzurufen. Damit Ihre Anwendung weiß, was zu tun ist, enthält dieses Handbuch ausführliche Anweisungen zur Gestaltung und Handhabung von Eingabefeldern. Ohne dieses Handbuch wüsste die Anwendung nicht, wie sie mit Textfeldern umgehen soll. Die zweite Zeile ist vergleichbar mit der Mitteilung an den Bibliothekar, dass Sie dieses Handbuch zur Erstellung eines neuen Containers verwenden möchten. Der Typ garantiert, dass sich dieser Container wie ein echter bearbeitbarer Kasten verhält, der Text aufnehmen kann, und Sie geben ihm einen Namen, damit Sie ihn später wiedererkennen. Noch ist es nur ein leerer Entwurf, der in diesem Stadium in ein Regal gestellt werden muss; er ist im Speicher, aber niemand kann ihn sehen.

Ähnlich wie bei der Beschriftung eines Containers, damit jeder, der das Regal betrachtet, weiß, welches das richtige ist, erzeugen Sie eine separate Zeichenfolge für den Namen des Eingabefeldes. Ähnlich wie der Hinweis „Dies ist die rote Kiste“ unter mehreren Kisten, hilft dieses Label dem Programm, den Container zu identifizieren, wenn es mit ihm interagieren muss. Die endgültige Platzierung des Behälters im Regal ist die Phase, in der das Eingabefach hergestellt wird. Sie wählen nun das Etikett aus, zu dem sie gehören soll, beschriften sie, befestigen sie im Hauptfach und passen ihre horizontale und vertikale Platzierung nach Ihren Wünschen an. Anschließend passen Sie die Größe an, um sicherzustellen, dass sie hoch und breit genug ist, um den Text aufzunehmen, auch wenn er anfangs noch klein ist. Dies ist vergleichbar mit der Umgestaltung eines Containers, in den Bücher problemlos hineinpassen.

Das Hinzufügen des Eingabefeldes zum Panel entspricht dem Einstellen des beschrifteten Containers in das zugewiesene Regal des Bibliothekstisches. Theoretisch gibt es sie, aber sie ist nicht zugänglich, bis Sie diese Maßnahme ergreifen. Sobald der Container im Regal steht, kann jeder Bücher hineinlegen. Er wird gleich nach seiner Einführung zu einem funktionalen Container, in den die Nutzer Inhalte eingeben können.

 

Hinzufügen von Aktionsbuttons zu Ihrem Panel

Der nächste Schritt ist die Erstellung einer Aktionstaste für das Kontrollpanel. In diesem Fall fungiert die Schaltfläche als Übertragungsschaltfläche, die Nutzereingaben aus dem Textfeld an die API überträgt. Aktionsschaltflächen sind von entscheidender Bedeutung, da sie es dem Nutzer ermöglichen, Aufgaben selbst zu starten. In diesem Fall zeigt das Drücken der Sendetaste der Software an, dass der Nutzer bereit ist, seine Eingaben von der KI verarbeiten zu lassen.

Beispiel:

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

CAppDialog panel;
CEdit input_box;
CButton send_button;
string send_button_name = "SEND BUTTON";

int panel_x = 32;
int panel_y = 82;
int panel_w = 600;
int panel_h = 200;

ulong chart_ID = ChartID();
string panel_name = "Google Generative AI";
string input_box_name = "INPUT BOX";
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   panel.Create(chart_ID,panel_name,0,panel_x,panel_y,panel_w,panel_h);

   input_box.Create(chart_ID,input_box_name,0,5,55,0,0);
   input_box.Width(500);
   input_box.Height(30);
   panel.Add(input_box);

   send_button.Create(chart_ID,send_button_name,0,510,55,556,85);
   send_button.Text("Send");
   panel.Add(send_button);

   panel.Run();

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   panel.Destroy(reason);
  }

Ausgabe:

Erläuterung:

Im ersten Abschnitt wird die Datei geladen, die alle notwendigen Informationen für MetaTrader 5 enthält, um die Schaltflächen in einem Panel zu bedienen. Durch das Hinzufügen dieser Datei gewähren Sie Ihrem Programm Zugriff auf die Definitionen und Verhaltensweisen, die für die Erstellung von klickbaren Schaltflächen erforderlich sind, einschließlich der Verwaltung von Klicks, der Anzeige von Text und der Reaktion auf Nutzeraktionen. Ohne diesen Schritt würde das Programm nicht verstehen, was eine Schaltfläche ist oder wie sie funktionieren soll. Anschließend wird eine Button-Variable deklariert.

Diese Deklaration zeigt dem Programm an, dass Sie mit dem Schaltflächensteuerelement arbeiten möchten, und gibt ihm einen Namen, mit dem Sie sein Aussehen verändern oder auf Nutzereingaben reagieren können. Die Schaltfläche erscheint noch nicht auf dem Chart und ist derzeit nur ein geplantes Steuerelement. Der Name der Schaltfläche wird dann als String definiert. Damit MetaTrader 5 diese Schaltfläche von anderen Steuerelementen unterscheiden kann, die sich auf demselben Panel oder Chart befinden können, dient dieser Name als interne Kennzeichnung. Sie dient nicht nur als visuelle Kennzeichnung, sondern ermöglicht es der Plattform, die Schaltfläche im Hintergrund zu verfolgen und eindeutig zu behandeln.

Das tatsächliche Erscheinen der Schaltfläche im Chart erfolgt während des Erstellungsprozesses. An dieser Stelle legen Sie fest, in welches Chart es gehört, geben ihm den Namen, den Sie sich zuvor ausgedacht haben, und geben die Positionskoordinaten an, die bestimmen, wo es sich im Panel befindet. Diese Koordinaten regeln die Gesamtgröße der Schaltfläche und den Abstand von der oberen linken Ecke des Panels. Sie können die Schaltfläche gut neben dem Eingabefeld oder an einer anderen Stelle des Panels platzieren, indem Sie sie sorgfältig anpassen.

Bei der Erstellung der Schaltfläche wird ihr eine Bezeichnung gegeben. Die Funktion der Schaltfläche wird durch den Text angezeigt, den der Nutzer auf der Schaltfläche sieht. Der Ausdruck „Send“ bedeutet in diesem Fall, dass der Nutzer durch Drücken der Schaltfläche seine Eingabe abschicken wird. Die Schaltfläche wird in die Oberfläche des Panels integriert, nachdem der Text zugewiesen wurde. Die Taste ist im Speicher vorhanden, funktioniert aber erst, wenn sie eingesteckt wird. Nachdem es hinzugefügt wurde, können die Nutzer darauf klicken, um Aktionen zu starten, wodurch es zu einem interaktiven Element wird.

Analogie:

Dieser Prozess ist vergleichbar mit der Einrichtung eines speziellen Aktionsschalters in einer Bibliothek. Das Hinzufügen der Schaltflächensteuerungsdatei ist zunächst vergleichbar mit einem Handbuch aus dem Referenzteil der Bibliothek, in dem beschrieben wird, wie Schaltflächen funktionieren, wie sie aussehen und wie Nutzer mit ihnen interagieren können. Ohne diesen Leitfaden wüssten Sie nicht, wie man einen Knopf konstruiert oder bedient. Wenn Sie sagen: „Ich möchte einen Knopf auf meinem Schreibtisch platzieren“, obwohl der Knopf noch nicht dort platziert wurde, ist dies gleichbedeutend mit der Deklaration der Knopfvariablen. Es handelt sich lediglich um eine Strategie, die Raum für sie schafft.

Das Benennen der Schaltfläche ist vergleichbar mit dem Beschriften einer Bibliotheksschublade. Das Label kann von den Besuchern unbemerkt bleiben, aber es ermöglicht dem Bibliothekar, schnell festzustellen, welche Schublade er bei Bedarf öffnen muss. In ähnlicher Weise vereinfacht es die Benennung einer Schaltfläche für Ihre Anwendung, sie in Zukunft zu identifizieren, wenn das Panel mehrere Bedienelemente hat.

Die Herstellung des Knopfes ist vergleichbar mit dem Aufstellen eines beschrifteten Behälters in einem Regal. In welchem Regal er steht, wo genau er sich befindet und wie viel Platz er einnimmt, bleibt Ihnen überlassen. Dank dieser durchdachten Positionierung erscheint die Schaltfläche genau dort, wo Sie sie benötigen, nämlich neben dem Eingabefeld für die Nachricht. Das Drücken der Taste ist vergleichbar mit dem Einschieben eines Buches oder einer Schachtel in einen dafür vorgesehenen Schlitz auf einem Tisch. Sie wählen den Tisch aus, wo er auf dem Tisch stehen soll und wie viel Platz er benötigt. Die Schaltfläche befindet sich genau dort, wo sie sein sollte, damit der Nutzer sie leicht betätigen kann, wenn sie richtig positioniert ist.

Anzeige von Text in der Systemsteuerung

In diesem Abschnitt konzentrieren wir uns auf die Anzeige von Text im Kontrollpanel, insbesondere auf die Antwort des AI-Servers. Denken Sie daran, dass wir in diesem Lernprogramm nur die Anzeige von Text demonstrieren. Da die Kontrollpaneler von MetaTrader 5 keine Zeilenumbrüche wie \n erkennen können, wird der Umgang mit längeren Antworten oder Scrolling im folgenden Artikel behandelt. Das Label-Objekt des Panels wird zur Anzeige von Text verwendet. Das Label dient als Container für die Antwort des Servers. Der Name der Beschriftung, die Position im Panel, die Breite, die Höhe und das Chart, zu dem sie gehört, werden bei der ersten Deklaration einer Variablen für die Beschriftung festgelegt. Die Antwort des Servers wird dem Textattribut des Labels zugewiesen, nachdem es erstellt wurde, und wird dann zur Sichtbarkeit in das Panel eingefügt.

Mit dieser Konfiguration können Sie grundlegende KI-Antworten direkt im Panel anzeigen und dem Nutzer ein sofortiges visuelles Feedback geben. Dieser Schritt ist von entscheidender Bedeutung, da er die Idee der Anzeige dynamischer Inhalte in einem Panel einführt, auch wenn längere Antworten vorerst abgeschnitten werden. Um sicherzustellen, dass keine Informationen verloren gehen, werden wir im nächsten Artikel erörtern, wie der Text automatisch gescrollt werden kann, wenn die Serverantwort zu lang ist, um hineinzupassen.

Beispiel:

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

CAppDialog panel;
CEdit input_box;
CButton send_button;
string send_button_name = "SEND BUTTON";

CLabel  response_display;
string response_text_name = "AI RESPONSE";

int panel_x = 32;
int panel_y = 82;
int panel_w = 600;
int panel_h = 200;

ulong chart_ID = ChartID();
string panel_name = "Google Generative AI";
string input_box_name = "INPUT BOX";

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   panel.Create(chart_ID,panel_name,0,panel_x,panel_y,panel_w,panel_h);

   input_box.Create(chart_ID,input_box_name,0,5,55,0,0);
   input_box.Width(500);
   input_box.Height(30);
   panel.Add(input_box);
   
   send_button.Create(chart_ID,send_button_name,0,510,55,556,85);
   send_button.Text("Send");
   panel.Add(send_button);
   
   response_display.Create(0, "PanelText", 0, 0, 0, 0, 0);
   response_display.Text("THIS WILL BE THE SERVER RESPONSE......");
   panel.Add(response_display);   
   
   panel.Run();

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   panel.Destroy(reason);
  }

Ausgabe:

Erläuterung:

Die Labeldefinition wird zunächst mithilfe der Include-Zeile aus dem Ordner Controls importiert. Diese Datei gibt Ihrem Programm Zugriff auf den gesamten Code, der für die Erzeugung und Pflege von Label-Objekten erforderlich ist, die zur Anzeige von Text in einem Panel verwendet werden. Ohne diese Datei wäre das Programm nicht in der Lage, Labels zu verarbeiten. Es ist vergleichbar mit einem Bauplan für einen speziellen Container, der nur für die Aufbewahrung von Text in Ihrem Werkzeugkasten gedacht ist.

Die Variablendeklaration von CLabel erzeugt dann response_display, ein bestimmtes Label-Objekt. Indem diese Variable als Ersatz für das Label dient, teilt sie dem Programm mit, dass Sie einen Textcontainer haben wollen, der Inhalte speichern und anzeigen kann. Das Label ist noch nicht auf dem Chart zu sehen; zu diesem Zeitpunkt ist es lediglich ein gedanklicher Hinweis, der vorbereitet und auf dem Panel angebracht wird. Gemäß der Analogie zum Bücherregal ist es so, als hätte man einen leeren Behälter mit einem Label im Lager, der bereit ist, in ein bestimmtes Regal gestellt zu werden.

Dieses Label wird durch die String-Variable für seinen Namen identifiziert. Dies ist von Bedeutung, da es der Software ermöglicht, diesen speziellen Textcontainer in Zukunft zu verwenden. Das ist so ähnlich wie die Benennung eines bestimmten Containers in Ihrer Bibliothek, damit Sie genau wissen, welchen Sie übertragen oder füllen wollen. Das Label auf dem Panel erwacht während der Erstellungsfunktion wirklich zum Leben. Hier legen Sie das Chart fest, zu dem es gehört, geben ihm einen Namen, bestimmen den übergeordneten Bereich und legen seine Startgröße und -position fest. Um den Text angemessen anzupassen, können die Position und die Größe in diesem Beispiel geändert werden, nachdem sie zunächst auf Null gesetzt wurden. Dies ist vergleichbar mit dem Aufstellen eines beschrifteten Behälters auf einem bestimmten Regal, auch wenn dieser ursprünglich leer ist und Bücher aufnehmen kann, wie im Beispiel des Bücherregals.

Der Inhalt des Labels wird dann über die Textfunktion zugewiesen. In diesem Fall wird die Antwort des Servers hier angezeigt, was durch eine Platzhaltermeldung angezeigt wird. Dieser Schritt ist vergleichbar mit dem Anbringen eines Musterzettels in Ihrem Behälter, damit jeder, der ihn betrachtet, weiß, was er enthalten soll. Durch das Anbringen des Labels am Panel wird es schließlich sichtbar und interaktiv. Das Label befindet sich bis zu diesem Zeitpunkt im Speicher, ist aber nicht sichtbar oder verwendbar. Durch die Anbringung am Panel wird es nutzbar, ähnlich wie der beschriftete Container im Regal Ihrer Bibliothek.

 

Schlussfolgerung

Die Grundlage für die Erstellung interaktiver Kontrollpanels in MetaTrader 5 und deren Verknüpfung mit API-Anfragen war der Schwerpunkt dieses Artikels. Sie haben die grundlegenden Ideen hinter Panels kennengelernt, wie sie sich von Standard-Chartobjekten unterscheiden und wie man die Steuerelementbibliothek verwendet, um sie zu erstellen und zu verwalten. Um das Panel für die Nutzerinteraktion vorzubereiten, haben wir auch besprochen, wie man wichtige UI-Komponenten wie Aktionsschaltflächen und Eingabefelder hinzufügt. Das Panel ist derzeit vollständig aufgebaut und funktionsfähig; es ist jedoch noch nicht mit einer Backend-Logik oder API verbunden. Im nächsten Artikel werden wir uns mit der Handhabung von Chartereignissen, der Aufzeichnung von Schaltflächenklicks, dem Senden von API-Abfragen und der Anzeige der Serverantwort im Panel beschäftigen.