Einführung in MQL5 (Teil 35): Beherrschen der API- und WebRequest-Funktion in MQL5 (IX)

Einführung

Willkommen zurück zu Teil 35 der Serie „Einführung in MQL5!“ Im letzten Artikel haben wir uns auf die Entwicklung des interaktiven Kontrollpanels des MetaTrader 5-Charts als Frontend des Projekts konzentriert. Wir haben gelernt, wie man das Layout des Panels erstellt, Schaltflächen und Eingabefelder einbindet und Text innerhalb des Panels anzeigt. Das Panel kommunizierte noch nicht mit externen Diensten und war zu diesem Zeitpunkt nur visuell. Indem wir dieses Kontrollpanel mit der Backend-Logik verknüpfen, gehen wir in diesem Abschnitt einen Schritt weiter. In diesem Artikel geht es in erster Linie um die Verwaltung der Nutzerinteraktion mithilfe von Chart-Ereignissen, die Erkennung, wann die Schaltfläche „Send“ angeklickt wird, und die Verwendung der Funktion WebRequest, um Nutzerdaten zum Senden an eine externe API bereitzustellen.

Ferner werden wir den grundlegenden Rahmen für das Abrufen der Serverantwort und die Vorbereitung für die Anzeige auf dem Bildschirm skizzieren. Wie schon in früheren Teilen dieser Serie werden wir nicht versuchen, jede Idee bis ins kleinste Detail zu erläutern. Wir werden uns vielmehr auf das konzentrieren, was zur Erfüllung der Aufgabe erforderlich ist. Dadurch wird verhindert, dass Sie mit irrelevanten Informationen überfrachtet werden, und der Lernprozess bleibt anwendbar. Ihr Kontrollpanel wird nach der Lektüre dieses Artikels nicht mehr statisch sein. Sie wird mit einem externen API-Server interagieren und aktiv auf Nutzereingaben reagieren.

Erkennen von Schaltflächenklicks mithilfe von Chart-Ereignissen

In diesem Abschnitt werden wir uns darauf konzentrieren, wie MetaTrader 5 die Nutzereingaben in einem Kontrollpanel erkennt und darauf reagiert. MetaTrader 5 betrachtet den Klick eines Nutzers auf eine Schaltfläche, wie z. B. die Schaltfläche „Send“ in unserem Panel, nicht als einfachen Objektklick. Vielmehr wird ein Chart-Ereignis erstellt. Wenn ein Mausklick, ein Tastendruck oder eine Interaktion mit einem Steuerelement im Chart erfolgt, sendet die Plattform Nachrichten, die als Chart-Ereignisse bezeichnet werden, an Ihr Programm. Das Wichtigste in dieser Situation ist, dass Tasten und andere Steuerungen keine unabhängige Logik ausführen. Sie zeigen lediglich das Auftreten einer Aktivität an. Die Aufgabe, auf diese Signale zu achten und zu entscheiden, was als Nächstes zu tun ist, fällt Ihrem Programm zu. Dies wird durch das Chart-Ereignisbehandlungssystem erreicht, das es Ihrem Code ermöglicht, zu reagieren, wenn der Nutzer die Schaltfläche „Send“ drückt.

MetaTrader 5 liefert ein Ereignis mit Details darüber, womit interagiert wurde, wenn die Schaltfläche gedrückt wird. Die Art des Ereignisses und die Kennung der Kontrolle, die es ausgelöst hat, sind in diesen Daten enthalten. Anhand dieser Daten kann Ihr Programm feststellen, ob die Schaltfläche „Send“ gedrückt wurde oder ob das Ereignis von einer anderen Stelle des Charts ausging. Das Programm kann die Eingaben des Nutzers lesen und sie für den API-Aufruf vorbereiten, nachdem es überprüft hat, dass die Schaltfläche „Send“ das Ereignis ausgelöst hat. Diese klare Aufteilung der Zuständigkeiten ist von entscheidender Bedeutung. Das Chart-Ereignis meldet die Aktion des Nutzers, die durch die Schaltfläche dargestellt wird, und Ihr Code bestimmt, was als Nächstes geschehen soll. Die Verknüpfung des Kontrollpanels mit der Backend-Logik, die im folgenden Abschnitt der Serie mit der KI interagieren wird, erfordert ein Verständnis dieses Ablaufs.

Beispiel:

//+------------------------------------------------------------------+
//| ChartEvent function                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int32_t id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//---
   if(id == CHARTEVENT_OBJECT_CLICK)
     {
      if(sparam == send_button_name)
        {

         Comment("BUTTON WORKING PERFECTLY");

        }
     }
  }

Ausgabe:

Erläuterung:

Sobald ein Ereignis im Chart auftritt, ruft MetaTrader 5 automatisch die Methode OnChartEvent auf, eine spezielle Funktion zur Ereignisbehandlung. Sie wird nur dann ausgeführt, wenn eine Interaktion oder ein Ereignis stattgefunden hat, im Gegensatz zu OnTick, das ständig läuft. Mausklicks, Tastendrucke, Objektinteraktionen und Kontrollpanel-Operationen sind einige Beispiele für solche Vorgänge. Ziel der Funktion ist es, auf diese Ereignisse zu achten und darauf zu reagieren. Die Art des gerade aufgetretenen Chart-Ereignisses wird durch den ersten Parameter, id, angegeben. Wenn ein Objekt angeklickt, eine Taste angetippt oder die Größe des Charts geändert wird, beschreibt MetaTrader 5 diese Aktionen mithilfe vordefinierter Konstanten. Hier bestimmt der Code, ob der Ereignistyp einem Klick auf ein Objekt entspricht. Dies bedeutet, dass das Programm alle anderen Chart-Ereignisse ignoriert und sich nur für die Ereignisse interessiert, auf die der Nutzer geklickt hat.

