Erstellen eines Handelsadministrator-Panels in MQL5 (Teil XI): Modernes Merkmal Kommunikationsschnittstelle (I)

Inhalt:

• Einführung
• Übersicht
• Entwurf und Code-Implementierung
• Tests und Ergebnisse
• Schlussfolgerung

Einführung

Das MetaTrader 5-Terminal entwickelt sich rasch zu einem effizienteren und kompakteren Arbeitsbereich für den Handel. Mit der kürzlich integrierten Chat-Funktion können Händler nun privat mit MQL5-Freunden kommunizieren, Gruppen beitreten und Kanäle abonnieren - alles direkt im Terminal. Dies ist ein großer Schritt nach vorn bei der sicheren Verbindung der MQL5-Gemeinschaft über die MQL5-API.

Um diese Funktionen nutzen zu können, müssen die Nutzer bei ihren MQL5-Konten im Terminal angemeldet sein, Online-Freunde haben und Teil aktiver Kanäle oder Gruppen sein. Diese Communities sind wertvolle Quellen für Handelseinblicke, in denen Experten häufig Ideen, Screenshots und Live-Diskussionen austauschen - alles nahtlos integriert, ohne Ihre Chartansicht zu unterbrechen.

Allerdings gibt es derzeit eine Einschränkung: Die Kommunikation findet nur innerhalb des MQL5-Ökosystems statt. Was fehlt, ist die Möglichkeit, MetaTrader 5 mit externen sozialen Plattformen zu verbinden. Glücklicherweise ermöglicht die API des Terminals in Verbindung mit den Möglichkeiten von WebRequest die Verbindung mit Kommunikationsservern von Drittanbietern, wie Telegram, WhatsApp und anderen.

Unser Handelsadministrator-Panel zielt darauf ab, diese Funktionalität durch die Einführung eines modernen Kommunikations-Panels zu erweitern - einer nutzerfreundlichen Oberfläche, die von den Messaging-Apps inspiriert ist, die wir alle täglich nutzen. Wir gehen von einem rechnerähnlichen Prototyp zu einem intuitiveren, ausgefeilteren Design über. Während die ursprüngliche Grundlage für erste Tests gut geeignet war, wird die neue Version eine echte Zwei-Wege-Kommunikation unterstützen.

Es ist nicht mehr nur der Administrator, der Nachrichten verschickt - auch die Empfänger können antworten. Diese Umstellung erfordert die Implementierung eines geeigneten Kontaktsystems, das eindeutige Chat-IDs zur Verwaltung externer Kommunikationsziele verwendet.

Die folgende Abbildung zeigt, wie Sie von der Handelsplattform auf die MQL5 Community und den Chats vom MetaTrader 5 aus zugreifen können. Das Symbol für das Nutzerkonto befindet sich in der Regel in der rechten oberen Ecke der Terminalschnittstelle, wie in der Abbildung hervorgehoben.

Zugriff auf die MQL5 Community und Chats vom MetaTrader 5 Terminal aus

Wenn Sie Ihr MQL5-Konto bereits hinzugefügt haben, zeigt das Terminal normalerweise eine Zusammenfassung im Startjournal an, die angibt, dass das MQL5-Community-Konto und die Chats aktiviert sind. Nachstehend finden Sie mein Terminal-Startprotokoll vom 16. April 2025.

2025.04.16 08:44:10.343 Network '40538052': previous successful authorization performed from 197.221.254.8 on 2025.04.16 03:48:48
2025.04.16 08:44:10.461 Experts expert New_Admin_Panel- (Volatility 75 (1s) Index.0,M5) loaded successfully
2025.04.16 08:44:12.323 Experts expert New_Admin_Panel- (Volatility 10 (1s) Index.0,M1) loaded successfully
2025.04.16 08:44:12.324 Network '40538052': terminal synchronized with Deriv.com Limited: 0 positions, 0 orders, 150 symbols, 0 spreads
2025.04.16 08:44:12.324 Network '40538052': trading has been enabled - hedging mode
2025.04.16 08:44:14.354 Trades  use MetaTrader VPS Hosting Service to speed up the execution: 2.26 ms via 'MQL5 Frankfurt FRA8 01' instead of 212.79 ms
2025.04.16 08:44:14.776 MQL5.community  activated for 'Billionaire2024', balance: 
0.00 
2025.04.16 08:44:15.826 MQL5.chats      activated for 'Billionaire2024'

In der folgenden Übersicht gehen wir auf das eigentliche Design ein und erläutern, wie wir diese nächste Entwicklung des Kommunikationspanels erreichen wollen.

Übersicht

