Handel mit dem MQL5 Wirtschaftskalender (Teil 3): Hinzufügen de Filter für Währung, Bedeutung und Zeit

Einführung

In diesem Artikel bauen wir auf unserer früheren Arbeit mit dem Wirtschaftskalender in MetaQuotes Language 5 (MQL5) auf, wo wir ein News-Dashboard-Panel zur Anzeige von Wirtschaftsereignissen in Echtzeit entwickelt haben. Nun werden wir dieses Dashboard erweitern, indem wir spezifische Filter für Währung, Bedeutung und Zeit implementieren, die es den Händlern ermöglichen, sich nur auf die Nachrichten zu konzentrieren, die für ihre Strategien am wichtigsten sind. Diese Filter bieten einen gezielten Überblick über marktbewegende Ereignisse und tragen dazu bei, die Entscheidungsfindung zu rationalisieren und die Handelseffizienz zu verbessern. Zu den Themen, die wir behandeln werden, gehören:

1. Einführung
2. Verstehen von Filtertypen in Wirtschaftskalendern
3. Implementierung von Filtern in MQL5
4. Schlussfolgerung

Mit diesen Ergänzungen wird unser Dashboard zu einem leistungsstarken Instrument zur Überwachung und Filterung von Wirtschaftsnachrichten im Umfeld von MQL5, das auf den Bedarf der Händler an zeitnahen und relevanten Informationen zugeschnitten ist.

Verstehen von Filtertypen in Wirtschaftskalendern

Um die Funktionalität unseres Dashboards zu verfeinern, müssen wir den Zweck und die Vorteile der einzelnen Filtertypen verstehen: Währung, Bedeutung und Zeit (Currency, Impact, Time). Mit dem Währungsfilter können wir wirtschaftliche Ereignisse anzeigen, die sich speziell auf die von uns gehandelten Währungen auswirken. Dieser Filter trägt dazu bei, das Dashboard zu optimieren, indem er die Informationsflut reduziert und sich nur auf die Währungen in unserem Handelsportfolio konzentriert. Im Handelsterminal MetaTrader 5 können wir auf die Nachrichten zugreifen und sie nach der Währung filtern, indem wir mit dem Mauszeiger über die Registerkarte „Kalender“ fahren, mit der rechten Maustaste darauf klicken und entweder die gewünschte Währung oder das Land auswählen. Hier ist eine Illustration.

Der Bedeutungsfilter kategorisiert Ereignisse auf der Grundlage ihrer erwarteten Auswirkungen, die als gering, mittel oder hoch eingestuft werden. Ereignisse von großer Tragweite, wie z. B. Ankündigungen der Zentralbank oder Arbeitslosenzahlen, können zu Marktschwankungen führen. Durch die Filterung nach Bedeutung können wir schnell einschätzen, welche Ereignisse sich am stärksten auf unsere Handelsentscheidungen auswirken könnten, was die Reaktionsfähigkeit verbessert. Um die Nachrichten nach ihrer Bedeutung zu filtern, können Sie erneut mit der rechten Maustaste auf die Registerkarte „Kalender“ klicken und „nach Relevanz“ auswählen. Hier ist eine Illustration.

Der Zeitfilter schließlich ermöglicht es uns, den Zeitrahmen für relevante wirtschaftliche Ereignisse festzulegen, was besonders für diejenigen nützlich ist, die innerhalb bestimmter Sitzungen handeln oder sich auf kommende Nachrichten vorbereiten. Mit diesem Filter können wir Ereignisse innerhalb eines bestimmten Zeitraums sehen, z. B. die nächste Stunde, den nächsten Tag oder die nächste Woche. Zusammen schaffen diese Filter eine anpassbare Erfahrung, die Wirtschaftsnachrichten auf die individuellen Handelsbedürfnisse zuschneidet und das Rückgrat eines reaktionsschnellen und effizienten MQL5-Dashboards bildet.

Implementierung von Filtern in MQL5