Die anschließende Prüfung konzentriert sich auf die Feststellung, welches Objekt das Ereignis verursacht hat, nachdem festgestellt wurde, dass ein Objekt angeklickt wurde. In dieser Situation ist der Parameter sparam nützlich. Der Name des Objekts, mit dem interagiert wurde, ist im sparam-Wert enthalten. Das Programm kann feststellen, ob der Klick nur von der Sendeschaltfläche oder von einem anderen Objekt auf dem Chart stammt, indem es dies mit dem Namen der Sendeschaltfläche vergleicht. Der Code in diesem Block wird ausgeführt, wenn beide Bedingungen erfüllt sind, was bedeutet, dass ein Objekt angeklickt wurde und dieses Objekt die Schaltfläche „Send“ ist. In diesem Fall zeigt das Chart eine Meldung an, die bestätigt, dass der Klick auf die Schaltfläche erfolgreich erkannt wurde. Die korrekte Verbindung der Taste mit den Chart-Ereignissen wird durch diesen einfachen Test nachgewiesen.

Hier ist der Gedanke der Trennung der Zuständigkeiten entscheidend. Wenn sie angeklickt wird, bewirkt die Schaltfläche selbst nichts. Vielmehr kommuniziert sie mit dem Chart. Ihr Code bestimmt dann, was in Abhängigkeit von den Ereignisinformationen zu tun ist, nachdem das Chart die Ereignisbehandlung des Charts initiiert hat. Wenn Sie später die Schaltfläche „Send“ mit einer Logik verbinden, die Nutzereingaben liest und eine Anfrage an die API sendet, benötigen Sie die vollständige Kontrolle darüber, wie Ihr Programm auf Nutzerinteraktionen reagiert.

Analogie:

Stellen Sie sich das Chart als einen aktiven Arbeitsbereich vor und die Funktion OnChartEvent als einen Wachmann, der diesen Bereich überwacht. Die meiste Zeit tut der Wachmann nichts, aber wenn etwas passiert, z. B. wenn eine Taste gedrückt wird, bemerkt er es sofort und wird aktiv. Die Ereigniskennung hat eine ähnliche Funktion wie die Information der Empfangsdame über die Art der kürzlich stattgefundenen Aktion. Wurde ein Knopf gedrückt, hat jemand geklopft oder hat ein Telefon geklingelt? Die Empfangsdame ist in diesem Fall nur mit einer bestimmten Aktion beschäftigt, nämlich wenn jemand eine Taste auf dem Schreibtisch berührt. Die anderen Aktivitäten des Raums bleiben unberücksichtigt.

Die Empfangsdame stellt fest, welche Taste gedrückt wurde, nachdem sie bemerkt hat, dass eine Taste gedrückt wurde. Dies ist vergleichbar mit dem Namen auf einer Schaltfläche, den man anhand der Beschriftung erkennen kann. Die Empfangsdame weiß genau, was der Besucher möchte, wenn das Label der Schaltfläche „Send“ entspricht. Sie tut nichts, wenn es eine andere Taste oder ein anderes Objekt ist. Sie erledigt die notwendige Aufgabe, nachdem sie sich vergewissert hat, dass die Schaltfläche „Send“ gedrückt wurde. Später wird derselbe Schritt erweitert, um die Nachricht des Nutzers zu lesen und an den Server zu übermitteln. In diesem Beispiel meldet diese Aufgabe nur, dass die Schaltfläche funktionsfähig ist, ähnlich wie ein Empfangsmitarbeiter sagt: „Ihre Anfrage ist eingegangen.“

Dieser Vergleich lenkt die Aufmerksamkeit auf ein entscheidendes Konzept. Die Aktion wird nicht von der Schaltfläche selbst ausgeführt. Sie zeigt lediglich an, dass sie gedrückt wurde. Der Schreibtisch der Empfangsdame ist der Ort, an dem die eigentliche Entscheidungsfindung stattfindet, denn er ist der Ereignisbehandler des Charts. Deswegen behandelt MetaTrader 5 Schaltflächenklicks über Chart-Ereignisse und nicht über die Schaltfläche selbst.

Senden von API-Anforderungen als Reaktion auf Nutzeraktionen

Wenn der Nutzer eine Eingabeaufforderung in das Kontrollpanel eingibt und auf die Schaltfläche „Send“ klickt. Dieser Klick dient als Signal für die Software, fortzufahren und mit der API zu interagieren. Um sicherzustellen, dass die Software konsistent und effektiv arbeitet, warten wir absichtlich auf diese Nutzereingabe, anstatt die Abfragen automatisch oder bei jedem Häkchen zu senden. Diese Verbindung zwischen Logik und menschlichen Eingaben wird in MetaTrader 5 durch Chart-Ereignisse gesteuert. Das Programm löst ein Chart-Ereignis aus und zeichnet es auf, wenn die Sendetaste gedrückt wird. Das Programm kann feststellen, welches Steuerelement angeklickt wurde, um dann innerhalb dieser Ereignisbehandlung die entsprechenden Maßnahmen ergreifen. Die WebRequest-Logik kann ausgeführt werden, sobald die Schaltfläche „Send“ als Ursprung des Ereignisses verifiziert wurde. Dadurch wird gewährleistet, dass API-Anforderungen nur dann gesendet werden, wenn der Nutzer sie ausdrücklich wünscht.

Diese Strategie ist aus einer Reihe von Gründen entscheidend. Um zu vermeiden, dass die API-Ratenbeschränkungen überschritten werden, wird zunächst verhindert, dass sinnlose Anfragen an den Server gestellt werden. Zweitens ermöglicht es dem Nutzer die vollständige Kontrolle über das Senden und Empfangen von Daten. Und schließlich wird durch die Trennung von Hintergrundlogik und Nutzerinteraktion ein gut strukturierter Code beibehalten. Während die Backend-Logik die Kommunikation mit der API verwaltet, verwaltet die Schnittstelle Eingaben und Klicks. Sie können einen klaren und reaktionsschnellen Arbeitsablauf einrichten, indem Sie WebRequest direkt mit Nutzeraktionen verbinden. Das Kontrollpanel verwandelt sich von einer visuellen Komponente in ein interaktives Gateway, das dem Nutzer die Kontrolle darüber gibt, wie und wann das Programm mit externen Diensten interagiert.

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 REPONSE";


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);

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---

  }