Jetzt wird die Erweiterbarkeit des Programms dank unserer jüngsten Verbesserungen bei der Codeorganisation immer deutlicher. Wie Sie sehen, können wir uns jetzt ganz auf das Kommunikationspanel konzentrieren, ohne von anderen Komponenten des größeren Projekts abgelenkt zu werden. Dieser modulare Ansatz ermöglicht es uns, unsere Kreativität und Produktivität zu maximieren.

Heute machen wir mit dem Kommunikations-Panel einen weiteren bedeutenden Schritt nach vorn - ähnlich dem Fortschritt, den wir mit der Verbesserung und Vereinfachung der Admin-Home-Oberfläche gemacht haben. Derzeit ist das Kommunikationspanel optisch wenig ansprechend und nicht sehr nutzerfreundlich, was bedeutet, dass wir noch einige Arbeit vor uns haben, um es zu verfeinern und zu verbessern.

Wir werden zwar weiterhin die MQL5-Standardbibliothek nutzen, aber in dieser Iteration werden auch neue nutzerdefinierte Klassen eingeführt, die auf unsere Bedürfnisse zugeschnitten sind. Um einen klaren Weg vorwärts zu gewährleisten, beginnen wir mit einem konzeptionellen Entwurf der Schnittstelle, identifizieren die Kernkomponenten und beschreiben ihre individuellen Zwecke. Danach gehen wir in die Kodierungs- und Implementierungsphase über.

Merkmale einer Messaging-Schnittstelle auf der Grundlage der beliebten Messaging-Apps

Bevor wir uns mit der Gestaltung unserer eigenen Schnittstelle befassen, sollten wir uns einen Moment Zeit nehmen, um die allgemeinen Merkmale von Nachrichtenschnittstellen zu betrachten, die von den heute beliebtesten Anwendungen verwendet werden. Durch die Untersuchung dieser gemeinsamen Entwurfsmuster können wir uns inspirieren lassen - und je nachdem, was mit unseren aktuellen Zielen übereinstimmt, Funktionen anpassen, hinzufügen oder entfernen.

Im Folgenden habe ich zehn Schlüsselmerkmale zusammengestellt und skizziert, die wir erkunden sollten. Danach werden wir uns einige Referenzbilder ansehen, die ich vorbereitet habe, um zu veranschaulichen, wie diese Elemente in realen Anwendungen zusammenkommen.

1. Sauberes und minimalistisches Design:

• Flache Nutzeroberfläche mit modernen Farbschemata (helle/dunkle Modi)
• Einheitliche Abstände und Ausrichtung
• Abgerundete Sprechblasen und fließende Übergänge
• Einfache Symbole (Büroklammer, Emoji, Mikrofon usw.) mit intuitiver Anordnung

2. Nachrichten-Thread-Bereich (Haupt-Chatfenster):

• Scrollbarer Bereich zur Anzeige der Nachrichtenhistorie
• Zeitstempel der Nachrichten
• Nachrichtengruppierung nach Absender
• Visuelles Feedback: zugestellt, gelesen, bearbeitet, angeheftet
• Unterstützung für Multimedia (Bilder, Video, Sprache, Dateien)

 3. Seitenleiste - Kontakte oder Kanäle:

• Liste der Nutzer, Gruppen oder Kanäle
• Online-Statusanzeigen (grüne Punkte, zuletzt gesehen)
• Vorschau der letzten Nachrichten
• Such- und Filteroptionen

4. Obere Navigationsleiste:

• Chat-Titel oder Kontaktname
• Nutzeravatare oder Gruppensymbole
• Dropdown-Menü Einstellungen/Optionen (Stummschaltung, Archivierung, Löschen usw.)
• Info-Schaltfläche zur Anzeige des Nutzer- oder Gruppenprofils

 5. Nachrichteneingabebereich (unteres Feld):

• Texteingabefeld mit Platzhalter („Geben Sie eine Nachricht ein...“)
• Buttons:
• Senden (Papierflugzeug-Symbol)
• Datei anhängen (Büroklammer)
• Emoji-Auswahl (Smiley)
• Spracheingabe (Mikrofon-Symbol)
• Tastaturkürzel (Enter zum Senden, Shift+Enter für Zeilenumbruch)

6. Vorschau auf Medien und Anhänge:

• Inline-Vorschau von Bildern, Videos und Dateien
• Ansicht aufklappen/zusammenklappen
• Unterstützung für Drag-and-Drop-Uploads

 7. Benachrichtigungen und Alarme:

• In-App- und System-Benachrichtigungen
• Umschalten zwischen Ton und Vibration
• Erwähnungen mit Hervorhebungen (@username)
• Nachrichten-Popups oder Badges (Anzahl ungelesener Nachrichten)

 8. Geräteübergreifend synchronisieren:

