Vom Neuling zum Experten: Entwicklung eines geografischen Marktbewusstseins mit MQL5-Visualisierung

Inhalt

• Einführung
• Umsetzung
• Tests
• Schlussfolgerung
• Wichtige Lektionen
• Anlagen

Einführung

In meinen jüngsten Veröffentlichungen über die Zeiträume der Börsensitzungen ging es vor allem darum, die Persönlichkeit jeder Sitzung deutlich zu machen – und nicht nur ihre Uhrzeiten. In vielen Quellen wird erklärt, wann Sydney, Tokio, London und New York öffnen und schließen, aber weit weniger befassen sich damit, wie das Wissen um die Börsensitzung selbst die Handelspsychologie stärkt. Zu wissen, welcher Teil der Welt aktiv ist und warum sich der Preis so bewegt, wie er sich bewegt, kann den Geist beruhigen und die Entscheidungsfindung schärfen.

Der 24-Stunden-Zyklus des Devisenmarktes ist eigentlich eine geografische Symphonie, doch die meisten Händler erleben ihn als eine flache Zeitlinie. Wir sehen Stunden und Kerzen, nicht das Erwachen von Sydney, den Morgentee in London oder die nachmittägliche Volatilitätswelle in New York. Diese Diskrepanz zwischen zeitbasierten Charts und geografischer Liquidität ist so, als würde man handeln, ohne den Herzschlag des Marktes wirklich zu sehen.

In diesem Artikel schließen wir diese Lücke, indem wir das Chart selbst mit Hilfe der MQL5-Bitmap-Fähigkeiten in einen Live-Weltkarten-Slideplayer verwandeln. Anstelle eines statischen Hintergrunds werden wir eine intelligente visuelle Ebene erstellen, die die derzeit aktiven Sitzungen in Echtzeit direkt im Chart hervorhebt. Es wird zu einem maßgeschneiderten Thema mit einem Zweck: Auf einen Blick sieht das Auge, welche Sitzung den Preis treibt, Überschneidungen sind sofort erkennbar, und Ihre Psychologie bleibt im globalen Rhythmus des Marktes verankert. Danach werden wir uns mit der Kernimplementierung befassen und die Tools entwickeln, die diese sitzungsbezogene Visualisierung ermöglichen.

Am Ende werden wir eine intelligente Engine haben, die die im Bild gezeigten Themen steuert

Eine historische Perspektive: Wie die Zeit den modernen Handel prägte

Das Konzept der Handelssitzungen entstand nicht aus einer Idee, sondern aus der Notwendigkeit heraus. In den 1970er Jahren, als die Währungen anfingen, sich frei zu bewegen, ergab sich ein natürliches Muster: Wenn die Händler in Sydney nach Hause gingen, wachte Tokio auf. Als Tokio schloss, öffnete London. Durch diese Übergabe entstand der moderne Sitzungszyklus, der heute täglich 7,5 Billionen Dollar bewegt.

Was als geografische Notwendigkeit begann, entwickelte sich zu einer Chance. Professionelle Händler bemerkten etwas Tiefgreifendes: Überschneidungen waren nicht nur Übergaben – sie waren Verstärker. Die dreistündige Überschneidung zwischen London und New York macht nur 12,5 % des Handelstages aus, verursacht aber 40 % der EURUSD-Bewegungen. Das ist kein Zufall, sondern die geografische Realität des Marktes, die durch den Preis sichtbar wird.

Jahrzehntelang verwalteten Händler das Sitzungsbewusstsein durch mentale Berechnungen, mehrere Zeitzonenuhren oder einfache farbcodierte Charts. Diese Lösungen hatten einen gemeinsamen Fehler: Sie erhöhten die kognitive Belastung, anstatt Intuition zu schaffen. Man musste über Sitzungen nachdenken, anstatt sie zu fühlen.

Die moderne handelspsychologische Forschung hat eine entscheidende Erkenntnis zutage gefördert: Profis analysieren nicht nur die Märkte – sie entwickeln ein Gespür für den Markt. Sie „spüren“, wenn London kurz vor der Eröffnung steht, und sie „fühlen“, wenn die Liquidität in Asien schwindet. Das ist nichts Mystisches – es ist eine Mustererkennung, die bewusstes Wissen in unterbewusstes Bewusstsein umwandelt. Aber das braucht Jahre, um sich natürlich zu entwickeln. Was wäre, wenn wir es beschleunigen könnten?

Unser Auftrag: Das Unsichtbare sichtbar machen

Dies ist der Beginn unserer Reise. Wir bauen keinen weiteren Indikator, der mehr Daten auf unseren Bildschirm bringt. Wir schaffen eine visuelle Übersetzungsebene zwischen der geografischen Realität des Marktes und unserem chronologischen Chart.

Stellen Sie sich vor, die Handelsplattform verwandelt sich in eine dynamische Weltkarte, auf der

1. Australien leuchtet blau, wenn Sydney aktiv ist.
2. Japan leuchtet, während Tokio die Macht übernimmt.
3. Europa wird durch die Energie Londons lebendig.
4. Die Amerikas leuchten während der New Yorker Zeit.

Untersuchungen im Bereich der Finanzvisualisierung zeigen, dass die räumliche Darstellung zeitlicher Daten die Entscheidungsgeschwindigkeit um 30 % und die Genauigkeit um 22 % erhöht. Indem Sie die Sitzungen geografisch einordnen, entwickeln Sie ein Gespür für den Markt, das normalerweise erst nach jahrelanger Erfahrung entsteht.

