Erstellen eines Handelsadministrator-Panels in MQL5 (Teil X): Externe, ressourcenbasierte Schnittstelle

Inhalt:

• Einführung
• Überblick über die Diskussion
• Konzeptionelle Gestaltung
• Implementierung des Codes
• Tests
• Schlussfolgerung

Einführung

Ich bin mir sicher, dass es immer schwierig ist, einen Ausgangspunkt zu finden. Doch wenn man erst einmal einen ersten Entwurf erstellt hat, ist es einfacher, darauf aufzubauen und neue Möglichkeiten zu entdecken. Viele erfolgreiche Designer und Entwickler beginnen mit einfachen Skizzen und entwickeln ihre Arbeit weiter, bis sie wirklich ins Auge sticht. Selbst wenn Sie glauben, dass Sie die ultimative Version Ihres Produkts erreicht haben, gibt es immer noch Raum für weitere Verbesserungen. Die Entwicklung ist ein kontinuierlicher Prozess, und jede neue Iteration muss etwas Einzigartiges im Vergleich zu ihrem Vorgänger bieten.

In dieser Entwicklungsserie haben wir mit einem monolithischen Admin-Panel-Programm begonnen, das mehrere Schnittstellen aufweist. Als der Code zu lang und unhandlich wurde, führten wir eine bessere Codeorganisation ein, indem wir die MQL5-Standardbibliothek, Klassenvererbung und nutzerdefinierte Header-Dateien nutzten. Dieser Ansatz ermöglichte es uns, uns auf einzelne Aspekte des Programms zu konzentrieren, ohne andere Teile zu beeinträchtigen, was die Wahrscheinlichkeit von Fehlern erheblich reduzierte und künftige Erweiterungen möglich machte - nur begrenzt durch die Vorstellungskraft des Entwicklers. Heute beginnen wir einen neuen Zyklus, beginnend mit dem Home-Panel. 

Meiner Meinung nach sind Symbole eine der wirksamsten Formen der visuellen Kommunikation, die in der Lage sind, detaillierte Informationen sofort und auf kleinstem Raum zu vermitteln. Im Laufe der Geschichte haben Symbole eine wichtige Rolle in der menschlichen Kommunikation gespielt - lange vor der Erfindung der Schriftsprache verwendeten frühe Zivilisationen Piktogramme und Glyphen, um Ideen, Gefühle und Anweisungen darzustellen. Von den alten Ägyptische Hieroglyphen bis zu den modernen Emojiemojis sind Symbole eine universelle visuelle Kurzschrift geblieben, die Sprachbarrieren überwindet.

In der digitalen Welt wird diese Tradition fortgesetzt. Ein Beispiel dafür ist der Schrifttyp Wingdings - eine Sammlung von Symbolen, die in den Text eingebettet sind und die Bedeutung ohne Worte vermitteln. In der MQL5-Entwicklung sind Symbole wie diese unglaublich nützlich, da sie gut dokumentiert und einfach zu implementieren sind. Ihre Verwendung kann die Anzahl der auf einem Chart angezeigten visuellen Objekte erheblich reduzieren und dennoch wesentliche Informationen mit Klarheit und Eleganz vermitteln. Ein Kaufsignal kann beispielsweise durch einen einfachen Aufwärtspfeil anstelle einer Volltextbeschriftung dargestellt werden, was sowohl Bildschirmfläche als auch Rechenleistung spart.

Mein Schwerpunkt liegt dabei auf der Gestaltung und Verwaltung von Schnittstellenbereichen. Durch die Einbeziehung von symbolischen Elementen können wir die Unübersichtlichkeit minimieren und die Nutzerfreundlichkeit maximieren. Wingdings ist ein Werkzeug, aber ich möchte auch die Verwendung von nutzerdefinierten Bitmap-Bildern hervorheben. Diese können große Schaltflächen ersetzen, wobei die Funktionalität erhalten bleibt, und bieten eine schlanke und effiziente Alternative, die die Nutzeroberfläche sauber und ansprechend hält.

