Einführung in MQL5 (Teil 9): Verstehen und Verwenden von Objekten in MQL5

Einführung

Willkommen zurück zu unserer MQL5-Serie! In diesem Kapitel werden wir ein faszinierendes Thema behandeln, das Sie sicher sehr nützlich und faszinierend finden werden. Wir werden ein Projekt beginnen, in dem wir mit verschiedenen Chart-Objekten in MQL5 arbeiten werden, was eine wesentliche Grundlage für unsere zukünftigen Projekte sein wird. Dieser Ausgangspunkt ist besonders nützlich, wenn wir uns mit komplexeren Projekten befassen, z. B. mit verschiedenen harmonischen Mustern. Chart-Objekte in MQL5 sind grafische Elemente, die in Handelscharts platziert werden können, um verschiedene Datentypen, einschließlich Preisniveaus, Handelszonen und Textanmerkungen, visuell darzustellen. Diese Objekte bieten Händlern und Entwicklern die Flexibilität, nutzerdefinierte Grafiken zu erstellen, die die Chartanalyse verbessern und das Erkennen von Markttrends, wichtigen Kursniveaus und Handelsmöglichkeiten erleichtern.

In MQL5 stehen verschiedene Chart-Objekte zur Verfügung, von einfachen Linien und Formen bis hin zu komplizierten Komponenten wie Text, Pfeilen und nutzerdefinierten Indikatoren. Durch Ändern von Farbe, Größe, Position und anderen Attributen der einzelnen Objekte kann eine sehr individuelle Handelsumgebung geschaffen werden. Chart-Objekte sind mehr als nur dekorative Akzente; sie sind wirksame Instrumente für eine klare, verständliche visuelle Darstellung von Marktdaten. So kann es beispielsweise einfacher sein, mögliche Umkehrpunkte zu erkennen, wenn Unterstützungs- und Widerstandsniveaus durch Rechtecke hervorgehoben werden. Dieser Artikel führt Sie anhand eines praktischen Projekts in die Idee der Chart-Objekte in MQL5 ein und zeigt Ihnen, wie Sie sie verwenden können.

In diesem Projekt entwickeln wir einen Expert Advisor (EA), der den Handel verbessert, indem er klare Visualisierungen direkt auf dem Chart anzeigt. Der Weg vom Einstiegspunkt bis zu den Stop-Loss- und Take-Profit-Zonen wird vom EA automatisch angezeigt, sodass Sie eine schnelle visuelle Bewertung des Risikos und des Gewinns Ihres Handels erhalten. Ohne dass Sie andere Datenquellen konsultieren müssen, wird der EA in Echtzeit aktualisiert, um Ihren aktuellen Gewinn oder Verlust widerzuspiegeln, wenn sich der Markt bewegt. Darüber hinaus liefert es auf einen Blick präzise Informationen, indem es den Einstiegs-, Stop-Loss- und Take-Profit-Kurs für die aktuelle Position anzeigt.

Die Anpassungsfähigkeit dieses EA an Änderungen in Ihrem Handels-Setup ist eines seiner Hauptmerkmale. Ihre visuellen Hinweise sind immer auf dem neuesten Stand, da der EA das Chart sofort aktualisiert, wenn Sie Ihre Take-Profit- oder Stop-Loss-Ebenen ändern. Der EA passt sich auch an die Länge Ihres Handels an. Wenn Sie den Handel länger halten, passt sich der EA allmählich an, sodass die visuellen Elemente besser sichtbar werden. Auf diese Weise können Sie den Handel mit verschiedenen Zeitrahmen effektiv überwachen, auch wenn sie auf den höheren Zeitrahmen zunächst vielleicht nicht sehr auffällig sind. Dank dieser dynamischen Anpassung ist es nun einfacher, Geschäfte aus niedrigeren Zeitrahmen zu verwalten und sie bei ihren Veränderungen im Auge zu behalten.

Mit dem EA können Sie frühere Handelsgeschäfte untersuchen, was eine aufschlussreiche historische Analyse ermöglicht. Es hilft Ihnen, Ihre Handelsleistung zu bewerten und kluge Entscheidungen zu treffen, indem es Ihnen zeigt, wie viel Sie bei früheren Positionen gewonnen oder verloren haben. Sie können historische Daten direkt im Chart anzeigen, indem Sie den Datumsbereich festlegen. So erhalten Sie einen umfassenden Überblick über Ihre Handelshistorie und haben die Möglichkeit, bestimmte Geschäfte für eine tiefer gehende Analyse heranzuzoomen.

Visualisierung des aktuellen Handels:

Historische Einblicke in den Handel:

In diesem Artikel erfahren Sie mehr darüber:

• Erstellen und Ändern von Chart-Objekten für eine verbesserte visuelle Analyse
• Schleifen durch Positionen zur effizienten Verwaltung und Anzeige der Handelsgeschäfte auf dem Chart
• Nutzung der Daten historischer Handelsgeschäfte für die Platzierung von Chart-Objekten
• Visualisierung historischer Geschäftsgewinne/-verluste auf dem Chart zur Leistungsverfolgung
• Verwendung von Datumsumwandlungen zur genauen Zeitbestimmung bei der Erstellung von Chart-Objekten
• Details zu Einstieg, Take Profit (TP) und Stop Loss (SL) auf dem Chart vermerken
• Verwendung von Eingabeparametern zum Anpassen Ihres Expert Advisors

Dieses Projekt zielt darauf ab, Sie mit den nützlichen Anwendungen von Chart-Objekten in MQL5 vertraut zu machen. Dieser praktische Ansatz zeigt Ihnen, wie Sie Handelsgeschäfte verwalten, die visuelle Analyse verbessern und wichtige Handelsdaten direkt in Ihren Charts anzeigen können, indem Sie Chart-Objekte effizient in Ihren Expert Advisor (EA) integrieren und modifizieren. Damit Sie besser verstehen, wie Sie diese Tools für Handelsentscheidungen und die Leistungsüberwachung nutzen können, werden Sie in diesem Projekt durch den Prozess der Erstellung, Änderung und Verwaltung verschiedener Chart-Objekte geführt.

1.  Chart-Objekte in MQL5

1.1. Was sind Chart-Objekte?

Chart-Objekte in MQL5 sind visuelle Komponenten, die Händler in ihre Charts einfügen können, um die Analyse und Entscheidungsfindung zu verbessern. Bei diesen Objekten kann es sich um kompliziertere Elemente wie Kanäle oder Pfeile, aber auch um einfachere Formen, Linien und Text handeln. Chart-Objekte werden in erster Linie zur visuellen Darstellung wichtiger Daten verwendet, die Händlern bei der Planung von Geschäften, der Bewertung von Marktbedingungen und der Verfolgung offener Positionen helfen. Mit Chart-Objekten können Sie wichtige Kursniveaus hervorheben und Trendlinien auf dem Chart zeichnen, die die Richtung des Marktes anzeigen. Durch die Visualisierung dieser Daten auf dem Chart können Händler fundierte Handelsentscheidungen treffen und die Marktbedingungen schnell einschätzen, anstatt sich nur auf numerische Daten zu verlassen.