MQL5 ist unser Pinsel für diese Visualisierung. Wir nutzen seine einzigartigen Fähigkeiten:

• Einbettung von Ressourcen zur Schaffung nahtloser visueller Erlebnisse
• Ereignisgesteuerte Architektur, die auf natürliche Weise auf Marktrhythmen reagiert
• Objektorientierter Entwurf für sauberen, wartbaren Code
• Echtzeit-Benachrichtigungen, die Sie ohne Ablenkung auf dem Laufenden halten

Jede Codezeile dient einem bestimmten Zweck: der Verringerung Ihrer kognitiven Belastung bei gleichzeitiger Steigerung des Marktbewusstseins. Wir bauen das auf, was professionelle Händler schon seit Jahren stillschweigend nutzen, aber Privatanleger nur selten Zugang dazu haben: Sitzungsvisualisierung in institutioneller Qualität.

Der Erfolg im Handel hängt oft von einem subtilen Bewusstsein ab – nicht nur davon, was passiert, sondern auch warum es passiert. Wenn der EURUSD während der asiatischen Handelszeiten ins Stocken gerät, liegt das nicht nur an der geringen Volatilität, sondern an der geografischen Lage Tokios, die sich auf die JPY-Paare konzentriert. Wenn der GBPUSD um 8 Uhr GMT explodiert, sind das nicht nur „Nachrichten“, sondern auch Londons massiver Liquiditätspool wird aktiviert.

Dieses Tool überbrückt die Lücke zwischen:

• Wissen und Intuition
• Analyse und Bewusstsein
• Handel und Marktteilnahme

Unsere Umsetzungsphilosophie

Das sind die Schritte, in denen wir bauen:

1. Erst die Optik, dann die Daten: Das Display muss sofort kommunizieren.
2. Nicht-invasives Design: Er bereichert Ihren Arbeitsbereich, ohne ihn zu überladen.
3. Konfigurierbare Intelligenz: Passt sich an Ihren Handelsstil und Ihren Broker an.
4. Berufliche Robustheit: Behandelt Randfälle und Fehler anständig.

In den kommenden Abschnitten werden wir diese Vision in die Tat umsetzen. Wir beginnen mit der Kern-Engine, die den Sitzungsstatus berechnet, fügen dann die Visualisierung hinzu und fügen dann intelligente Benachrichtigungen hinzu. Jeder Schritt baut auf dem letzten auf und schafft ein Werkzeug, das mehr ist als die Summe seiner Teile.

Aber dies ist mehr als nur ein Programmierlehrgang. Es geht darum, eine tiefe Beziehung zum Rhythmus des Marktes zu entwickeln. Am Ende werden Sie nicht nur ein neues Werkzeug haben, sondern auch eine neue Sichtweise auf die Märkte.

Umsetzung

Um den Arbeitsablauf anfängerfreundlich zu gestalten, habe ich zunächst zwei Basis-Weltkarten unter Creative Commons-Lizenzen von Google Images beschafft – eine mit einem hellblauen Ozean für das helle Thema und eine mit einer dunkelgrauen Palette für das dunkle Thema. Jedes Bild wurde als GIMP-Datei geöffnet und auf ein einheitliches Querformat (z. B. 1920×1080) skaliert, sodass es sich gut hinter den meisten MetaTrader 5-Charts einfügt, ohne gestreckt oder verzerrt zu wirken. Der Grundgedanke ist, diese Landkarten als „Folienhintergründe“ zu behandeln, d. h. sie sollten sauber, lesbar und nicht mit zusätzlichen Verzierungen überladen sein.

Nachdem die Basiskarten erstellt waren, fügte ich mit den Text- und Formwerkzeugen von GIMP einfache, lesbare Beschriftungen für jede Handelssitzung direkt in das Bild ein. Auf der Landkarten mit dem blauen Ozean habe ich die Regionen Sydney, Tokio, London und New York in den Farben hervorgehoben und beschriftet, die den Sitzungsfarben im Code entsprechen, und den Text in der Nähe des entsprechenden Teils der Welt platziert, ohne zu viel Küstenlinie zu verdecken. Ich wiederholte den gleichen Vorgang auf der dunkelgrauen Landkarte, wobei ich etwas hellere, „neonartige“ Farben verwendete, damit sich die Beschriftungen von dem dunkleren Hintergrund abheben. Das Ziel ist eine subtile Führung: Das Auge soll sofort erkennen, auf welchen Teil der Welt wir uns beziehen, aber die Elemente müssen so weich bleiben, dass Kerzen und Kursbewegungen im Vordergrund lesbar bleiben.

Danach wurde jede thematische Landkarte aus GIMP als separate BMP-Datei exportiert, die für MQL5 bereit ist. Für jede Sitzung habe ich einen speziellen Hintergrund erstellt (z. B. world_sydney.bmp, world_tokyo.bmp usw. für das helle Thema, plus passende _dark-Versionen für das dunkle Thema) und dafür gesorgt, dass ich sie im BMP-Format exportiert habe, damit MetaTrader 5 sie als Ressourcen einbetten kann. Diese Dateien wurden dann in den Ordner MQL5\Images gelegt, wo der EA auf sie zugreifen und je nach aktiver Marktsitzung in Echtzeit zwischen ihnen wechseln kann.