Um die Filter in MQL5 zu implementieren, müssen wir als Erstes die booleschen Variablen in einem globalen Bereich definieren. Diese Variablen steuern, ob die Filter für Währung, Bedeutung und Zeit aktiviert oder deaktiviert sind. Indem wir sie global definieren, stellen wir sicher, dass auf die Filter im gesamten Code zugegriffen und sie geändert werden können, was eine flexible Arbeitsweise des Nachrichten-Dashboards ermöglicht. Dieser Schritt bildet die Grundlage für die Implementierung der Filterlogik und ermöglicht es uns, die Funktionalität des Dashboards an unsere Handelsanforderungen anzupassen. Um dies zu erreichen, verwenden wir die folgende Logik.

//--- Define flags to enable/disable filters
bool enableCurrencyFilter = true;  // Set to 'true' to enable currency filter, 'false' to disable
bool enableImportanceFilter = true; // Set to 'true' to enable importance filter, 'false' to disable
bool enableTimeFilter = true; // Set to 'true' to enable time filter, 'false' to disable

Hier definieren wir drei boolesche Variablen, nämlich „enableCurrencyFilter“, „enableImportanceFilter“ und „enableTimeFilter“, mit denen wir steuern, ob die jeweiligen Filter für Währung, Bedeutung und Zeit aktiviert oder deaktiviert sind. Jede Variable ist auf den Standardwert „true“ eingestellt, was bedeutet, dass standardmäßig alle Filter aktiv sind. Indem wir diese Werte auf „false“ ändern, können wir alle Filter, die wir nicht verwenden möchten, deaktivieren und so die Funktionalität des Nachrichten-Dashboards an unsere Handelspräferenzen anpassen.

Ab hier beginnen wir in der Initialisierungslogik beim Zählen der gültigen Nachrichtenereignisse mit dem Währungsfilter. Zunächst müssen wir die Währungscodes definieren, auf die wir den Filter anwenden wollen. Wir werden sie daher wie folgt definieren.

string curr_filter[] = {"AUD","CAD","CHF","EUR","GBP","JPY","NZD","USD"};
int news_filter_count = 0;

Hier definieren wir das Array „curr_filter“ „string“, das eine Liste von Währungspaaren enthält: „AUD“, „CAD“, „CHF“, „EUR“, „GBP“, „JPY“, „NZD“ und „USD“, die wir verwenden wollen, um die Nachrichten nach bestimmten Währungen zu filtern. Dieses Feld hilft uns dabei, die auf dem Dashboard angezeigten Nachrichten einzugrenzen und sich nur auf die für die ausgewählten Währungen relevanten Ereignisse zu konzentrieren. Außerdem definieren wir die Variable „news_filter_count“, mit der wir die Anzahl der gefilterten Nachrichtenereignisse, die unseren ausgewählten Kriterien entsprechen, verfolgen, um sicherzustellen, dass wir nur die wichtigsten Informationen anzeigen. Dann können wir wie folgt zur Filterlogik übergehen.

//--- Check if the event’s currency matches any in the filter array (if the filter is enabled)
bool currencyMatch = false;
if (enableCurrencyFilter) {
   for (int j = 0; j < ArraySize(curr_filter); j++) {
      if (country.currency == curr_filter[j]) {
         currencyMatch = true;
         break;
      }
   }
   
   //--- If no match found, skip to the next event
   if (!currencyMatch) {
      continue;
   }
}

Hier wird geprüft, ob die Währung des Ereignisses mit einer der Währungen im Array „curr_filter“ übereinstimmt, allerdings nur, wenn der Währungsfilter aktiviert ist, was durch das Flag „enableCurrencyFilter“ angezeigt wird. Wenn der Filter aktiviert ist, wird das Array „curr_filter“ in einer for-Schleife durchlaufen, und bei jedem Durchlauf wird die Währung des Ereignisses mit den Währungen im Filter verglichen.