1.2. Warum ist die Anpassung von Chart-Objekten wichtig?

Sie können die visuelle Klarheit Ihrer Handelscharts verbessern und sich selbst helfen, bessere Entscheidungen zu treffen, indem Sie die Chart-Objekte anpassen. Indem Sie die Farbe, Größe oder Position dieser Objekte ändern, können Sie das Chart besser an Ihre Handelsvorlieben und Ihren Stil anpassen. Sie können diese Anpassung nutzen, um die wichtigsten Informationen auf einen Blick zu erkennen, indem Sie sie hervorheben.

Wenn Sie Ihr Augenmerk auf Unterstützungs- und Widerstandsniveaus richten, sollten Sie fette, dicke Linien verwenden, die sich in leuchtenden Farben abheben und auch beim schnellen Überfliegen des Charts leicht zu erkennen sind. Auf diese Weise verringern Sie die Wahrscheinlichkeit, dass Sie während einer hektischen Handelssitzung wichtige Signale übersehen. In ähnlicher Weise kann eine stärkere Hervorhebung von Textanmerkungen als visueller Anhaltspunkt dienen, um Sie an wichtige Handelsentscheidungen oder geplante Strategien zu erinnern.

1.3. Chart-Objekte, die wir für das Projekt verwenden werden

In diesem Projekt werden mehrere wichtige MQL5-Chart-Objekte verwendet, um unsere Handelsanalyse zu verbessern. Wir werden die folgenden Chart-Objekte verwenden:

1.3.1. Trend-Linien

Ein wesentliches Instrument in unserem Projekt ist die Trendlinie, die vor allem dazu dient, den aktuellen Marktpreis hinsichtlich wichtiger Trendniveaus zu verfolgen und den Einstiegspunkt zu identifizieren. Um die Gesamtrichtung des Marktes zu bestimmen, zeichnen wir eine Trendlinie zwischen wichtigen Kurspunkten. Wenn sich der Marktpreis ändert (oder „tickt“), wird die Trendlinie in Echtzeit aktualisiert, sodass sie sich kontinuierlich vom anfänglichen Einstiegskurs bis zum letzten Marktpreis erstreckt.

Dadurch wird sichergestellt, dass die Trendlinie immer die aktuellsten Kursdaten widerspiegelt, was die genaue Verfolgung der Performance des Handels und die Entscheidungsfindung für die Verwaltung der Position erleichtert. Die Trendlinie beginnt häufig bei dem Kurs, zu dem die Position eingegangen wurde, und spiegelt den Ausgangspunkt des Handels wider. Die Linie reicht bis zum aktuellen Marktpreis oder Briefkurs. Dies zeigt, wie sich der Preis seit der Eröffnung des Handels bewegt hat.

1.3.2. Textbeschriftungen

Wie die Kommentare auf dem Schaubild zeigen, bieten Textbeschriftungen klare, verständliche Details über verschiedene Facetten eines Handels. Wichtige Informationen wie Einstiegspunkte, Stop-Loss-Levels, Take-Profit-Ziele und andere relevante Hinweise für die Handelsstrategie können darauf angezeigt werden. Durch Hinzufügen von Textbeschriftungen zu wichtigen Bereichen des Charts können Sie wichtige Informationen leicht abrufen, ohne externe Notizen oder Ihr Gedächtnis zu bemühen. Dieses visuelle Hilfsmittel erleichtert es Ihnen, alle Informationen, die Sie für Ihre Entscheidungen benötigen, zur Hand zu haben.

Mit jedem Tick erscheint ein Textlabel, das den aktuellen Gewinn oder Verlust der offenen Position angibt. Mit dieser Echtzeit-Aktualisierung können Sie die Performance ihres Handels im Auge behalten, während sich der Markt bewegt, und Sie erhalten sofort ein Gefühl dafür, ob der Handel in die richtige Richtung geht. Mit einer Kennzeichnung wie +$100 oder -$50 neben dem Handel wird der aktuelle Gewinn oder Verlust in Echtzeit angezeigt, während der Markt tickt. Auf diese Weise können Sie die Leistung Ihres Handels überwachen und notwendige Anpassungen vornehmen.

1.3.3. Rechteckige Objekte

Rechteckige Objekte können unter anderem dazu verwendet werden, Unterstützungs- und Widerstandsniveaus in einem Chart anzuzeigen. In diesem Projekt wird ihre Verwendung jedoch auf die Identifizierung von Gewinn- und Verlustzonen in einem Handel beschränkt sein. Wenn eine Position gerade Geld verliert, zeichnen wir ein Rechteck vom Einstiegspunkt bis zum Stop-Loss-Niveau. So können wir schnell erkennen, wann sich die Position dem Stop-Loss nähert, indem wir den Bereich, in dem sich der Handel in eine negative Richtung entwickelt, visuell darstellen. Sobald die Position im Gewinn ist, wird ein Rechteck vom Einstiegspunkt zum Take-Profit-Level gezeichnet. Dies hilft uns, den Fortschritt der Position in Richtung des Take-Profit-Ziels zu verfolgen, indem wir die Bereiche hervorheben, in der sie sich gut entwickelt.

Es gibt viele verschiedene Chart-Objekte in MQL5, und jedes von ihnen soll die Handelsanalyse auf eine bestimmte Weise verbessern. Es würde jedoch den Rahmen sprengen, alle diese Punkte in einem Artikel zu behandeln. Aus diesem Grund habe ich mich auf die Gegenstände beschränkt, die in unserem Projekt verwendet werden. Diese ausgewählten Objekte, zu denen Rechtecke, Trendlinien und Textbeschriftungen gehören, sind nicht nur für diese spezielle Strategie unerlässlich, sondern haben auch Erstellungs- und Änderungsprozesse, die mit denen anderer MQL5-Objekte vergleichbar sind. Sie erwerben die grundlegenden Kenntnisse, die für die Arbeit mit verschiedenen Chart-Objekten in MQL5 erforderlich sind, und verwenden vergleichbare Methoden, um sie entsprechend Ihren Handelsbedürfnissen zu erstellen und zu verändern, indem Sie die Konzepte und Strategien für diese speziellen Objekte verstehen.

2. Anlegen und Anpassen von Objekten

In diesem Abschnitt werden wir uns auf das Erstellen und Ändern verschiedener Chart-Objekte in MQL5 konzentrieren. Es wird gezeigt, wie man Objekte wie Rechtecke, Trendlinien und Textbeschriftungen erstellt und wie man ihre Farbe, ihren Stil und ihre Breite an den eigenen Handelsplan anpasst. 

2.1. Pseudocode

In diesem Projekt ist Pseudocode unerlässlich, da er vor dem Schreiben von Code eine gut organisierte und prägnante Zusammenfassung der Überlegungen und Verfahren bietet, die zum Erreichen unserer Ziele erforderlich sind. Sie hilft bei der Zerlegung schwieriger Aufgaben in kleinere, leichter zu handhabende Komponenten, was die Planung erleichtert, hilft, mögliche Probleme zu erkennen, und garantiert, dass der von uns geschriebene Code effizient und gut organisiert ist. Pseudocode ermöglicht es uns, den gesamten Ablauf des Expert Advisors zu visualisieren, was die Implementierung von Chart-Objekten und anderen Funktionen erleichtert.