//+------------------------------------------------------------------+
//| ChartEvent function                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int32_t id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//---
   if(id == CHARTEVENT_OBJECT_CLICK)
     {
      if(sparam == send_button_name)
        {

         //Comment("BUTTON WORKING PERFECTLY");
         string API_KEY = "AbcdefKJXiFPdvvM6f4ivPZ-zA2Qnoq612345";
         string url =  "https://generativelanguage.googleapis.com/v1beta/models/"
                       "gemini-2.5-flash-lite:generateContent?key=" + API_KEY;

         string headers = "Content-Type: application/json\r\n";

         string body = "{"
                       "\"contents\": ["
                       "{"
                       "\"parts\": ["
                       "{"
                       "\"text\": \"" + input_box.Text() + "\""
                       "}"
                       "]"
                       "}"
                       "]"
                       "}";

         char data[];
         int copied = StringToCharArray(body, data, 0, WHOLE_ARRAY, CP_UTF8);

         if(copied > 0)
            ArrayResize(data, copied - 1);

         char result[];
         string result_headers;
         int timeout = 15000;

         int response = WebRequest("POST",url,headers,timeout,data,result,result_headers);

         if(response == -1)
           {
            Print("WebRequest failed. Error: ", GetLastError());
            return;
           }

         string response_text = CharArrayToString(result);
         Print(response_text);

        }
     }
  }

Ausgabe:

Erläuterung:

Um zu verstehen, was ab dem Moment passiert, an dem der Nutzer auf die Schaltfläche klickt, bis der Server antwortet, gehen wir diesen Code Schritt für Schritt durch. Alles beginnt mit der Ereignishandlung des Charts. MetaTrader 5 löst diese Funktion sofort aus, sobald ein Mausklick, ein Tastendruck oder ein Element des Kontrollpanels im Chart verwendet wird. MetaTrader gibt vier Parameter an, wenn diese Funktion aufgerufen wird. Der Identifikator des Ereignisses, der die Art der Aktion angibt, die stattgefunden hat, und das Textargument, das den Namen des betroffenen Objekts angibt, sind in diesem Fall die wichtigsten.

Das erste Kriterium bestimmt, ob die Ereigniskennung mit dem Klickwert des Objekts übereinstimmt. Dadurch wird sichergestellt, dass die interne Logik nur ausgeführt wird, wenn ein Chart-Objekt vom Nutzer angeklickt wird. Der Code könnte auf andere Ereignisse, wie Mausbewegungen oder Chartänderungen, reagieren, wenn diese Prüfung fehlt, was zu unerwartetem Verhalten führen könnte. Die anschließende Überprüfung prüft den Objektnamen aus dem Ereignis auf den Namen der Sendeschaltfläche, nachdem ein Klickereignis verifiziert wurde. Da mehrere Dinge gleichzeitig auf dem Chart erscheinen können, ist dieser Schritt unerlässlich. Der Computer überprüft, ob der Klick von der Sendeschaltfläche und nicht von einem anderen Steuerelement oder Objekt stammt, indem er den Objektnamen überprüft. Das Programm wird nicht fortgesetzt, wenn diese Bedingung nicht erfüllt ist.

Der Code richtet alles ein, was für die Interaktion mit der generativen KI-API von Google erforderlich ist, nachdem überprüft wurde, dass die Schaltfläche „Send“ gedrückt wurde. Zuerst wird der API-Schlüssel definiert. Dieser Schlüssel dient nicht nur zur Identifizierung Ihrer Anwendung bei Google, sondern ermöglicht es dem Server auch, die Nutzung zu messen, Einschränkungen anzuwenden und Anfragen zu authentifizieren. Ohne diesen Schlüssel würde die Anfrage abgelehnt werden. Anschließend wird die Anfrage-URL erstellt. Die URL gibt die auszuführende Aktivität, den Server, das ausgewählte KI-Modell und die API-Version an. Der Server kann den Anfragenden identifizieren, indem er den API-Schlüssel an die URL anhängt. Dadurch wird sichergestellt, dass die Anwendung sowohl den Ort, an dem die Anfrage bearbeitet wird, als auch den Dienst, mit dem sie zu tun hat, vollständig kennt.

Als Nächstes wird die Kopfzeile der Anfrage eingerichtet. Der Content-Type-Header weist den Server darauf hin, dass die Daten im JSON-Format gesendet werden, wie es von der API verlangt wird. Ohne diese Kopfzeile wird die Anfrage vom Server möglicherweise nicht korrekt analysiert. Nachdem die Header definiert sind, wird der Request-Body erstellt. Die eigentliche Nachricht, die an die KI übermittelt wird, ist in diesem Textkörper enthalten. Anstatt eine fest kodierte Eingabeaufforderung zu verwenden, wird der Text direkt aus dem Eingabefeld des Kontrollpanels extrahiert. Mit anderen Worten: Die KI erhält die Eingabeaufforderung, die der Nutzer eingegeben hat. Der Text des Nutzers wird in den entsprechenden JSON-Feldern platziert, und der Textkörper wird so organisiert, dass er dem von der API vorgegebenen Format entspricht.

Der Textkörper muss in ein Array des Typs „character“ umgewandelt werden, nachdem er als Zeichenkette erstellt wurde. Dies ist erforderlich, da Strings von der WebRequest-Methode von MQL5 nicht direkt für den Request-Body akzeptiert werden. Bei dieser Konvertierung wird die UTF-8-Codierung verwendet, um eine genaue Übertragung aller Zeichen, einschließlich Sonderzeichen, zu gewährleisten. Um sicherzustellen, dass das JSON nach der Konvertierung noch gültig ist, wird das Array erweitert, um das zusätzliche Null-Zeichen, das automatisch eingefügt wird, zu entfernen.

Die Funktion WebRequest in MQL5 akzeptiert nur Daten in diesem Format; wenn der Anfragekörper also als String erstellt wird, wird er in ein Zeichenarray umgewandelt. Um sicherzustellen, dass alle Zeichen, einschließlich Sonderzeichen, korrekt übertragen werden, wird in dieser Phase die UTF-8-Codierung verwendet. Die JSON-Struktur wird dann beibehalten, indem die Größe des Arrays angepasst wird, um das zusätzliche Null-Zeichen, das während der Konvertierung eingefügt wurde, zu entfernen. Anschließend werden Variablen konfiguriert, um die Antwort des Servers aufzuzeichnen. Die Antwortdaten werden in einem gespeichert, die Antwortkopfzeilen in einem anderen, und eine Timeout-Einstellung legt fest, wie lange das Programm auf eine Antwort wartet, bevor es beendet wird.