Wenn eine Übereinstimmung gefunden wird, setzen wir das Flag „currencyMatch“ auf true und verlassen die Schleife. Wird keine Übereinstimmung gefunden (d. h. „currencyMatch“ bleibt falsch), verwenden wir die Anweisung continue, um das aktuelle Ereignis zu überspringen und mit dem nächsten fortzufahren, um sicherzustellen, dass nur relevante Ereignisse verarbeitet werden. Mit der gleichen Logik filtern wir dann die Ereignisse nach ihrer Bedeutung.

//--- Check importance level if importance filter is enabled
bool importanceMatch = false;
if (enableImportanceFilter) {
   for (int k = 0; k < ArraySize(allowed_importance_levels); k++) {
      if (event.importance == allowed_importance_levels[k]) {
         importanceMatch = true;
         break;
      }
   }
   
   //--- If importance does not match the filter criteria, skip the event
   if (!importanceMatch) {
      continue;
   }
}

Hier wird die Bedeutungsstufe des Ereignisses mit dem vordefinierten Array „allowed_importance_levels“ abgeglichen, allerdings nur, wenn der Bedeutungsfilter aktiviert ist, was durch das Flag „enableImportanceFilter“ angezeigt wird. Wenn der Filter aktiviert ist, wird das Array „allowed_importance_levels“ in einer for-Schleife durchlaufen und die Bedeutung des Ereignisses mit den Werten im Array verglichen.

Wenn eine Übereinstimmung gefunden wird, setzen wir das Flag „importanceMatch“ auf true und verlassen die Schleife. Wird keine Übereinstimmung gefunden (d. h. „importanceMatch“ bleibt falsch), wird das aktuelle Ereignis mit der continue-Anweisung übersprungen, um sicherzustellen, dass nur Ereignisse mit der gewünschten Bedeutungsstufe verarbeitet werden. Wir haben ein weiteres Array verwendet, um die Bedeutungsstufen wie folgt zu definieren:

// Define the levels of importance to filter (low, moderate, high)
ENUM_CALENDAR_EVENT_IMPORTANCE allowed_importance_levels[] = {CALENDAR_IMPORTANCE_LOW, CALENDAR_IMPORTANCE_MODERATE, CALENDAR_IMPORTANCE_HIGH};

Hier haben wir alle Bedeutungsstufen hinzugefügt, was bedeutet, dass wir technisch gesehen alle Nachrichten nach Priorität zulassen, aber Sie können die Nachrichten auswählen, die für Ihre Handelsentscheidungen am besten geeignet sind. Als Nächstes müssen wir die Zeitfilterbereiche definieren.

//--- Define time range for filtering news events based on daily period
datetime timeRange = PeriodSeconds(PERIOD_D1);
datetime timeBefore = TimeTradeServer() - timeRange;
datetime timeAfter = TimeTradeServer() + timeRange;

Wir definieren einen Zeitbereich für die Filterung von Nachrichtenereignissen auf der Grundlage des Tageszeitraums. Wir verwenden die Funktion PeriodSeconds mit der Konstante PERIOD_D1, um die Anzahl der Sekunden eines Tages zu ermitteln, die wir dann der Variablen „timeRange“ vom Typ Datetime zuweisen. Die Variablen „timeBefore“ und „timeAfter“ werden gesetzt, um die Zeitspanne um die aktuelle Serverzeit zu berechnen, die mit der Funktion TimeTradeServer abgerufen wird, indem die „timeRange“ subtrahiert bzw. addiert wird. Dadurch wird sichergestellt, dass nur Ereignisse, die in den angegebenen Zeitbereich fallen (innerhalb eines Tages vor oder nach der aktuellen Serverzeit), für die Verarbeitung berücksichtigt werden. Stellen Sie sicher, dass Sie dies Ihren Bedürfnissen entsprechend anpassen. Mit dieser Logik ausgestattet, können wir dann den Zeitfilter anwenden.