In dieser Phase erläutern wir, wie wir abstraktes Markt-Timing in visuelle Intuition umwandeln. Dies ist nicht nur ein weiterer Indikator, sondern wir bauen ein komplettes visuelles Bewusstseinssystem auf, das uns den Herzschlag des Marktes erkennen lässt. Zum besseren Verständnis werde ich die einzelnen Abschnitte erläutern. Wir werden in zwei Schritten vorgehen: Zuerst werden wir eine bestehende Bibliotheksdatei überarbeiten und sie für die Verwendung in unserem aktuellen Projekt anpassen; dann werden wir zur Entwicklung des Hauptcodes übergehen.

Auf bestehenden Fundamenten aufbauen: Anpassen von SessionVisualizer.mqh

Bevor wir mit der Konstruktion unserer Haupt-EA-Logik beginnen, sollten wir einen wichtigen Grundsatz der beruflichen Entwicklung beachten: Wir müssen nicht jede Komponente neu erfinden. Nachdem wir unsere Weltkartenbilder vorbereitet haben, brauchen wir auch eine Möglichkeit, Sitzungsgrenzen direkt auf dem Preisdiagramm zu markieren. Anstatt dies von Grund auf neu zu erstellen, haben wir eine hervorragende bestehende Ressource aus unserem letzten Artikel wieder aufgegriffen.

Die Originaldatei SessionVisualizer.mqh bot eine umfassende Sitzungsvisualisierung mit OHLC-Rechtecken, Dochten und detaillierten Beschriftungen. Für unser Projekt brauchten wir jedoch etwas Subtileres – visuelle Markierungen, die unsere Weltkartenfolien ergänzen und nicht mit ihnen konkurrieren sollten.

Strategische Anpassungen an unsere Bedürfnisse

Hier sind die wichtigsten Änderungen, um diese Komponente für unseren auf Folien basierenden Visualisierungsansatz anzupassen:

1. Einführung eines Modus-Umschalters

Wir haben ein einfaches, aber leistungsstarkes Flag hinzugefügt, das den gesamten Visualisierungsansatz verändert:

private:
   bool        m_markers_only;   // NEW: when true, only draw time markers

public:
   void SetMarkersOnly(bool markers_only) { m_markers_only = markers_only; }

Dieser einzelne Boolesche Wert bestimmt, ob wir die vollständige OHLC-Visualisierung (Originalverhalten) oder nur minimale Grenzmarkierungen (unsere Anpassung) anzeigen.

2. Erstellen einer minimalistischen Zeichenmethode

Wir haben eine neue Methode DrawSessionMarkers() implementiert, die genau das bietet, was unser Projekt braucht:

void DrawSessionMarkers(const SessionInfo &sess,
                        datetime t_open, datetime t_close,
                        bool is_current)
{
   // Creates clean vertical lines at session boundaries
   // with minimal labels showing session abbreviations
}

Diese Methode erzeugt:

• Dezente vertikale Linien, die die Zeiten für das Öffnen und Schließen der Sitzung markieren
• Kleine Textbeschriftungen (SYD, TOK, LON, NY), ohne das Chart zu überfrachten
• Visuelle Unterscheidung zwischen aktuellen Sitzungen (durchgezogene Linien) und historischen Sitzungen (gestrichelte Linien)

3. Intelligente bedingte Logik

Wir haben die bestehende Methode DrawSessionVisuals() geändert, um unseren neuen Ansatz zu verwenden, wenn es angebracht ist:

void DrawSessionVisuals(const SessionInfo &sess,
                        datetime t_open, datetime t_close,
                        double o,double h,double l,double c,
                        bool is_current)
{
   // --- markers-only mode: keep chart minimal
   if(m_markers_only)
   {
      DrawSessionMarkers(sess, t_open, t_close, is_current);
      return;
   }
   // ... original comprehensive drawing logic
}

Dieser bedingte Ansatz bewahrt die Abwärtskompatibilität und bietet gleichzeitig unsere optimierte Ausgabe.

Diese Änderung zeigt mehrere Praktiken der beruflichen Entwicklung auf:

1. Ressourceneffizienz: Wir haben vorhandenen, getesteten Code genutzt, anstatt bei Null anzufangen.
2.  Zielgerichtetes Design: Wir haben die Funktionalität an unsere spezifischen Projektanforderungen angepasst – eine ergänzende Visualisierung, keine umfassende Analyse.
3. Zerstörungsfreies Enhancement: Wir haben neue Funktionen hinzugefügt, ohne bestehende Funktionen zu entfernen oder zu zerstören. Die ursprüngliche Komponente bleibt für andere Anwendungen voll funktionsfähig.
4. Schwerpunkt Nutzererfahrung: Unsere Anpassung reduziert die visuelle Unübersichtlichkeit, während die wesentlichen Informationen erhalten bleiben, und schafft so eine bessere Erfahrung für Händler, die unsere Weltkartenvisualisierung nutzen.

Die geänderte Datei SessionVisualizer.mqh ist unter diesem Artikel angehängt, und das Original bleibt unter dem MQL5-Artikel-Link für Entwickler verfügbar, die die umfassende Visualisierung benötigen. Dieser Ansatz – Anpassung statt Neuaufbau – ermöglichte es uns, unsere Entwicklungsbemühungen auf die einzigartigen Aspekte unseres Projekts zu konzentrieren.

Nachdem wir unsere visuellen Assets vorbereitet und unsere Sitzungsmarker-Komponente angepasst haben, sind wir nun bereit, den WorldSessionSlides EA zu erstellen, der diese Elemente zu einem kohärenten Handelsinstrument zusammenfügt.