Obwohl ich mit der Home-Oberfläche New_Admin_Panel bereits einen funktionierenden Erfolg verbuchen kann, lässt ihre optische Erscheinung noch Raum für Verbesserungen. Nun, da die Grundstruktur steht, ist es an der Zeit, das Oberflächendesign zu verfeinern und zu verbessern. Im nächsten Abschnitt werde ich einen Überblick über die heutigen Entwicklungsziele geben und erläutern, wie wir diese Entwicklung vorantreiben wollen.

Überblick über die Diskussion

Das heutige Ziel konzentriert sich auf die Hauptschnittstelle, wo wir die Elemente neu gestalten und organisieren werden, um ein kompakteres und visuell effizienteres Panel zu schaffen. Wir beginnen damit, das Konzept der neuen Nutzeroberfläche und ihrer Komponenten zu skizzieren, und fahren dann mit der Implementierung unter Verwendung von MQL5 fort, wo wir neue Ressourcen integrieren und die verbesserte Version des Admin-Panels kompilieren werden. Nachfolgend finden Sie ein Referenzbild, das Ihnen die Richtung verdeutlichen soll, die wir einschlagen.

Ich habe bereits erwähnt, dass Wingdings ein hervorragendes Beispiel für symbolische Kommunikation ist - es bietet visuelle Hinweise, die die Bedeutung schnell und einfach vermitteln. Sie dienen zwar als ideale Referenz für minimalistische Icons, aber ich habe nicht vor, sie direkt zu verwenden. Stattdessen erwäge ich individuell gestaltete Bitmap-Bilder, die besser zu den ästhetischen und funktionalen Zielen unserer neuen Schnittstelle passen. Tools wie GIMP, ein Open-Source-Bildbearbeitungsprogramm, eignen sich hervorragend für die Erstellung dieser maßgeschneiderten Grafiken.

Sobald die nutzerdefinierten Bilder fertig sind, gehen wir dazu über, ihre Funktionalität zu kodieren und sie in die Funktionen des bestehenden Programms zu integrieren. Mit diesen visuellen Hilfsmitteln können wir sperrige Schaltflächen durch leichtgewichtige Symbole ersetzen und so die visuelle Unübersichtlichkeit verringern, ohne dass die Funktionalität beeinträchtigt wird.

Im Rahmen dieses Entwicklungszyklus werden wir auch die Nutzerauthentifizierung vorübergehend deaktivieren, um die Tests zu optimieren und ständige Anmeldeaufforderungen zu vermeiden. Sicherheit ist in diesem Stadium für das Panel zwar nicht unbedingt erforderlich, wird aber wichtig, wenn das Tool in Umgebungen eingesetzt werden soll, in denen ein unbefugter Zugriff sensible Vorgänge gefährden könnte. Obwohl frühere Implementierungen fest kodierte Werte für die Schlüsselverschlüsselung verwendeten, werden die Entwickler ermutigt, bei Bedarf diesen zusätzlichen Schritt zur sicheren Zugriffsverwaltung zu unternehmen.

Diese Sitzung wird Sie durch die Arbeit mit nutzerdefinierten visuellen Ressourcen in MQL5 führen, vom Konzept bis zur Implementierung. Am Ende wollen wir eine raffinierte, reaktionsschnelle und skalierbare Schnittstelle schaffen, die nicht nur gut funktioniert, sondern auch sauber und modern aussieht.

Neue Skizze der minimierten Nutzeroberfläche (56px x 400px)

Konzeptionelle Gestaltung