//--- Apply time filter and set timeMatch flag (if the filter is enabled)
bool timeMatch = false;
if (enableTimeFilter) {
   datetime eventTime = values[i].time;
   
   if (eventTime <= TimeTradeServer() && eventTime >= timeBefore) {
      timeMatch = true;  //--- Event is already released
   }
   else if (eventTime >= TimeTradeServer() && eventTime <= timeAfter) {
      timeMatch = true;  //--- Event is yet to be released
   }
   
   //--- Skip if the event doesn't match the time filter
   if (!timeMatch) {
      continue;
   }
}

Hier wenden wir den Zeitfilter an, indem wir prüfen, ob die Zeit des Ereignisses in den angegebenen Zeitbereich fällt, und wir verwenden das Flag „timeMatch“, um zu verfolgen, ob das Ereignis die Kriterien erfüllt. Wenn der „enableTimeFilter“ wahr ist, wird zunächst die Zeit des Ereignisses aus der Variablen „values[i].time“ abgerufen. Anschließend wird geprüft, ob der Zeitpunkt des Ereignisses entweder in der Vergangenheit (zwischen der aktuellen Serverzeit und „timeBefore“) oder in der Zukunft (zwischen der aktuellen Serverzeit und „timeAfter“) liegt. Wenn der Zeitpunkt des Ereignisses in einen der beiden Bereiche fällt, wird das Flag „timeMatch“ auf „true“ gesetzt, was bedeutet, dass das Ereignis dem Zeitfilter entspricht. Wenn keine Übereinstimmung gefunden wird, wird das Ereignis mit der Anweisung continue übersprungen.

Das war's mit den Filtern. Wenn wir hier ankommen, bedeutet das, dass wir alle Tests bestanden haben und dass es einige neue Ereignisse gibt. Wir aktualisieren also die Anzahl der Nachrichtenfilter um eins.

//--- If we reach here, the currency matches the filter
news_filter_count++; //--- Increment the count of filtered events

Wir verwenden nun die Zähldaten des Nachrichtenfilters, um die Datenhalterabschnitte zu erstellen, da wir dieses Mal nicht alle ausgewählten Ereignisse berücksichtigen. Auf diese Weise wird sichergestellt, dass wir im Dashboard gerade so viele Datenhalter anlegen, wie für uns relevant sind.

//--- Set alternating colors for each data row holder
color holder_color = (news_filter_count % 2 == 0) ? C'213,227,207' : clrWhite;

//--- Create rectangle label for each data row holder
createRecLabel(DATA_HOLDERS+string(news_filter_count),62,startY-1,716,26+1,holder_color,1,clrNONE);

Hier haben wir abwechselnde Farben für jeden Datenzeilenhalter eingestellt, um die visuelle Unterscheidung zwischen den Zeilen zu verbessern. Die „holder_color“ wird mit Hilfe eines ternären Operators bestimmt. Ist die „news_filter_count“ gerade (d. h. „news_filter_count % 2 == 0“), wird die Farbe auf einen hellgrünen Farbton (C'213,227,207') gesetzt, ist sie ungerade, wird die Farbe auf Weiß gesetzt. Dadurch wird sichergestellt, dass jede Zeile eine andere Farbe hat, was die Lesbarkeit der Daten erleichtert.

Anschließend wird mit der Funktion „createRecLabel“ für jeden Datenzeilenhalter ein Rechtecklabel erstellt, das an den angegebenen Koordinaten ein farbiges Rechteck platziert. Die Beschriftung wird eindeutig identifiziert, indem „DATA_HOLDERS“ mit der String-Darstellung von „news_filter_count“ kombiniert wird, um sicherzustellen, dass jede Zeile einen eindeutigen Namen hat, und die Abmessungen des Rechtecks werden an den Inhalt angepasst. Der Rahmen des Rechtecks wird auf eine Dicke von 1 gesetzt, während wir die Füllfarbe auf die alternierende „holder_color“ und die Rahmenfarbe auf „clrNONE“ für keine Rahmenfarbe setzen.