Danach wird die WebRequest-Funktion ausgeführt. An dieser Stelle wird die Anfrage tatsächlich an den Server übermittelt. Die Funktion nimmt die Antwort in die vorbereiteten Variablen auf, nachdem sie die HTTP-Methode, die URL, die Header, die Zeitüberschreitung und den Anfragekörper gesendet hat. Die Funktion gibt einen Wert zurück, der angibt, ob die Anfrage erfolgreich war. Der Code validiert den Rückgabewert direkt nach der Anfrage. Die Ausführung wird angehalten, und eine Fehlermeldung und der letzte Fehlercode werden angezeigt, wenn der Wert einen Fehler anzeigt. Diese Phase der Fehlerbehandlung ist von entscheidender Bedeutung, da sie die Fehlersuche vereinfacht und verhindert, dass das Programm mit falschen oder fehlenden Daten läuft. Die Antwortdaten, die als Zeichenfeld empfangen wurden, werden bei erfolgreicher Anfrage in eine lesbare Zeichenkette zurückverwandelt. Die rohe Antwort, die der AI-Server zurückgegeben hat, wird durch diese letzte Zeichenfolge dargestellt. Das Programm hat nun den gesamten Zyklus erfolgreich abgeschlossen. Als Reaktion auf einen Schaltflächenklick sammelte es Nutzereingaben, übertrug sie an die API und erhielt eine Antwort, die angezeigt, weiterverarbeitet oder zur späteren Verwendung gespeichert werden konnte.

Analogie:

Stellen Sie sich Ihre Tafel als einen kleinen Schreibtisch und Ihr Chart als ein geschäftiges Büro vor. Eine Nachricht kann in das Eingabefeld geschrieben werden, das ähnlich wie ein Notizblock funktioniert, und die Sendetaste ist eine physische Taste auf dem Schreibtisch, auf der „Send“ steht. Der KI-Server funktioniert ähnlich wie ein entfernter Arbeitsplatz, an dem ein Spezialist für die Beantwortung von Anfragen zur Verfügung steht. Die Funktion des Charts ist vergleichbar mit der einer Empfangsdame, die immer auf der Suche nach Aktivitäten ist. Die Empfangsdame bemerkt und meldet alles, was passiert, z. B. wenn jemand eine Taste berührt. Die Empfangsdame prüft jedoch zunächst die Einzelheiten des Vorfalls, bevor sie Maßnahmen ergreift. Sie stellt fest, welche Schaltfläche angeklickt wurde, wenn sie das Ereignis einer geklickten Schaltfläche beobachtet. Sie ist sich bewusst, dass die Nachricht weitergeleitet werden muss, wenn es die Schaltfläche „Send“ betrifft.

Das Programm sammelt alle Informationen, die zum Versenden der Nachricht erforderlich sind, nachdem der Klick auf die Schaltfläche verifiziert wurde. Auf das entfernte Büro des Fachmanns kann Ihr Büro über den API-Schlüssel zugreifen, der ähnlich wie ein geheimer Passcode funktioniert. Die URL ist die genaue Adresse des entfernten Arbeitsplatzes des Fachmanns. Um den Experten nicht zu verwirren, fungieren die Kopfzeilen als eine Art Hinweis, der besagt: „Die Nachricht ist in einer Sprache verfasst, die Sie verstehen.“ Die Nachricht wird dann aus dem Eingabefeld des Notizblocks akribisch in einen Umschlag kopiert, was der Umwandlung einer Zeichenkette in ein Zeichenfeld ähnelt. Um sicherzustellen, dass nichts Zusätzliches übermittelt wird, wird der Umschlag anschließend so verkleinert, dass nur die Botschaft genau hineinpasst.

Der Umschlag wird nun an die Funktion WebRequest, einen Kurierdienst, zusammen mit einer Frist, dem sogenannten Timeout, übergeben. Nach der Übergabe an das Büro des Fachmanns wartet der Kurier auf eine Antwort. Sie erhalten eine Fehlermeldung, dass etwas schiefgelaufen ist, wenn der Kurier nicht zustellen kann. Im Erfolgsfall bringt der Kurier einen Umschlag mit der Antwort des Fachmanns zurück, die anschließend geöffnet und in ein für Sie lesbares Format umgewandelt wird. Kurz gesagt: Der Nutzer schreibt eine Nachricht und klickt auf die Schaltfläche „Send“ , woraufhin die Empfangsdame die Aktion prüft, die Nachricht mit allen erforderlichen Informationen vorbereitet, sie per Kurier an den Fachmann sendet und die Antwort des Experten überbringt, um sie auf Ihrem Schreibtisch anzuzeigen. Genau auf diese Weise kommunizieren die ereignisgesteuerten, interaktiven Frontend-Aktivitäten des MetaTrader 5 mit den Backend-Diensten.

 

Extrahieren nützlicher Daten aus der API-Antwort

Ihre WebRequest-Anfrage wird oft eine Antwort vom Server in einem strukturierten Format wie JSON erhalten. Diese Antwort enthält zusätzlich zu der von der KI generierten Antwort weitere Informationen, wie Metadaten oder interne Details. Wir konzentrieren uns in unserem Projekt ausschließlich darauf, den Text zu erhalten, den die KI als Reaktion auf menschliche Eingaben erzeugt hat. Um Informationen zu extrahieren, erstellen wir zunächst einen lesbaren Text aus dem rohen Byte-Array, das wir von der WebRequest erhalten haben. Auf diese Weise erhalten wir die vollständige Antwort des Servers in manipulierbarer Form. Der Abschnitt der Zeichenkette, der den Text der KI enthält, wird dann gefunden. Dies wird in der Regel mit einem bestimmten Schlüssel gekennzeichnet, wie z. B. „Text“ in der Antwort von Google Generative AI. Nachdem wir mithilfe von String-Funktionen die Anfangsposition des Schlüssels bestimmt haben, extrahieren wir die Teilzeichenkette, die die eigentliche Nachricht der KI enthält.

