Marktsimulation (Teil 23): Positionsansicht (I)

Einführung

Hallo und willkommen zu einem weiteren Artikel in der Serie über die Erstellung eines Replay-/Simulationssystems.

Im vorherigen Artikel, Marktsimulation (Teil 22): Einstieg in SQL (V), haben wir die Erklärungen zu allem abgeschlossen, was Sie benötigen, um den Stoff in den nächsten Artikeln zu verstehen. Ich weiß, dass das gesamte Thema, das wir in den letzten Artikeln besprochen haben, beim ersten Mal nicht so leicht zu verstehen ist. Und ich denke, viele von Ihnen haben sich nicht einmal vorstellen können, dass bestimmte Dinge hier in MQL5 machbar sind. Dennoch war alles, was bisher zu sehen war, nur die Spitze eines riesigen Eisbergs. Das liegt daran, dass ich bisher nur kurz auf Sockets und SQL eingegangen bin.

Meiner Meinung nach wird Ihnen das in dieser Zeit erworbene Wissen in den nächsten Phasen nützlich sein. Von diesem Punkt an werden wir beginnen, ein noch komplexeres Thema zu behandeln. Dennoch werde ich mein Bestes tun, um Ihnen das Leben nicht schwer zu machen, lieber Leser. Gleichzeitig möchte ich Sie wirklich motivieren, zu lernen und sich noch intensiver mit dem zu beschäftigen, was ich von nun an zeigen werde.

Atmen Sie tief durch und machen Sie sich bereit, denn jetzt tauchen wir kopfüber in das Replay-/Simulationssystem ein. Was ich bezüglich der Entwicklung dieses Systems zu zeigen geplant habe, nähert sich bereits seinem Höhepunkt. Mit anderen Worten: Es gibt nur noch sehr wenig zu zeigen. Da der Inhalt jedoch theoretisch viel komplexer ist, werde ich versuchen, ihn so einfach wie möglich darzustellen. Der Programmierteil selbst ist recht einfach und unkompliziert. Aber wenn Sie die Theorie dahinter nicht verstehen, werden Sie überhaupt keine praktische Grundlage haben, um das Replay-/Simulationssystem für andere Aufgaben als die, die ich zeigen werde, zu verfeinern oder anzupassen.

Ich möchte nicht, dass Sie den von mir präsentierten Code lediglich kompilieren und verwenden. Ich möchte, dass Sie lernen, verstehen und, wenn möglich, in der Lage sind, etwas Besseres zu schaffen. Ich werde nicht zeigen, wie man eine Reihe von Dingen macht. Dies liegt daran, dass es sich bei diesen Dingen um Modelle handelt, die ich in der Praxis verwende und die speziell entwickelt wurden, um ein Handelssystem, den sogenannten Expert Advisor, zu erstellen oder vielmehr zu implementieren, das mit der Zeit lernt. Das System entwickelt dabei auch einen eigenen Handelsansatz und nähert sich dem an, was ein menschlicher Trader in der Praxis tun würde.

In dem früheren Artikel, Marktsimulation (Teil 5): Erstellung der Klasse C_Orders (II), haben wir in dem Abschnitt, der sich mit dem Replay-/Simulationssystem befasste, einen kleinen Expert Advisor erstellt, der in der Lage ist, mit dem zuvor entwickelten Chart-Trade-Programm zu interagieren. Das ist schon eine ganze Weile her. Wenn Sie sich also nicht mehr daran erinnern, wie der Code aussah, lassen Sie uns kurz in Erinnerung rufen, wie am Ende alles aussah. Lassen Sie uns an diesem Punkt beginnen. Alles, was von diesem Moment an bis jetzt entwickelt wurde, wird sehr bald verwendet werden. Aber lassen Sie uns daran erinnern, wie die Dinge zuvor gemacht wurden.

Erinnerung an das, was bereits im Replay-/Simulationssystem entwickelt wurde

Dies ist ein wichtiger Punkt, denn ohne das Wissen darüber, was bereits entwickelt wurde, werden Sie am Ende zu Teilen zurückkehren, die bereits voll funktionsfähig sind und nicht überprüft werden müssen. Dennoch plane ich weiterhin zu zeigen, wie man etwas Bestimmtes macht. Aber darüber reden wir ein andermal. Lassen Sie uns für den Moment betrachten, was bereits voll funktionsfähig ist.