Dies ist der grundlegende Pseudocode unseres EAs:

1. Initialisierung:

• Definiere die Farben für die SL-Zone, die TP-Zone und die Trendlinie.
• Stelle den Positionsindex ein.
• Gib an, ob historische Daten angezeigt werden sollen.
• Definiere das Anfangs- und Enddatum für historische Daten.
• Stelle die Zeit für das Schließen der Zone ein.
• Ruf die aktuellen Chart-ID ab.
• Initialisiere die Variablen zum Speichern von Positionsdetails (Eröffnungskurs, Stop Loss, Take Profit, Gewinn, Eröffnungszeit).

2.  Bei jedem Tick:

• Konvertiere die Zeichenkette time in ein datetime-Objekt für die Zone von close.
• Ermittele den aktuellen Briefkurs (ask).
• Iteriere durch alle Positionen.
• Hole die Ticketnummer für die Position.
• Prüfe, ob die Position mit dem Chart-Symbol übereinstimmt.
• Rufe Details ab: Eröffnungskurs, Stop Loss, Take Profit, Eröffnungszeit und Gewinn.
• Wenn die Position mit dem angegebenen Index übereinstimmt.
• Erstelle und konfiguriere ein Rechteck der SL-Zone.
• Lege die Eigenschaften fest (Farbe, Stil, Breite, Füllung).
• Erstelle und konfiguriere ein Rechteck der TP-Zone.
• Lege die Eigenschaften fest (Farbe, Stil, Breite, Füllung).
• Erstelle und konfiguriere eine Trendlinie.
• Lege die Eigenschaften (Farbe, Stil, Breite) fest.
• Berechne und zeige den Positionsgewinn.
• Formatiere und zeige den Gewinn als Text.
• Erstelle und konfiguriere Textobjekte für Eröffnung, TP und SL:
• Lege die Eigenschaften (Farbe, Schriftgröße) fest.

3. Wenn die Anzeige historischer Daten aktiviert ist:

• Lösche die vorherigen Kommentare.
• Wähle historische Geschäfte innerhalb des angegebenen Datumsbereichs aus und iteriere mit einer Schleife durch die Liste:
• Ruf die Details zu jedem Geschäft (Eröffnungskurs, Schlusskurs, SL, TP, Gewinn, Zeiten) ab.
• Zeige Gewinn-/Verlustinformationen.
• Erstelle und konfiguriere SL-Zone, TP-Zone und die Trendlinie für historische Geschäfte:
• Lege die Eigenschaften (Farbe, Stil, Breite) fest.

2.2. Praktische Anwendung: Anlegen und Anpassen von Objekten

2.2.1 Erstellung von Chart-Objekten

Ein wichtiges Werkzeug in MQL5, mit dem Sie verschiedene Arten von Objekten in Ihrem Trading-Chart erstellen können, ist die Funktion ObjectCreate(). Zu diesen Objekten, die Händlern helfen, Marktdaten besser zu visualisieren, Trends zu analysieren und wichtige Punkte im Chart zu markieren, können Trendlinien, Rechtecke, Textbeschriftungen, Pfeile und vieles mehr gehören.

Mehr als nur Erstellen: Festlegen der Objektplatzierung

Mit ObjectCreate() können Sie nicht nur Objekte im Chart erstellen, sondern Sie können mit den Parametern auch genau steuern, wo diese Objekte erscheinen. Sie können die Effektivität Ihrer Analyse gezielt verbessern, indem Sie diese Objekte an bestimmten Stellen in Ihrem Chart platzieren und bestimmte Parameter angeben. Zeit und Preis sind die beiden Hauptfaktoren, die bestimmen, wo die Artikel in der Tabelle platziert werden. Diese Elemente dienen als Anker für das Objekt auf dem Chart an dieser bestimmten Stelle.

Syntax:

ObjectCreate(chart_id, object_name, object_type, sub_window, time1, price1, time2, price2, time3, price3);

Das Verhältnis zwischen Zeit und Preis bei der Objektplatzierung

Jeder Punkt auf einem Handelschart in MQL5 wird durch das Zusammenspiel von Preis (die vertikale Achse) und Zeit (die horizontale Achse) bestimmt. Diese beiden Dimensionen werden verwendet, um die genaue Position des Objekts im Chart anzugeben, wenn Sie es mit ObjectCreate erstellen

Verstehen der Ankerpunkte: time1, price1, time2, price2, time3, price3

Es ist üblich, einen oder mehrere Ankerpunkte zu definieren, wenn ObjectCreate() verwendet wird, um Objekte zu erstellen. Die genaue Position des Objekts auf der Chart wird durch diese Ankerpunkte festgelegt. Diese Ankerpunkte sind die Parameter time1, price1, time2, price2, time3 und price3.

• time1 und price1: Diese Parameter legen den anfänglichen Ankerpunkt des Objekts fest. Wenn Sie beispielsweise eine Trendlinie zeichnen, würde time1 den Zeitpunkt des Startpunkts angeben (z. B. eine bestimmte Kerze), und price1 würde das Preisniveau zu diesem Zeitpunkt angeben.
• time2 und price2: Geben Sie den zweiten Ankerpunkt des Objekts an. Dies wäre der Endpunkt der Linie im Beispiel der Trendlinie. Preis2 gibt das Preisniveau zu diesem Zeitpunkt an, und Zeit2 gibt den Zeitpunkt des zweiten Punktes an.
  

• time3, price3: Ein dritter Ankerpunkt ist für bestimmte kompliziertere Objekte, wie Kanäle oder Dreiecke, erforderlich. Sie können diesen dritten Punkt mit time3 und price3 angeben, was beim Zeichnen einiger Formen, die drei Koordinaten erfordern, erforderlich sein kann.

Beispiel:

// Get the ID of the current chart
long chart_id = ChartID();

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
// Define the first anchor point for the trendline
// 'time1' is the datetime for the first point, and 'price1' is the price at that time
   datetime time1  = D'2024.08.21 16:00';
   double   price1 = 8766.01;

// Define the second anchor point for the trendline
// 'time2' is the datetime for the second point, and 'price2' is the price at that time
   datetime time2  = D'2024.08.28 08:00';
   double   price2 = 8854.51;

// Create a trendline object on the chart
// 'chart_id' is the ID of the chart where the object will be placed
// "Trend Line" is the name of the trendline object
// 'OBJ_TREND' specifies that the object is a trendline
// The last four parameters (0, time1, price1, time2, price2) specify the anchor points of the trendline
   ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, time1, price1, time2, price2);
  }

Ausgabe:

Textbeschriftungen (OBJ_TEXT) können mit nur einem Ankerpunkt auf dem Chart positioniert werden. Der Ankerpunkt gibt die Position des Textes auf der Grundlage der angegebenen Preis- und Zeitkoordinaten an. Eine Textbeschriftung auf dem Chart, die zu einem bestimmten Zeitpunkt und Preis „Hier kaufen“ lautet.

Beispiel:

// Get the ID of the current chart
long chart_id = ChartID();

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
// Define the time for the text label's position (August 21, 2024, at 16:00)
   datetime time1  = D'2024.08.21 16:00';

// Define the price level for the text label's position (8766.01)
   double   price1 = 8766.01;

// Create a text object named "Text" on the chart at the specified time and price
   ObjectCreate(chart_id, "Text", OBJ_TEXT, 0, time1, price1);

// Set the text content of the object to display "Buy Here"
   ObjectSetString(chart_id, "Text", OBJPROP_TEXT, "Buy Here");
  }

Ausgabe:

2.3. Objekte anpassen

Sie können die visuellen Komponenten der Chart-Objekte an Ihren Handelsstil anpassen. Wenn es Ihnen gefällt, können Sie auch ihre Größe, Farbe und ihren Stil ändern. Um eine Trendlinie von anderen Elementen im Chart abzuheben, können Sie beispielsweise ihre Farbe, Dicke und Position ändern, um sicherzustellen, dass sie zu wichtigen Marktniveaus passt.  Ebenso können Textbeschriftungen durch Änderung der Schriftart und des Farbschemas verändert werden, um die Aufmerksamkeit auf wichtige Details wie Gewinnziele oder Einstiegspunkte zu lenken.

Beispiel:

// Define the time for the text label's position (August 21, 2024, at 16:00)
datetime time1  = D'2024.08.21 16:00';

// Define the price level for the text label's position (8766.01)
double   price1 = 8766.01;

// Create a text object named "Text" on the chart at the specified time and price
ObjectCreate(chart_id, "Text", OBJ_TEXT, 0, time1, price1);

// Set the text content of the object to display "Buy Here"
ObjectSetString(chart_id, "Text", OBJPROP_TEXT, "Buy Here");

// Set the color of the text object to Medium Blue
ObjectSetInteger(chart_id, "Text", OBJPROP_COLOR, clrMediumBlue);

Dieser Code zeigt den Text „Buy Here“ an, fügt dem Chart zu einem bestimmten Zeitpunkt und Preis eine Textbeschriftung hinzu und ändert die Farbe des Textes in Mittelblau.

Ausgabe:

2.3.1. Objektfunktionen zur Anpassung von Chart-Objekten in MQL5

Chart-Objekte in MQL5 können durch die Verwendung verschiedener Objektfunktionen angepasst werden. Mit Hilfe dieser Funktionen können Sie das Aussehen, die Darstellung und die Position von Chart-Objekten ändern, um Ihren individuellen Handelsanforderungen besser gerecht zu werden.

ObjectSetInteger()

Sie wird verwendet, um ganzzahlige Eigenschaften eines Chart-Objekts, wie Farbe, Breite und Stil, festzulegen.

Beispiel:

// Get the ID of the current chart
long chart_id = ChartID();

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {

   datetime time1  = D'2024.08.21 16:00';
   double   price1 = 8766.01;

// Define the second anchor point for the trendline
// 'time2' is the datetime for the second point, and 'price2' is the price at that time
   datetime time2  = D'2024.08.28 08:00';
   double   price2 = 8854.51;

// Create a trend line object on the chart with the name "Trend Line"
// The trend line will be drawn from time1/price1 to time2/price2
   ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, time1, price1, time2, price2);

// Set the style of the trend line to a dashed line
   ObjectSetInteger(chart_id, "Trend Line", OBJPROP_STYLE, STYLE_DASH);

// Set the width of the trend line to 2
   ObjectSetInteger(chart_id, "Trend Line", OBJPROP_WIDTH, 2);
  }

Ausgabe:

ObjectSetDouble()

Sie setzt Attribute vom doppelten Typ, häufig über Preis oder Zeit. Beispiel: Anpassen der Koordinaten von Ankerpunkten auf einer Trendlinie.

ObjectSetString()

Sie dient zum Festlegen von Eigenschaften des Typs „string“, wie z. B. dem von einer Textbeschriftung angezeigten Text.

Beispiel: Hinzufügen von Anmerkungen oder Notizen direkt auf dem Chart.

// Create a text object named "Text" on the chart at the specified time and price
ObjectCreate(chart_id, "Text", OBJ_TEXT, 0, time1, price1);

// Set the text content of the object to display "Buy Here"
ObjectSetString(chart_id, "Text", OBJPROP_TEXT, "Buy Here");

Verschiedene Arten von Chart-Objekten können zum Erstellen, Anpassen und Verwalten mit verschiedenen in MQL5 verfügbaren Objektfunktionen verwendet werden. Diese Funktionen sind entscheidend für die Verbesserung der visuellen Darstellung von Handelsdaten in Ihren Charts. ObjectCreate und ObjectSetInteger sind zwei wichtige Funktionen, die wir in unserem Projekt besprochen haben, aber es gibt noch viele weitere. Für ein tieferes Verständnis zusätzlicher Funktionen können Sie die MQL5-Dokumentation zu Rate ziehen, die ausführliche Details zu allen verfügbaren Chartfunktionen enthält.

3. Implementierung von Chart-Objekten in unserem Projekt

3.1. Chart-Objekte für aktuelle Positionen erstellen

Dieser Abschnitt befasst sich mit der Konfiguration von Chart-Objekten zur Verarbeitung und Darstellung von Daten über die aktuellen Positionen im Chart. Zur visuellen Darstellung von Echtzeit-Handelsdaten müssen Rechtecke, Trendlinien und Textbeschriftungen erstellt und geändert werden.

3.1.1. Rechtecke zum Hervorheben von Bereichen verwenden

Wir werden zwei verschiedene Rechtecke verwenden, um die kritischen Zonen auf Ihrem Chart visuell hervorzuheben, in denen der Stop Loss (SL) und der Take Profit (TP) festgelegt sind. Diese Rechtecke stellen dynamisch die SL- und TP-Zonen dar, sodass Sie die Risiko- und Ertragsstufen auf einen Blick im Auge behalten können.

a. Hervorhebung der SL-Zone:

• Anker 1: Der erste Anker des SL-Zonen-Rechtecks wird auf den Einstiegskurs des Handels und den genauen Zeitpunkt der Positionseröffnung gesetzt.
• Anker 2: Der zweite Anker wird am SL-Kurs positioniert und erstreckt sich horizontal bis 23:59 Uhr des aktuellen Tages. Diese Erweiterung sorgt dafür, dass das Rechteck jeden Tag dynamisch aktualisiert wird und die SL-Zone visuell abdeckt , bis der Handel entweder geschlossen wird oder der Tag endet.
• Zweck: Dieses Rechteck markiert den Risikobereich auf dem Chart, sodass Sie schnell erkennen können, wie nah der aktuelle Kurs am SL-Level liegt.

b. Hervorhebung der TP-Zone:

• Anker 1: Der erste Anker des TP-Zonen-Rechtecks beginnt ebenfalls mit dem Einstiegskurs des Handels.
• Anker 2: Der zweite Anker, der sich horizontal bis 23:59 Uhr des aktuellen Tages erstreckt, wird am TP-Kurs für die aktuelle Position positioniert. Wie die SL-Zone wird auch der potenzielle Belohnungsbereich jeden Tag durch dieses sich erweiternde Rechteck hervorgehoben.

Die Rechtecke, die die SL- und TP-Zonen hervorheben, können erst erstellt werden, nachdem wir die notwendigen Informationen für jede Position programmatisch abgerufen haben. Dies umfasst den Eröffnungskurs, das Stop-Loss-Niveau (SL), das Take-Profit-Niveau (TP) und den Zeitpunkt, zu dem der Handel eröffnet wurde. Wir stellen sicher, dass die Rechtecke auf dem Chart richtig positioniert sind, indem wir diese Werte programmgesteuert abrufen und für jede Position die entsprechenden Niveaus und Zeiten festlegen. Dank dieser automatisierten Methode können die Rechtecke auch dynamisch mit neuen Positionen aktualisiert werden, sodass die visuelle Darstellung stets aktuell und relevant ist.

Beispiel:

// Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      // Retrieve and store the entry price of the position
      open_price = PositionGetDouble(POSITION_PRICE_OPEN);

      // Retrieve and store the Stop Loss level of the position
      stop_loss = PositionGetDouble(POSITION_SL);

      // Retrieve and store the Take Profit level of the position
      take_profit = PositionGetDouble(POSITION_TP);

      // Retrieve and store the open time of the position
      position_open_time = (int)PositionGetInteger(POSITION_TIME);

      // Print the retrieved values for debugging or verification
      Print("Open Price index ",i,": ",open_price);
      Print("SL index ",i,": ",stop_loss);
      Print("TP index ",i,": ",take_profit);
      Print("Open time index ",i,": ",position_open_time);
     }
  }

Erläuterung:

Jedes Mal, wenn der Kurs des Handelsinstruments tickt oder sich ändert, führt die Funktion OnTick den Code aus. Zu jeder offenen Position im Handelskonto werden wichtige Informationen abgerufen. Es wird durch alle offenen Positionen auf dem Handelskonto iteriert. Die Funktion PositionsTotal() liefert spezifische Informationen über jede Position auf der Grundlage ihres Index in der Gesamtliste der Positionen. Wir verwenden die Funktionen PositionGetDouble und PositionGetInteger, um diese Details abzurufen. Zur Fehlersuche oder Überprüfung werden die abgerufenen Daten auf dem Terminal ausgedruckt, bevor dem Chart visuelle Elemente hinzugefügt werden, wie z. B. Rechtecke, die die SL- und TP-Zonen hervorheben. Dadurch wird gewährleistet, dass genaue Daten erfasst werden.

Bei der derzeitigen Umsetzung ergeben sich zwei Probleme:

• Identifizierung der genauen Position: Im Moment weiß der EA nicht, welche Position er genau durchläuft, um die Zeit- und Preisdaten zu erhalten. Das bedeutet, dass der Code Daten aus allen offenen Positionen extrahiert, wenn wir nur Informationen zu einer bestimmten Position benötigen, was zu Verwirrung oder zur Verwendung falscher Daten führen kann.
• Spezifische Daten für das Chart-Instrument: Die Informationen, die abgerufen werden, müssen sich auf die offenen Positionen und Geschäfte beziehen, die das Instrument betreffen, das derzeit auf dem Chart angezeigt wird. Der EA könnte Daten aus den Positionen anderer Instrumente extrahieren, die für den aktuellen Chart nicht relevant wären, wenn das Symbol im Chart nicht herausgefiltert würde, was zu ungenauen oder irreführenden visuellen Darstellungen führen könnte.

Die Lösung für dieses Problem ist die Bereitstellung einer Eingabe, bei der der Nutzer auswählen kann, von welchem Positionsindex er Daten abrufen möchte. Mit diesen Informationen kann sich der EA auf die spezielle Rolle konzentrieren, die der Nutzer sucht. Der Code sollte auch sicherstellen, dass die gewählte Position mit dem Instrument übereinstimmt, das gerade auf dem Chart zu sehen ist, um zu gewährleisten, dass nur relevante Daten für die visuelle Darstellung verwendet werden.

Beispiel:

// Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position

// Define the position index for the first position
input int position_index  = 0; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();


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


// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      if(PositionGetInteger(POSITION_TICKET) == PositionGetTicket(position_index) && PositionGetString(POSITION_SYMBOL) == ChartSymbol(chart_id))
        {

         // Retrieve and store the entry price of the position
         open_price = PositionGetDouble(POSITION_PRICE_OPEN);

         // Retrieve and store the Stop Loss level of the position
         stop_loss = PositionGetDouble(POSITION_SL);

         // Retrieve and store the Take Profit level of the position
         take_profit = PositionGetDouble(POSITION_TP);

         // Retrieve and store the open time of the position
         position_open_time = (int)PositionGetInteger(POSITION_TIME);

         // Print the retrieved values for debugging or verification
         Print("Open Price index ",i,": ",open_price);
         Print("SL index ",i,": ",stop_loss);
         Print("TP index ",i,": ",take_profit);
         Print("Open time index ",i,": ",position_open_time);

        }
     }

  }

Der Algorithmus durchläuft jede offene Position, stellt fest, ob sie dem gewählten Index und Chartsymbol entspricht, und ermittelt dann die entsprechenden Informationen. Wir können nun die beiden Rechtecke erstellen, die die Zonen von SL (Stop Loss) und TP (Take Profit) anzeigen, nachdem wir erfolgreich die Preis- und Zeitdaten für die gegebene Position abgerufen haben. Um zu gewährleisten, dass diese Rechtecke die SL- und TP-Zonen auf dem Chart angemessen darstellen, werden die erfassten Daten als Input für die Funktion ObjectCreate() verwendet.

Beispiel:

// Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position

// Define the position index for the first position
input int position_index  = 1; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();  // Store the ID of the current chart

string time = "23:59";      // Define a specific time as a string

// Define the color for the losing zone
input color sl_zonez_color   = clrPink; // Choose a color for Losing Zone

// Define the color for the winning zone
input color tp_zonez_color   = clrSpringGreen; // Choose a color for Winning Zone


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

// Convert the string time to datetime
   datetime close_zone = StringToTime(time);

// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      // Check if the position matches the specified index and symbol of the current chart
      if(PositionGetInteger(POSITION_TICKET) == PositionGetTicket(position_index) && PositionGetString(POSITION_SYMBOL) == ChartSymbol(chart_id))
        {

         // Retrieve and store the entry price of the position
         open_price = PositionGetDouble(POSITION_PRICE_OPEN);

         // Retrieve and store the Stop Loss level of the position
         stop_loss = PositionGetDouble(POSITION_SL);

         // Retrieve and store the Take Profit level of the position
         take_profit = PositionGetDouble(POSITION_TP);

         // Retrieve and store the open time of the position
         position_open_time = (int)PositionGetInteger(POSITION_TIME);

         // Print the retrieved values for debugging or verification
         Print("Open Price index ",i,": ",open_price);
         Print("SL index ",i,": ",stop_loss);
         Print("TP index ",i,": ",take_profit);
         Print("Open time index ",i,": ",position_open_time);

         // Create a rectangle to represent the Stop Loss (SL) zone on the chart
         ObjectCreate(chart_id, "SL Zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, stop_loss);

         // Create a rectangle to represent the Take Profit (TP) zone on the chart
         ObjectCreate(chart_id, "TP zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, take_profit);

         // Set properties for the SL zone rectangle
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_COLOR, sl_zonez_color); // Set color to the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_FILL, sl_zonez_color);  // Fill the rectangle with the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

         // Set properties for the TP zone rectangle
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_COLOR, tp_zonez_color); // Set color to the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_FILL, tp_zonez_color);  // Fill the rectangle with the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

        }
     }

  }

Erläuterung:

Dieser Code ermittelt für jede Position die Eröffnungszeit, den SL, den TP und den Eröffnungskurs der Position. Anhand dieser Informationen werden zwei sichtbare Rechtecke auf dem Chart gezeichnet: eines für den möglichen Verlustbereich und ein weiteres für den potenziellen Gewinnbereich. Andererseits könnte die Nichtangabe von TP- oder SL zu Problemen mit den Ankerpunkten dieser Rechtecke führen, was sich auf ihre Positionierung oder Darstellung im Chart auswirken könnte. Um eine genaue Visualisierung zu gewährleisten, werde ich einen Code implementieren, der dieses Verhalten korrigiert.

if(stop_loss > 0)
  {
// Create a rectangle to represent the Stop Loss (SL) zone on the chart
   ObjectCreate(chart_id, "SL Zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, stop_loss);
  }


if(take_profit > 0)
  {
// Create a rectangle to represent the Take Profit (TP) zone on the chart
   ObjectCreate(chart_id, "TP zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, take_profit);
  }

Erläuterung:

Bevor die entsprechenden Rechtecke auf dem Chart erstellt werden, prüft das Codeschnipsel, ob Stop-Loss und Take-Profit größer als Null sind. Wenn der SL gesetzt ist (d.h. größer als 0), wird ein Rechteck gezeichnet, das die SL-Zone darstellt und den potenziellen Verlustbereich markiert; wenn der TP gesetzt ist, wird ein weiteres Rechteck erstellt, das die TP-Zone darstellt und den potenziellen Gewinnbereich angibt. Indem sie die Erstellung von Rechtecken mit ungültigen Ankerpunkten verhindern, gewährleisten diese Prüfungen eine genaue Chart-Darstellung.

Ausgabe:

3.1.2. Erstellen von Trend-Linien

Zur Veranschaulichung der Kursbewegung seit der Eröffnung des Geschäfts konzentrieren wir uns in diesem Teil auf das Zeichnen einer Trendlinie vom Eröffnungskurs der Position bis zum aktuellen Kurs. Es ist leicht zu erkennen, wie sich der Markt um diese beiden Eingangsorte herum verändert hat, was eine genauere Untersuchung der Entwicklung des Handels ermöglicht.

Beispiel:

// Get the current ask price
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
// Create a trend line object on the chart from the position's open time and price to the current time and ask price
ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, position_open_time, open_price, TimeCurrent(), ask);

// Set the color of the trend line
ObjectSetInteger(chart_id, "Trend Line", OBJPROP_COLOR, clrYellow);

// Set the style of the trend line to dashed
ObjectSetInteger(chart_id, "Trend Line", OBJPROP_STYLE, STYLE_DASH);

// Set the width of the trend line
ObjectSetInteger(chart_id, "Trend Line", OBJPROP_WIDTH, 2);

Ausgabe:

3.1.3. Hinzufügen von Textbeschriftungen

In dieser Phase werden wir das Chart mit vier verschiedenen Textbeschriftungen versehen. Der Eröffnungskurs, Take-Profit (TP), Stop-Loss (SL) und der aktuelle Gewinn werden von dieser Textbeschriftung angezeigt. Diese wichtigen Handelsparameter haben eindeutige visuelle Bezüge für jede Textbeschriftung im Chart, was es einfacher macht, den Status der Transaktion direkt im Chart im Auge zu behalten.

Beispiel:

// Variables to store position details
double open_price;          // Variable to store the entry price of the position
double stop_loss;           // Variable to store the Stop Loss level of the position
double take_profit;         // Variable to store the Take Profit level of the position
datetime position_open_time; // Variable to store the open time of the position


// Define the position index for the first position
input int position_index  = 1; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();  // Store the ID of the current chart

string time = "23:59";      // Define a specific time as a string

// Define the color for the losing zone
input color sl_zonez_color   = clrPink; // Choose a color for Losing Zone

// Define the color for the winning zone
input color tp_zonez_color   = clrSpringGreen; // Choose a color for Winning Zone

// Define the color for the trend line
input color line_zonez_color = clrYellow; // Choose a color for the line


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

// Get the current ask price
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

// Convert the string time to datetime
   datetime close_zone = StringToTime(time);

// Loop through all open positions
   for(int i = 0; i < PositionsTotal(); i++)
     {
      // Get the ticket number of the position at index 'i'
      ulong ticket = PositionGetTicket(i);

      // Check if the position matches the specified index and symbol of the current chart
      if(PositionGetInteger(POSITION_TICKET) == PositionGetTicket(position_index) && PositionGetString(POSITION_SYMBOL) == ChartSymbol(chart_id))
        {

         // Retrieve and store the entry price of the position
         open_price = PositionGetDouble(POSITION_PRICE_OPEN);

         // Retrieve and store the Stop Loss level of the position
         stop_loss = PositionGetDouble(POSITION_SL);

         // Retrieve and store the Take Profit level of the position
         take_profit = PositionGetDouble(POSITION_TP);

         // Retrieve and store the open time of the position
         position_open_time = (int)PositionGetInteger(POSITION_TIME);



         if(stop_loss > 0)
           {
            // Create a rectangle to represent the Stop Loss (SL) zone on the chart
            ObjectCreate(chart_id, "SL Zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, stop_loss);
           }

         if(take_profit > 0)
           {
            // Create a rectangle to represent the Take Profit (TP) zone on the chart
            ObjectCreate(chart_id, "TP zone", OBJ_RECTANGLE, 0, position_open_time, open_price, close_zone, take_profit);
           }

         // Set properties for the SL zone rectangle
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_COLOR, sl_zonez_color); // Set color to the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_FILL, sl_zonez_color);  // Fill the rectangle with the selected SL zone color
         ObjectSetInteger(chart_id, "SL Zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

         // Set properties for the TP zone rectangle
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_COLOR, tp_zonez_color); // Set color to the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_STYLE, STYLE_SOLID);    // Set style to solid
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_WIDTH, 1);              // Set the width of the rectangle border
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_FILL, tp_zonez_color);  // Fill the rectangle with the selected TP zone color
         ObjectSetInteger(chart_id, "TP zone", OBJPROP_BACK, true);            // Set the rectangle to appear behind the chart objects

         // Create a trend line object on the chart from the position's open time and price to the current time and ask price
         ObjectCreate(chart_id, "Trend Line", OBJ_TREND, 0, position_open_time, open_price, TimeCurrent(), ask);

         // Set Trend Line properties
         ObjectSetInteger(chart_id, "Trend Line", OBJPROP_COLOR, line_zonez_color);
         ObjectSetInteger(chart_id, "Trend Line", OBJPROP_STYLE, STYLE_DASH);
         ObjectSetInteger(chart_id, "Trend Line", OBJPROP_WIDTH, 2);



         // Calculate the profit of the current position
         double profit = PositionGetDouble(POSITION_PROFIT);

         // Variables to store the formatted profit text
         string curent_profits;
         string profit_to_string;

         // Check if the profit is positive or zero
         if(profit >= 0)
           {
            // Convert the profit to a string with 2 decimal places
            profit_to_string = DoubleToString(profit, 2);
            // Format the profit as a positive amount with a '+' sign
            curent_profits = StringFormat("+$%s", profit_to_string);
           }
         // Check if the profit is negative
         else
            if(profit < 0)
              {
               // Convert the negative profit to a positive number
               double profit_to_positive = MathAbs(profit);
               // Convert the positive profit to a string with 2 decimal places
               profit_to_string = DoubleToString(profit_to_positive, 2);
               // Format the profit as a negative amount with a '-' sign
               curent_profits = StringFormat("-$%s", profit_to_string);
              }

         // Create a text label on the chart to display the current profit
         string text_object_name = "Profit";
         ObjectCreate(chart_id, text_object_name, OBJ_TEXT, 0, TimeCurrent(), ask);
         ObjectSetString(chart_id, text_object_name, OBJPROP_TEXT, curent_profits);

         // Set the color of the profit text based on whether the profit is positive or negative
         if(profit > 0)
           {
            ObjectSetInteger(chart_id, text_object_name, OBJPROP_COLOR, clrMediumBlue); // Positive profit in blue
           }
         else
            if(profit < 0)
              {
               ObjectSetInteger(chart_id, text_object_name, OBJPROP_COLOR, clrRed); // Negative profit in red
              }

         // Display the Take Profit (TP) level on the chart
         string tp_display = "TP";
         string t_display = StringFormat("Take Profit: %.5f", take_profit);
         ObjectCreate(chart_id, tp_display, OBJ_TEXT, 0, close_zone, take_profit);
         ObjectSetString(chart_id, tp_display, OBJPROP_TEXT, t_display);
         ObjectSetInteger(chart_id, tp_display, OBJPROP_COLOR, clrBlue); // TP text in blue
         ObjectSetInteger(chart_id, tp_display, OBJPROP_FONTSIZE, 8); // Set font size for TP

         // Display the Stop Loss (SL) level on the chart
         string sl_display = "SL";
         string s_display = StringFormat("Stop Loss: %.5f", stop_loss);
         ObjectCreate(chart_id, sl_display, OBJ_TEXT, 0, close_zone, stop_loss);
         ObjectSetString(chart_id, sl_display, OBJPROP_TEXT, s_display);
         ObjectSetInteger(chart_id, sl_display, OBJPROP_COLOR, clrRed); // SL text in red
         ObjectSetInteger(chart_id, sl_display, OBJPROP_FONTSIZE, 8); // Set font size for SL

         // Display the Entry Price on the chart
         string en_display = "Entry Price";
         string e_display = StringFormat("Entry Point: %.5f", open_price);
         ObjectCreate(chart_id, en_display, OBJ_TEXT, 0, close_zone, open_price);
         ObjectSetString(chart_id, en_display, OBJPROP_TEXT, e_display);
         ObjectSetInteger(chart_id, en_display, OBJPROP_COLOR, clrPaleVioletRed); // Entry Price text in pale violet red
         ObjectSetInteger(chart_id, en_display, OBJPROP_FONTSIZE, 8); // Set font size for Entry Price


        }
     }

  }