• Web-, Mobil- und Desktop-Anwendungen, die in Echtzeit synchronisiert werden
• Dauerhafter Chatverlauf über Sitzungen hinweg
• Unterstützung für den Offlinemodus mit automatischer Synchronisierung, wenn wieder online

9. Funktionen für Sicherheit und Datenschutz:

• Ende-zu-Ende-Verschlüsselung (z. B. bei WhatsApp)
• Nachrichtentimer/Selbstzerstörung (Telegram)
• 2FA und sichere Anmeldesitzungen

10. Erweiterbarkeit & Bots:

• Unterstützung für Bots und Automatisierung
• Plugins/Integrationen mit anderen Tools (Kalender, Task-Manager, Trading-Terminal)
• Umfangreiche APIs und WebSocket-Unterstützung

Wir beziehen uns nun auf die nachstehende Abbildung, um einige der zuvor genannten Punkte zu bestätigen. Wenn Sie sich erinnern, als wir das Konzept der Zwei-Faktor-Authentifizierung vorstellten, erwähnten wir, dass der Authentifizierungscode über einen speziellen Telegram-Bot empfangen wird. Ein Teil des Chatverlaufs ist zwar immer noch verfügbar, aber die folgende Abbildung soll die wichtigsten Komponenten der Nachrichtenschnittstelle hervorheben. Auf der Grundlage meiner Beobachtungen und des Layouts von Telegram habe ich ein paar bemerkenswerte Abschnitte markiert:

• Der Nachrichteneingabebereich ist rot umrandet.
• Der Abschnitt mit dem Chatverlauf ist blau umrandet.
• Der obere, grün umrandete Bereich enthält den Kontaktnamen, die Suchschaltfläche und das Drei-Punkte-Menü.

Zur Veranschaulichung sehen Sie sich bitte die folgende Abbildung an.

Referenzbild des Telegram Chat

Eine weitere enge Referenz ist die MQL5-Nachrichtenschnittstelle, die ich vor einiger Zeit in einem von mir erstellten MQL5-Kanal erfassen konnte. Schauen Sie sich das Layout unten an - Sie werden einige Ähnlichkeiten und leichte Unterschiede im Design im Vergleich zum vorherigen Telegram-Bild feststellen. Aus diesem allgemeinen Layout der Nachrichtenschnittstelle können wir einige nützliche Erkenntnisse ziehen.

MQL5-Referenz für Nachrichtenübermittlung

Die Beispiele, auf die wir uns berufen können, sind praktisch unerschöpflich. Viele folgen einem ähnlichen Layout - ob es sich um E-Mail-Nachrichtensysteme mit Antwortschaltflächen und zusätzlichen Funktionen, Chatbot-Schnittstellen oder andere handelt. Sie alle bieten wertvolle Einblicke in die typischen Anforderungen an eine Kommunikationsschnittstelle. Auf der Grundlage dieser Referenzen können wir nun weitergehen und das am besten geeignete Design für unser Handelskommunikations-Panel in Betracht ziehen, unter Berücksichtigung seiner Grenzen und der spezifischen Art der Kommunikation, die es verarbeiten soll.

Entwurf und Code-Implementierung

An dieser Stelle beginnt die Migration - vom aktuellen Panel zum neuen. Zuvor müssen wir jedoch die wichtigsten Kommunikationsbedürfnisse des Handelsadministrators bei der Interaktion mit anderen Händlern berücksichtigen. Dazu gehören in der Regel:

1. Besondere Hinweise für Händler

Wir hatten bereits die Idee von Schaltflächen für Schnellnachrichten umgesetzt, um die Zeit zwischen dem Verfassen und Versenden einer Nachricht zu verkürzen. Dadurch wird sichergestellt, dass die Händler wichtige Informationen so schnell wie möglich erhalten. Der Administrator muss jedoch auch die Möglichkeit haben, nutzerdefinierte Nachrichten zu senden, und der Nachrichteneingabebereich ist so konzipiert, dass er dies ermöglicht. Wir werden den Zugriff auf die schnellen Meldungen verbessern.

2. Einweg vs. Zwei-Wege-Kommunikation

Normalerweise darf nur der Administrator Nachrichten senden, sodass es sich um ein einseitiges Kommunikationssystem handelt. Es gibt jedoch Szenarien, in denen es sinnvoll sein könnte, dass die Handelsgemeinschaft reagiert. Wir sollten in Erwägung ziehen, diese Art der Interaktion in den neuen Paneldesigns zu unterstützen.

3. Gemeinsame Nutzung von Screenshots und visuelle Analyse

Die gemeinsame Nutzung von Bildern - insbesondere von kommentierten Charts oder Screenshots - wird immer wichtiger. Das MQL5-Terminal enthält bereits ein Screenshot-Tool, das direkte Uploads in MQL5-Gemeinschaftscharts ermöglicht. Wir würden gerne eine Schaltfläche einbauen, die einen Screenshot aufnimmt und an eine Nachricht anhängt, um ihn schnell weiterzugeben. Auf diese Weise kann der Verwalter Handelseinblicke effektiver visuell vermitteln.