Mit diesem Konzept im Hinterkopf - und nachdem ich unter den verfügbaren Ressourcen keine zufriedenstellenden Symboloptionen gefunden hatte - beschloss ich, meine eigenen zu erstellen und dabei Open-Source-Tools für Flexibilität und Anpassung zu nutzen. Für die schnelle Gestaltung meiner Entwürfe habe ich Inkscape verwendet, einen der leistungsfähigsten und effizientesten Vektorgrafik-Editoren auf dem Markt. Allerdings gibt es in Inkscape Einschränkungen, wenn es um den Export bestimmter Dateiformate geht.

Um dieses Problem zu lösen, habe ich GIMP verwendet, um die Bilder weiter zu verfeinern und sie in das gewünschte Bitmap-Format zu exportieren, das für die Integration in MQL5 geeignet ist. Nachfolgend finden Sie das konzeptionelle Layout der Schnittstelle. Nach der Überprüfung des Designs werden wir die Funktionen der einzelnen Schaltflächen aufschlüsseln und dann zur Implementierungsphase im Code übergehen.

Konzeptionelles Layout der AdminHome-Oberfläche

Beschreibung der Home-Tasten und ihrer Funktionen

Schaltfläche zum Einklappen und Erweitern:

Diese Schaltfläche hat zwei Zustände: einen für das Erweitern, wodurch alle Schaltflächen der Schnittstelle sichtbar werden, und einen für das Zusammenklappen, wodurch alle Schaltflächen ausgeblendet werden.

 Einblenden

Ausblenden

Die Schaltfläche „Handelsmanagement“:

Wir haben zwei Pfeilsymbole verwendet, um die Konzepte von Kauf und Verkauf visuell darzustellen. Dies erleichtert es dem Nutzer, den Zweck der Schaltfläche intuitiv auf einen Blick zu erfassen.

 Schaltfläche des Handelsverwaltungspanels

 Gedrückte Schaltfläche des TradeManagement

Schaltflächen des Kommunikationspanels:

Für diese Schaltfläche habe ich ein Envelope-Symbol entworfen, um das Konzept der Kommunikation darzustellen. Dieses vertraute Symbol macht es dem Nutzer leicht, seinen Zweck schnell zu erkennen und seine Funktion auf einen Blick zu verstehen.

 Schaltfläche des Kommunikationspanels

Gedrückte Schaltfläche des Kommunikationspanels

Schaltfläche Analytik-Panel:

Diese Schaltfläche mit einem grafischen Symbol vermittelt auf wirksame Weise den Gedanken der Analyse. Da Charts ein wichtiges Instrument für die Marktanalyse sind, signalisiert das Symbol dem Nutzer sofort seinen Zweck.

 Schaltfläche Analytik-Panel

Gedrückte Schaltfläche von Analytics Panel

Alle Schaltflächen des Panels ein- und ausblenden:

Diese Schaltfläche dient als praktische Verknüpfung zum sofortigen Erweitern oder Verkleinern aller Bereiche. Das Design ist mit divergierenden Pfeilen versehen, die eine erweiterte oder umfassende Sicht symbolisieren und dem Nutzer die Funktion visuell vermitteln.

Alle Schaltfläche ein- und ausblenden

Alle gedrückten Schaltflächen ein- und ausblenden

Tipp:

Damit die Bilder in MetaTrader 5 korrekt funktionieren, musste ich sie mit GIMP im BMP-Format exportieren, und zwar mit einer Einstellung von 24 Bit. Jedes andere Format wird im Terminal nicht richtig angezeigt. Die oben gezeigten Bilder sind im PNG-Format und dienen nur der Illustration. Die aktuellen BMP-Dateien finden Sie in dem angehängten Ordner am Ende dieses Artikels.

Implementierung des Codes

Jetzt beginnen wir mit unserem MQL5-Code zu arbeiten, um das oben beschriebene Konzept zum Leben zu erwecken. Dies bedeutet eine Umgestaltung der Schnittstelle - von der früheren Struktur zu einem raffinierteren und phantasievolleren Design - während wir unser Verwaltungspanel weiter verbessern und weiterentwickeln. Am Ende werden wir eine neue Nutzeroberfläche erstellen, wie sie in der folgenden Abbildung dargestellt ist.

