Entwicklung des Price Action Analysis Toolkit (Teil 46): Entwicklung eines interaktiven Fibonacci Retracement EA mit intelligenter Visualisierung in MQL5

Einführung

In unserem letzten Artikel aus dieser Reihe, Entwicklung des Price Action Analysis Toolkit, haben wir uns auf das Testen von Kursniveaus konzentriert, um zu überprüfen, wie der Markt in der Vergangenheit darauf reagiert hat – und dabei Ausbrüche, Berührungen und empirische Ausbruchswahrscheinlichkeiten identifiziert. Ein Schlüsselmerkmal für die Funktionalität dieses Tools war das Eingabefeld auf dem Bildschirm, das es den Nutzern ermöglichte, ein Preisniveau einzugeben und die Analyse mit einer einzigen Schaltfläche „Analysieren“ auszulösen.  

In diesem Teil bauen wir auf der gleichen Idee auf, Werte direkt im Chart einzugeben, und verbessern dieses Mal die Erfahrung für die Fibonacci-Retracement-Analyse in MQL5. Anstatt das Standard-Fibonacci-Tool manuell anzuwenden – ein Prozess, der für neue Nutzer verwirrend sein kann – bietet dieser EA eine einfachere, interaktive Alternative. Sie ermitteln einfach den Höchst- und Tiefstwert der Welle, geben diese Werte in das Feld ein und drücken auf „Draw Fib“ (Fib. zeichnen). Der EA zeichnet automatisch alle relevanten Rücksetzungs- und Erweiterungsebenen (Retracement und Extension) auf und überwacht dann kontinuierlich das Chart, wobei er Warnungen ausgibt, sobald der Preis mit diesen Ebenen interagiert. Diese Automatisierung ist wertvoll, da manuelle Zeichnungen allein keine laufenden Analysen oder Echtzeit-Feedback liefern können.

Ich werde Sie Schritt für Schritt durch den Prozess der Entwicklung des Tools und dessen Implementierung in MQL5 führen. Bitte beachten Sie das nachstehende Inhaltsverzeichnis; anschließend werden die einzelnen Abschnitte im Detail erläutert:

• Gestaltung des Tools
• Aufbau der Schnittstelle
• Zeichnen von Fibonacci-Ebenen
• Interaktiv machen
• Visualisierung
• Tests und Ergebnisse
• Schlussfolgerung

Gestaltung des Tools

Bevor wir mit der Entwicklung des EA beginnen, ist es wichtig zu verstehen, was das Fibonacci Retracement Tool ist und wie Händler es verwenden. Der Begriff leitet sich von der mathematischen Folge ab, die der italienische Gelehrte Leonardo Fibonacci im 13. Jahrhundert entwickelte. Aus dieser Folge gewonnenen Quotienten wie 0,382 und 0,618 kommen in der Natur häufig vor und werden in der Marktanalyse häufig verwendet, um das proportionale Verhalten von Preisbewegungen zu beschreiben. In MetaTrader 5 finden Sie das Fibonacci-Retracement-Tool unter Einfügen → Objekte → Fibonacci → Rücksetzungsebenen. Händler nutzen ihn, um potenzielle Unterstützungs- und Widerstandszonen innerhalb eines Trends zu identifizieren. Wenn Sie die Linien jedoch einmal manuell gezogen haben, bleiben sie starr und geben keine automatische Rückmeldung, wenn sich der Markt weiter bewegt. Unser Ziel ist es, diesen Prozess durch Automatisierung zu verbessern.

Bevor wir einen Code schreiben, müssen wir entwerfen, wie sich der Interactive Fibonacci EA verhalten wird und wie Händler mit ihm interagieren werden. Eine sorgfältige Planung stellt sicher, dass jede Funktion einen definierten Zweck hat und dass sich das Tool logisch verhält, wenn es auf einer Live-Chart läuft.  

Der Zweck dieses EAs ist es, die Fibonacci-Rücksetzungsanalyse einfacher, schneller und anpassungsfähiger zu machen. Anstatt als statisches Zeichenwerkzeug zu arbeiten, fungiert es als aktiver Analyseassistent, der Retracement- und Extension-Ebenen visualisiert, während sich der Markt entwickelt. 

Wesentliche Ziele des Entwurfs: 

1. Vereinfachung der Interaktion: Erlauben Sie es den Nutzern, die Werte für den hohen und den tiefen Umkehrpunkt (A und B) direkt im Chart einzugeben oder anzupassen, anstatt die Indikator-Handles zu verwenden.
2. Automatisieren der Analyse: Zeichnen Sie sofort Retracement- und Extension-Ebenen und überwachen Sie diese in Echtzeit, während sich der Markt bewegt.
3. Verbessern der Visualisierung: Präsentieren Sie die Ebenen in einer klaren, stilvollen Art und Weise, indem Sie Farben, Linienstile und Beschriftungen auf dem Chart zur schnellen Erkennung verwenden.
4. Feedback: Benachrichtigung des Händlers, wenn der Kurs ein Fibonacci-Level berührt, durch Warnungen, Markierungen oder Ticker-Updates.
5. Verbesserung der Nutzerfreundlichkeit: Ersetzen Sie mehrere Werkzeugeinstellungen durch ein einziges, intuitiv bedienbares Bedienfeld für eine optimierte Steuerung.

Kurz gesagt, dieses Design verwandelt das statische Standard-Fibonacci-Tool in einen lebendigen, reaktionsfähigen Assistenten, der Analyse, Automatisierung und Präsentation in einem nutzerfreundlichen Paket vereint.

Interface- und Funktionsdesign