4. Verwaltung von Kontakten

Da Telegram mehrere Kommunikationsmodi anbietet, z. B. Einzelchats, Kanäle und Gruppen, können wir eindeutige Chat-IDs verwenden, um Kontakte zuzuordnen und die Kommunikation in Einzel- und Gruppenkategorien zu organisieren. Das bedeutet auch, dass wir die Speicherung und den Abruf von Kontakten innerhalb unserer Anwendung effektiv verwalten müssen.

Hier ist unser konzeptioneller Entwurf und dann können wir mit der Code-Implementierung fortfahren:

Neues Design: Das Kommunikationspanel

Derzeit liegt unsere Priorität auf der Verfeinerung des Schnittstellendesigns. In den nächsten Abschnitten dieses Artikels werden wir auf dieser Grundlage aufbauen, neue Funktionen hinzufügen und die Nutzerfreundlichkeit weiter verbessern.

Die MQL5-Standardbibliothek bietet mehrere #include-Direktiven, die wir für die Gestaltung unserer Schnittstelle nutzen werden. In der nachstehenden Tabelle sind die relevanten Header-Dateien aufgeführt und ihre beabsichtigte Verwendung im Projekt beschrieben.

Header-Datei	Zweck
Dialog.mqh	Stellt die Basisklasse für Dialogfenster, die Verwaltung von UI-Komponenten, die Ereignisbehandlung und das Rendering zur Verfügung.
Panel.mqh	Wird verwendet, um Steuerelemente zu gruppieren und visuell anzuordnen und Layoutbereiche wie den Hauptbereich und das Kompositionsfeld zu aktivieren.
Label.mqh	Zeigt nicht editierbaren Text an, z. B. Beschriftungen von Eingabefeldern und Abschnittsüberschriften wie „Nutzername“ oder „Chat-ID“.
Edit.mqh	Bietet bearbeitbare Textfelder für Nutzereingaben, einschließlich der Zusammensetzung der Nachricht und der Telegram-Anmeldedaten.
Button.mqh	Ermöglicht die Erstellung anklickbarer Schaltflächen für Nutzeraktionen wie „Senden“, „Datei anhängen“, „Screenshot“ oder „Thema umschalten“.
VirtualKeys.mqh	Definiert Konstanten für die Behandlung von Tastatureingabeereignissen, wie z. B. das Erkennen von Eingabetastendrücken im Nachrichtenfeld.
Telegram.mqh	Verwaltet die Logik für das Senden von Nachrichten über die Telegram Bot API, einschließlich URL-Anfragen und HTTP-Kommunikation.

Die Kopfzeile der Klasse CommunicationsDialog (CommunicationsDialog.mqh)

In diesem Abschnitt werde ich aufschlüsseln, wie unser Code funktioniert, und die Vorteile der Organisation in konzentrierte, wiederverwendbare Teile hervorheben. Indem wir die Logik jedes Panels in einem eigenen Header isolieren - mit Defines, Aufzählungen, Klassendeklarationen und Methodenimplementierungen - halten wir unser Hauptprogramm einfach, wartbar und können es leicht über mehrere EAs hinweg nutzen. Sie müssen sich nicht um interne GUI-Details kümmern, wenn Sie einen dieser Header einbinden; Sie rufen einfach seine Schnittstelle auf. Lassen Sie uns nun Schritt für Schritt die Verbesserung unseres Kommunikationspanels erkunden.

Struktur des Klassen-Headers

Ganz oben in der Datei schützen wir uns vor mehreren Includes und ziehen alle notwendigen Abhängigkeiten ein: 

• Enthält: MQL5-Standard-UI-Steuerelemente (Dialog, Panel, Edit, Button, Label) plus VirtualKeys (für Tastencodes) und unsere eigene Telegram.mqh.

• Konstanten & Enums: Makros für die Panel-Geometrie, UI-Paddings und zwei Aufzählungen für Nachrichtentypen (OUTGOING, INCOMING, SYSTEM) und Status (SENT, FAILED).

• Definition der Klasse: CCommunicationDialog erbt von CAppDialog und deklariert:

1. Private Mitglieder für Bedienfelder, Schaltflächen, Beschriftungen, Bearbeitungen und ein Flag für den Dunkelmodus.
2. Öffentliche Methoden wie Konstruktor, InitCredentials, CreatePanel, Ereignisbehandlung (OnEvent) und Aktionshandler (OnSendMessage usw.).
3. Private Helfer für den Aufbau der einzelnen UI-Bereiche, Thematisierung, History I/O und Formatierung von Nachrichten.