Die Migration von der alten Heimschnittstelle zu einer neuen externen, ressourcenbasierten Schnittstelle

Wie bereits erwähnt, deaktivieren wir vorübergehend die Authentifizierungsfunktion, um Unterbrechungen durch Eingabeaufforderungen während der Tests zu vermeiden. Wichtig ist, dass dies nicht bedeutet, dass die Authentifizierungslogik vollständig entfernt wird. Stattdessen wird der entsprechende Code einfach auskommentiert. Denken Sie daran, dass Kommentare im Code nicht ausgeführt werden; sie dienen dazu, Entwicklern zu helfen, Logik in einfacher Sprache zu kommunizieren und zu erklären.

In diesem Schritt wird auch gezeigt, wie die von uns vorbereiteten nutzerdefinierten Bilder als Ressourcen verwendet werden, die als schwebende Schaltflächen auf der Hauptschnittstelle angezeigt werden. Dies bedeutet eine Abkehr von der Verwendung der Dialogklasse für die Home-Panel-Schnittstelle. Das neue Design ist vereinfacht und minimalistischer.

Lassen Sie uns nun die Struktur unseres Hauptprogramms aufschlüsseln.

1. Übersicht

In diesem Abschnitt geht es darum, ein einfaches Admin-Panel in eine moderne, schwebende Oberfläche mit BMP-Bildschaltflächen zu verwandeln. Ziel ist es, eine Schnittstelle zu schaffen, bei der die als Bilder dargestellten Schaltflächen ihren Zustand ändern (z. B. zwischen „Ausblenden“ und „Einblenden“) und so ein optisch ansprechendes und interaktives Design bieten. Diese Schaltflächen schweben über anderen Chartelementen, wie z. B. Candlesticks, und gewährleisten so eine reibungslose Nutzerinteraktion.

Wir haben externe Module für die Authentifizierung integriert (zusammen mit Kommunikation, Telegram, Dialogsteuerung, Handelsmanagement und Analysen), auch wenn die Authentifizierungslogik selbst derzeit durch Auskommentieren deaktiviert ist. Diese Entscheidung ist vorübergehend, da die Funktionalität noch in Arbeit ist, und sie ermöglicht es uns, uns auf die Entwicklung und das Testen der Floating-Button-Schnittstelle ohne Passwortabfrage zu konzentrieren. Wir können den Authentifizierungscode später mit minimalen Anpassungen wieder aktivieren, sodass ein nahtloser Übergang zu einem vollständig sicheren System möglich ist.

//+------------------------------------------------------------------+
//|                                               New_Admin_Panel.mq5|
//|                                Copyright 2024, Clemence Benjamin |
//|             https://www.mql5.com/en/users/billionaire2024/seller |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, Clemence Benjamin"
#property link      "https://www.mql5.com/en/users/billionaire2024/seller"
#property version   "1.00"

// Authentication inputs (unused; authentication disabled).
input string AuthPassword = "2024";
input string TwoFactorChatID = "YOUR_CHAT_ID";
input string TwoFactorBotToken = "YOUR_BOT_TOKEN";

#include <Authentication.mqh>
#include <CommunicationsDialog.mqh>
#include <Telegram.mqh>
#include <Controls\Dialog.mqh>
#include <TradeManagementPanel.mqh>
#include <AnalyticsPanel.mqh>

2. Datei-Ressourcen in MQL5

MQL5 erlaubt es, externe Dateien - wie z.B. Bilder und Töne - mit Hilfe von Ressourcenanweisungen direkt in das Programm einzubetten. Dieses Projekt verwendet BMP-Bilddateien als Ressourcen für die Erstellung nutzerdefinierter Schaltflächen. Durch Einbetten dieser Bilddateien in Ressource-Anweisungen werden die Bilder mit der ausführbaren Datei verpackt, sodass sie immer verfügbar sind, wenn das Programm ausgeführt wird. Diese Technik ist für den Aufbau einer zuverlässigen und portablen Schnittstelle von entscheidender Bedeutung, da sie unabhängig vom externen Dateisystem einen konsistenten Zugriff auf die erforderlichen visuellen Elemente gewährleistet.