Erläuterung:

Wichtige Handelsdaten sollen durch diesen Teil des Codes direkt auf dem Chart angezeigt werden. Es berechnet den aktuellen Positionsgewinn und stellt ihn als Textetikett dar, wobei der Gewinn bei einem negativen Gewinn in Rot und bei einem positiven Gewinn in Blau angezeigt wird. Um TP, SL und den Eröffnungskurs visuell zu unterscheiden, fügt jeweils auch Textbeschriftungen ein. Diese Textbeschriftungen sind unterschiedlich gefärbt. Die Beschriftungen wurden auf dem Chart positioniert, um den Händlern die schnelle Identifizierung der entscheidenden Niveaus und des aktuellen Gewinnstatus ihrer Position zu erleichtern.

Ausgabe:

3.2. Chart-Objekte für historische Daten erstellen

Kapitel 3 hat bisher die Erstellung von Chart-Objekten behandelt, die die aktuelle Position symbolisieren. Wir werden uns nun mit den historischen Aufzeichnungen befassen, die es uns ermöglichen, historische Handelstrends und Daten auf dem Chart zu sehen. Auf diese Weise können wir frühere Transaktionen untersuchen und historisches Wissen auf aktuelle Handelspläne anwenden.

Beispiel:

// Define the position index for the first position
input int position_index  = 1; // POSITION INDEX (Index starts from 0)

// Get the ID of the current chart
long chart_id = ChartID();  // Store the ID of the current chart

string time = "23:59";      // Define a specific time as a string

// Define the color for the losing zone
input color sl_zonez_color   = clrPink; // Choose a color for Losing Zone

// Define the color for the winning zone
input color tp_zonez_color   = clrSpringGreen; // Choose a color for Winning Zone

// Define the color for the trend line
input color line_zonez_color = clrYellow; // Choose a color for the line

// Define whether to show past history or not
input string show_history = "no"; // Type yes to show past history

// Define the start date to show history
input datetime date1 = D'1970.08.10 00:00:00'; // Show history from this date

// Define the end date to show history
input datetime date2 = D'2024.08.15 00:00:00'; // To this date


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