#ifndef COMMUNICATIONS_MQH
#define COMMUNICATIONS_MQH

#include <Controls\Dialog.mqh>
#include <Controls\Panel.mqh>
#include <Controls\Edit.mqh>
#include <Controls\Button.mqh>
#include <Controls\Label.mqh>
#include <VirtualKeys.mqh>
#include "Telegram.mqh"

#define COMM_PANEL_LEFT    80
… 
enum ENUM_UI_CONSTANTS { UI_INDENT=10, UI_GAP=5, … };
enum ENUM_MESSAGE_TYPE   { MSG_OUTGOING, MSG_INCOMING, MSG_SYSTEM };
enum ENUM_MESSAGE_STATUS { STATUS_SENT,   STATUS_FAILED };

class CCommunicationDialog : public CAppDialog
{
private:
   CPanel  m_mainPanel, m_composePanel;
   CButton m_toggleSidebar, m_sendButton, m_attachButton, m_screenshotButton;
   CLabel  m_usernameLabel, m_chatIdLabel, m_tokenLabel, m_mainUserLabel;
   CEdit   m_usernameInput, m_chatIdInput, m_tokenInput, m_messageThread, m_messageInput;
   bool    m_isDarkMode;

public:
   CCommunicationDialog():m_isDarkMode(false){}
   bool CreatePanel(...);
   virtual bool OnEvent(...);
   void OnSendMessage();
   …  
private:
   bool CreateSidebar();
   bool CreateMainContent();
   bool CreateComposeArea();
   void ApplyTheme();
   void LoadChatHistory(string);
   void SaveMessageToHistory(...);
   string FormatMessage(...);
   void AddMessageToHistory(...);
};
#endif // COMMUNICATIONS_MQH

1. CreatePanel: Zusammenstellen des Dialogs

Diese Methode steuert den gesamten Dialogaufbau. Zunächst wird das Basisdialogfeld erstellt, dann werden nacheinander die Seitenleiste, die Hauptanzeige der Nachricht und der Erstellungsbereich erstellt. Jeder Schritt wird auf Erfolg geprüft - bei einem Fehler bricht der Dialog sofort ab. Sobald alle Regionen platziert sind, wird das aktuelle Design angewendet, der gespeicherte Verlauf geladen und das Chart neu gezeichnet, um die komplette Oberfläche zu präsentieren.

bool CCommunicationDialog::CreatePanel(const long chart,const string name,const int subwin,
                                       const int x1,const int y1,const int x2,const int y2)
{
   if(!CAppDialog::Create(chart,name,subwin,x1,y1,x2,y2)) return(false);
   if(!CreateSidebar())     { Destroy(); return(false); }
   if(!CreateMainContent()) { Destroy(); return(false); }

   Add(m_mainPanel);
   Add(m_messageThread);
   Add(m_mainUserLabel);

   if(!CreateComposeArea()){ Destroy(); return(false); }
   Add(m_composePanel);
   Add(m_messageInput);
   Add(m_screenshotButton);
   Add(m_attachButton);
   Add(m_sendButton);

   ApplyTheme();
   LoadChatHistory(m_chatIdInput.Text());
   ChartRedraw();
   return(true);
}

2. CreateSidebar: Berechtigungsnachweise & Thema Toggle

In der Seitenleiste platzieren wir oben eine Schaltfläche zum Umschalten des Themas, gefolgt von drei beschrifteten Eingabefeldern: Nutzername, Chat-ID und Bot-Token. Diese Eingänge ermöglichen die manuelle Eingabe von Telegram-Anmeldedaten. Obwohl dieses Panel derzeit noch manuell ist, legt es den Grundstein für ein zukünftiges Kontaktverwaltungssystem, bei dem die Nutzer gespeicherte Chat-IDs speichern und auswählen können, anstatt sie erneut einzugeben.

bool CCommunicationDialog::CreateSidebar()
{
   int x=UI_INDENT, y=UI_INDENT, w=UI_SIDEBAR_WIDTH-2*UI_INDENT, h=16;

   m_toggleSidebar.Create(m_chart_id,m_name+"_Toggle",m_subwin,x,y,x+h,y+h);
   m_toggleSidebar.Text("🌙"); Add(m_toggleSidebar);
   y+=h+UI_GAP;

   m_usernameLabel.Create(...); m_usernameLabel.Text("Username:");
   m_usernameInput.Create(...); Add(m_usernameLabel); Add(m_usernameInput);
   y+=h+UI_GAP;

   m_chatIdLabel.Create(...); m_chatIdLabel.Text("Chat ID:");
   m_chatIdInput.Create(...); Add(m_chatIdLabel); Add(m_chatIdInput);
   y+=h+UI_GAP;

   m_tokenLabel.Create(...); m_tokenLabel.Text("Bot Token:");
   m_tokenInput.Create(...); Add(m_tokenLabel); Add(m_tokenInput);

   return(true);
}