#resource "\\Images\\expand.bmp"
#resource "\\Images\\collapse.bmp"
#resource "\\Images\\TradeManagementPanelButton.bmp"
#resource "\\Images\\TradeManagementPanelButtonPressed.bmp"
#resource "\\Images\\CommunicationPanelButton.bmp"
#resource "\\Images\\CommunicationPanelButtonPressed.bmp"
#resource "\\Images\\AnalyticsPanelButton.bmp"
#resource "\\Images\\AnalyticsPanelButtonPressed.bmp"
#resource "\\Images\\ShowAllHideAllButton.bmp"
#resource "\\Images\\ShowAllHideAllButtonPressed.bmp"

3. Oberflächengestaltung und Schaltflächendesign

Die Schnittstelle besteht aus „Bitmap-Label“-Objekten, die BMP-Bilder anzeigen. Jede Schaltfläche in der Nutzeroberfläche wird durch eines dieser Bildobjekte dargestellt, und ihre Position auf dem Chart wird durch vorher festgelegte Koordinaten definiert. Diesen Objekten wird ein hoher Z-Ordnungswert zugewiesen, sodass sie über anderen Chartelementen gerendert werden und somit sehr schnell auf Klicks des Nutzers reagieren. So wird sichergestellt, dass die schwebenden Schaltflächen nicht nur optisch ansprechend, sondern auch funktional robust sind.

// Button names
string toggleButtonName    = "ToggleButton";
string tradeButtonName     = "TradeButton";
string commButtonName      = "CommButton";
string analyticsButtonName = "AnalyticsButton";
string showAllButtonName   = "ShowAllButton";

// Button original positions
const int BUTTON_TOGGLE_X    = 10;
const int BUTTON_TOGGLE_Y    = 30;
const int BUTTON_TRADE_X     = 10;
const int BUTTON_TRADE_Y     = 100;
const int BUTTON_COMM_X      = 10;
const int BUTTON_COMM_Y      = 170;
const int BUTTON_ANALYTICS_X = 10;
const int BUTTON_ANALYTICS_Y = 240;
const int BUTTON_SHOWALL_X   = 10;
const int BUTTON_SHOWALL_Y   = 310;

4. Technik zum Ausblenden und Einblenden von Schaltflächen

Hilfsfunktionen werden verwendet, um die Schaltflächen an eine bestimmte Koordinate außerhalb des Bildschirms zu verschieben und so einen Klappeffekt zu simulieren. Wenn die Oberfläche erweitert wird, stellt ein weiterer Satz von Hilfsfunktionen die Schaltflächen wieder an ihre ursprüngliche Position auf dem Bildschirm zurück. Diese Technik ist sowohl effizient als auch reaktionsschnell, um die Sichtbarkeit der Elemente der Nutzeroberfläche zu verwalten.

// Off-screen coordinate for hiding buttons
const int HIDDEN_X = -50;

// Hide a button by moving it off-screen.
void HideButton(string buttonName)
{
   ObjectSetInteger(0, buttonName, OBJPROP_XDISTANCE, HIDDEN_X);
}

// Restore a button to its original position.
void ShowButton(string buttonName, int X, int Y)
{
   ObjectSetInteger(0, buttonName, OBJPROP_XDISTANCE, X);
   ObjectSetInteger(0, buttonName, OBJPROP_YDISTANCE, Y);
}

5. Handhabung von Interaktionen zwischen Unterfenstern