Der extrahierte Text kann nun an beliebiger Stelle in der Anwendung, einschließlich des Panels, verwendet und in einer Variablen gespeichert werden. Wir stellen sicher, dass der Rest der Serverantwort die Anzeige oder die nachfolgende Verarbeitung nicht beeinträchtigt, indem wir nur die relevanten Daten isolieren. Diese Phase ist für die Sauberkeit und den Fokus unserer Anwendung von entscheidender Bedeutung, damit der Nutzer nur die wichtigen Ergebnisse der KI sehen kann.

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 REPONSE";

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";

string ai_response;
//+------------------------------------------------------------------+
//| 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);
   panel.Add(response_display);

   panel.Run();

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   panel.Destroy(reason);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
  }
//+------------------------------------------------------------------+
//| ChartEvent function                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int32_t id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//---
   if(id == CHARTEVENT_OBJECT_CLICK)
     {
      if(sparam == send_button_name)
        {
         //Comment("BUTTON WORKING PERFECTLY");

         string API_KEY = "AIzaSyCKJXiFPdvvM6f4ivPZ-zA2Qnoq6g62X7M";

         string url =  "https://generativelanguage.googleapis.com/v1beta/models/"
                       "gemini-2.5-flash-lite:generateContent?key=" + API_KEY;

         string headers = "Content-Type: application/json\r\n";

         string body = "{"
                       "\"contents\": ["
                       "{"
                       "\"parts\": ["
                       "{"
                       "\"text\": \"" + input_box.Text() + "\""
                       "}"
                       "]"
                       "}"
                       "]"
                       "}";

         char data[];
         int copied = StringToCharArray(body, data, 0, WHOLE_ARRAY, CP_UTF8);

         if(copied > 0)
            ArrayResize(data, copied - 1);

         char result[];
         string result_headers;
         int timeout = 15000;

         int response = WebRequest("POST",url,headers,timeout,data,result,result_headers);

         if(response == -1)
           {
            Print("WebRequest failed. Error: ", GetLastError());
            return;
           }

         string response_text = CharArrayToString(result);
         //  Print(response_text);

         string pattern = "\"text\": ";
         int pattern_lenght = StringFind(response_text,pattern);
         pattern_lenght += StringLen(pattern);

         int end = StringFind(response_text,"}",pattern_lenght + 1);

         ai_response = StringSubstr(response_text,pattern_lenght,end - pattern_lenght);

         response_display.Text(ai_response);

        }
     }
  }

Ausgabe:

Erläuterung:

Um die Antwort der KI zu speichern, deklarieren wir zunächst eine Variable. Nur der relevante Text, der aus der längeren Serverantwort herausgenommen und von Metadaten oder anderen Daten getrennt wurde, wird in dieser Variablen ai_response gespeichert. Der Schlüssel in der Antwort des Servers, in dem der von der KI produzierte Text gespeichert wird, wird dann durch eine von uns definierte Musterzeichenfolge dargestellt. Die eigentliche Antwort in der JSON-Antwort der generativen KI von Google ist mit „Text“ gekennzeichnet; daher weist dieses Muster das Programm an, wo es nach dem Anfang der entsprechenden Nachricht suchen soll. Anschließend suchen wir mit einer Stringsuchfunktion in der gesamten Antwortnachricht nach diesem Muster. Dies ergibt die erste Stelle im Text, an der das Muster zu finden ist. Wir addieren die Länge des Musters zu dieser Position, um sicherzustellen, dass wir mit der Extraktion des Materials direkt nach dem Schlüssel beginnen. Damit haben wir den genauen Beginn der Nachricht der KI.

Nach dem Startpunkt suchen wir nach der nächsten schließenden geschweiften Klammer }, um das Ende der Nachricht zu bestimmen. Dadurch wissen wir, wann der Text der KI endet, sodass wir nur den relevanten Teil der Antwort aufzeichnen und den Rest ausschließen können. Wir verwenden eine Substring-Funktion, um die Teilzeichenkette abzurufen, die die Antwort der KI enthält, nachdem wir die Anfangs- und Endstellen kennen. Die Variable ai_response enthält den generierten Text. Schließlich aktualisieren wir den Inhalt des Labels, um den extrahierten Text im Panel anzuzeigen. Mit diesem Schritt wird sichergestellt, dass die KI-Antwort auf der Oberfläche des Kontrollpanels dem Nutzer direkt angezeigt wird.

Analogie:

Angenommen, Sie sind Bibliothekar und ein Verlag schickt Ihnen einen dicken Umschlag. Darin befinden sich zahlreiche Dokumente, darunter Berichte, Plakate, Ankündigungen und Rechnungen. Die Buchbesprechung, die Sie interessiert, befindet sich auf einer Seite von allen. Es liegt in Ihrer Verantwortung, die Zeitungen durchzusehen, die betreffende Seite zu finden und sie an der Pinnwand der Bibliothek auszuhängen, damit alle sie lesen können. Um nur die Buchbesprechung zu speichern, müssen Sie einen eigenen Ordner namens ai_response anlegen. Dies ist gleichbedeutend mit der Erklärung: „Ich habe einen Ort, an dem ich nur die Botschaft aufbewahre, die mir wichtig ist, und sonst nichts.“ Sie wissen, dass jeder Brief eine Überschrift hat, die „Text“ lautet: Wie ein Klebezettel auf dem Umschlag, auf dem steht: „Die Nachricht beginnt hier“, ist dies Ihr Hinweis. Sie suchen den ersten Umschlag mit diesem Label im Stapel. Der Anfangspunkt für den Buchstaben, den Sie extrahieren möchten, ist die Stelle, an der Sie ihn finden.

Das bloße Auffinden des Labels ist jedoch nicht ausreichend. Um zu vermeiden, dass Sie die zusätzlichen Dokumente versehentlich in Ihre Anzeige einfügen, müssen Sie wissen, wo das Schreiben endet. Sie suchen nach dem Schlusszeichen, das nach jedem Abschnitt in der JSON-Antwort erscheint. Das ist so, als würde man einen Umschlag öffnen, die letzte Zeile eines Briefes lesen und feststellen, dass alles, was danach kommt, zu etwas anderem gehört. Sie schneiden den Brief vorsichtig aus der übrigen Post heraus, nachdem Sie sich über seinen Anfang und sein Ende im Klaren sind. Genau das tut die Substring-Funktion: Sie extrahiert nur den Text zwischen Anfang und Ende und liefert Ihnen so eine übersichtliche Buchbesprechung, die frei von überflüssigen Details ist. Zum Schluss legen Sie den Brief auf die Anzeigetafel response_display. Die Nachricht ist nun für alle Besucher der Bibliothek gut sichtbar. Die relevanten Informationen werden übersichtlich im Rahmen präsentiert, sodass die Besucher nicht selbst einen Stapel von Dokumenten durchsehen müssen.