3. CreateMainContent: Anzeige der Nachrichtenhistorie

Dieser Abschnitt initialisiert das zentrale Panel und sein schreibgeschütztes Bearbeitungsfeld, das den Gesprächsfaden anzeigt. Eine Kennzeichnung am oberen Rand zeigt den Namen des aktuellen Nutzers an. Nutzer können vergangene Nachrichten nicht direkt bearbeiten - neue Nachrichten werden programmatisch angehängt, was eine übersichtliche, einzeilige Ansicht des Chatverlaufs ermöglicht.

bool CCommunicationDialog::CreateMainContent()
{
   int x1=UI_SIDEBAR_WIDTH, y1=0;
   int x2=ClientAreaWidth(), y2=ClientAreaHeight()-UI_COMPOSE_HEIGHT;

   m_mainPanel.Create(...);
   m_messageThread.Create(...);
   m_messageThread.ReadOnly(true);
   m_messageThread.FontSize(9);
   m_messageThread.TextAlign(ALIGN_LEFT);

   m_mainUserLabel.Create(...);
   m_mainUserLabel.Text(m_usernameInput.Text());
   return(true);
}

4. CreateComposeArea: Tippen & Aktionsschaltflächen

Hier bauen wir den unteren Bereich, in dem die Nutzer neue Nachrichten eingeben. Es enthält ein Platzhaltertextfeld und drei Aktionsschaltflächen: Screenshot, Datei anhängen und Senden. Das Feld beginnt mit einem Hinweistext und einer gedämpften Farbe, die den Nutzer dazu anleitet, seine Nachricht einzugeben, bevor er eine der Aktionsschaltflächen aufruft.

bool CCommunicationDialog::CreateComposeArea()
{
   int caW=ClientAreaWidth(), caH=ClientAreaHeight();
   int y1=caH-UI_COMPOSE_HEIGHT, y2=caH;
   int x1=UI_SIDEBAR_WIDTH, x2=caW;

   m_composePanel.Create(...);

   m_screenshotButton.Create(...); m_screenshotButton.Text(StringFormat("%c",58));
   m_attachButton.    Create(...); m_attachButton.   Text(StringFormat("%c",49));
   m_sendButton.      Create(...); m_sendButton.     Text(StringFormat("%c",216));

   m_messageInput.Create(...);
   m_messageInput.Text("Type here...");
   m_messageInput.Color(clrGray);

   return(true);
}

5. OnCaptureScreenshot: GIF-Schnappschuss

Wenn die Screenshot-Schaltfläche angeklickt wird, nimmt die Methode das aktuelle Chart als GIF-Datei mit einem Zeitstempel auf, speichert es im Ordner MQL5 Files und protokolliert eine Systemmeldung, die den Erfolg oder Misserfolg anzeigt. Dies gibt Händlern eine schnelle Möglichkeit, Chart-Schnappschüsse direkt über Telegram zu teilen.

void CCommunicationDialog::OnCaptureScreenshot()
{
   datetime ts=TimeCurrent();
   string tstr=TimeToString(ts, TIME_DATE|TIME_MINUTES|TIME_SECONDS);
   StringReplace(tstr,":","");  

   string path=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\Files\\";
   string fn=path+"shot_"+tstr+".gif";

   bool ok=ChartScreenShot(m_chart_id,fn,0,0);
   m_messageThread.Text(
      FormatMessage(ok ? "Screenshot saved: "+fn : "Screenshot failed",
                    MSG_SYSTEM, ok ? STATUS_SENT : STATUS_FAILED, ts));
   ChartRedraw();
}

6. OnSendMessage: Versenden & Historie

Dieser Handler prüft, ob die Eingabe der Nachricht nicht leer ist und ob die Anmeldeinformationen angegeben wurden. Es ruft unsere Telegram-Sendefunktion auf, zeichnet das Ergebnis in einer Verlaufsdatei auf und fügt die neue Nachricht mit einem Häkchen oder Kreuzsymbol an die Thread-Anzeige an. Schließlich setzt es das Eingabefeld auf seinen Platzhalterstatus zurück und löst ein erneutes Zeichnen aus.