Jede Schaltfläche auf der Nutzeroberfläche ist mit einem Unterbereich verknüpft (z. B. Handelsmanagement, Kommunikation oder Analyse). Wenn eine Schaltfläche angeklickt wird, wird das zugehörige Unterfenster entweder erstellt, wenn es noch nicht vorhanden ist, oder zwischen dem sichtbaren und dem ausgeblendetem Zustand umgeschaltet. Diese bedarfsorientierte Erstellung minimiert die Ressourcennutzung und sorgt für eine übersichtliche Nutzeroberfläche. Jeder Unterbereich wird unabhängig verwaltet, sodass der Nutzer jeweils mit einem Bereich arbeiten kann, während er bei Bedarf auf andere Bereiche zugreifen kann.

// Handle the Communications Panel button.
void HandleCommunications()
{
   if(g_commPanel != NULL && g_commPanel.IsVisible())
   {
      g_commPanel.Hide();
      ChartRedraw();
      return;
   }
   if(g_commPanel == NULL)
   {
      g_commPanel = new CCommunicationDialog(TwoFactorChatID, TwoFactorBotToken);
      if(!g_commPanel.Create(g_chart_id, "CommPanel", g_subwin, 80, 100, 380, 300))
      {
         delete g_commPanel;
         g_commPanel = NULL;
         return;
      }
      ObjectSetInteger(0, "CommPanel", OBJPROP_ZORDER, 10);
   }
   g_commPanel.Toggle();
   ChartRedraw();
}

// Handle the Trade Management Panel button.
void HandleTradeManagement()
{
   if(g_tradePanel != NULL && g_tradePanel.IsVisible())
   {
      g_tradePanel.Hide();
      ChartRedraw();
      return;
   }
   if(g_tradePanel == NULL)
   {
      g_tradePanel = new CTradeManagementPanel();
      if(!g_tradePanel.Create(g_chart_id, "TradeManagementPanel", g_subwin, 390, 20, 900, 530))
      {
         delete g_tradePanel;
         g_tradePanel = NULL;
         return;
      }
      ObjectSetInteger(0, "TradeManagementPanel", OBJPROP_ZORDER, 10);
   }
   g_tradePanel.Toggle();
   ChartRedraw();
}

// Handle the Analytics Panel button.
void HandleAnalytics()
{
   if(g_analyticsPanel != NULL && g_analyticsPanel.IsVisible())
   {
      g_analyticsPanel.Hide();
      ChartRedraw();
      return;
   }
   if(g_analyticsPanel == NULL)
   {
      g_analyticsPanel = new CAnalyticsPanel();
      if(!g_analyticsPanel.CreatePanel(g_chart_id, "AnalyticsPanel", g_subwin, 980, 20, 1480, 480))
      {
         delete g_analyticsPanel;
         g_analyticsPanel = NULL;
         return;
      }
      ObjectSetInteger(0, "AnalyticsPanel", OBJPROP_ZORDER, 10);
   }
   g_analyticsPanel.Toggle();
   ChartRedraw();
}

6. Verkapselung der Umschaltlogik zwischen ein- und ausblenden

Um die Verwaltung der Nutzeroberfläche zu vereinfachen, ist die Logik für das Ein- und Ausklappen in einer einzigen Funktion gekapselt. Diese Funktion liest den aktuellen Zustand der Hauptschaltfläche, kehrt ihren Zustand um und stellt dann die Positionen der anderen Schaltflächen entweder wieder her oder versteckt sie. Durch die Kapselung dieser Logik in einer Funktion wird Redundanz im Code für die Ereignisbehandlung vermieden und das Gesamtdesign wird sauberer und leichter zu pflegen.

// Toggle collapse/expand of interface buttons.
void ToggleInterface()
{
   // Toggle the state of the toggle button.
   bool currentState = ObjectGetInteger(0, toggleButtonName, OBJPROP_STATE);
   bool newState = !currentState;
   ObjectSetInteger(0, toggleButtonName, OBJPROP_STATE, newState);
   
   if(newState)
      UpdateButtonVisibility(false);  // Collapse: hide buttons and minimize sub-panels.
   else
      UpdateButtonVisibility(true);   // Expand: restore button positions.
   
   ChartRedraw();
}