Die WorldSessionSlides EA 

1. Den Grundstein legen: Eigenschaften und Ressourcen

Wir beginnen mit #property strict, weil professioneller Code nicht um Ecken und Kanten kürzt – dies erzwingt eine starke Typisierung und fängt Fehler frühzeitig auf. 

Der eigentliche Zauber beginnt mit der #Ressource Direktiven. Anstatt die Bilder während der Laufzeit von der Festplatte zu laden (was fehlschlagen würde, wenn die Nutzer Dateien verschieben), betten wir sie direkt in die EX5-Datei ein. Stellen Sie sich das so vor, als würden Sie Ihre Zutaten in den Kuchen einbacken – keine externen Abhängigkeiten, keine fehlenden Dateien. Wir bieten sowohl helle als auch dunkle Themenoptionen an, da seriöse Händler in unterschiedlichen Umgebungen arbeiten; einige bevorzugen tagsüber helle Charts, während andere dunkle Themen für nächtliche Sitzungen benötigen.

//+------------------------------------------------------------------+
//|                                           WorldSessionSlides.mq5 |
//|   Session-based world map slideshow + session time markers       |
//|   with terminal & push notifications on session changes          |
//+------------------------------------------------------------------+
#property strict
#property copyright "Clemence Benjamin"
#property link      "https://mql5.com"
#property version   "1.00"

//--- Embed BLUE OCEAN bitmaps as resources
#resource "\\Images\\world_idle.bmp"
#resource "\\Images\\world_sydney.bmp"
#resource "\\Images\\world_tokyo.bmp"
#resource "\\Images\\world_london.bmp"
#resource "\\Images\\world_newyork.bmp"

//--- Embed DARK GRAY theme bitmaps as resources
#resource "\\Images\\world_idle_dark.bmp"
#resource "\\Images\\world_sydney_dark.bmp"
#resource "\\Images\\world_tokyo_dark.bmp"
#resource "\\Images\\world_london_dark.bmp"
#resource "\\Images\\world_newyork_dark.bmp"

2. Konfigurieren der Nutzereinstellungen: Der Eingabebereich

Wir legen die Sitzungszeiten nicht fest, da die Makler unterschiedlich sind – bei manchen öffnet Sydney um 21:00 Uhr, bei anderen um 22:00 Uhr. Durch diese Eingaben stellen wir sicher, dass unser Instrument weltweit funktioniert.

 Wir bieten den Nutzern drei Stufen von Warnmeldungen. Einige Händler wollen ihre Ruhe haben (NOTIFY_OFF), andere wollen über jede Änderung in der Sitzung informiert werden, während ernsthafte Volatilitätshändler sich vielleicht nur für Überschneidungen interessieren, bei denen die wirkliche Action stattfindet. Die Option für Push-Benachrichtigungen ist absichtlich auf „false“ voreingestellt – Handy-Benachrichtigungen sollten eine Option sein, für die man sich entscheidet, und kein Ärgernis.

//--- Inputs: session times in broker time (hours 0..23)
input int  InpSydneyOpen    = 22;
input int  InpSydneyClose   = 7;
// ... (other session inputs)

//--- Timer period in seconds
input int  InpCheckPeriod   = 15;

//--- Theme toggle: false = blue ocean, true = dark gray
input bool InpUseDarkTheme  = false;

//--- Marker control
input bool InpShowSessionMarkers = true;
input int  InpMarkersGMTOffset   = 0;

//--- Notification control
enum ENUM_NOTIFY_MODE
  {
   NOTIFY_OFF = 0,
   NOTIFY_SESSION_CHANGES,
   NOTIFY_OVERLAPS_ONLY
  };

input ENUM_NOTIFY_MODE InpNotifyMode        = NOTIFY_SESSION_CHANGES;
input bool             InpTerminalAlerts    = true;
input bool             InpPushNotifications = false;

3. Zentrale Logik: Zeitberechnungen und Bitmaskenzauber

HourInRange() behandelt eine schwierige Realität – manche Sitzungen überschreiten Mitternacht. Sydney (22:00 Uhr bis 07:00 Uhr) geht um, also brauchen wir eine Logik, die „22 oder später ODER vor 7“ versteht, und nicht nur eine einfache Bereichsprüfung.

Mit der Funktion GetSessionMaskFromTime() werden wir schlau. Anstatt jede Sitzung mit separaten Variablen zu verfolgen, verwenden wir eine Bitmaske – eine einzelne Ganzzahl, bei der jedes Bit den Zustand einer Sitzung darstellt. Bit 0 für Sydney, Bit 1 für Tokio, und so weiter. Dies hat mehrere Vorteile: Wir können mehrere Sitzungen auf einmal überprüfen (Überschneidungen), Zustände schnell vergleichen und nur wenig Speicherplatz verwenden. Wenn wir mask |= (1 << SESSION_SYDNEY) sehen, setzen wir das Sydney-Bit, ohne andere zu beeinflussen.

bool HourInRange(int start_hour,int end_hour,int h)
  {
   if(start_hour < end_hour)
      return (h >= start_hour && h < end_hour);
   if(start_hour > end_hour)
      return (h >= start_hour || h < end_hour);
   return(false);
  }

int GetSessionMaskFromTime(datetime t)
  {
   MqlDateTime st;
   TimeToStruct(t,st);
   int h    = st.hour;
   int mask = 0;

   if(HourInRange(InpSydneyOpen,InpSydneyClose,h))
      mask |= (1 << SESSION_SYDNEY);
   // ... other sessions
   return(mask);
  }