Das Replay-/Simulationssystem besteht aus mehreren separaten Anwendungen. Wenn sie jedoch kombiniert werden, ermöglichen sie es Ihnen, mit MetaTrader 5 fast so zu interagieren, als wären Sie mit einem Demo- oder Echtkonto verbunden. Zu diesen Elementen gehört der Mauszeiger, mit dem wir analytische Zeichnungen im Chart erstellen oder mit Chart-Elementen interagieren können, sowie Chart Trade, das über den Expert Advisor Marktorders oder Anfragen auf Marktausführung senden kann. Dies liegt daran, dass wir bei der Verwendung des Mauszeigers und von Chart Trade, das ebenfalls ein Indikator ist, über ein Messaging-Protokoll mit dem Expert Advisor kommunizieren können, der sich ebenfalls auf dem Chart befindet.

Diese drei Anwendungen sind für sich genommen nicht sehr praktisch. Sobald sie sich jedoch auf dem Chart befinden, können Sie einfach mit MetaTrader 5 interagieren, indem Sie Marktorders senden. Wenn jedoch eine Position eröffnet oder geschlossen wird, wird dies im Chart immer noch nicht angezeigt. Obwohl das nicht ganz stimmt. Wir können uns auf die visuelle Anzeige verlassen, die MetaTrader 5 bietet. Wenn Sie jedoch ein Cross-Order-System verwenden möchten – bei dem Orders für ein anderes Symbol als das aktuell angezeigte platziert werden –, erhalten Sie überhaupt keine angemessene visuelle Anzeige. Dies liegt daran, dass wir bei der Verwendung von Cross-Orders den Chart des Symbols betrachten, das wir beobachten. Die Order- oder Handelsanfrage wird jedoch für ein anderes Symbol platziert, dessen Chart nicht geöffnet ist. In diesem Moment kann uns MetaTrader 5 mit seinem integrierten visuellen Anzeige-System nicht mehr weiterhelfen.

Dasselbe geschieht bei der Nutzung des Replay-/Simulations-Services. Obwohl wir eine Möglichkeit zur Visualisierung von Operationen im Replay-/Simulationssystem implementieren können und dies auch bald tun werden, verfügen wir noch nicht über eine geeignete Methode dafür. Der Grund ist einfach: Wir verfügen über kein System zur visuellen Darstellung, das es uns ermöglichen würde, mit Orders oder Positionen zu interagieren, die für dieses spezifische Symbol existieren könnten, sei es ein reales Symbol oder ein simuliertes, also ein Symbol, über das wir Daten wiedergeben.

Obwohl das Replay-/Simulationssystem also bereits in der Lage ist, seine Aufgabe zu erfüllen, müssen wir zunächst eine Möglichkeit implementieren, jede Position oder Order, die für dieses Handelsinstrument existieren könnte, zu visualisieren und mit ihr zu interagieren. Denn ohne dies ist die Erstellung eines Ordersystems zur Unterstützung der Analyse innerhalb des Replay-/Simulationssystems völlig nutzlos. Wir wären nicht in der Lage, mit Orders oder Positionen zu interagieren, die für dieses Symbol existieren.

Daher hat die Erstellung dieses Teils für uns oberste Priorität. Keine Sorge: Zuerst werden wir ein recht einfaches System erstellen. Eine ausreichend einfache Lösung, die es uns ermöglicht, den Prozess während der Arbeit am Replay-/Simulationssystem zu steuern. Fangen wir also gleich damit an. Dazu erstellen wir ein neues Thema.

Erstellen eines einfachen Positionsindikators

Wir beginnen mit Folgendem: Da sich unser Chart-Trade-Indikator nicht auf Pending Orders konzentriert, sondern nur auf die sofortige Auftragserteilung, beginnen wir mit der Erstellung eines grundlegenden Indikators, der offene Positionen anzeigt. An dieser Stelle werden wir uns also nicht mit Pending Orders befassen. Wir konzentrieren uns nur auf offene Positionen und darauf, wie diese im Chart angezeigt werden können. Es ist noch einmal hervorzuheben, dass es hier nicht darum geht, das zu zeigen, was MetaTrader 5 bereits tut. Die Idee ist, sichtbar zu machen, was MetaTrader 5 uns nicht zeigt. Besonders bei der Verwendung des Cross-Order-Systems.