7. Programm-Initialisierung

Gründliche Tests sind unerlässlich, um sicherzustellen, dass sich die Schnittstelle wie erwartet verhält. Die Initialisierungsfunktion richtet die Schaltflächen ein und gewährleistet, dass sie von Anfang an sichtbar sind. Beim Testen sollte man überprüfen, ob die Schaltflächen reaktionsschnell sind, ob die Unter-Panels korrekt umgeschaltet werden und ob die Schaltflächen dank der hohen Z-Ordnungswerte immer über den Chartelementen erscheinen. Außerdem ist die Authentifizierung zwar derzeit deaktiviert, aber der entsprechende Code ist als Kommentar enthalten, sodass die Zugriffsbeschränkungen bei Bedarf leicht wieder aktiviert werden können. Zukünftige Erweiterungen könnten die Integration von Sounds oder Animationen umfassen, um das Nutzererlebnis weiter zu verbessern.

// Expert initialization function
int OnInit()
{
   g_chart_id = ChartID();
   g_subwin   = 0;

   // For potential future use, authentication can be re-enabled by uncommenting these:
   // if(!g_authManager.Initialize())
   //    return INIT_FAILED;

   // Create main toggle and sub-panel buttons using their original positions.
   CreateObjectBITMAP_LABEL(toggleButtonName, BUTTON_TOGGLE_X, BUTTON_TOGGLE_Y, "::Images\\expand.bmp", "::Images\\collapse.bmp");
   CreateObjectBITMAP_LABEL(tradeButtonName, BUTTON_TRADE_X, BUTTON_TRADE_Y, "::Images\\TradeManagementPanelButtonPressed.bmp", "::Images\\TradeManagementPanelButton.bmp");
   CreateObjectBITMAP_LABEL(commButtonName, BUTTON_COMM_X, BUTTON_COMM_Y, "::Images\\CommunicationPanelButtonPressed.bmp", "::Images\\CommunicationPanelButton.bmp");
   CreateObjectBITMAP_LABEL(analyticsButtonName, BUTTON_ANALYTICS_X, BUTTON_ANALYTICS_Y, "::Images\\AnalyticsPanelButtonPressed.bmp", "::Images\\AnalyticsPanelButton.bmp");
   CreateObjectBITMAP_LABEL(showAllButtonName, BUTTON_SHOWALL_X, BUTTON_SHOWALL_Y, "::Images\\ShowAllHideAllButtonPressed.bmp", "::Images\\ShowAllHideAllButton.bmp");

   // Always show the interface initially.
   UpdateButtonVisibility(true);
   ChartRedraw();
   return INIT_SUCCEEDED;
}

// Expert deinitialization function
void OnDeinit(const int reason)
{
   ObjectDelete(0, toggleButtonName);
   ObjectDelete(0, tradeButtonName);
   ObjectDelete(0, commButtonName);
   ObjectDelete(0, analyticsButtonName);
   ObjectDelete(0, showAllButtonName);

   if(g_commPanel != NULL)
   {
      g_commPanel.Destroy(reason);
      delete g_commPanel;
      g_commPanel = NULL;
   }
   if(g_tradePanel != NULL)
   {
      g_tradePanel.Destroy(reason);
      delete g_tradePanel;
      g_tradePanel = NULL;
   }
   if(g_analyticsPanel != NULL)
   {
      g_analyticsPanel.Destroy(reason);
      delete g_analyticsPanel;
      g_analyticsPanel = NULL;
   }
}

Tests

Wie in MetaTrader 5 üblich, können Sie Ihr Programm starten, indem Sie es einfach aus der Liste der Expert Advisors auf einen Chart ziehen. Um eine reibungslose Kompilierung und Ausführung zu gewährleisten, ist es wichtig, dass alle externen Module ordnungsgemäß in ihren jeweiligen Ordnern platziert sind und dass alle erforderlichen Ressourcen - wie z. B. Bilder - korrekt organisiert sind.