4. Sitzung Intelligenz: Überschneidungserkennung und Vorrang

Wenn sich zwei Sitzungen überschneiden, welche Landkarte wird dann angezeigt? Unser Prioritätssystem (New York > London > Tokio > Sydney) spiegelt die Bedeutung des Marktes wider. Die Überschneidung New York-London zeigt New York, und die Überschneidung London-Tokio zeigt London – dies entspricht dem Ort, an den die meiste Liquidität fließt.

Die Kennzeichnung verarbeitet alle Kombinationen: Einzelne Sitzungen zeigen „LONDON SESSION (LIVE)“, Überschneidungen zeigen „LONDON + NEW YORK SESSIONS (OVERLAP)“. Dieses unmittelbare visuelle Feedback zeigt uns, was aktiv ist und ob wir uns in einer Phase hoher Liquidität befinden.

//+------------------------------------------------------------------+
//| Build a bitmask of all active sessions at time t                 |
//| bit 0: Sydney, bit 1: Tokyo, bit 2: London, bit 3: New York      |
//+------------------------------------------------------------------+
int GetSessionMaskFromTime(datetime t)
  {
   MqlDateTime st;
   TimeToStruct(t,st);
   int h    = st.hour;
   int mask = 0;

   if(HourInRange(InpSydneyOpen,InpSydneyClose,h))
      mask |= (1 << SESSION_SYDNEY);
   if(HourInRange(InpTokyoOpen,InpTokyoClose,h))
      mask |= (1 << SESSION_TOKYO);
   if(HourInRange(InpLondonOpen,InpLondonClose,h))
      mask |= (1 << SESSION_LONDON);
   if(HourInRange(InpNewYorkOpen,InpNewYorkClose,h))
      mask |= (1 << SESSION_NEWYORK);

   return(mask);
  }

//+------------------------------------------------------------------+
//| Count how many sessions are active in mask (for overlaps)        |
//+------------------------------------------------------------------+
int CountActiveSessions(int mask)
  {
   int count = 0;
   for(int i=0; i<4; ++i)
     {
      if(mask & (1<<i))
         count++;
     }
   return(count);
  }

//+------------------------------------------------------------------+
//| Pick one "dominant" session from a mask (for bitmap selection)   |
//| Priority: New York > London > Tokyo > Sydney                     |
//+------------------------------------------------------------------+
int DominantSessionFromMask(int mask)
  {
   if((mask & (1 << SESSION_NEWYORK)) != 0)
      return SESSION_NEWYORK;
   if((mask & (1 << SESSION_LONDON)) != 0)
      return SESSION_LONDON;
   if((mask & (1 << SESSION_TOKYO)) != 0)
      return SESSION_TOKYO;
   if((mask & (1 << SESSION_SYDNEY)) != 0)
      return SESSION_SYDNEY;

   return SESSION_NONE;
  }

//+------------------------------------------------------------------+
//| Build human-readable label from mask (handles overlaps)          |
//+------------------------------------------------------------------+
string BuildSessionLabel(int mask)
  {
   if(mask == 0)
      return "NO MAJOR SESSION (IDLE MAP)";

   string label = "";
   int    count = 0;

   if((mask & (1 << SESSION_SYDNEY)) != 0)
     {
      if(count > 0) label += " + ";
      label += "SYDNEY";
      count++;
     }

   if((mask & (1 << SESSION_TOKYO)) != 0)
     {
      if(count > 0) label += " + ";
      label += "TOKYO";
      count++;
     }

   if((mask & (1 << SESSION_LONDON)) != 0)
     {
      if(count > 0) label += " + ";
      label += "LONDON";
      count++;
     }

   if((mask & (1 << SESSION_NEWYORK)) != 0)
     {
      if(count > 0) label += " + ";
      label += "NEW YORK";
      count++;
     }

   if(count > 1)
      label += " SESSIONS (OVERLAP)";
   else
      label += " SESSION (LIVE)";

   return(label);
  }

5. Professionelle Visualisierung: Chart-Objekte richtig gemacht

Sie erstellen Chart-Objekte ohne angemessene Verwaltung. Unsere Funktion EnsureBackgroundObject() prüft, ob das Objekt existiert, bevor es erstellt wird, und verhindert so Duplikate. Das OBJPROP_BACK, true ist entscheidend – es platziert unsere Landkarte hinter den Preiskerzen, sodass wir das Chart verbessern und nicht blockieren.

CenterBackgroundToChart() zeigt professionelle Liebe zum Detail. Wir lesen die tatsächlichen Bildabmessungen aus der Ressource und zentrieren sie dann mathematisch. Wenn die Landkarte kleiner als unsere Landkarte ist, erlauben wir negative Versätze – das Bild wird symmetrisch zugeschnitten. Dadurch bleibt die visuelle Qualität ohne Verzerrungen erhalten.

//+------------------------------------------------------------------+
//| Create background bitmap label if missing                        |
//+------------------------------------------------------------------+
void EnsureBackgroundObject()
  {
   // Make sure chart is NOT in foreground mode so BACK objects sit behind candles
   ChartSetInteger(0,CHART_FOREGROUND,false);

   if(ObjectFind(0,g_bg_name) < 0)
     {
      if(!ObjectCreate(0,g_bg_name,OBJ_BITMAP_LABEL,0,0,0))
        {
         Print(__FUNCTION__,": failed to create bitmap label, error=",GetLastError());
         return;
        }

      ObjectSetInteger(0,g_bg_name,OBJPROP_CORNER,CORNER_LEFT_UPPER);
      ObjectSetInteger(0,g_bg_name,OBJPROP_BACK,true);   // draw behind candles
     }
  }