Jetzt, da der Zweck des Tools klar ist, geht es im nächsten Schritt darum, wie die Händler damit interagieren werden. Der EA wird über ein On-Chart-Kontrollfeld verfügen, das es den Nutzern ermöglicht, Umkehrpunkte einzustellen, Funktionen auszuführen und Feedback zu visualisieren, ohne das Einstellungsfenster zu öffnen. Da alle Steuerelemente im Chart angezeigt werden, entsteht ein Gefühl der Unmittelbarkeit, und das Tool ist bei der aktiven Marktanalyse weitaus praktischer.

Layout der Nutzeroberfläche

Element	Typ	Zweck
Label A	OBJ_LABEL	Statischer Text „A:“ vor dem ersten Eingabefeld
Edit Box A	OBJ_EDIT	Feld, in das der Nutzer den Wert des tiefen Umkehrpunkts (Beginn der Bewegung) eingibt
Label B	OBJ_LABEL	Statischer Text „B:“ vor dem zweiten Eingabefeld
Edit Box B	OBJ_EDIT	Feld für den Wert des hohen Umkehrpunkts (Ende der Bewegung)
Draw Fib Button	OBJ_BUTTON	Führt die Berechnung aus und stellt alle Fibonacci-Ebenen dar
Clear Button	OBJ_BUTTON	Entfernt zuvor gezeichnete Objekte aus dem Chart
Ticker Headline	OBJ_LABEL	Kleine Bildlaufleiste für die Anzeige von Aktualisierungen und Warnungen

Diese Objekte bilden eine kompakte Schnittstelle, die in der oberen linken Ecke des Charts sichtbar bleibt. Sie werden programmatisch mit ObjectCreate() erstellt und mit ObjectSetInteger() und ObjectSetString() so angepasst, dass sie auch beim Zoomen oder Ändern der Größe des Charts deutlich sichtbar bleiben. Ziel ist es, dass das Panel leicht, intuitiv und jederzeit zugänglich ist, ohne den Handelsbereich zu überladen.

Funktionale Anforderungen

Jedes Element der Schnittstelle erfüllt einen bestimmten Zweck innerhalb des EA. Die Eingabefelder A und B akzeptieren nutzerdefinierte Werte für Umkehrpunkte, die den zu analysierenden Bereich darstellen. Wenn diese Felder leer gelassen werden, kann der EA die letzten Höchst- und Tiefststände aus den Chartdaten schätzen. Wenn Sie auf die Schaltfläche „Draw Fib“ klicken, werden alle zuvor gezeichneten Linien entfernt, die Standard-Fibonacci-Retracement- und -Extension-Verhältnisse berechnet und als horizontale Linien mit farbigen Markierungen und Beschriftungen auf dem Chart dargestellt. Die Schaltfläche „Clear“ löscht einfach alle mit dem EA verbundenen Objekte und bietet eine schnelle Möglichkeit, das Chart zurückzusetzen. Alle Nutzerinteraktionen werden über die Funktion OnChartEvent() verarbeitet, die sofort auf Eingabeänderungen und Schaltflächenklicks reagiert. Dieses Design macht das Tool reaktionsschnell und einfach zu bedienen, auch wenn sich der Markt schnell bewegt. Händler können den Bereich der Umkehrpunkte ändern oder die Ebenen sofort aktualisieren, ohne den EA neu zu starten.

Visuelle Gestaltung

Ein konsistenter und lesbarer visueller Stil ist von entscheidender Bedeutung, wenn mehrere Linien in einem Chart erscheinen. Der EA verwendet ein klares Farbschema, bei dem Aufwärts-Retracements in hellgrün und Abwärts-Retracements in tomatenrot dargestellt werden. Die wichtigsten Ebenen – 0 %, 50 % und 100 % – werden durch dickere Linienbreiten in Gold hervorgehoben. Für die Kennzeichnung wird die Schriftart Arial Black in der Größe 10 verwendet, um sicherzustellen, dass der Text vor jedem Chartthema gut erkennbar ist. Jede Kennzeichnung enthält sowohl das prozentuale Verhältnis als auch den genauen Kurswert, sodass Händler die Niveaus auf einen Blick erkennen können. Am unteren Rand des Charts zeigt eine Laufschrift Warnungen und Aktualisierungen an, z. B. „Monitoring Fibonacci levels 1.2000 → 1.2500“ oder „Price touched 61.8% level.“ Die Farbe dieses Tickers wird durch die TickerColor-Eingabeeinstellung gesteuert, sodass der Nutzer sie an seine bevorzugte Chartpalette anpassen kann. Zusammen schaffen diese Designentscheidungen eine saubere, moderne visuelle Präsentation, die Klarheit schafft, ohne abzulenken.

Logisches Kernkonzept

Hinter den Kulissen folgt das System einer einfachen Logik. Wenn der Händler die Werte von Umkehrpunkten eingibt und auf Draw Fib drückt, berechnet der EA jedes Verhältnis und zeichnet die entsprechenden Linien und Labels. Bei jedem neuen Kurs-Tick wird geprüft, ob der aktuelle Geld- oder Briefkurs innerhalb einer kleinen Spanne um ein Fibonacci-Level liegt. Wenn eine Übereinstimmung auftritt, löst der EA einen Alarm aus, markiert das Ereignis im Chart und veröffentlicht eine Aktualisierung in der Schlagzeile. Dieser Prozess setzt sich autonom fort und verwandelt das statische Fibonacci-Tool in einen reaktionsschnellen analytischen Assistenten, der arbeitet, während sich der Händler auf die Entscheidungsfindung konzentriert.

Nachstehend finden Sie ein Flussdiagramm des interaktiven Fibonacci-Tools, das die Abfolge von Nutzereingaben, EA-Verarbeitung und Echtzeit-Feedback zeigt.

Aufbau der Schnittstelle