Bevor wir uns den Code ansehen, den wir implementieren werden, möchte ich klarstellen, dass das Ziel in dieser Phase nur darin besteht, eine Funktion zu implementieren, die die Anzeige von Preislinien ermöglicht. Ich erstelle derzeit kein produktionsreifes Tool. Das heißt, wir müssen zunächst dafür sorgen, dass die Linien erscheinen, wenn nur eine offene Position vorhanden ist. Vorerst werden wir uns nicht auf die Verwaltung vieler offener Positionen konzentrieren. Ich bitte daher die ungeduldigsten Leser, sich noch ein wenig zu gedulden. Das Ziel hierbei ist es, Anfängern oder Enthusiasten zu erklären, wie man das praktisch umsetzt.

Zuerst erstellen wir eine neue Datei. Man könnte meinen, dass es sich dabei um eine Expert-Advisor-Datei handeln sollte, da wir mit Positionen arbeiten werden, die möglicherweise auf dem Handelsserver vorhanden sind. Aber nein, wir werden keinen Expert Advisor erstellen. Lassen Sie uns einen Indikator erstellen. Der Quellcode ist nachfolgend zu sehen:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "Indicator for tracking an open position on the server."
04. #property version   "1.00"
05. #property indicator_chart_window
06. #property indicator_plots 0
07. //+------------------------------------------------------------------+
08. int OnInit()
09. {
10.     return INIT_SUCCEEDED;
11. }
12. //+------------------------------------------------------------------+
13. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
14. {
15.     return rates_total;
16. }
17. //+------------------------------------------------------------------+
18. void OnDeinit(const int reason)
19. {
20. }
21. //+------------------------------------------------------------------+

Quellcode

Wenn Sie sich das ansehen, denken Sie vielleicht: „Sind Sie verrückt geworden oder haben Sie völlig den Verstand verloren? Es gibt keine Möglichkeit, einen Indikator für so etwas zu verwenden.“ Beruhigen Sie sich, lieber Leser, haben Sie ein wenig Geduld. Bitte. Die Tatsache, dass Sie etwas noch nie gesehen haben, bedeutet nicht, dass es nicht machbar ist oder nicht existiert. Die Verwendung eines Indikators für diese Aufgabe hat eine Reihe von Vorteilen, auch wenn ihn nur wenige Leute empfehlen würden. Aber wenn Sie sehen, wie der Code aufgebaut ist, werden Sie schließlich verstehen, warum wir dafür einen Indikator verwenden werden und keinen Expert Advisor. Wie wir schon seit einiger Zeit sagen, wird das Material in dieser Artikelserie über das Replay-/Simulationssystem immer komplexer. Ich versuche jedoch, wann immer möglich, alles so einfach und zugänglich wie möglich zu halten.

Das Problem bei der Verwendung eines Indikators besteht darin, dass wir bei einer fehlerhaften Implementierung des Codes den Betrieb des Charts vollständig stören könnten. Dies geschieht, weil MetaTrader 5 alle Indikatoren im selben Ausführungs-Thread platziert. Wenn also ein Indikator einfriert oder für eine Weile nicht reagiert, wird auch der Chart, auf dem er sich befindet, davon betroffen sein. Viele Leute füllen manchmal einen Chart mit Indikatoren. Obwohl dies akzeptabel erscheinen mag, wird es nicht empfohlen, da sie alle im selben Thread ausgeführt werden. Ein Indikator kann die anderen beeinträchtigen und die Gesamtleistung der Plattform gefährden.

Unsere Idee hier ist jedoch genau, den Indikator auf dem Chart zu platzieren und ihn in Ruhe zu lassen. Mit anderen Worten: Er wird nicht aktualisiert. Selbst wenn Sie den Take-Profit- oder Stop-Loss-Preis manuell ändern, wird der Indikator diese Änderung an dieser Stelle nicht anzeigen. Dies wird später geschehen, wenn ich im Detail erkläre, wie genau diese Aktualisierung durchgeführt wird. Also lassen Sie uns nichts überstürzen. Das Erste ist die Anzeige der Preislinien; vergessen Sie vorerst alles andere, denn wir werden dies auf die einfachste und lehrreichste Weise implementieren. Ich möchte, dass Sie dies lernen, damit Sie die für Ihre persönlichen Projekte erforderlichen Änderungen selbst vornehmen können, anstatt einfach nur das zu verwenden, was ich Ihnen beibringe, und später völlig eingeschränkt zu sein, ohne zu wissen, wie es weitergeht.