Implementierung von scrollbarem Text in Ihrem Control Panel

In diesem Abschnitt werden wir uns ansehen, wie Sie die KI-Antwort im Kontrollpanel verschieben können. Das Kontrollpanel in MQL5 erkennt keine Zeilenumbrüche mit \n, im Gegensatz zu herkömmlichen Textbereichen in der Programmierung. Das bedeutet, dass der Text, wenn die Serverantwort lang ist, einfach über den sichtbaren Bereich hinausgeht und nicht automatisch umbricht oder neue Zeilen beginnt. Wir lösen dieses Problem, indem wir einen Bildlaufmechanismus implementieren, der den sichtbaren Bereich des Textes schrittweise über das Label verschiebt.

Ziel ist es, den sichtbaren Teil des Textes schrittweise zu verändern, wobei immer nur ein Teil der Antwort angezeigt wird. Wir erreichen dies, indem wir einen Zeitgeber verwenden, der periodisch eine Funktion auslöst. Die Funktion erzeugt die Illusion eines kontinuierlichen Bildlaufs, indem sie bei jeder Ausführung das Label mit einem neuen Teil der Antwort aktualisiert. Diese Methode garantiert, dass auch extrem lange KI-Antworten innerhalb der vorgegebenen Größe des Panels verständlich sind, ohne dass wichtige Informationen ausgelassen werden oder ein mühsames Scrollen erforderlich ist. Dank der Implementierung von scrollbarem Text können die Nutzer die gesamte KI-Antwort problemlos lesen, wodurch das Panel klein und gut in das Chart integriert ist. Um eine flüssige und verständliche Darstellung zu gewährleisten, werden wir in den folgenden Abschnitten die Codelogik für die Extraktion des Inhalts, die Aktualisierung der Beschriftung und die Regulierung der Bildlaufgeschwindigkeit aufschlüsseln.

Beispiel:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   EventSetMillisecondTimer(150);
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {

   EventKillTimer();
  }
//+------------------------------------------------------------------+
//| Timer function for animation                                     |
//+------------------------------------------------------------------+
void OnTimer()
  {
   Print("EURUSD")
  }

Erläuterung:

Ein Millisekunden-Timer mit einem kurzen Intervall wird durch den Initialisierungsteil des Programms gestartet. Die Software kann die Nutzeroberfläche wiederholt aktualisieren, indem sie den konsistenten und vorhersehbaren Rhythmus nutzt, den dieser Timer erzeugt. Der Timer ermöglicht es der Software, den angezeigten Text schrittweise zu aktualisieren, anstatt zu versuchen, die gesamte Serverantwort auf einmal anzuzeigen, was in Kontrollfeldern unpraktisch ist. Der Timer wird automatisch aufgerufen, wenn das Timer-Ereignis eintritt. So können Sie den sichtbaren Bereich des Textes bei jedem Aufruf leicht verschieben. So kann die Anwendung beispielsweise eine Aufwärts- oder Seitwärtsbewegung imitieren, die Startposition des Textes ändern oder den folgenden Zeichensatz anzeigen. Der Text scheint langsam zu laufen und nicht plötzlich zu springen, da der Timer eine hohe Frequenz hat. Auf diese Weise können wir einen Bildlauf simulieren, ohne dass Zeilenumbruchzeichen erforderlich sind.

Der De-Initialisierungsteil beendet den Timer, wenn der Expert Advisor aus dem Chart gelöscht wird oder sich der Status des Charts ändert. Dies ist von entscheidender Bedeutung, da das Scrollen eine fortlaufende Aktivität ist, die häufige Aktualisierungen erfordert. Um zu verhindern, dass die Bildlauflogik im Hintergrund weiterläuft, nachdem das Panel verschwunden ist, muss der Timer angehalten werden. Ferner werden unnötige Verarbeitungen vermieden und die Stabilität der Plattform gewahrt.

Analogie:

Stellen Sie sich das Kontrollpanel wie ein kleines elektronisches schwarzes Brett vor, das nur eine begrenzte Wortanzahl anzeigen kann. Die Antwort des Servers gleicht einem langen Brief, der auf einem Blatt Papier geschrieben ist, das deutlich länger ist als der Bildschirm des Schwarzen Bretts. Sie benötigen eine Methode, um das Papier langsam zu bewegen, damit verschiedene Teile der Nachricht allmählich sichtbar werden, da der Bildschirm nicht die gesamte Nachricht auf einmal anzeigen kann und keine Zeilenumbrüche unterstützt. Es ist vergleichbar mit dem Einschalten eines kleinen Motors in der Tafel, wenn Sie den Timer während der Initialisierung einstellen. Dieser Motor arbeitet mit einer bestimmten Frequenz, die in diesem Fall 150 Millisekunden beträgt. Der Motor weist das System an, das Papier bei jedem Tick ein wenig weiterzubewegen. Die Bewegung ist sanft und kontrolliert und nicht zufällig, weil das Ticken gleichmäßig ist.

Die eigentliche Bewegung findet im Timer statt. Sie können den Teil der Meldung ändern, der nun bei jedem Tick des Motors auf dem Bildschirm angezeigt wird. Obwohl sich der Bildschirm selbst nicht vergrößert oder neue Funktionen hinzufügt, hat der Betrachter den Eindruck, dass der Text am Laufen ist. Sie zeigen jedes Mal nur einen anderen Teil der gleichen langen Nachricht an. Der Motor wird abgeschaltet, wenn das schwarze Brett entfernt oder ausgeschaltet wird. Dadurch wird verhindert, dass es funktioniert, wenn kein Bildschirm vorhanden ist, auf dem die Nachricht angezeigt wird. Wenn die Anwendung beendet wird, garantiert das Anhalten des Zeitgebers, dass der Bildlauf ordnungsgemäß beendet wird und keine Ressourcen verschwendet werden.