Unten habe ich ein Bild eingefügt, das das Ergebnis unserer neu gestalteten Schnittstelle zeigt. Anhand dieser Bilder können Sie sich ein klares Bild von der Richtung machen, in die wir uns bewegen, und Bereiche identifizieren, in denen weitere Verbesserungen vorgenommen werden können.

Testen der Schnittstelle New_Admin_Home

Tipp:

Wenn Sie die Schaltfläche „Neu“ zum ersten Mal verwenden, nachdem Sie das Programm zum Chart hinzugefügt haben, wird durch den ersten Klick das entsprechende Feld initialisiert, aber das Feld wird nicht sofort angezeigt. Sie wird erst nach dem zweiten Klick sichtbar.

Schlussfolgerung

Heute haben wir untersucht, wie man externe Ressourcen effektiv nutzen kann, um eine leistungsstarke und anpassbare Nutzeroberfläche in MQL5 zu erstellen. Bei diesem Projekt entwickelten wir eine einfache Home-Oberfläche zu einem dynamischeren und optisch ansprechenderen Floating-Panel-System weiter - unter Beibehaltung der Kernfunktionalität bei gleichzeitiger Einführung neuer Funktionen zur Verbesserung der Nutzerfreundlichkeit und Zugänglichkeit.

Eine der wichtigsten Erkenntnisse ist, dass diese Entwicklung unser Verständnis der Fähigkeiten von MQL5 verbessert, insbesondere im Hinblick auf grafische Ressourcen wie BMP-Bilder. Das Design der schwebenden Schaltflächen bietet einen zentralen Zugriff auf die Funktionen des Verwaltungspanels, während das Chart übersichtlich bleibt und mehr sichtbarer Chartraum (Pixel) für Handelseinblicke erhalten bleibt.

Es sei darauf hingewiesen, dass keine Lösung jemals wirklich perfekt ist. Doch jede Iteration, jeder Schritt nach vorn, bringt uns einer besseren, effizienteren Version näher. Frühere Versionen sind nach wie vor von großer Bedeutung, da sie als Referenzpunkte für Innovationen und Verbesserungen dienen.

Um andere dabei zu unterstützen, ohne Probleme mitzumachen, habe ich mir überlegt, den heutigen Quellcode zusammen mit früheren Modulen in eine einheitliche ZIP-Datei zu packen. Auf diese Weise wird sichergestellt, dass alle erforderlichen Dateien enthalten sind, insbesondere für diejenigen, die eine frühere Einrichtung übersprungen oder verpasst haben. Fehlende Dateien führen oft zu Kompilierfehlern, sodass die Nutzer einen reibungslosen Start haben werden.

Ein besonderer Dank geht an MetaQuotes für ihren informativen Artikel über die Verwendung von Ressourcen in MQL5, der als wertvolle Referenz diente. Die Umsetzung dieser Ideen in einem realen Projekt wie diesem war eine aufschlussreiche und lohnende Erfahrung.

Dateiname	Spezifikationen
New_Admin_Panel.mq5	Das neue Hauptprogramm in neuem Gewand.
New_Admin_Panel_BMP images.zip	Dies ist ein Ordner, der alle verwendeten Bitmap-Bilder enthält. Bitte fügen Sie diese Bilder dem Verzeichnis MQL5\images hinzu, um sicherzustellen, dass sie ordnungsgemäß geladen und von der Schnittstelle angezeigt werden.
All Modules.zip	Ein Ordner, der alle in Teil (IX) verwendeten Header-Dateien enthält. Bitte extrahieren Sie diese Dateien in das Include-Verzeichnis Ihrer MQL5-Installation, um eine korrekte Kompilierung und Funktionalität zu gewährleisten.