Sehr gut. Jetzt werden wir den Code, den wir zuvor gesehen haben, modifizieren, damit wir ein paar Dinge testen können. Unser neuer Code ist unten zu sehen:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "Indicator for tracking an open position on the server."
04. #property version   "1.00"
05. #property indicator_chart_window
06. #property indicator_plots 0
07. //+------------------------------------------------------------------+
08. #include <Market Replay\Auxiliar\C_Terminal.mqh>
09. //+------------------------------------------------------------------+
10. C_Terminal *Terminal;
11. //+------------------------------------------------------------------+
12. int OnInit()
13. {
14.     Terminal = new C_Terminal();
15.     if (!PositionSelect((*Terminal).GetInfoTerminal().szSymbol)) return INIT_FAILED;
16.     Print (
17.             "Position Ticket: ", PositionGetInteger(POSITION_TICKET), "   ",
18.             "Opening Price: ",PositionGetDouble(POSITION_PRICE_OPEN), "   ",
19.             "Stop Position: ", PositionGetDouble(POSITION_SL), "   ",
20.             "Take Position: ", PositionGetDouble(POSITION_TP)
21.           );
22.           
23.     return INIT_SUCCEEDED;
24. }
25. //+------------------------------------------------------------------+
26. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
27. {
28.     return rates_total;
29. }
30. //+------------------------------------------------------------------+
31. void OnDeinit(const int reason)
32. {
33.     delete Terminal;
34. }
35. //+------------------------------------------------------------------+

Quellcode des grundlegenden Positionsindikators

Da dieser Code recht einfach ist, werde ich ihn kurz durchgehen, damit Sie verstehen, wie er funktioniert. Ich gehe davon aus, dass Sie ihn nicht allein durch das Betrachten des Codes verstehen werden. In Zeile 08 fügen wir eine Datei hinzu, die bereits im Replay-/Simulationssystem vorhanden ist. Diese Datei hat seit ihrer letzten Aktualisierung, die hier in dieser Serie gezeigt wurde, keine Änderungen erfahren. In Zeile 10 geben wir an, dass wir über einen Zeiger auf die in der Header-Datei vorhandene Klasse zugreifen werden. In Zeile 14 initialisieren wir die Klasse. In Zeile 15 bitten wir MetaTrader 5 uns mitzuteilen, ob für dieses Symbol eine Position offen ist. Wenn sie nicht existiert, beenden wir den Indikator mit einer Fehlermeldung.

Und jetzt aufgepasst! Wenn Zeile 15 ihre Arbeit erledigt und true zurückgibt, werden die Daten zur Position für das angeforderte Handelsinstrument zur Verwendung verfügbar. Bis zu diesem Moment stehen uns keine zuverlässigen Daten zur Verfügung. Beachten Sie dieses Detail. Wenn Zeile 15 erfolgreich ausgeführt wird, wird Zeile 16 ausgeführt. In dieser Zeile geben wir die durch den Aufruf in Zeile 15 erhaltenen Positionsdaten im Terminal aus. Schließlich geben wir in Zeile 23 einen Wert zurück, der anzeigt, dass der Indikator erfolgreich initialisiert wurde.

Innerhalb dieses Indikators passiert nichts weiter, bis er aus irgendeinem Grund aus dem Chart entfernt wird. Wenn das geschieht, zerstören wir in Zeile 33 die Klasse und geben den zugewiesenen Speicher an das System zurück.

Alles ist einfach. Infolgedessen zeigt das Terminal die folgenden Daten an, ausgehend von der im nächsten Bild gezeigten Position:

Nachdem der Indikator seine Aufgabe ausgeführt hat, können Sie das Ergebnis seines Betriebs überprüfen, wie im nächsten Bild gezeigt.