Der nächste Schritt ist die Verwendung der Ereignisbehandlung von OnTimer, um den Text zum Laufen zu bringen, da wir nun wissen, wie er funktioniert. Wir werden den Timer verwenden, um den im Kontrollpanel angezeigten Text regelmäßig zu aktualisieren, anstatt die gesamte Serverantwort auf einmal anzuzeigen. Jedes Mal, wenn der Timer abläuft, wird ein winziger Teil der Antwort angezeigt, der beim nächsten Tick leicht verschoben wird. Bei wiederholter Anwendung scheint der Text auf der Anzeige kontinuierlich zu fließen. Auch wenn Control Panels keinen mehrzeiligen Text oder Zeilenumbrüche akzeptieren, ermöglicht uns diese Methode, längere KI-Antworten auf einfache und verständliche Weise zu bearbeiten.

Beispiel:

int    display_length;

//+------------------------------------------------------------------+
//| ChartEvent function                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int32_t id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//---
   if(id == CHARTEVENT_OBJECT_CLICK)
     {
      if(sparam == send_button_name)
        {

         //Comment("BUTTON WORKING PERFECTLY");

         string API_KEY = "AIzaSyCKJXiFPdvvM6f4ivPZ-zA2Qnoq6g62X7M";

         string url =  "https://generativelanguage.googleapis.com/v1beta/models/"
                       "gemini-2.5-flash-lite:generateContent?key=" + API_KEY;

         string headers = "Content-Type: application/json\r\n";

         string body = "{"
                       "\"contents\": ["
                       "{"
                       "\"parts\": ["
                       "{"
                       "\"text\": \"" + input_box.Text() + "\""
                       "}"
                       "]"
                       "}"
                       "]"
                       "}";

         char data[];
         int copied = StringToCharArray(body, data, 0, WHOLE_ARRAY, CP_UTF8);

         if(copied > 0)
            ArrayResize(data, copied - 1);

         char result[];
         string result_headers;
         int timeout = 15000;

         int response = WebRequest("POST",url,headers,timeout,data,result,result_headers);

         if(response == -1)
           {
            Print("WebRequest failed. Error: ", GetLastError());
            return;
           }

         string response_text = CharArrayToString(result);
         //  Print(response_text);

         string pattern = "\"text\": ";
         int pattern_lenght = StringFind(response_text,pattern);
         pattern_lenght += StringLen(pattern);

         int end = StringFind(response_text,"}",pattern_lenght + 1);

         ai_response = StringSubstr(response_text,pattern_lenght,end - pattern_lenght);

         //   response_display.Text(ai_response);
         Print(ai_response);

         int res_lenght = StringLen(ai_response);
         if(res_lenght < 100)
           {

            display_length = res_lenght;

           }
         if(res_lenght >= 100)
           {

            display_length = 100;

           }
        }
     }
  }

Erläuterung:

In diesem Fall besteht die Funktion des Codes darin, festzulegen, wie viel des von AI erzeugten Textes auf einmal im Kontrollpanel angezeigt werden soll. Zunächst wird die Länge der Antwort berechnet, d. h., jedes Zeichen des Textes wird gezählt. Bevor das Programm seine Präsentation verwaltet, hat es dank dieser Informationen einen klaren Überblick über die Größe der Antwort. Auf der Grundlage dieser Länge wird dann eine einfache Auswahl getroffen. Das Programm passt die Anzeigelänge so an, dass sie die gesamte Antwort wiedergibt, wenn die Antwort weniger als 100 Zeichen umfasst. Da der Text bereits gut in das Feld passt, kann er ohne Scrollen in seiner Gesamtheit angezeigt werden.

Das Programm beschränkt den sichtbaren Teil auf jeweils 100 Zeichen, wenn die KI-Antwort länger als 100 Zeichen ist. Zunächst ist nur dieser Abschnitt sichtbar; der Rest des Textes wird erst durch Scrollen sichtbar. Auf diese Weise bleibt das Panel übersichtlich und lange Antworten nehmen nicht zu viel Platz in Anspruch, während gleichzeitig die gesamte Nachricht im Laufe der Zeit angezeigt werden kann.

Analogie:

Stellen Sie sich ein Fenster auf einem Bücherregal vor. Ein langer Stapel Bücher im Regal steht für die Antwort der KI. Wie bei der Messung der Länge der Antwort beginnt man mit der Zählung der Anzahl der Bände. Das Fenster kann alle Bücher gleichzeitig anzeigen, wenn es weniger als 100 sind, sodass Sie alles sehen können, ohne das Fenster verschieben zu müssen. In das Fenster passen nur 100 Bücher, wenn es mehr als 100 sind. Sie müssen das Fenster verschieben, um die anderen zu sehen. Damit das Regal ordentlich aussieht, während Sie durch alle Bücher blättern, ist die Einstellung der Anzeigegrenze vergleichbar mit der angemessenen Größe des Fensters, um ein Überlaufen zu verhindern.

OnTimer wird verwendet, um den Text scrollen zu lassen, nachdem Sie entschieden haben, wie viele Zeichen Sie im Panel auf einmal anzeigen möchten. Um auch längere KI-Antworten innerhalb des festen Bereichs des Panels schrittweise anzuzeigen, fungiert OnTimer als Mechanismus, der den sichtbaren Teil des Textes wiederholt um jeweils ein Zeichen verschiebt. Dies ermöglicht dem Nutzer einen reibungslosen Bildlauf, da das Panel den gesamten Inhalt anzeigen kann, ohne zu überlaufen.

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 REPONSE";

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";

string ai_response = " ";

int    display_length; // Number of characters visible at once
int    scroll_pos = 0;
//+------------------------------------------------------------------+
//| 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(ai_response);
   panel.Add(response_display);

   EventSetMillisecondTimer(150);
   panel.Run();

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