//+------------------------------------------------------------------+
//| Center the bitmap in the chart, using its original size          |
//| - No scaling; symmetric cropping when chart is smaller           |
//+------------------------------------------------------------------+
void CenterBackgroundToChart(const string file)
  {
   if(ObjectFind(0,g_bg_name) < 0)
      return;

   // Chart size in pixels
   int chartW = (int)ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
   int chartH = (int)ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
   if(chartW <= 0 || chartH <= 0)
      return;

   // Read image size from resource
   uint imgW = 0, imgH = 0;
   uint data[];

   if(!ResourceReadImage(file,data,imgW,imgH))
     {
      // Fallback: put object at (0,0) and stretch object to chart
      ObjectSetInteger(0,g_bg_name,OBJPROP_XDISTANCE,0);
      ObjectSetInteger(0,g_bg_name,OBJPROP_YDISTANCE,0);
      ObjectSetInteger(0,g_bg_name,OBJPROP_XSIZE,chartW);
      ObjectSetInteger(0,g_bg_name,OBJPROP_YSIZE,chartH);
      return;
     }

   if(imgW == 0 || imgH == 0)
      return;

   int imgWi = (int)imgW;
   int imgHi = (int)imgH;

   // Object size = image size (no scaling)
   ObjectSetInteger(0,g_bg_name,OBJPROP_XSIZE,imgWi);
   ObjectSetInteger(0,g_bg_name,OBJPROP_YSIZE,imgHi);

   // Compute offset so that image center aligns with chart center
   int xOffset = (chartW - imgWi) / 2;
   int yOffset = (chartH - imgHi) / 2;

   // Negative offsets are allowed (chart will crop symmetrically)
   ObjectSetInteger(0,g_bg_name,OBJPROP_XDISTANCE,xOffset);
   ObjectSetInteger(0,g_bg_name,OBJPROP_YDISTANCE,yOffset);
  }

6. Benachrichtigungssystem: Intelligente Alarme

Die Prüfung if (InpNotifyMode == NOTIFY_OVERLAPS_ONLY && active < 2) return bedeutet, dass es niemanden stören wird, der sich nur für Volatilitätsperioden interessiert. Beachten Sie, dass wir sowohl das Symbol als auch den Zeitrahmen in die Meldung einbeziehen – wenn Sie dies auf mehreren Charts ausführen, wissen Sie genau, welcher sich geändert hat.

void NotifySessionChange(int old_mask,int new_mask)
  {
   if(InpNotifyMode == NOTIFY_OFF) return;
   int active = CountActiveSessions(new_mask);
   if(InpNotifyMode == NOTIFY_OVERLAPS_ONLY && active < 2) return;
   
   string msg = "WorldSessionSlides: " + BuildSessionLabel(new_mask) +
                " on " + _Symbol + " [" + EnumToString((ENUM_TIMEFRAMES)_Period) + "]";
   
   if(InpTerminalAlerts) Alert(msg);
   if(InpPushNotifications) SendNotification(msg);
  }

7. Ereignisgesteuerte Architektur: Die Hauptschleife

Anstatt ständig zu prüfen (was die CPU belastet), verwenden wir OnTimer(), um in angemessenen Abständen (standardmäßig 15 Sekunden) Stichproben zu nehmen. Wir aktualisieren nur, wenn sich tatsächlich etwas ändert – der Vergleich von Bitmasken geht blitzschnell.

Die Ereignisbehandlung durch OnChartEvent() zeigt Weitsicht: Wenn Nutzer die Größe der Charts ändern, wird unsere Landkarte automatisch neu zentriert. Keine Pannen, keine manuellen Einstellungen erforderlich.

void OnTimer()
  {
   int mask_now = GetSessionMaskFromTime(TimeCurrent());
   if(mask_now != g_current_session_mask)
     {
      int old_mask = g_current_session_mask;
      g_current_session_mask = mask_now;
      ShowSessionSlideByMask(g_current_session_mask);
      NotifySessionChange(old_mask, g_current_session_mask);
     }
  }

void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
  {
   if(id == CHARTEVENT_CHART_CHANGE)
     {
      EnsureBackgroundObject();
      if(g_last_bitmap_file != "")
         CenterBackgroundToChart(g_last_bitmap_file);
     }
  }

8. Saubere Initialisierung und Abschaltung

 OnInit() richtet beim ersten Durchlauf alles korrekt ein. Wir begrenzen die Zeitspanne auf mindestens 5 Sekunden, um zu verhindern, dass Nutzer versehentlich 1-Sekunden-Prüfungen einstellen, die die CPU belasten würden.

OnDeinit() ist ebenso wichtig. Wir beenden unseren Timer, löschen unsere Chart-Objekte und bereinigen die Sitzungsmarkierungen. Keine Speicherlecks, keine verwaisten Objekte in den Charts.

int OnInit()
  {
   g_current_session_mask = GetSessionMaskFromTime(TimeCurrent());
   ShowSessionSlideByMask(g_current_session_mask);
   
   if(InpShowSessionMarkers)
     {
      g_sess_vis.SetGMTOffset(InpMarkersGMTOffset);
      g_sess_vis.SetShowWicks(false);
      g_sess_vis.SetMarkersOnly(true);
      g_sess_vis.RefreshSessions(1);
     }
     
   g_check_period = (InpCheckPeriod < 5 ? 5 : InpCheckPeriod);
   EventSetTimer(g_check_period);
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   EventKillTimer();
   ObjectDelete(0,g_bg_name);
   ObjectDelete(0,g_text_name);
   if(InpShowSessionMarkers) g_sess_vis.ClearAll();
  }

 