Bitte beachten Sie, dass es uns gelungen ist, diese Daten zu erhalten. Entgegen der landläufigen Meinung können wir tatsächlich Daten über Positionen oder Pending Orders direkt von einem Indikator abrufen. Wir müssen dafür nicht unbedingt einen Expert Advisor verwenden. Die Tatsache, dass wir Daten über eine Position oder Pending Order abrufen können, bedeutet jedoch nicht, dass wir einen Indikator verwenden können, um eine Position oder eine Pending Order zu senden oder zu ändern. Bitte verwechseln Sie diese Konzepte nicht. Die Komponente, die dafür verantwortlich ist, also für das Senden oder Ändern einer Position oder Pending Order, ist der Expert Advisor. Versuchen Sie nicht, dies über einen Indikator zu tun, da dies nicht funktionieren wird.

Also gut. Alles ist in Ordnung, sogar ausgezeichnet, aber wir sind noch weit von dem entfernt, was wir wirklich implementieren müssen. Wie jedoch viele Leute sagen:

Einem Weisen genügt ein Wort.

Daher wird jeder, der bereits weiß, wie man Objekte zu einem Chart hinzufügt, die Idee wahrscheinlich verstehen. Aber falls das bei Ihnen nicht der Fall war, lieber Leser, verzweifeln Sie nicht. Wir gehen nun zum nächsten Schritt über, den wir implementieren müssen. Dieser nächste Schritt ist etwas umfangreicher. Dennoch werden wir versuchen, den Entwicklungsprozess zumindest angenehm zu gestalten. Dies liegt an den Möglichkeiten, die sich von diesem Punkt an eröffnen. Wir werden jedoch nicht direkt zum Endergebnis springen. Wir werden schrittweise vorgehen, da es eine Reihe von Punkten gibt, die berücksichtigt werden müssen, um den Programmieraufwand auf ein Minimum zu beschränken. Denken Sie daran: Wir haben bereits mehrere fertige Anwendungen, wie Chart Trade, den Mausindikator und den grundlegenden Expert Advisor.

Jetzt müssen wir den Positionsindikator erstellen. Idealerweise sollte er auf dem Chart platziert werden, wenn die anderen drei Anwendungen ebenfalls dort vorhanden sind. Aber darüber machen wir uns erst einmal keine Gedanken. Lassen Sie uns zunächst einige Objekte erstellen, die wir auf dem Chart platzieren können, damit wir dieselben Informationen sehen, die wir sehen würden, wenn MetaTrader 5 Cross-Orders nativ unterstützen würde. Machen wir uns also an die Arbeit.

Platzieren von Objekten auf dem Chart

Sie denken vielleicht, dass das Platzieren von Objekten direkt auf dem Chart mit MQL5 entweder sehr schwierig oder sehr einfach ist. In gewisser Weise hängt alles davon ab, wie wir arbeiten wollen und was Sie von der Funktionalität erwarten. Das Platzieren von Objekten auf einem Chart im MetaTrader 5 Terminal ist jedoch nicht schwierig. Es ist tatsächlich recht einfach, entweder mit MQL5-Code oder direkt aus MetaTrader 5 heraus, wo das Menü den Punkt „Einfügen“ mit dem Untermenü „Objekte“ enthält, das es uns ermöglicht, einige Objekte sehr einfach und direkt auf dem Chart zu platzieren. Sie können dies im nächsten Bild sehen:

Es gibt jedoch ein Problem. Ich bin mir nicht ganz sicher, ob ich das schon einmal erwähnt habe. Auf jeden Fall sollten Sie ab diesem Punkt, lieber Leser, verstehen, dass wir nicht willkürlich vorgehen können. Sie sollten nicht einfach Objekte zum Chart hinzufügen, nur damit der Chart optisch ansprechender wirkt oder Daten oder Informationen anzeigt, die wir für notwendig halten. Dies ohne die gebotene Sorgfalt zu tun, ist ein großer Fehler. Bitte missverstehen Sie mich nicht, denn es gibt etwas, dessen sich viele Menschen nicht einmal bewusst sind. Früher oder später stoßen sie auf ein ernstes Problem, das die Erfahrung bei der Nutzung von MetaTrader 5 buchstäblich ruiniert.