//+------------------------------------------------------------------+
//| Timer function for animation                                     |
//+------------------------------------------------------------------+
void OnTimer()
  {
   int message_len = StringLen(ai_response);

// SAFETY CHECK (very important)
   if(message_len == 0)
      return;

   string visible_text = "";

   for(int i = 0; i < display_length; i++)
     {
      int char_index = (scroll_pos + i) % message_len;
      visible_text += StringSubstr(ai_response, char_index, 1);
     }

   response_display.Text(visible_text);

   scroll_pos++;
   if(scroll_pos >= message_len)
      scroll_pos = 0;
  }

Ausgabe:

Erläuterung:

Zunächst bestimmt die Funktion, wie lang der AI-Antwortstring insgesamt ist. Dadurch erhält die Anwendung die Zeichenzahl der Nachricht, die entscheidend dafür ist, wann der Text beim Blättern umbrochen werden soll. Es ist vergleichbar mit der Messung eines langen Bandes in seiner gesamten Länge, bevor es durch ein Schaufenster geführt wird. Danach findet eine Sicherheitsüberprüfung statt. Die Funktion stoppt sofort und tut nichts, wenn die KI-Antwort leer ist. Dadurch wird verhindert, dass die Software versucht, eine nicht existierende Zeichenfolge zu scrollen. Es ist vergleichbar damit, dass man sich vergewissert, dass das Farbband vorhanden ist, bevor man versucht, es durch die Anzeige zu bewegen. Der Teil der AI-Antwort, der nun im Panel erscheint, wird in einer temporären Zeichenfolge gespeichert. Stellen Sie sich vor, Sie öffnen ein kleines Fenster auf einem langen Band, sodass Sie nur einen Teil davon sehen können. Ähnlich wie beim Bewegen des Farbbands über das Fenster, um einen Teil auf einmal zu zeigen, fügt eine Schleife dann jedes Zeichen aus der AI-Antwort der sichtbaren Zeichenfolge für die durch die Anzeigelänge bestimmte Anzahl von Zeichen hinzu.

Das Programm bestimmt, welches Zeichen der AI-Antwort als Nächstes in der Schleife angezeigt werden soll. Die Modulo-Prozedur stellt sicher, dass der Bildlauf unbegrenzt fortgesetzt wird, indem sie zum Anfang zurückspringt, wenn das Ende der Antwort erreicht ist. Wie bei einem Band, das durch ein kleines Fenster geführt wird, wird jedes ausgewählte Zeichen nacheinander in die sichtbare Zeichenfolge eingefügt, sodass der Betrachter einen kontinuierlichen Textfluss sehen kann. Das Programm zeigt dem Nutzer diesen Teil der KI-Antwort an, indem es den sichtbaren Text auf der Tafel einstellt, nachdem es alle Zeichen für das aktuelle Bild gesammelt hat. Das ist so, als würde man das Farbband komplett in ein kleines Fenster legen, das der Leser sehen kann. Der Anfangspunkt des Bildlaufs rückt um ein Zeichen vor, sobald die Anzeige geändert wird, was zu einem sanften Bildlaufeffekt führt, wenn der folgende Timer-Tick das nächste Segment anzeigt.

Analogie:

Stellen Sie sich die KI-Antwort als ein langes Band mit einer Nachricht darauf vor. Auf dem Anzeigefeld können Sie jeweils nur einen Teil des Farbbands sehen, ähnlich wie ein kleines Fenster an der Wand. Das Programm bestimmt zunächst die Länge des Farbbandes. Bevor Sie beginnen, das Farbband durch das Fenster zu rollen, sollten Sie es dehnen, um seine Länge zu bestimmen. Es ist wichtig, die gesamte Länge zu verstehen, da sie angibt, wann wir das Ende erreichen und zum Anfang zurückkehren müssen. Anschließend führt das Programm eine Sicherheitsüberprüfung durch. Das Farbband bleibt stehen und tut nichts, wenn kein Text vorhanden ist, um Fehler oder leere Anzeigen zu vermeiden. Dann wird, genau wie beim Einrichten eines Rahmens und der Auswahl des Teils des Farbbands, der dem Betrachter angezeigt werden soll, eine leere Zeichenfolge gebildet, die den Teil des Farbbands enthält, der über das Fenster zu sehen sein wird.

Um dieses Fenster zu füllen, wird eine Schleife ausgeführt. Der Computer wählt für jedes Zeichen der Anzeigelänge das passende Zeichen aus dem Farbband aus und fügt es in den sichtbaren Text ein. Um die Nachricht sichtbar zu machen, schieben Sie das Band vor das Fenster und fügen Sie ein Zeichen nach dem anderen ein. Das Programm passt das Panel so an, dass dieser Teil des Farbbands angezeigt wird, sobald alle Zeichen für den aktuellen Rahmen platziert sind. Dies ist vergleichbar mit der Möglichkeit, den aktuellen Teil des Bandes durch ein Glas zu sehen. Damit das Fenster beim nächsten Timer-Tick den nächsten Abschnitt der Multifunktionsleiste anzeigt, wird die Bildlaufposition nach der Anzeige um ein Zeichen weitergeschoben. Um sicherzustellen, dass die Nachricht reibungslos über das Fenster fließt, ist dies vergleichbar mit dem Vorschieben des Farbbands.

Schließlich setzt das Programm die Position an den Anfang zurück, wenn der Bildlauf das Ende des Bandes erreicht. Dadurch wird gewährleistet, dass die Nachricht in einer Schleife weiterläuft, ähnlich wie wenn das Menüband an den Anfang zurückkehrt, um die Nachricht auf unbestimmte Zeit anzuzeigen.

Schlussfolgerung

In diesem Artikel haben wir untersucht, wie wir unser MetaTrader 5-Kontrollfeld interaktiv machen können, indem wir Nutzeraktionen erkennen und Anfragen an eine API senden. Wir haben gelernt, wie man mit Chart-Ereignissen umgeht, sodass das Programm reagiert, wenn der Nutzer auf die Schaltfläche „Send“ klickt, und wie man die Serverantwort verarbeitet, um den nützlichen KI-generierten Text zu extrahieren. Wir haben auch das Konzept des Lauftextes eingeführt und den OnTimer-Ereignishandler verwendet, um eine reibungslose, kontinuierliche Anzeige für Antworten zu erstellen, die länger sind, als das Panel auf einmal anzeigen kann.