// Check if history display is enabled
   if(show_history == "yes")
     {
      Comment(""); // Clear previous comments

      // Select deal history within the specified date range
      bool deal_history = HistorySelect(date1, date2);

      // Variables to store deal details
      double deal_close_price = 0.0;
      double deal_open_price = 0.0;
      double deal_sl = 0.0;
      double deal_tp = 0.0;
      double deal_profit = 0.0;
      datetime deal_close_time = 0;
      datetime deal_open_time = 0;

      // Check if deal history is available
      if(deal_history)
        {
         // Loop through all history deals
         for(int i = 0; i < HistoryDealsTotal(); i++)
           {
            ulong ticket = HistoryDealGetTicket(i);

            // Check for deal entry in
            if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_IN)
              {
               if(HistoryDealGetString(ticket, DEAL_SYMBOL) == ChartSymbol(chart_id))
                 {
                  deal_open_price = HistoryDealGetDouble(ticket, DEAL_PRICE);
                  deal_open_time = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);
                 }
              }

            // Check for deal entry out
            if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_OUT)
              {
               deal_profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
               deal_close_price = HistoryDealGetDouble(ticket, DEAL_PRICE);
               deal_sl = HistoryDealGetDouble(ticket, DEAL_SL);
               deal_tp = HistoryDealGetDouble(ticket, DEAL_TP);
               deal_close_time = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);

               if(HistoryDealGetString(ticket, DEAL_SYMBOL) == ChartSymbol(chart_id))
                 {
                  string deal_string;
                  string current_deal_profit;
                  string object_name;

                  // Display deal profit/loss
                  if(deal_profit > 0)
                    {
                     deal_string = DoubleToString(deal_profit, 2);
                     current_deal_profit = StringFormat("YOU WON +$%s", deal_string);
                     object_name = StringFormat("PROFIT %d", i);
                     ObjectCreate(chart_id, object_name, OBJ_TEXT, 0, deal_close_time, deal_close_price);
                     ObjectSetString(chart_id, object_name, OBJPROP_TEXT, current_deal_profit);
                     ObjectSetInteger(chart_id, object_name, OBJPROP_COLOR, clrMediumBlue);
                     ObjectSetInteger(chart_id, object_name, OBJPROP_FONTSIZE,8);
                    }
                  else
                     if(deal_profit < 0)
                       {
                        double deal_to_positive = MathAbs(deal_profit);
                        deal_string = DoubleToString(deal_to_positive, 2);
                        object_name = StringFormat("PROFIT %d", i);
                        current_deal_profit = StringFormat("YOU LOST -$%s", deal_string);
                        ObjectCreate(chart_id, object_name, OBJ_TEXT, 0, deal_close_time, deal_close_price);
                        ObjectSetString(chart_id, object_name, OBJPROP_TEXT, current_deal_profit);
                        ObjectSetInteger(chart_id, object_name, OBJPROP_COLOR, clrRed);
                        ObjectSetInteger(chart_id, object_name, OBJPROP_FONTSIZE,8);
                       }

                  // Display deal SL zone
                  string sl_obj_name = StringFormat("SL ZONE %d", i);
                  if(deal_sl > 0)
                    {
                     ObjectCreate(chart_id, sl_obj_name, OBJ_RECTANGLE, 0, deal_open_time, deal_open_price, deal_close_time, deal_sl);
                    }
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_COLOR, sl_zonez_color);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_STYLE, STYLE_SOLID);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_WIDTH, 1);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_FILL, sl_zonez_color);
                  ObjectSetInteger(chart_id, sl_obj_name, OBJPROP_BACK, true);

                  // Display deal TP zone
                  string tp_obj_name = StringFormat("TP ZONE %d", i);
                  if(deal_tp > 0)
                    {
                     ObjectCreate(chart_id, tp_obj_name, OBJ_RECTANGLE, 0, deal_open_time, deal_open_price, deal_close_time, deal_tp);
                    }
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_COLOR, tp_zonez_color);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_STYLE, STYLE_SOLID);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_WIDTH, 1);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_FILL, tp_zonez_color);
                  ObjectSetInteger(chart_id, tp_obj_name, OBJPROP_BACK, true);

                  // Display deal trend line
                  string line_obj_name = StringFormat("line %d", i);
                  ObjectCreate(chart_id, line_obj_name, OBJ_TREND, 0, deal_open_time, deal_open_price, deal_close_time, deal_close_price);
                  ObjectSetInteger(chart_id, line_obj_name, OBJPROP_COLOR, line_zonez_color);
                  ObjectSetInteger(chart_id, line_obj_name, OBJPROP_STYLE, STYLE_DASH);
                  ObjectSetInteger(chart_id, line_obj_name, OBJPROP_WIDTH, 2);


                 }
              }
           }
        }
     }

  }

Erläuterung:

Dieser Codeabschnitt wertet zunächst die Variable show_history aus, um festzustellen, ob die Funktion zur Anzeige des Verlaufs aktiviert ist. Wenn „ja“ ausgewählt wird, verwendet der Code Comment(""), um alle früheren Kommentare aus dem Chart zu entfernen, sodass nur die neuesten Daten sichtbar sind. Das Ergebnis wird dann in der booleschen Variable deal_history gespeichert. Die Methode HistorySelect(date1, date2) wird dann verwendet, um die historischen Geschäfte innerhalb des angegebenen Datumsbereichs auszuwählen. Bei dieser Auswahl können wir auf historische Handelsdaten zurückgreifen. Die Daten zu jeder früheren Vereinbarung werden dann in verschiedenen Variablen gespeichert. Die Schluss- und Eröffnungskurse des Geschäfts werden in deal_close_price und deal_open_price erfasst. Die Felder „deal_sl“ und „deal_tp“ werden verwendet, um die Werte von Take Profit und Stop Loss zu protokollieren. Die Angaben „deal_close_time“ und „deal_open_time“ dokumentieren den Abschluss- bzw. Eröffnungszeitraum des Geschäfts, ebenso wie „deal_profit“, das den Gewinn oder Verlust des Geschäfts erfasst.

Der Code bestimmt, ob der Geschäftsverlauf zugänglich ist. Wenn dies der Fall ist, beginnt eine Schleife, die mit HistoryDealGetTicket(i) die Ticketnummer für jedes Geschäft abruft, während sie alle möglichen Geschäfte durchläuft. Bei jedem Ticket wird zwischen Einstiegs- und Ausstiegsangeboten unterschieden. Während bei Exit-Transaktionen der Schlusskurs, der Gewinn, der Stop-Loss und der Take-Profit-Wert angegeben werden, werden bei Entry-Transaktionen der Eröffnungskurs und die Uhrzeit erfasst. Diese Angaben werden verwendet, um verschiedene Chart-Elemente zu generieren, z. B. Trendlinien, die die Preisbewegung während der Transaktion zeigen, Textbeschriftungen, die Gewinn oder Verlust anzeigen, und Rechtecke, die die Zonen für Take-Profit und Stop-Loss darstellen. Diese Methode stellt sicher, dass die historischen Handelsdaten effizient auf dem Bildschirm angezeigt werden und wichtige Einblicke in die frühere Performance geben.

Ausgabe:

Schlussfolgerung

In diesem Artikel haben wir die Arbeit mit Objekten in MQL5 untersucht und uns dabei auf die Erstellung und Änderung von Chart-Elementen zur Verbesserung der Handelsanalyse konzentriert. Wir haben Rechtecke für Take-Profit- und Stop-Loss-Zonen, Trendlinien zur Verfolgung von Preisänderungen und Textbeschriftungen für wichtige Handelsdaten erstellt. Wir haben auch untersucht, wie frühere Geschäfte mit Hilfe von Etiketten und visuellen Hilfsmitteln angezeigt werden können, um ein klares Bild der historischen Performance zu vermitteln.