Das Problem liegt jedoch nicht wirklich bei MetaTrader 5, sondern bei den verschiedenen Anwendungen, die Objekte ohne jegliche Kontrolle auf dem Chart erstellen. Selbst wenn diese Objekte das Bild nicht überladen und das normale Lesen des Charts nicht behindern, können sie zu einem echten Albtraum werden. Es ist wie ein Stein, der im Boden steckt: Wir denken, es ist ein kleiner Kieselstein, aber wenn wir versuchen, ihn herauszuziehen, entdecken wir, dass es eigentlich ein riesiger Felsbrocken ist, viel größer, als wir uns hätten vorstellen können.

Vielleicht denken Sie: „In Ordnung, aber wie betrifft mich das oder warum sollte mich das interessieren?“ Nun, wenn Sie so denken, habe ich Ihnen nichts weiter zu sagen, außer Ihnen viel Glück zu wünschen. Aber wenn Sie wirklich interessiert sind und die beste Erfahrung bei der Nutzung von Anwendungen machen möchten, die mit Objekten auf dem Chart arbeiten, könnte dieses Thema Sie sehr interessieren. Das Problem ist nicht schwer zu bemerken; ganz im Gegenteil, es sticht deutlich hervor. Und wenn Sie wirklich sehen wollen, wie dieses Problem entsteht, reicht es aus, den Code zu verwenden, den ich vor einiger Zeit veröffentlicht habe. Damals habe ich nicht verstanden, wie MetaTrader 5 mit bestimmten Situationen umgeht. Aber für das, was wir tun werden, ist es äußerst wichtig zu wissen, wie MetaTrader 5 mit einigen davon umgeht.

Wenn Sie ein Bild zum Chart hinzufügen, sodass es den gesamten grafischen Bereich abdeckt, ist das Ergebnis ein Hintergrundbild, das dazu dienen kann, schnell zu erkennen, welches Symbol auf dem Bildschirm zu sehen ist. Darüber hinaus sieht die Verwendung eines Bildes auf dem Chart viel ansprechender aus als ein einfarbiger Hintergrund. Einfach gesagt, über Geschmack lässt sich nicht streiten; im schlimmsten Fall bereuen wir unsere Wahl. Also gut. Dies kann geschehen, indem ein Objekt direkt auf dem Chart platziert wird oder indem eine spezielle Anwendung für diesen Zweck verwendet wird. Im ersten Fall werden wir bestimmte Dinge nicht kontrollieren können. Im zweiten Fall werden wir die volle Kontrolle über den Prozess haben.

Also gut. Diejenigen, die meine Artikel verfolgen, wissen, dass wir im Rahmen dessen, was bereits gezeigt wurde, an einem Punkt eine Klasse namens C_DrawImage erstellt haben. Ihr Zweck ist es, die Platzierung von Objekten zu ermöglichen, deren Inhalte Bitmap-Bilder sind. Zumindest vorerst, da wir noch nicht gezeigt haben, wie man mit anderen Bildformaten arbeitet. Aber das ist nicht das, was uns hier interessiert; entscheidend ist ein anderer Aspekt. Somit können wir unter Verwendung des gesamten Codes, den wir gezeigt haben, die folgende Datei erstellen, die unten dargestellt ist:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "This indicator allows you to add"
04. #property description "a wallpaper to the chart."
05. #property version   "1.00"
06. #property indicator_chart_window
07. #property indicator_plots 0
08. //+------------------------------------------------------------------+
09. #include <Market Replay\Auxiliar\C_DrawImage.mqh>
10. //+------------------------------------------------------------------+
11. input string    user00 = "WallPaper_1";         //WallPaper
12. input uchar     user01 = 60;                    //Transparency
13. //+------------------------------------------------------------------+
14. C_DrawImage *Draw;
15. C_Terminal *Terminal;
16. //+------------------------------------------------------------------+
17. int OnInit()
18. {
19.     Terminal = new C_Terminal();
20.     if (!Terminal.IndicatorCheckPass("Indicator WallPaper")) return INIT_FAILED;
21.     Draw = new C_DrawImage(Terminal, "WallPaper", 0, "WallPapers\\" + user00 + ".bmp", NULL);
22.     
23.     return INIT_SUCCEEDED;
24. }
25. //+------------------------------------------------------------------+
26. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
27. {
28.     return rates_total;
29. }
30. //+------------------------------------------------------------------+
31. void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
32. {
33.     switch (id)
34.     {
35.         case CHARTEVENT_CHART_CHANGE:
36.             (*Terminal).DispatchMessage(id, lparam, dparam, sparam);
37.             (*Draw).Paint(0, 0, (*Terminal).GetInfoTerminal().Width, (*Terminal).GetInfoTerminal().Height, user01, 0);
38.             break;
39.     }
40.     ChartRedraw((*Terminal).GetInfoTerminal().ID);
41. }
42. //+------------------------------------------------------------------+
43. void OnDeinit(const int reason)
44. {
45.     delete Draw;
46.     delete Terminal;
47. }
48. //+------------------------------------------------------------------+