void CCommunicationDialog::OnSendMessage()
{
   string txt=m_messageInput.Text();
   if(txt==""||txt=="Type here...") { /* show error */ return; }

   string chatId=m_chatIdInput.Text(), token=m_tokenInput.Text();
   if(chatId==""||token=="")        { /* show error */ return; }

   datetime ts=TimeCurrent();
   bool sent = SendMessageToTelegram(txt, chatId, token);
   SaveMessageToHistory(chatId, ts, MSG_OUTGOING,
                        sent ? STATUS_SENT : STATUS_FAILED, txt);

   m_messageThread.Text(FormatMessage(txt, MSG_OUTGOING,
                                     sent ? STATUS_SENT : STATUS_FAILED, ts));

   m_messageInput.Text("Type here...");
   m_messageInput.Color(clrGray);
   ChartRedraw();
}

7. Theming & Formatierungshilfen

Unterstützende Methoden behandeln dynamische Thematisierung und Nachrichtenformatierung. ApplyTheme schaltet Hintergrund- und Textfarben für den dunklen oder hellen Modus um. FormatMessage erstellt zeitgestempelte Zeilen mit Nutzer- oder Systempräfixen und Symbolen für gesendete/gescheiterte Nachrichten. Die E/A-Methoden für den Verlauf speichern und laden Gespräche in Datendateien für jeden Chat, um die Persistenz über Sitzungen hinweg zu gewährleisten.

void CCommunicationDialog::ApplyTheme()
{
   color bg = m_isDarkMode ? (color)0x2E2E35 : clrWhite;
   color txt= m_isDarkMode ? clrWhite       : clrBlack;
   m_mainPanel.ColorBackground(bg);
   m_composePanel.ColorBackground(bg);
   m_messageThread.Color(txt);
   m_messageInput.Color(txt);
   …
}

string CCommunicationDialog::FormatMessage(const string message,
                                           ENUM_MESSAGE_TYPE type,
                                           ENUM_MESSAGE_STATUS status,
                                           datetime ts)
{
   string user = (type==MSG_OUTGOING ? m_mainUserLabel.Text()
                                     : type==MSG_INCOMING ? "Them" : "System");
   string ico = (status==STATUS_SENT ? ShortToString(0x2713)
                                     : ShortToString(0x2717));
   return StringFormat("[%s] %s: %s %s",
                       TimeToString(ts,TIME_MINUTES), user, message,
                       (type==MSG_SYSTEM ? "" : ico));
}

Integration der Klasse CommunicationsDialog in den EA

In dem Haupt-EA (New_Admin_Pane.mq5) wird der Header von Communications.mqh in der Routine HandleCommunications zum Leben erweckt. Wenn der Nutzer auf die Schaltfläche Kommunikation klickt, schaltet der Code entweder die Sichtbarkeit einer vorhandenen CCommunicationDialog-Instanz um oder instanziiert bei der ersten Verwendung das Dialogfeld, initialisiert es mit der gespeicherten Chat-ID und dem Bot-Token und erstellt seine Nutzeroberfläche durch den Aufruf von CreatePanel. Schließlich wird show() aufgerufen, um das Panel im Chart darzustellen. Dieses Muster - schnelle Erstellung beim ersten Klick, gefolgt von einer einfachen Logik zum Ein- und Ausblenden - hält den Ressourcenverbrauch minimal und trennt die CommunicationsDialog-Schnittstelle sauber vom Rest des EA.

// handle showing/hiding communications panel
void HandleCommunications()
{
   if(g_commPanel)
   {
      // toggle visibility if already created
      if(g_commPanel.IsVisible()) g_commPanel.Hide();
      else                        g_commPanel.Show();
      ChartRedraw();
      return;
   }

   // first‐time creation
   g_commPanel = new CCommunicationDialog();

   // build the UI
   if(!g_commPanel.CreatePanel(g_chart_id,
                               "CommunicationsPanel",
                               g_subwin,
                               80, 100, 430, 500))
   {
      delete g_commPanel;
      g_commPanel = NULL;
      Print("CommPanel creation failed: ", GetLastError());
      return;
   }

   // pre‐fill credentials and display
   g_commPanel.InitCredentials(TwoFactorChatID, TwoFactorBotToken);
   g_commPanel.Show();
   ChartRedraw();
}

Tests und Ergebnisse

Ich begann mit der Kompilierung des EA in MetaTrader 5, ohne Fehler oder Warnungen. Beim Start erschien die Hauptschnittstelle wie erwartet, komplett mit den Schaltflächen Toggle, Trade, Communications, Analytics und Show All/Hide All.

1. Start des Kommunikationspanels

Durch Klicken auf die Schaltfläche „Kommunikation“ wird der CCommunicationDialog instanziiert. Das Dialogfeld wird im zugewiesenen Chartbereich angezeigt und bestätigt, dass die CreatePanel-Routine und ihre Abschnitte für die Seitenleiste, den Hauptfaden und die Zusammenstellung korrekt erstellt wurden.

2. Anmeldeinformationen eingeben