Beachten Sie jedoch, dass wir 1 Pixel zur y-Verschiebung der Halter hinzugefügt haben, wie in gelber Farbe hervorgehoben, um die Ränder loszuwerden. Hier ist ein Vergleichsergebnis.

Vor der Hinzufügung von einem Pixel:

Nach der Hinzufügung von einem Pixel:

Das war ein Erfolg. Als Nächstes müssen wir die Gesamtnachrichten aktualisieren, die im Dashboard angezeigt werden, wenn die Filter angewendet werden.

updateLabel(TIME_LABEL,"Server Time: "+TimeToString(TimeCurrent(),
           TIME_DATE|TIME_SECONDS)+"   |||   Total News: "+
           IntegerToString(news_filter_count)+"/"+IntegerToString(allValues));

Hier verwenden wir die Funktion „updateLabel“, um das Label zu aktualisieren, das die aktuelle Serverzeit und die Gesamtzahl der gefilterten Nachrichten anzeigt. Wir aktualisieren das Label „TIME_LABEL“ mit einer neuen Zeichenfolge, die die aktuelle Serverzeit und die Anzahl der Nachrichtenereignisse kombiniert. Um die aktuelle Serverzeit zu erhalten, verwenden wir die Funktion TimeCurrent und formatieren sie mit der Funktion TimeToString mit den Flags „TIME_DATE | TIME_SECONDS“.

Anschließend wird die Gesamtzahl der gefilterten Nachrichtenereignisse, die in „news_filter_count“ gespeichert ist, zusammen mit der Gesamtzahl der verfügbaren Nachrichtenereignisse, die durch „allValues“ dargestellt wird, angezeigt. Durch die Aktualisierung dieser Kennzeichnung informieren wir in Echtzeit sowohl über die Serverzeit als auch über den Status des Nachrichtenfilters und bleiben so über die aktuellen Marktnachrichten, die für uns von Bedeutung sind, informiert.

Der Codeabschnitt der nutzerdefinierten Funktion, die wir zur Aktualisierung der Beschriftung verwenden, lautet wie folgt:

//+------------------------------------------------------------------+
//|     Function to create text label                                |
//+------------------------------------------------------------------+

bool updateLabel(string objName,string txt) {
    // Reset any previous errors
    ResetLastError();

    if (!ObjectSetString(0,objName,OBJPROP_TEXT,txt)) {
        Print(__FUNCTION__, ": failed to update the label! Error code = ", _LastError);
        return (false);
    }

    ObjectSetString(0, objName, OBJPROP_TEXT, txt); // Text displayed on the label

    // Redraw the chart to display the label
    ChartRedraw(0);

    return (true); // Label creation successful
}

Hier definieren wir die Funktion „updateLabel“, mit der wir eine bestehende Beschriftung im Chart aktualisieren. Die Funktion benötigt zwei Parameter: „objName“ (der Name des Etikettenobjekts) und „txt“ (der Text, der auf dem Etikett angezeigt werden soll). Zunächst werden mit der Funktion ResetLastError alle früheren Fehler zurückgesetzt, um eine saubere Weste zu gewährleisten. Als Nächstes versuchen wir, den Text des Etiketts mit der bereitgestellten Zeichenfolge „txt“ zu aktualisieren, indem wir die Funktion ObjectSetString verwenden. Wenn die Aktualisierung fehlschlägt, wird mit der Funktion Print eine Fehlermeldung zusammen mit dem aus _LastError abgerufenen Fehlercode ausgegeben und „false" zurückgegeben.

Wenn die Aktualisierung der Beschriftung erfolgreich war, rufen wir die Funktion ChartRedraw auf, um das Chart zu aktualisieren und die aktualisierte Beschriftung anzuzeigen, und schließlich geben wir „true" zurück, um anzuzeigen, dass der Vorgang erfolgreich war. Mit dieser Funktion können wir den Inhalt der Beschriftungen im Chart dynamisch aktualisieren und so eine flexible Methode zur Anzeige von Informationen wie der Serverzeit oder der Anzahl der Nachrichtenereignisse bieten. Nach dem Ausführen des Programms sehen wir folgendes Ergebnis.