Quellcode von Wallpaper.mq5

Beachten Sie, dass dies nur ein Indikator ist. Aber was macht diese Datei eigentlich? Nun, das ist einfach. Diese kleine und bescheidene Datei ist eigentlich eine Aktualisierung einer anderen Datei aus einem meiner früheren Artikel. Wie ich bereits erwähnte, wusste ich zu diesem Zeitpunkt bestimmte Dinge über MetaTrader 5 noch nicht.

Dies ist der Artikel Wie man das Chart interessanter gestaltet: Hinzufügen eines Hintergrunds, für diejenigen, die an der Motivation und detaillierteren Informationen über die Idee hinter der gesamten Arbeit interessiert sind. Wenn Sie die Codes vergleichen, können Sie sehen, dass sie völlig unterschiedlich sind. Und ja, das sind sie, aber nicht in dem Ausmaß, das Sie sich vielleicht vorstellen. Der in diesem Artikel vorgestellte Code hat ein Problem, dessen Lösung extrem einfach ist. Nach dem Kompilieren dieses Codes und dem Laden auf das Chart als MetaTrader 5-Anwendung erscheint ein Hintergrundbild auf dem Chart. Tatsächlich sollte das Bild als Hintergrund dienen.

Obwohl dies im Code deutlich sichtbar ist, passiert dies jedoch nicht genau so, wenn der Zeitrahmen geändert wird. Selbst wenn wir MetaTrader 5 mitteilen, dass die Balken im Vordergrund sein sollen, wird dieses Hintergrundbild sie dennoch verdecken und kann das Chart vollständig verbergen. Aber es kommt noch schlimmer. Das dort erstellte Objekt hat anfangs die Standardpriorität für den Empfang von Klickereignissen, im Gegensatz zu dem aktualisierten Code, den ich hier zeige.

Aber was ist das Problem? Es gibt kein Problem, wenn sich nur wenige Objekte auf dem Chart befinden und diese voneinander isoliert sind. Aber was passiert, wenn wir ein Objekt, wie zum Beispiel ein Hintergrundbild, platzieren, das den gesamten Chart abdeckt? Und was ist, wenn es die gleiche Priorität für den Empfang von Ereignissen hat wie andere Objekte, die ebenfalls auf dem Chart vorhanden sind? Die Situation beginnt ein wenig kompliziert zu werden, nicht wahr? Dies liegt daran, dass MetaTrader 5 nicht weiß, an welches Objekt die Ereignisse gesendet werden sollen.

Denken Sie nun über Folgendes nach: Wir haben bereits mehrere notwendige Objekte auf dem Chart. Sie befinden sich im Maus-Indikator und im Chart-Trade-Indikator. Die Priorität der Objekte des Maus-Indikators wurde jedoch auf -1 reduziert. Die Objekte des Chart-Trade-Indikators haben die Priorität Null. Das heißt, selbst wenn wir versuchen, ein Klick-Ereignis an ein im Maus-Indikator erstelltes Objekt zu senden, können wir dieses Ereignis nicht empfangen, wenn sich der Mauszeiger über einem beliebigen Objekt des Chart-Trade-Panels befindet. Das haben wir bereits während der Implementierung des Chart-Trade-Panels gesehen. Ich weiß jedoch nicht, ob dies noch frisch in Ihrem Gedächtnis ist, lieber Leser.

Und nun taucht ein neuer erschwerender Faktor auf. Wir werden noch mehr Objekte auf dem Chart erstellen und platzieren. Dies liegt daran, dass wir den Auftrags- und Positionsindikator erstellen werden. Die Frage bleibt jedoch dieselbe. Was sollten wir tun, wenn wir Objekte im Auftrags- und Positionsindikator erstellen? Wenn sie die gleiche Priorität für den Ereignisempfang haben wie das Chart-Trade-Panel, können wir auf Probleme stoßen, wenn ein Objekt ein anderes überlappt.