Tests

Unser umfassendes Testprotokoll, das sowohl über das MetaTrader 5-Terminal als auch über den integrierten Strategietester ausgeführt wurde, hat die Kernfunktionalität des Systems mit außergewöhnlicher Präzision validiert. Der Algorithmus zur Sitzungserkennung löste stets korrekte visuelle Übergänge aus, während die Rendering-Engine eine stabile Leistung ohne Speicherlecks oder grafische Artefakte bot.

Test der WorldSessionSlides

Die beigefügte Bildserie enthält eindeutige Beweispunkte:

1. Sitzungsspezifische Landkarten: In den Sitzungen in Sydney, Tokio, London und New York werden jeweils die entsprechenden Regionen hervorgehoben.
2. Dynamische Übergänge: Zeitgestempelte Sequenzen zeigen reibungslose Übergänge zwischen Sitzungen.
3. Überschneidungsszenarien: Mehrere aktive Sitzungen werden korrekt mit kombinierter Beschriftung angezeigt.
4. Thema Adaption: Konsistentes Rendering in den Themen Blue Ocean und Dark Gray.
5. Integration von Benachrichtigungen: Terminalwarnungen, die genau an den Sitzungsgrenzen abgefeuert werden.

Diese Ergebnisse bestätigen, dass Händler nun die globalen Marktaktivitäten in Echtzeit visuell verfolgen können, indem sie zeitliche Daten in räumliches Bewusstsein umwandeln. Das Journal des Strategietesters zeigt, dass wir auch Sitzungswarnungen erhalten können; siehe den Protokollausschnitt unten.

2025.12.03 11:33:55.238 2025.12.01 07:00:00   Alert: WorldSessionSlides: TOKYO SESSION (LIVE) on EURUSD [PERIOD_M5]
2025.12.03 11:33:59.696 2025.12.01 08:00:00   Alert: WorldSessionSlides: TOKYO + LONDON SESSIONS (OVERLAP) on EURUSD [PERIOD_M5]
2025.12.03 11:34:06.315 2025.12.01 09:00:00   Alert: WorldSessionSlides: LONDON SESSION (LIVE) on EURUSD [PERIOD_M5]
2025.12.03 11:34:21.396 2025.12.01 13:00:00   Alert: WorldSessionSlides: LONDON + NEW YORK SESSIONS (OVERLAP) on EURUSD [PERIOD_M5]
2025.12.03 11:34:39.553 2025.12.01 17:00:00   Alert: WorldSessionSlides: NEW YORK SESSION (LIVE) on EURUSD [PERIOD_M5]
2025.12.03 11:34:55.388 2025.12.01 22:00:00   Alert: WorldSessionSlides: SYDNEY SESSION (LIVE) on EURUSD [PERIOD_M5]

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass es uns gelungen ist, ein einfaches, aber nützliches visuelles Handelsinstrument zu entwickeln, das abstraktes Markt-Timing in unmittelbare geografische Intuition verwandelt. Durch die Implementierung eines intelligenten Systems zur Erkennung von Sitzungen, gepaart mit einer dynamischen Weltkartenvisualisierung, haben wir das kritische Problem der zeitlichen Desorientierung auf globalen Märkten gelöst. Die Lösung zeigt, dass die professionelle MQL5-Entwicklung eine Brücke zwischen technischer Präzision und praktischer Handelspsychologie schlägt und Werkzeuge schafft, die Informationen anzeigen und die Marktwahrnehmung grundlegend verbessern.

Technisch gesehen ist unsere Implementierung mit ihrer effizienten Bitmask-Sitzungsverfolgung, ressourcengebundenen Grafiken und ereignisgesteuerten Architektur ein Musterbeispiel für die besten Praktiken der Branche. Die strenge Testvalidierung bestätigt die Zuverlässigkeit des Systems sowohl in Live- als auch in historischen Umgebungen, mit fehlerfreien Sitzungsübergängen und adaptivem Theme-Rendering. Dieses Projekt ist ein Beispiel dafür, wie robuste Codierungsmethoden, die eine angemessene Speicherverwaltung, Fehlerbehandlung und ein nutzerorientiertes Design umfassen, Werkzeuge hervorbringen, die professionellen Handelsumgebungen würdig sind.

Letztlich ist dieses Tool mehr als nur ein weiterer Indikator; es bedeutet eine Verlagerung hin zu visueller Intelligenz in den Handelsabläufen. Indem wir die geografischen Rhythmen des Marktes intuitiv zugänglich machen, befähigen wir die Händler, ein besseres Gespür für den Markt zu entwickeln und gleichzeitig die kognitive Belastung zu verringern. Das Projekt ist ein erfolgreicher Beweis dafür, dass das Zusammentreffen von technischer Exzellenz und Handelswissen die Art und Weise, wie Händler mit dem kontinuierlichen Fluss des globalen Marktes interagieren und ihn verstehen, verändert.