Mit der Umsetzung sind wir nun sicher, dass wir nur die Nachrichten berücksichtigen, die für uns relevant sind, und die anderen ignorieren. Wir zeigen auch die Gesamtzahl der übermittelten Nachrichten aus allen ausgewählten Nachrichten an, wobei sowohl die verfügbaren als auch die berücksichtigten Nachrichtenereignisse angezeigt werden. Der vollständige Initialisierungscode, der für die Anwendung der Filter verantwortlich ist, lautet wie folgt.

string curr_filter[] = {"AUD","CAD","CHF","EUR","GBP","JPY","NZD","USD"};
int news_filter_count = 0;

// Define the levels of importance to filter (low, moderate, high)
ENUM_CALENDAR_EVENT_IMPORTANCE allowed_importance_levels[] = {CALENDAR_IMPORTANCE_LOW, CALENDAR_IMPORTANCE_MODERATE, CALENDAR_IMPORTANCE_HIGH};

//--- Loop through each calendar value up to the maximum defined total
for (int i = 0; i < valuesTotal; i++){

   MqlCalendarEvent event; //--- Declare event structure
   CalendarEventById(values[i].event_id,event); //--- Retrieve event details by ID

   MqlCalendarCountry country; //--- Declare country structure
   CalendarCountryById(event.country_id,country); //--- Retrieve country details by event's country ID

   MqlCalendarValue value; //--- Declare calendar value structure
   CalendarValueById(values[i].id,value); //--- Retrieve actual, forecast, and previous values
   
   
   //--- Check if the event’s currency matches any in the filter array (if the filter is enabled)
   bool currencyMatch = false;
   if (enableCurrencyFilter) {
      for (int j = 0; j < ArraySize(curr_filter); j++) {
         if (country.currency == curr_filter[j]) {
            currencyMatch = true;
            break;
         }
      }
      
      //--- If no match found, skip to the next event
      if (!currencyMatch) {
         continue;
      }
   }
   
   //--- Check importance level if importance filter is enabled
   bool importanceMatch = false;
   if (enableImportanceFilter) {
      for (int k = 0; k < ArraySize(allowed_importance_levels); k++) {
         if (event.importance == allowed_importance_levels[k]) {
            importanceMatch = true;
            break;
         }
      }
      
      //--- If importance does not match the filter criteria, skip the event
      if (!importanceMatch) {
         continue;
      }
   }
   
   //--- Apply time filter and set timeMatch flag (if the filter is enabled)
   bool timeMatch = false;
   if (enableTimeFilter) {
      datetime eventTime = values[i].time;
      
      if (eventTime <= TimeTradeServer() && eventTime >= timeBefore) {
         timeMatch = true;  //--- Event is already released
      }
      else if (eventTime >= TimeTradeServer() && eventTime <= timeAfter) {
         timeMatch = true;  //--- Event is yet to be released
      }
      
      //--- Skip if the event doesn't match the time filter
      if (!timeMatch) {
         continue;
      }
   }
   
   //--- If we reach here, the currency matches the filter
   news_filter_count++; //--- Increment the count of filtered events
   
   //--- Set alternating colors for each data row holder
   color holder_color = (news_filter_count % 2 == 0) ? C'213,227,207' : clrWhite;

   //--- Create rectangle label for each data row holder
   createRecLabel(DATA_HOLDERS+string(news_filter_count),62,startY-1,716,26+1,holder_color,1,clrNONE);

   //--- Initialize starting x-coordinate for each data entry
   int startX = 65;
   
   //--- Loop through calendar data columns
   for (int k=0; k<ArraySize(array_calendar); k++){
         
      //--- Print event details for debugging
      //Print("Name = ",event.name,", IMP = ",EnumToString(event.importance),", COUNTRY = ",country.name,", TIME = ",values[i].time);
   
      //--- Skip event if currency does not match the selected country code
      // if (StringFind(_Symbol,country.currency) < 0) continue;
   
      //--- Prepare news data array with time, country, and other event details
      string news_data[ArraySize(array_calendar)];
      news_data[0] = TimeToString(values[i].time,TIME_DATE); //--- Event date
      news_data[1] = TimeToString(values[i].time,TIME_MINUTES); //--- Event time
      news_data[2] = country.currency; //--- Event country currency
   
      //--- Determine importance color based on event impact
      color importance_color = clrBlack;
      if (event.importance == CALENDAR_IMPORTANCE_LOW){importance_color=clrYellow;}
      else if (event.importance == CALENDAR_IMPORTANCE_MODERATE){importance_color=clrOrange;}
      else if (event.importance == CALENDAR_IMPORTANCE_HIGH){importance_color=clrRed;}
   
      //--- Set importance symbol for the event
      news_data[3] = ShortToString(0x25CF);
   
      //--- Set event name in the data array
      news_data[4] = event.name;
         
      //--- Populate actual, forecast, and previous values in the news data array
      news_data[5] = DoubleToString(value.GetActualValue(),3);
      news_data[6] = DoubleToString(value.GetForecastValue(),3);
      news_data[7] = DoubleToString(value.GetPreviousValue(),3);         
      
      //--- Create label for each news data item
      if (k == 3){
         createLabel(ARRAY_NEWS+IntegerToString(i)+" "+array_calendar[k],startX,startY-(22-12),news_data[k],importance_color,22,"Calibri");
      }
      else {
         createLabel(ARRAY_NEWS+IntegerToString(i)+" "+array_calendar[k],startX,startY,news_data[k],clrBlack,12,"Calibri");
      }
   
      //--- Increment x-coordinate for the next column
      startX += buttons[k]+3;
   }
   //--- Increment y-coordinate for the next row of data
   startY += 25;
   //Print(startY); //--- Print current y-coordinate for debugging
}