Das könnte man meinen: „Aber das ist einfach. Das Objekt im Vordergrund hat Vorrang.“ Ja, aber ich wiederhole: Von welchem Objekt sprechen wir? Dies liegt daran, dass MetaTrader 5, wenn zwei Objekte mit derselben Priorität erstellt werden und sich beide an derselben Position befinden, diese in der Reihenfolge zeichnet, in der sie platziert wurden. Mit anderen Worten: Das zuletzt platzierte Objekt verdeckt die früher erstellten Objekte. Das ist jedoch nicht das Problem. Das Problem ist, was passiert, wenn ein Ereignis eintritt, das eine Neuzeichnung des Charts erfordert, wie es beim Ändern des Zeitrahmens der Fall ist. In diesem Moment kann die Reihenfolge, in der die Objekte erstellt werden, eine andere sein als zuvor, was die Verwaltung sehr schwierig macht. Wenn alle Objekte von einer einzigen Anwendung erstellt würden, wäre das Problem gelöst. Wir haben uns jedoch dazu entschieden, nicht alles in einer riesigen Datei zu konzentrieren. Deshalb brauchen wir etwas mehr Kontrolle darüber, wie die Dinge erstellt werden.

Abschließende Überlegungen

Für diejenigen, die einfach erwartet haben, dass sich die Ereignisse schnell und chaotisch entwickeln, war dieser Artikel vielleicht ein böses Erwachen. Hier haben wir begonnen, die Richtung zu skizzieren, die wir bei der Implementierung des Ordersystems einschlagen werden. Erstens müssen wir eine Art Indikator erstellen, um mit dem System zu interagieren. Zweitens darf die Erstellung, oder besser gesagt die Implementierung, nicht chaotisch erfolgen. Wenn das passiert, könnten wir die Kontrolle über die auf dem Chart vorhandenen Objekte vollständig verlieren. Drittens, da der Indikator, den wir implementieren werden, noch mehr Objekte zum Chart hinzufügen wird, müssen wir einen Weg finden, mögliche Interaktionsfehler zu vermeiden. Denn wenn sich zwei Objekte an derselben Stelle befinden, kann eines davon Ereignisse empfangen, selbst wenn es verdeckt ist, einfach weil es eine höhere Priorität hat.

Ich möchte jedoch nicht in Probleme geraten, wenn wir mit mehr als einer Order oder Position auf dem Chart arbeiten. Denn wenn die Implementierung falsch erfolgt, könnten wir am Ende das schließen, was wir offen halten wollten, und das offen lassen, was wir schließen wollten. Ich möchte Ihnen zeigen, wie Sie diese Art von Fehler beseitigen können. Daher hoffe ich, dass Sie, lieber Leser, wirklich lernen wollen, denn wir werden viele neue Dinge sehen, bevor das Replay-/Simulationssystem fertiggestellt ist.

Datei	Beschreibung
Experts\Expert Advisor.mq5	Zeigt die Interaktion zwischen Chart Trade und dem Expert Advisor (für die Interaktion ist „Mouse Study“ erforderlich).
Indicators\Chart Trade.mq5	Erstellt ein Fenster zur Konfiguration des zu versendenden Auftrags (für die Interaktion ist „Mouse Study“ erforderlich).
Indicators\Market Replay.mq5	Erstellt Steuerelemente für die Interaktion mit dem Replay-/Simulations-Service (Mouse Study ist für die Interaktion erforderlich).
Indicators\Mouse Study.mq5	Ermöglicht die Interaktion zwischen grafischen Steuerelementen und dem Benutzer (erforderlich sowohl für das Replay-/Simulationssystem als auch im realen Markt).
Indicators\Order Indicator.mq5	Verantwortlich für die Anzeige von Marktorders sowie deren Interaktion und Verwaltung.
Indicators\Position View.mq5	Verantwortlich für die Anzeige von Marktpositionen sowie deren Interaktion und Verwaltung.
Services\Market Replay.mq5	Erstellt und verwaltet den Markt-Replay-/Simulations-Service (die Hauptdatei des gesamten Systems).