Bei den Tests gab es jedoch einige ungewöhnliche Beobachtungen. Während die meisten Bilde klar und deutlich angezeigt wurden, gab es bei einigen wenigen leichte „Schauer“ oder Störungen. Mein erster Gedanke war, dass dies mit einem kleinen Arbeitsspeicher zusammenhängen könnte, aber die Protokolle meldeten keine Fehler, sodass es auch möglich ist, dass einige der Bilder einfach zu schwer waren, um reibungslos verarbeitet zu werden. Ich bin noch dabei, die Ursache für diese Störung zu untersuchen und werde meine Ergebnisse in einem zukünftigen Update mitteilen.

Alle Quelldateien und Bilder, die in diesem Projekt verwendet werden, sind unten angehängt, zusammen mit ihrer Beschreibung in der Tabelle der Anhänge. Sie sind herzlich eingeladen, sich an der Diskussion im Kommentarbereich zu beteiligen. Bleiben Sie bis zu unserer nächsten Veröffentlichung dran.

Wichtige Lektionen

Wichtige Lektion	Beschreibung
Bitmaske Statusverwaltung	Beherrschen Sie die effiziente Sitzungsverfolgung mithilfe bitweiser Operationen und speichern Sie mehrere Sitzungszustände in einem einzigen Integer-Wert, um Überschneidungen schnell zu erkennen und den Speicherverbrauch zu minimieren, und ermöglichen Sie gleichzeitig eine anspruchsvolle Marktanalyse.
Ereignisgesteuerte Architektur	Entwerfen Sie effiziente Systeme mit OnTimer() für periodische Überprüfungen und OnChartEvent() für reaktionsschnelle UI-Aktualisierungen, sodass die Sitzungsvisualisierung nahtlos und ohne ressourcenintensive Polling-Schleifen abläuft.
Zeitmathematik mit Wrap-around-Logik	Implementieren Sie robuste Zeitbereichsberechnungen, die Sitzungen über Mitternacht hinaus korrekt behandeln – eine entscheidende Fähigkeit für eine genaue globale Marktanalyse über verschiedene Zeitzonen hinweg.
Einbettung und Verwaltung von Ressourcen	Lernen Sie, wie Sie Bitmap-Dateien mit Hilfe von #resource-Direktiven direkt in EX5-Programme einbetten und so professionelle visuelle Werkzeuge erstellen, die in verschiedenen Handelsumgebungen portabel bleiben.
Sitzungsspezifische Strategieausrichtung	Verstehen und programmieren Sie für Sitzungsmerkmale: Die technische Präzision von Tokio für JPY-Paare, das Richtungsmomentum von London für EUR/GBP und die optimalen Überlappungszeiträume für Volatilitätsstrategien.
Erkennung von Überschneidungsgelegenheiten	Implementieren Sie eine Logik, die kritische Überschneidungszeiträume (Tokio-London, London-New York) identifiziert und hervorhebt, in denen Liquiditätsschübe zu erstklassigen Handelsmöglichkeiten in verschiedenen Stilrichtungen führen.
Professionelle Handhabung von Chart-Objekten	Beherrschen Sie die korrekte Erstellung, Positionierung und Bereinigung von Chart-Objekten unter Berücksichtigung der Rendering-Ebenen (HINTEN vs. VORNE), um visuelle Klarheit zu gewährleisten, ohne die Preisaktionsanalyse zu beeinträchtigen.
Sitzungsbasiertes Risikomanagement	Entwickeln Sie Systeme, die automatisch Handelsparameter auf der Grundlage von Volatilitätsmustern der Sitzungen anpassen – höhere Aktivität während Überschneidungen gegenüber geringerem Risiko während einzelner Sitzungen oder Totzonen.
Modulare Wiederverwendbarkeit von Code	Wenden Sie professionelle Entwicklungspraktiken an, indem Sie bestehende Komponenten (SessionVisualizer.mqh) mit speziellen Modi anpassen und gleichzeitig die ursprüngliche Funktionalität für zukünftige Projekte beibehalten.
Konfigurierbare Benachrichtigungssysteme	Erstellen Sie flexible Alarmsysteme mit mehreren Benachrichtigungsmodi, die auf unterschiedliche Handelsstile zugeschnitten sind – von konservativen, auf Überschneidungen beschränkten Alarmen bis hin zu umfassenden Benachrichtigungen bei Sitzungsänderungen.

Anlagen

Quelldatei	Version	Beschreibung
WorldSessionSlides.mq5	1.01	Hauptdatei des Expert Advisors, die die Hauptlogik für die Sitzungsvisualisierung, das Benachrichtigungssystem und die Chart-Event-Handler enthält. Diese Datei implementiert die dynamische Weltkartenanzeige mit Echtzeit-Sitzungsverfolgung.
SessionVisualizer.mqh	1.03	Helper-Include-Datei, die für das Zeichnen von Sitzungszeitmarkierungen auf dem Preisdiagramm verantwortlich ist. Bietet visuelle Indikatoren für Sitzungsgrenzen und Überschneidungen mit konfigurierbarem GMT-Offset und Anzeigeeinstellungen.
Light_theme.zip	1.00	Grafische Ergänzungen zum Thema Blue Ocean mit Weltkarten-Bitmaps für alle Handelssitzungen. Muss in den Ordner MQL5/Images entpackt werden, um die Visualisierung des Lichtthemas zu ermöglichen.
Dark_theme.zip	1.00	Dunkelgraue grafische Assets mit Weltkarten-Bitmaps für alle Handelssitzungen. Muss in den Ordner MQL5/Images entpackt werden, um die Visualisierung des dunklen Themas zu ermöglichen.