Sobald die Entwurfsphase abgeschlossen ist, besteht der nächste Schritt darin, das Konzept in funktionierende Objekte auf dem Chart umzusetzen. MetaTrader 5 bietet ein grafisches Objektsystem, das dies möglich macht. Jedes Objekt – sei es eine Schaltfläche, eine Beschriftung oder ein Eingabefeld – wird mit der Funktion ObjectCreate() erstellt und dann durch Funktionen zum Einstellen von Eigenschaften wie ObjectSetInteger() und ObjectSetString() angepasst. Durch die Kombination dieser grafischen Elemente können wir eine Panel entwerfen, die als Hauptkontrollzentrum für das Fibonacci-Tool dient.

Erstellen der Bedienelemente

Das folgende Beispiel zeigt, wie die grundlegenden Elemente des Panels erstellt werden. Es enthält zwei beschreibbare Eingabefelder, in die der Nutzer die Werte des hohen und des tiefen Umkehrpunkts eingeben kann, sowie zwei Befehlsschaltflächen zum Zeichnen und Löschen von Fibonacci-Ebenen.

void CreateInterface()
{
   long chartID = ChartID();

   // --- Label A
   ObjectCreate(chartID, "lbl_A", OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(chartID, "lbl_A", OBJPROP_XDISTANCE, 10);
   ObjectSetInteger(chartID, "lbl_A", OBJPROP_YDISTANCE, 20);
   ObjectSetString(chartID,  "lbl_A", OBJPROP_TEXT, "A:");
   ObjectSetInteger(chartID, "lbl_A", OBJPROP_COLOR, clrWhite);
   ObjectSetInteger(chartID, "lbl_A", OBJPROP_FONTSIZE, 10);

   // --- Edit box for A value
   ObjectCreate(chartID, "edit_A", OBJ_EDIT, 0, 0, 0);
   ObjectSetInteger(chartID, "edit_A", OBJPROP_XDISTANCE, 25);
   ObjectSetInteger(chartID, "edit_A", OBJPROP_YDISTANCE, 15);
   ObjectSetInteger(chartID, "edit_A", OBJPROP_BGCOLOR, clrBlack);
   ObjectSetInteger(chartID, "edit_A", OBJPROP_COLOR, clrLime);
   ObjectSetString(chartID,  "edit_A", OBJPROP_TEXT, "");

   // --- Label B
   ObjectCreate(chartID, "lbl_B", OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(chartID, "lbl_B", OBJPROP_XDISTANCE, 10);
   ObjectSetInteger(chartID, "lbl_B", OBJPROP_YDISTANCE, 45);
   ObjectSetString(chartID,  "lbl_B", OBJPROP_TEXT, "B:");
   ObjectSetInteger(chartID, "lbl_B", OBJPROP_COLOR, clrWhite);
   ObjectSetInteger(chartID, "lbl_B", OBJPROP_FONTSIZE, 10);

   // --- Edit box for B value
   ObjectCreate(chartID, "edit_B", OBJ_EDIT, 0, 0, 0);
   ObjectSetInteger(chartID, "edit_B", OBJPROP_XDISTANCE, 25);
   ObjectSetInteger(chartID, "edit_B", OBJPROP_YDISTANCE, 40);
   ObjectSetInteger(chartID, "edit_B", OBJPROP_BGCOLOR, clrBlack);
   ObjectSetInteger(chartID, "edit_B", OBJPROP_COLOR, clrLime);
   ObjectSetString(chartID,  "edit_B", OBJPROP_TEXT, "");

   // --- Draw Fib button
   ObjectCreate(chartID, "btn_Draw", OBJ_BUTTON, 0, 0, 0);
   ObjectSetInteger(chartID, "btn_Draw", OBJPROP_XDISTANCE, 10);
   ObjectSetInteger(chartID, "btn_Draw", OBJPROP_YDISTANCE, 70);
   ObjectSetInteger(chartID, "btn_Draw", OBJPROP_BGCOLOR, clrDarkGreen);
   ObjectSetInteger(chartID, "btn_Draw", OBJPROP_COLOR, clrWhite);
   ObjectSetString(chartID,  "btn_Draw", OBJPROP_TEXT, "Draw Fib");

   // --- Clear button
   ObjectCreate(chartID, "btn_Clear", OBJ_BUTTON, 0, 0, 0);
   ObjectSetInteger(chartID, "btn_Clear", OBJPROP_XDISTANCE, 100);
   ObjectSetInteger(chartID, "btn_Clear", OBJPROP_YDISTANCE, 70);
   ObjectSetInteger(chartID, "btn_Clear", OBJPROP_BGCOLOR, clrMaroon);
   ObjectSetInteger(chartID, "btn_Clear", OBJPROP_COLOR, clrWhite);
   ObjectSetString(chartID,  "btn_Clear", OBJPROP_TEXT, "Clear");
}

Die Funktion CreateInterface() erstellt das visuelle Layout, das wir zuvor entworfen haben. ObjectCreate() definiert jedes grafische Element und weist ihm einen eindeutigen Namen zu, auf den später bei Aktualisierungen oder Löschungen Bezug genommen werden kann. Die Positionierung von Objekten wird über Abstandseigenschaften (OBJPROP_XDISTANCE und OBJPROP_YDISTANCE) verwaltet, die sicherstellen, dass jedes Element relativ zur linken oberen Ecke des Charts gezeichnet wird. Farben, Textinhalte und Schriftarten werden dann mit zusätzlichen Aufrufen von ObjectSetInteger() und ObjectSetString() zugewiesen. Auf diese Weise wird jedes Element der Schnittstelle – Beschriftungen, Eingabefelder und Schaltflächen – in einem einheitlichen, leicht lesbaren Stil direkt auf dem Chart angezeigt.

Automatisches Initialisieren des Panels

Um sicherzustellen, dass diese Schnittstelle sofort erscheint, wenn der EA an ein Chart angehängt wird, wird die Erstellungsfunktion innerhalb von OnInit() aufgerufen. Dieses Ereignis wird nur einmal beim Laden des Expert Advisors ausgeführt und ist daher der ideale Ort, um Einrichtungsaufgaben durchzuführen.

int OnInit()
{
   CreateInterface();
   Print("Fibonacci Interface Initialized");
   return(INIT_SUCCEEDED);
}

Indem wir die Initialisierung des Panels in OnInit() einbetten, garantieren wir, dass die Oberfläche jedes Mal, wenn der EA startet, automatisch und ohne Nutzereingriff gezeichnet wird. Die Anweisung Print() ist optional, aber nützlich, um im Terminalprotokoll zu bestätigen, dass Ihre Schnittstelle korrekt geladen wurde.

Umgang mit Nutzerinteraktion

Der nächste Teil der Schnittstellenlogik beinhaltet die Reaktion auf die Aktionen des Händlers. MetaTrader 5 verwendet die Funktion OnChartEvent(), um den EA über jede Aktivität im Chart zu informieren, z. B. über das Drücken einer Schaltfläche oder das Bearbeiten von Text in einem Eingabefeld. Der folgende Code zeigt, wie diese Interaktionen erfasst werden können:

void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
{
   if(id == CHARTEVENT_OBJECT_CLICK)
   {
      if(sparam == "btn_Draw")    HandleDraw();   // Draw Fibonacci levels
      if(sparam == "btn_Clear")   HandleClear();  // Clear all objects
   }
}

Immer wenn ein Ereignis eintritt, sendet die Plattform den Namen des Objekts über sparam. Durch die Überprüfung dieses Parameters können wir feststellen, welche Schaltfläche angeklickt wurde, und die entsprechende Funktion aufrufen. Wenn in diesem Beispiel „Draw Fib“ gedrückt wird, wird die Platzhalterfunktion HandleDraw() später verwendet, um die A- und B-Werte des Nutzers zu sammeln, die Retracement-Verhältnisse zu berechnen und die Fibonacci-Ebenen darzustellen. In ähnlicher Weise löst die Schaltfläche „Clear“ HandleClear() aus, das alle Fibonacci-bezogenen Objekte aus dem Chart entfernt. Durch diese Struktur ist der EA ereignisgesteuert, d. h. er reagiert sofort auf Eingaben wie ein GUI-Programm und führt nicht alles in einer Endlosschleife aus.

Nachdem die Logik von CreateInterface() und OnChartEvent() implementiert worden ist, enthält der EA nun ein voll funktionsfähiges Bildschirmsteuerungsfeld, das eingegebene Werte akzeptiert und auf Schaltflächenklicks antwortet. Es stellt das Rückgrat der Nutzererfahrung des Tools dar – eine Brücke zwischen den Aktionen des Händlers und den algorithmischen Antworten. Da jedes Objekt unabhängig und explizit benannt ist, können Sie später Farben, Text und Positionen ändern, ohne die Struktur zu beeinträchtigen. Diese Flexibilität ist wertvoll, wenn Sie das Tool skalieren oder Funktionen wie automatische Erkennung, Ebenenbeschriftung oder Stilanpassung durch Eingaben hinzufügen.

In diesem Stadium ist das grafische Bedienfeld bereit; es kann hohe und niedrige Schwellenwerte vom Nutzer erfassen und auf grundlegende Interaktionsereignisse reagieren. Der nächste Schritt, der im folgenden Abschnitt „Zeichnen von Fibonacci-Ebenen“ beschrieben wird, zeigt, wie diese Nutzereingaben in dynamische Retracement- und Erweiterungsebenen umgewandelt werden können, die sich automatisch an das Marktverhalten anpassen.

Das Panel enthält die Eingabefelder A und B für die Schwungpunkte, die Aktionsschaltflächen „Draw Fib“ und „Clear“ sowie einen Tickermeldungsbereich, der den Status des Tools in Echtzeit anzeigt.

Zeichnen von Fibonacci-Ebenen

Nach der Einrichtung der Schnittstelle und der Aktivierung der Nutzereingabe besteht das Kernstück unseres Tools in der Fähigkeit, dynamisch Fibonacci-Retracement- und Extension-Ebenen auf dem Chart zu zeichnen. Diese Funktion verwandelt das Tool von einem einfachen Eingabefeld in einen aktiven analytischen Assistenten. Lassen Sie uns untersuchen, wie man die vom Nutzer eingegebenen Umkehrpunkte in visuelle Objekte umwandelt, die sowohl informativ als auch leicht zu interpretieren sind, wenn man in Echtzeit handelt.

Das Verständnis der Fibonacci-Verhältnisse und ihre Bedeutung

Die Fibonacci-Verhältnisse bilden die Grundlage vieler technischer Analysestrategien, da die Händler davon ausgehen, dass die Kurse häufig auf Niveaus reagieren, die mit diesen Verhältnissen in Zusammenhang stehen. Die am häufigsten verwendeten Retracement-Ebenen sind 23,6 %, 38,2 %, 50 %, 61,8 % und 78,6 %, wobei das 50 %-Level einen psychologischen Mittelpunkt darstellt, auch wenn es kein echtes Fibonacci-Verhältnis ist. Extension-Ebenen wie 127,2 %, 161,8 % und 261,8 % werden verwendet, um mögliche Ziele über die ursprüngliche Kursbewegung hinaus zu projizieren. Durch die Darstellung dieser Niveaus können Händler Bereiche der Unterstützung, des Widerstands oder einer möglichen Kursumkehr vorhersehen.

Umwandlung von Nutzereingaben in Preise der Ebenen

Nachdem der Nutzer den hohen (B) und tiefen (A) Umkehrpunkt eingegeben hat, muss der EA den entsprechenden Preis für jedes Fibonacci-Verhältnis berechnen. Die Richtung der Berechnung hängt vom Trend ab: Wenn A kleiner als B ist, ist die Bewegung aufwärts gerichtet, und die Retracement-Ebenen werden abwärts gemessen; wenn A größer als B ist, ist die Bewegung abwärts gerichtet, und die Ebenen werden aufwärts gemessen. Extension-Ebenen ragen über den Umkehrpunkt hinaus in Richtung des Trends.

Um zum Beispiel ein 61,8%-Retracement in einem Aufwärtstrend zu berechnen, verwenden wir die Formel:

• Level_Price = B – (B – A) * 0,618

Das bedeutet, dass wir 61,8 % der Bewegung von B zurück nach A messen. Für eine 161,8 %ige Extension lautet die Formel:

• Level_Price = B + (B – A) * 0,618

Damit werden 61,8 % der ursprünglichen Bewegung über Punkt B hinaus projiziert.

Implementierung der Darstellungslogik in MQL5

Um diese Verhältnisse in Chartlinien und Beschriftungen zu übersetzen, verwenden wir die Grafikobjektfunktionen von MQL5. Nachfolgend finden Sie eine Funktion, die jede Retracement- und Eextension-Ebene als horizontale Linie zeichnet, mit einer Kennzeichnung daneben, die das Verhältnis und den genauen Preis angibt.

void DrawFibonacciLevels(double A, double B)
{
   long chartID = ChartID();
   double ratios[]     = {0.0, 0.236, 0.382, 0.5, 0.618, 0.786, 1.0};
   double extensions[] = {1.272, 1.618, 2.618};
   color keyLevelColor = clrGold;

   // Draw retracement levels
   for(int i=0; i<ArraySize(ratios); i++)
   {
      double price = B - (B - A) * ratios[i];
      string levelName = StringFormat("FIB_RET_%d", int(ratios[i]*1000));
      ObjectCreate(chartID, levelName, OBJ_HLINE, 0, 0, price);
      ObjectSetInteger(chartID, levelName, OBJPROP_COLOR, (ratios[i]==0.5 || ratios[i]==0 || ratios[i]==1.0) ? keyLevelColor : clrLime);
      ObjectSetInteger(chartID, levelName, OBJPROP_WIDTH, (ratios[i]==0.5 || ratios[i]==0 || ratios[i]==1.0) ? 2 : 1);

      // Draw label for each level
      string labelName = StringFormat("FIB_LABEL_%d", int(ratios[i]*1000));
      ObjectCreate(chartID, labelName, OBJ_TEXT, 0, TimeCurrent(), price);
      ObjectSetString(chartID, labelName, OBJPROP_TEXT, StringFormat("%.1f%% (%.5f)", ratios[i]*100, price));
      ObjectSetInteger(chartID, labelName, OBJPROP_COLOR, (ratios[i]==0.5 || ratios[i]==0 || ratios[i]==1.0) ? keyLevelColor : clrWhite);
      ObjectSetInteger(chartID, labelName, OBJPROP_FONTSIZE, 10);
   }

   // Draw extension levels
   for(int i=0; i<ArraySize(extensions); i++)
   {
      double price = B + (B - A) * (extensions[i] - 1);
      string levelName = StringFormat("FIB_EXT_%d", int(extensions[i]*1000));
      ObjectCreate(chartID, levelName, OBJ_HLINE, 0, 0, price);
      ObjectSetInteger(chartID, levelName, OBJPROP_COLOR, clrTomato);
      ObjectSetInteger(chartID, levelName, OBJPROP_WIDTH, 1);

      // Draw label for each extension
      string labelName = StringFormat("FIB_EXT_LABEL_%d", int(extensions[i]*1000));
      ObjectCreate(chartID, labelName, OBJ_TEXT, 0, TimeCurrent(), price);
      ObjectSetString(chartID, labelName, OBJPROP_TEXT, StringFormat("%.1f%% (%.5f)", extensions[i]*100, price));
      ObjectSetInteger(chartID, labelName, OBJPROP_COLOR, clrTomato);
      ObjectSetInteger(chartID, labelName, OBJPROP_FONTSIZE, 10);
   }
}

Diese Funktion zeichnet die Niveaus und stellt sicher, dass die wichtigsten Retracement-Linien (0 %, 50 %, 100 %) visuell deutlich erkennbar sind, indem sie eine goldene Farbe und dickere Linien verwendet. Alle anderen Retracement-Ebenen sind in Limettenfarben gehalten, während Extension-Ebenen in Tomatenrot gestaltet sind. Jede Linie ist mit ihrem Verhältnis und ihrem Preis gekennzeichnet, sodass Händler die Bedeutung jedes Ebenen sofort erkennen können.

Integration der Zeichnung mit Nutzeraktionen

Damit diese Funktion auf Nutzereingaben reagiert, sollte sie immer dann aufgerufen werden, wenn die Schaltfläche „Draw Fib“ gedrückt wird. Dies wird in der Regel in Ihrer Funktion HandleDraw() behandelt. Der EA liest den Text aus den Eingabefeldern, wandelt ihn in Zahlen um und ruft dann DrawFibonacciEbenen() auf.

void HandleDraw()
{
   string strA = ObjectGetString(ChartID(), "edit_A", OBJPROP_TEXT);
   string strB = ObjectGetString(ChartID(), "edit_B", OBJPROP_TEXT);
   double A = StringToDouble(strA);
   double B = StringToDouble(strB);
   DrawFibonacciLevels(A, B);
}

Durch diese Integration wird sichergestellt, dass die Zeichnungslogik nur dann ausgelöst wird, wenn gültige Eingaben vorliegen, und dass die Schnittstelle reaktionsschnell und nutzerorientiert ist.

Warum visuelles Styling wichtig ist

Die Wahl der Farbe, der Schriftart und der Linienstärke ist nicht nur ästhetisch – die klare Gestaltung hilft den Händlern, die wichtigsten Ebenen schnell von den unwichtigen zu unterscheiden. Dies ist besonders wichtig auf schnelllebigen Märkten, wo Klarheit den Unterschied zwischen einem gut getimten Handel und einer verpassten Gelegenheit ausmachen kann. Die Verwendung von Gold für die Schlüsselebenen lenkt den Blick des Händlers auf die statistisch signifikantesten Retracements und Extensions.

Vorbereitungen für Interaktivität

Da die Fibonacci-Ebenen jetzt programmatisch gezeichnet werden, ist Ihr EA bereit für die nächste Entwicklung: Interaktivität. Im nächsten Abschnitt wird diese Grundlage erweitert, indem der EA Kursbewegungen in Echtzeit überwacht. Sie aktivieren Warnmeldungen und visuelle Hinweise, sobald der Kurs ein Fibonacci-Level berührt, wodurch Ihr Tool viel leistungsfähiger wird als ein statisches Zeichenprogramm.

Interaktiv machen

Das Zeichnen der Fibonacci-Ebenen ist ein guter erster Schritt, aber der wahre Vorteil der Automatisierung liegt darin, dass diese Ebenen auf das Marktgeschehen reagieren. In diesem Abschnitt werden wir den EA so verbessern, dass er die Kursbewegungen aktiv überwacht und ein Echtzeit-Feedback liefert, wenn sich der Kurs einem Fibonacci-Retracement- oder Extension-Level nähert oder es berührt. Damit wird das Instrument von einer passiven Sehhilfe zu einem aktiven Markthelfer.

Preisüberwachung in Echtzeit

Um zu erkennen, wann der Preis mit einer Fibonacci-Ebene interagiert, muss der EA kontinuierlich den Geldkurs (oder Briefkurs) des Marktes beobachten. Dies geschieht mit der Funktion OnTick(), die jedes Mal ausgelöst wird, wenn ein neuer Tick eintrifft. Durch den Vergleich des aktuellen Kurses mit den Werten aller gezogenen Ebenen kann der EA feststellen, ob ein bedeutendes Ereignis eingetreten ist.

Erkennung von Berührungen und Ausgabe von Warnungen

Ein praktischer Ansatz besteht darin, eine kleine Toleranz oder „Berührungszone“ um jede Fibonacci-Linie zu definieren. Wenn der Geldkurs innerhalb dieser Spanne liegt, betrachtet der EA das Niveau als „berührt“. Wann immer eine Berührung erkannt wird, sollte der EA eine sofortige Rückmeldung geben. Dies kann eine Markierung auf dem Bildschirm, eine akustische Warnung und eine Aktualisierung im Schlagzeilenticker umfassen.

Hier ist ein Beispiel, wie dies umgesetzt werden kann:

double TouchZone = 0.00015; // Sensitivity for level touch (adjust for instrument)

void OnTick()
{
   double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   long chartID = ChartID();

   // Check retracement levels
   double ratios[] = {0.0, 0.236, 0.382, 0.5, 0.618, 0.786, 1.0};
   for(int i=0; i<ArraySize(ratios); i++)
   {
      string levelName = StringFormat("FIB_RET_%d", int(ratios[i]*1000));
      double levelPrice = ObjectGetDouble(chartID, levelName, OBJPROP_PRICE);

      if(MathAbs(price - levelPrice) <= TouchZone)
      {
         MarkFibonacciTouch(levelName, levelPrice);
         PlaySound("alert.wav"); // Optional: play audio alert
         UpdateTicker(StringFormat("Price touched %s (%.1f%%)", levelName, ratios[i]*100));
      }
   }

   // Check extension levels
   double extensions[] = {1.272, 1.618, 2.618};
   for(int i=0; i<ArraySize(extensions); i++)
   {
      string levelName = StringFormat("FIB_EXT_%d", int(extensions[i]*1000));
      double levelPrice = ObjectGetDouble(chartID, levelName, OBJPROP_PRICE);

      if(MathAbs(price - levelPrice) <= TouchZone)
      {
         MarkFibonacciTouch(levelName, levelPrice);
         PlaySound("alert.wav");
         UpdateTicker(StringFormat("Price touched %s (%.1f%%)", levelName, extensions[i]*100));
      }
   }
}

Visuelles und akustisches Feedback

Die Funktion MarkFibonacciTouch() kann verwendet werden, um einen Pfeil oder eine andere Markierung auf dem Chart am Berührungspunkt zu platzieren. Dadurch erhalten die Händler einen sofortigen visuellen Hinweis auf das Ereignis, selbst wenn sie den akustischen Alarm verpasst haben. Die Funktion UpdateTicker() aktualisiert die Schlagzeile auf dem Chart und liefert eine laufende Aufzeichnung der wichtigsten Marktereignisse.

void MarkFibonacciTouch(string baseName, double price)
{
   long chartID = ChartID();
   string markerName = baseName + "_TOUCH";
   ObjectCreate(chartID, markerName, OBJ_ARROW, 0, TimeCurrent(), price);
   ObjectSetInteger(chartID, markerName, OBJPROP_COLOR, clrYellow);
   ObjectSetInteger(chartID, markerName, OBJPROP_WIDTH, 2);
}

Aktualisieren der Ticker-Schlagzeile

Die Ticker-Schlagzeile dient als Echtzeit-Status-Feed des EA. Jedes Mal, wenn ein Fibonacci-Level berührt wird, wird der Ticker aktualisiert, um den Nutzer zu informieren. Dieser Ansatz stellt sicher, dass Händler immer über wichtige Preisinteraktionen informiert sind, ohne dass sie ständig das gesamte Chart überprüfen müssen.

void UpdateTicker(string text)
{
   long chartID = ChartID();
   ObjectSetString(chartID, "Ticker_Headline", OBJPROP_TEXT, text);
}

Durch die aktive Verfolgung des Preises und die Reaktion auf wichtige Fibonacci-Ebenen mit Alarmen und Markern bietet der EA mehrere deutliche Vorteile:

• Weniger verpasste Gelegenheiten: Händler erhalten sofortiges Feedback zu wichtigen Marktereignissen, selbst wenn sie mehrere Charts überwachen.
• Gestärktes Vertrauen: Visuelle und akustische Hinweise bestätigen, dass der Preis auf bekannte technische Niveaus reagiert.
• Effizienter Arbeitsablauf: Automatische Warnungen und Aktualisierungen verringern die Notwendigkeit einer ständigen manuellen Überwachung der Charts.

Visualisierung

Ein leistungsstarkes Handelsinstrument bietet mehr als nur Automatisierung oder Warnmeldungen. Außerdem muss sie Informationen klar und intuitiv vermitteln. Visuelle Klarheit hilft Händlern, schnellere und sicherere Entscheidungen zu treffen, insbesondere wenn mehrere Linien und Beschriftungen auf dem Chart erscheinen. In diesem Abschnitt werden wir das Erscheinungsbild unseres Fibonacci-Tools verfeinern und uns dabei auf die Lesbarkeit und Nutzerfreundlichkeit aller Bildschirmelemente konzentrieren.

Wenn mehrere Fibonacci-Ebenen angezeigt werden, kann ein Chart leicht unübersichtlich werden. Um dem entgegenzuwirken, verwenden wir ein einheitliches Farbschema, um wichtige Ebenen wie 0 %, 50 % und 100 % von weniger wichtigen Ebenen zu unterscheiden. Die Verwendung von Gold für größere Retracement-Linien und ein helleres Grün oder Rot für kleinere Ebenen ermöglicht es Händlern beispielsweise, sich auf einen Blick auf die statistisch signifikantesten Bereiche zu konzentrieren. Extension-Ebenen sind in einer kontrastierenden Farbe gestaltet, z. B. tomatenrot, um Verwechslungen mit Retracements zu vermeiden.

Schriftart und -größe sind ebenso wichtig. Die Verwendung einer fettgedruckten, gut lesbaren Schriftart wie Arial Black in einer angemessenen Größe (z. B. 10pt) gewährleistet, dass die Beschriftungen vor jeder Hintergrundfarbe und jeder Zoomstufe des Charts lesbar sind. Der Verzicht auf übermäßigen Text oder Dekorationen trägt zu einem professionellen, übersichtlichen Erscheinungsbild bei.

Ticker und Etikettenpräsentation

Die Ticker-Schlagzeile ist ein zentrales Merkmal für Echtzeit-Updates. Um seine Wirksamkeit zu maximieren, positionieren Sie ihn am unteren linken oder rechten Rand des Charts, wo es weniger wahrscheinlich ist, dass er sich mit der Kursbewegung oder wichtigen technischen Bereichen überschneidet. Wählen Sie eine Schriftfarbe und einen Hintergrund, die einen guten Kontrast zum Thema des Charts bilden, und ziehen Sie in Erwägung, den Nutzern die Möglichkeit zu geben, das Aussehen des Tickers über eine EA-Eingabevariable anzupassen (z. B. Eingabefarbe TickerColor = clrLime;).

Achten Sie bei der Kennzeichnung darauf, dass sie sich nicht wesentlich mit Preisbalken oder untereinander überschneiden. Sie können den vertikalen Versatz für jede neue Beschriftung erhöhen oder die Eigenschaft OBJPROP_YDISTANCE verwenden, um die Abstände gleichmäßig zu gestalten. Wenn Ihr Tool sowohl Fibonacci-Retracements als auch Extension zeichnet, gruppieren Sie die Beschriftungen entsprechend – vielleicht mit einer etwas anderen Farbe oder einem anderen Präfix für Extension-Ebenen.

Nachstehend finden Sie ein Beispiel für die Logik zum Zeichnen von Laufschriften und Kennzeichnungen:

// Drawing the ticker with configurable color and position
void DrawTicker(string text, color textColor = clrLime, int x = 10, int y = 400)
{
   long chartID = ChartID();
   string tickerName = "Ticker_Headline";
   ObjectCreate(chartID, tickerName, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(chartID, tickerName, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(chartID, tickerName, OBJPROP_YDISTANCE, y);
   ObjectSetString(chartID, tickerName, OBJPROP_TEXT, text);
   ObjectSetInteger(chartID, tickerName, OBJPROP_COLOR, textColor);
   ObjectSetInteger(chartID, tickerName, OBJPROP_FONTSIZE, 10);
   ObjectSetInteger(chartID, tickerName, OBJPROP_CORNER, CORNER_LEFT_LOWER);
}

// Enhanced label drawing with dynamic spacing and color
void DrawLevelLabel(string name, double price, string label, color c, int y_offset)
{
   long chartID = ChartID();
   ObjectCreate(chartID, name, OBJ_TEXT, 0, TimeCurrent(), price);
   ObjectSetString(chartID, name, OBJPROP_TEXT, label);
   ObjectSetInteger(chartID, name, OBJPROP_COLOR, c);
   ObjectSetInteger(chartID, name, OBJPROP_FONTSIZE, 10);
   ObjectSetInteger(chartID, name, OBJPROP_YDISTANCE, y_offset);
}

Durch diese Verfeinerungen sind sowohl die Laufschrift als auch die Beschriftungen der Ebenen gut lesbar und fügen sich optisch harmonisch in den Rest des Charts ein. Händler können sofort erkennen, welche Niveaus am wichtigsten sind, und Live-Aktualisierungen ohne Verwirrung verfolgen.

Tests und Ergebnisse

Das Testen ist eine kritische Phase, die sicherstellt, dass das Fibonacci-Tool unter realen Marktbedingungen die erwartete Leistung erbringt. Es hilft, Fehler, Probleme mit der Nutzerfreundlichkeit oder Ungenauigkeiten zu erkennen, die während der Entwicklung möglicherweise nicht auffallen. Ordnungsgemäße Tests erhöhen das Vertrauen des Händlers und unterstützen die kontinuierliche Verbesserung des Tools. Das folgende Chart veranschaulicht den Prozess des Anhängens des Expert Advisors (EA) an ein Chart und zeigt, wie die Schnittstelle aussieht, bevor irgendwelche Operationen durchgeführt werden.

Um die Leistung des Fibonacci-Tools unter realen Handelsbedingungen zu bewerten, wurde der EA sowohl auf Live- als auch auf Democharts im MetaTrader 5 gestartet. Es wurden verschiedene Paare und Zeiträume ausgewählt, um die Robustheit des Tools in unterschiedlichen Marktumgebungen zu überprüfen. Nach dem Laden des EA wurden verschiedene Werte für hohe (A) und tiefe (B) Umkehrpunkte manuell in die Eingabefelder auf dem Chart eingegeben, die sowohl Aufwärts- als auch Abwärtstrends darstellen. Die Beobachtungen konzentrierten sich für jedes Szenario darauf, ob der EA Fibonacci-Retracement- und Extension-Linien auf den richtigen Kursniveaus einzeichnete. Die Lesbarkeit der Kennzeichnung und die Konsistenz der Gestaltung wurden sorgfältig überprüft, um die Übereinstimmung mit dem beabsichtigten Design sicherzustellen. Im Laufe der Kursentwicklung wurden die gezeichneten Ebenen überwacht, um die korrekte Ausrichtung an den tatsächlichen Marktschwankungen und die visuelle Stabilität auf verschiedenen Zoomstufen und Symbolen zu bestätigen.  Ein weiteres Testbeispiel ist unten abgebildet.

Neben der einfachen Darstellung von Fibonacci-Ebenen beruht die Nutzerfreundlichkeit des Tools auf der problemlosen Interaktion mit den Steuerelementen auf dem Chart. Jedes Element der Nutzeroberfläche wurde systematisch getestet, einschließlich der Eingabefelder für die Punkte A und B, der Schaltflächen „Draw Fib“ und „Clear“ sowie der Ticker-Schlagzeile. Das Eingeben oder Anpassen von Werten in den Eingabefeldern löste sofort eine Aktualisierung der gezeichneten Fibonacci-Ebenen aus, wenn „Draw Fib“ gedrückt wurde. Die Clear-Funktion wurde überprüft, um sicherzustellen, dass sie alle zuvor gezeichneten Objekte zuverlässig entfernt und einen sauberen Chartzustand wiederherstellt. Um die Fehlerbehandlung zu bewerten, wurden absichtlich ungültige oder leere Eingaben gemacht; in jedem Fall reagierte der EA angemessen, indem er eine Fehlermeldung anzeigte oder weitere Aktionen verhinderte, bis gültige Daten eingegeben wurden. Schließlich wurde die Reaktionsfähigkeit des Tickers bewertet, indem beobachtet wurde, wie schnell er Statusmeldungen nach jeder Nutzerinteraktion aktualisierte.

2025.10.15 12:43:12.132 Interactive Fibonacci EA (Volatility 75 (1s) Index,M15) Alert: Touch: FIB_0.000 @ 4148.78000
2025.10.15 12:43:12.132 Interactive Fibonacci EA (Volatility 75 (1s) Index,M15) Touch: FIB_0.000 @ 4148.78000

Um die Interaktivität des Tools zu überprüfen, konzentrierten sich die Tests darauf, wie es reagierte, wenn sich der Kurs einem der eingezeichneten Fibonacci-Ebenen näherte oder dieses berührte. Während der Live-Marktbewegungen wurde die Fähigkeit des EA, zu erkennen, wann der Geldkurs in die definierte Berührungszone einer Retracement- oder Extension-Linie eintritt, genau überwacht. Wann immer ein solches Ereignis eintrat, lieferte das Tool eine sofortige Rückmeldung: Eine Markierung auf dem Chart wurde auf der berührten Ebene angezeigt, ein akustischer Alarm wurde aktiviert, und die Ticker-Schlagzeile wurde sofort mit einer prägnanten Ereignismeldung aktualisiert.

Dies bestätigte, dass das Warn- und Ereignissystem wie beabsichtigt funktioniert und gewährleistet, dass die Händler rechtzeitig über wichtige technische Interaktionen benachrichtigt werden, ohne dass sie ständig den Chart beobachten müssen.

Schlussfolgerung

Das Interactive Fibonacci Tool kombiniert automatische Analysen, Echtzeit-Warnungen und eine nutzerfreundliche Oberfläche, um den Fibonacci-basierten Handel im MetaTrader 5 zu optimieren. Durch sorgfältiges Design, gründliche Tests und klares visuelles Feedback versetzt das Tool Händler in die Lage, wichtige Marktniveaus effizient zu identifizieren und schnell auf Kursbewegungen zu reagieren. Mit seinen anpassungsfähigen und intuitiven Funktionen ist dieser EA eine wertvolle Ergänzung für das Toolkit jedes Händlers.

Bitte beachten Sie, dass dieses Tool keine Handelsgeschäfte ausführt oder eröffnet. Es fungiert als automatisierter Assistent für die Preisaktionsanalyse im MetaTrader 5 und dient zu Ausbildungszwecken. Händler können es neben ihren eigenen Strategien und anderen Formen der Marktbestätigung verwenden.