Ich habe beide Methoden zur Eingabe von Anmeldeinformationen getestet: die Eingabe von Werten in die EA-Eingabeparameter (TwoFactorChatID und TwoFactorBotToken) und die direkte Bearbeitung über die Chat-ID- und Bot-Token-Felder in der Seitenleiste. In beiden Fällen füllte InitCredentials die Felder korrekt aus und aktualisierte die Kennzeichnung „You“.

3. Senden einer Nachricht

Nachdem ich gültige Anmeldedaten eingegeben hatte, gab ich eine Beispielnachricht in das Eingabefeld ein und drückte die Eingabetaste oder klickte auf die Schaltfläche Senden. Die Nachricht erschien im Thread mit einem ✓-Symbol, und ich erhielt dieselbe Nachricht in meinem Telegram-Chat, was beweist, dass die WebRequest-Logik und das JSON-Escaping wie vorgesehen funktionieren.

4. Thema Kippschalter

Mit einem Klick auf die Mond-/Sonnentaste wurde sofort zwischen dem hellen und dem dunklen Modus umgeschaltet. Die Hintergrund- und Textfarben des Panels wurden aktualisiert, und eine Systemmeldung („Dark mode enabled“ oder „Light mode enabled“) wurde an den Thread angehängt.

5. Schaltflächen für Screenshot & Anhängen

Durch Drücken der Screenshot-Schaltfläche wird erwartet, dass eine GIF-Datei in MQL5-Dateien erfasst und gespeichert wird, dann wird eine Bestätigungsmeldung gedruckt und auch ein Fehlerbericht erstellt. Die Schaltfläche für Anhänge protokolliert derzeit eine Platzhalter-Systemmeldung („Attachment TBD“), die anzeigt, dass die vollständige Funktionalität zum Hochladen von Dateien noch nicht implementiert ist.

Testen der Aktualisierung des Kommunikationspanels

Schlussfolgerung

Es ist durchaus möglich, ein modernes, vollständig in einen Expert Advisor integriertes Meldungspanel zu erstellen, aber die aktuellen Standardbibliothekssteuerungen unterliegen einigen Beschränkungen - insbesondere unterstützt das integrierte CEdit nur eine einzige Zeile und eine begrenzte Anzahl von Zeichen. In dieser ersten Phase haben wir ein solides Grundlayout mit Anmeldeinformationen, Nachrichtenkomposition, Themen und Telegram-Integration geliefert. Bei meinen Recherchen habe ich auch von der Community entwickelte Erweiterungen gefunden, die dieselben Einschränkungen überwinden; ich werde diese Referenzen in der nächsten Aktualisierung mitteilen.

Mit Blick auf den nächsten Artikel sind dies unsere wichtigsten Ziele:

1. Mehrzeiliger Chatverlauf

• Eingehende Nachrichten linksbündig, ausgehende rechtsbündig
• Automatischer Wortumbruch und eine Bildlaufleiste, wenn der Inhalt den Anzeigebereich überschreitet

2. Kontakt-Management-System

• Ein einfaches Adressbuch mit dauerhafter Speicherung und Abruf nach Nutzernamen oder Chat-ID

3. Zuverlässige Unterstützung für Bildschirmfotos und Anhänge

• Garantierte Dateierstellung und Upload-Workflows
• Auf diese Weise können Händler Chart-Einblicke in Echtzeit sofort weitergeben, was für die Zusammenarbeit im Team und für Handelsüberprüfungen von entscheidender Bedeutung ist. 

4. Verbesserte Tastaturkürzel

• Quick-Send-Mappings für gängige Nachrichten und Befehle

Dies sind nur einige der Neuerungen, die auf unserer Roadmap stehen. Ihr Feedback und Ihre Vorschläge sind immer willkommen - dies ist eine kontinuierliche Reise des Lernens, der Zusammenarbeit und der Verfeinerung. Eines Tages werden wir eine vollständig ausgefeilte externe API-Nachrichtenübermittlung innerhalb von MetaTrader 5 feiern. Ich hoffe, dass dieser Artikel zumindest eine neue Idee zu Ihrer Programmierhaltung beiträgt.

Viel Spaß beim Handeln, und bleiben Sie dran für den nächsten Artikel!

Datei	Spezifikationen
New_Admin_Panel.mq5	Ein integriertes Expert Advisor-System mit mehreren Bedienfeldern für die erweiterte Handelsverwaltung auf MetaTrader 5.
CommunicationsDialog.mqh	Kommunikationspanel-Modul: Definiert ein modernes Nachrichten-Interface-Panel (Telegram-basiert) für MetaTrader 5 Expert Advisors. Kopieren Sie es in den Include-Ordner des Terminals.
All Modules.zip	Enthält alle erforderlichen Headers. Fügen Sie sie dem Ordner MQL5/Include hinzu.

Zurück zur Einleitung