//Print("Final News = ",news_filter_count);
updateLabel(TIME_LABEL,"Server Time: "+TimeToString(TimeCurrent(),
           TIME_DATE|TIME_SECONDS)+"   |||   Total News: "+
           IntegerToString(news_filter_count)+"/"+IntegerToString(allValues));

Das war ein Erfolg. Am Ende wollen wir das Dashboard loswerden, wenn das Programm aus dem Chart entfernt wird, um eine saubere Umgebung zu hinterlassen. Um dies auf professionellere Weise zu erreichen, können wir eine Funktion definieren, in die wir die gesamte Steuerlogik einfügen.

//+------------------------------------------------------------------+
//|      Function to destroy the Dashboard panel                     |
//+------------------------------------------------------------------+

void destroy_Dashboard(){

   //--- Delete main rectangle panel
   ObjectDelete(0, MAIN_REC);
   
   //--- Delete first sub-rectangle in the dashboard
   ObjectDelete(0, SUB_REC1);
   
   //--- Delete second sub-rectangle in the dashboard
   ObjectDelete(0, SUB_REC2);
   
   //--- Delete header label text
   ObjectDelete(0, HEADER_LABEL);
   
   //--- Delete server time label text
   ObjectDelete(0, TIME_LABEL);
   
   //--- Delete label for impact/importance
   ObjectDelete(0, IMPACT_LABEL);

   //--- Delete all objects related to the calendar array
   ObjectsDeleteAll(0, ARRAY_CALENDAR);
   
   //--- Delete all objects related to the news array
   ObjectsDeleteAll(0, ARRAY_NEWS);
   
   //--- Delete all data holder objects created in the dashboard
   ObjectsDeleteAll(0, DATA_HOLDERS);
   
   //--- Delete all impact label objects
   ObjectsDeleteAll(0, IMPACT_LABEL);
   
   //--- Redraw the chart to update any visual changes
   ChartRedraw(0);
}

Hier definieren wir die nutzerdefinierte Funktion „destroy_Dashboard“, mit der wir alle Elemente, die für unser Dashboard-Panel im Chart erstellt wurden, vollständig entfernen und das Chart in seinen Ausgangszustand zurückversetzen. Dabei werden alle im Dashboard verwendeten Objekte, Beschriftungen und Halter gelöscht. Zunächst löschen wir das Rechteck des Haupt-Panels, indem wir die Funktion ObjectDelete für „MAIN_REC“ aufrufen, das den primären Container unseres Dashboards darstellt. Anschließend entfernen wir alle Unterrechtecke, wie z. B. „SUB_REC1“ und „SUB_REC2“, die wir zur Gliederung verschiedener Abschnitte des Dashboards verwendet haben.

Anschließend löschen wir Beschriftungen, die Informationen wie die Kopfzeile des Dashboards „HEADER_LABEL“, die Serverzeit „TIME_LABEL“ und die Auswirkungsstufe „IMPACT_LABEL“ anzeigen. Jede dieser Beschriftungen wird entfernt, um sicherzustellen, dass alle Textinformationen, die auf dem Chart angezeigt werden, gelöscht werden. Als Nächstes löschen wir alle Objekte in „ARRAY_CALENDAR“ und „ARRAY_NEWS“, die Informationen über die Kalender- bzw. Nachrichtendaten speichern. Wir führen diese Aktion mit der Funktion ObjectsDeleteAll durch, die es uns ermöglicht, alle dynamisch erstellten Objekte, die mit diesen Arrays verbunden sind, zu löschen.

Anschließend werden alle Objekte im Zusammenhang mit DATA_HOLDERS“ gelöscht, die einzelne Zeilen oder Container darstellen, die Datenpunkte im Dashboard anzeigen, gefolgt von einem weiteren Aufruf zum Löschen der Instanzen von „IMPACT_LABEL“, um sicherzustellen, dass keine visuellen Elemente übrig bleiben.

Zum Schluss rufen wir die Funktion ChartRedraw auf, die das Chart aktualisiert und alle Überreste des Dashboards löscht, sodass eine leere Leinwand für weitere Zeichnungen oder das Zurücksetzen des Dashboards entsteht. Diese Funktion demontiert im Wesentlichen die gesamte Anzeige des Dashboards und bereitet das Chart für neue Aktualisierungen oder andere visuelle Elemente vor, die nach dem Entfernen des Programms benötigt werden. Zum Schluss rufen wir die Funktion OnDeinit auf, um das Dashboard zu entfernen.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason){
//---

   destroy_Dashboard(); 
}

Nach dem Aufruf der nutzerdefinierten Funktion OnDeinit müssen wir sicherstellen, dass das Dashboard aus dem Chart entfernt wird. Das ist alles, was nötig ist, um die Filter zu unserem Dashboard hinzuzufügen.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass wir unser MQL5-Wirtschaftskalender-Dashboard erfolgreich verbessert haben, indem wir wesentliche Filterfunktionen integriert haben, mit denen wir nur die relevantesten Nachrichtenereignisse auf der Grundlage von Währung, Bedeutung und Zeit anzeigen können. Diese Filter bieten eine gestraffte und fokussierte Schnittstelle, die es uns ermöglicht, uns auf wirtschaftliche Ereignisse zu konzentrieren, die mit unserer spezifischen Handelsstrategie und unseren Zielen übereinstimmen.

Indem wir das Dashboard mit diesen Filtern verfeinern, machen wir es zu einem leistungsfähigeren und effizienteren Instrument für fundierte Entscheidungen. Im nächsten Teil werden wir diese Grundlage ausbauen, indem wir der Logik des Kalender-Dashboards Live-Updates hinzufügen, sodass es ständig mit den neuesten Wirtschaftsnachrichten direkt in unserem MQL5-Dashboard aktualisiert wird.