English Русский Español Português
preview
Marktsimulation: Positionsansicht (XI)

Marktsimulation: Positionsansicht (XI)

MetaTrader 5 — Tester |
11 0
Daniel Jose
Daniel Jose

Einleitung

Hallo, liebe Freunde! Willkommen zu einem weiteren Artikel unserer Reihe über die Erstellung eines Systems zur Marktwiedergabe und Marktsimulation.

Im vorherigen Artikel „Marktsimulation: Positionsansicht (X)“ haben wir erläutert, wie wir mithilfe von MetaTrader 5 die Objekte auswählen können, die wir im Chart erstellen. Bis zu diesem Zeitpunkt bestand die größte Herausforderung darin, eine zufriedenstellende Methode zur Auswahl von Objekten im Chart zu finden. Ohne die Hilfe von MetaTrader 5 und die Verwendung der Eigenschaft „ZOrder“ wäre diese Aufgabe ziemlich schwierig. Wie wir jedoch im vorherigen Artikel gezeigt haben, haben wir einen recht praktischen und effektiven Weg gefunden, MetaTrader 5 zu unserem Vorteil zu nutzen.

Sobald wir dieses Ergebnis erreicht hatten, wurde klar, dass wir noch ein weiteres Problem zu lösen hatten. Die konkrete Herausforderung besteht darin, Preislinien auszuwählen. Auch wenn diese Linien vergleichsweise dick sind, ist ihre Auswahl dennoch keine leichte Aufgabe. Vor allem, wenn es relativ schnell gehen muss und die Linien sehr dicht beieinander liegen.

Es ist absolut unerlässlich, die richtige Linie auszuwählen, und zwar so schnell wie möglich; dabei müssen wir jedoch auch wohlüberlegt vorgehen. Wir werden nicht nur eine Linie auswählen, sondern möchten auch die Möglichkeit bieten, direkt im Chart eine Preislinie zu erstellen, sei es eine Take-Profit-Linie oder eine Stop-Loss-Linie. Für einen Trader sollte dieser Vorgang so einfach wie möglich sein. Nicht aus Sicht des Codes, sondern aus Sicht des Traders.

Vor einiger Zeit haben wir in diesen Artikeln ein Modell vorgestellt, das meiner Meinung nach für unsere Anforderungen sehr gut geeignet ist. Dieses Modell war jedoch vollständig an den Expert Advisor gebunden, sodass es schwierig war, es aus dessen interner Struktur herauszulösen. Da dies jedoch für unsere Zwecke relevant ist, werden wir erklären, wie man dabei vorgeht. Diesmal werden wir dies jedoch als Indikator umsetzen. Na gut, dann fangen wir mal an.


Erstellen einer Schaltfläche zum Verschieben von Preisniveaus

Die Idee hinter diesem schon recht alten Modell bestand darin, die gewünschte Linie über eine spezielle Schaltfläche auszuwählen. Mit dieser Schaltfläche können Sie nicht nur eine Linie auswählen, sondern auch eine Linie erstellen, falls sie im Chart noch nicht vorhanden ist. Außerdem erfüllt sie weitere kleinere Funktionen, auf die wir in diesem Artikel ebenfalls eingehen werden. Das Erste, was Sie also tun müssen, ist im folgenden Code dargestellt:

001. //+------------------------------------------------------------------+
002. #property copyright "Daniel Jose"
003. //+------------------------------------------------------------------+
004. #define def_NameHLine       m_Info.szPrefixName + "#HLINE"
005. #define def_NameBtnClose    m_Info.szPrefixName + "#CLOSE"
006. #define def_NameBtnMove     m_Info.szPrefixName + "#MOVE"
007. //+------------------------------------------------------------------+
008. #define macro_LineInFocus(A) ObjectSetInteger(0, def_NameHLine, OBJPROP_YSIZE, m_Info.weight = (A ? 3 : 1));
009. //+------------------------------------------------------------------+
010. #define def_PathBtns "Images\\Market Replay\\Orders\\"
011. #define def_Btn_Close def_PathBtns + "Btn_Close.bmp"
012. #resource "\\" + def_Btn_Close;
013. //+------------------------------------------------------------------+
014. #include "..\Auxiliar\C_Mouse.mqh"
015. //+------------------------------------------------------------------+
016. class C_ElementsTrade : private C_Mouse
017. {
018.     private    :
019. //+------------------------------------------------------------------+
020.         struct st00
021.         {
022.             ulong         ticket;
023.             string        szPrefixName;
024.             EnumEvents    ev;
025.             double        price;
026.             bool          bClick;
027.             char          weight;
028.         }m_Info;
029. //+------------------------------------------------------------------+
030.         void UpdateViewPort(void)
031.         {
032.             int x, y;
033.             
034.             ChartTimePriceToXY(0, 0, 0, m_Info.price, x, y);            
035.             x = (m_Info.ev == evMsgClosePositionEA ? 150 : (m_Info.ev == evMsgCloseTakeProfit ? 220 : 290));
036.             ObjectSetInteger(0, def_NameHLine, OBJPROP_XDISTANCE, x);
037.             ObjectSetInteger(0, def_NameHLine, OBJPROP_YDISTANCE, y - (m_Info.weight > 1 ? (int)(m_Info.weight / 2) : 0));
038.             ObjectSetInteger(0, def_NameBtnClose, OBJPROP_XDISTANCE, x);
039.             ObjectSetInteger(0, def_NameBtnClose, OBJPROP_YDISTANCE, y);
040.             ObjectSetInteger(0, def_NameBtnMove, OBJPROP_XDISTANCE, x + 30);
041.             ObjectSetInteger(0, def_NameBtnMove, OBJPROP_YDISTANCE, y);
042.         }
043. //+------------------------------------------------------------------+
044. inline void CreateLinePrice(const color _color, const string szDescr)
045.         {
046.             string szObj;
047.             
048.             CreateObjectGraphics(szObj = def_NameHLine, OBJ_RECTANGLE_LABEL, _color, (EnumPriority)(ePriorityDefault));
049.             macro_LineInFocus(false);
050.             ObjectSetInteger(0, szObj, OBJPROP_BGCOLOR, _color);
051.             ObjectSetInteger(0, szObj, OBJPROP_XSIZE, TerminalInfoInteger(TERMINAL_SCREEN_WIDTH));
052.             ObjectSetInteger(0, szObj, OBJPROP_BORDER_TYPE, BORDER_FLAT);
053.             ObjectSetInteger(0, szObj, OBJPROP_CORNER, CORNER_LEFT_UPPER);
054.             ObjectSetString(0, szObj, OBJPROP_TOOLTIP, szDescr);
055.         }
056. //+------------------------------------------------------------------+
057. inline void CreateBoxMove(const color _color)
058.         {
059.             string szObj;
060.             
061.             CreateObjectGraphics(szObj = def_NameBtnMove, OBJ_LABEL, _color, (EnumPriority)(ePriorityDefault));
062.             ObjectSetString(0, szObj, OBJPROP_FONT, "Wingdings");
063.             ObjectSetString(0, szObj, OBJPROP_TEXT, "u");
064.             ObjectSetInteger(0, szObj, OBJPROP_FONTSIZE, 17);
065.             ObjectSetInteger(0, szObj, OBJPROP_ANCHOR, ANCHOR_CENTER);
066.             ObjectSetInteger(0, szObj, OBJPROP_XSIZE, 21);
067.             ObjectSetInteger(0, szObj, OBJPROP_YSIZE, 23);
068.         }
069. //+------------------------------------------------------------------+
070. inline void CreateButtonClose(void)
071.         {
072.             string szObj;
073.             
074.             CreateObjectGraphics(szObj = def_NameBtnClose, OBJ_BITMAP_LABEL, clrNONE, (EnumPriority)(ePriorityDefault));
075.             ObjectSetString(0, szObj, OBJPROP_BMPFILE, 0, "::" + def_Btn_Close);
076.             ObjectSetInteger(0, szObj, OBJPROP_ANCHOR, ANCHOR_CENTER);
077.         }
078. //+------------------------------------------------------------------+
079.     public    :
080. //+------------------------------------------------------------------+
081.         C_ElementsTrade(const ulong ticket, const EnumEvents ev, color _color, EnumPriority ePrio, string szDescr = "\n")
082.             :C_Mouse(0, "")
083.         {        
084.             ZeroMemory(m_Info);
085.             m_Info.szPrefixName = StringFormat("%I64u@%03d", m_Info.ticket = ticket, (int)(m_Info.ev = ev));
086.             CreateLinePrice(_color, szDescr);
087.             if (ev != evMsgClosePositionEA) CreateBoxMove(_color);
088.             CreateButtonClose();
089.         }
090. //+------------------------------------------------------------------+
091.         ~C_ElementsTrade()
092.         {
093.             ObjectsDeleteAll(0, m_Info.szPrefixName);
094.         }
095. //+------------------------------------------------------------------+
096. inline void UpdatePrice(const double price)
097.         {
098.             m_Info.price = price;
099.             UpdateViewPort();
100.         }
101. //+------------------------------------------------------------------+
102.         void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam)
103.         {
104.             string sz0;
105.             
106.             C_Mouse::DispatchMessage(id, lparam, dparam, sparam);
107.             switch (id)
108.             {
109.                 case CHARTEVENT_CUSTOM + evMsgSetFocus:
110.                     macro_LineInFocus((m_Info.ticket == (ulong)(lparam)) && ((EnumEvents)(dparam) == m_Info.ev));
111.                     m_Info.bClick = false;
112.                 case CHARTEVENT_CHART_CHANGE:
113.                     UpdateViewPort();
114.                     break;
115.                 case CHARTEVENT_OBJECT_CLICK:
116.                     sz0 = GetPositionsMouse().szObjNameClick;
117.                     if (m_Info.bClick) switch (m_Info.ev)
118.                     {
119.                         case evMsgClosePositionEA:
120.                             if (sz0 == def_NameBtnClose)
121.                                 EventChartCustom(0, evMsgClosePositionEA, m_Info.ticket, 0, "");
122.                             break;
123.                         case evMsgCloseTakeProfit:
124.                             if (sz0 == def_NameBtnClose)
125.                                 EventChartCustom(0, evMsgCloseTakeProfit, m_Info.ticket, PositionGetDouble(POSITION_SL), PositionGetString(POSITION_SYMBOL));
126.                             else if (sz0 == def_NameBtnMove)
127.                                 EventChartCustom(0, evMsgSetFocus, m_Info.ticket, evMsgCloseTakeProfit, "");
128.                             break;
129.                         case evMsgCloseStopLoss:
130.                             if (sz0 == def_NameBtnClose)
131.                                 EventChartCustom(0, evMsgCloseStopLoss, m_Info.ticket, PositionGetDouble(POSITION_TP), PositionGetString(POSITION_SYMBOL));
132.                             else if (sz0 == def_NameBtnMove)
133.                                 EventChartCustom(0, evMsgSetFocus, m_Info.ticket, evMsgCloseStopLoss, "");
134.                             break;
135.                     }
136.                     m_Info.bClick = false;
137.                     break;
138.                 case CHARTEVENT_MOUSE_MOVE:
139.                     m_Info.bClick = (CheckClick(C_Mouse::eClickLeft) ? true : m_Info.bClick);
140.                     if (m_Info.bClick && (m_Info.weight > 1)) EventChartCustom(0, evMsgSetFocus, 0, 0, "");
141.                     break;
142.             }
143.         }
144. //+------------------------------------------------------------------+
145. };
146. //+------------------------------------------------------------------+
147. #undef macro_LineInFocus
148. //+------------------------------------------------------------------+
149. #undef def_Btn_Close
150. #undef def_PathBtns
151. //+------------------------------------------------------------------+
152. #undef def_NameBtnMove
153. #undef def_NameBtnClose
154. #undef def_NameHLine
155. //+------------------------------------------------------------------+

C_ElementsTrade.mqh

An dieser Stelle beginnen wir mit der weiteren Verbesserung der Objektverwaltung. Beachten Sie, dass wir in Zeile 06 eine neue Definition erstellt haben. Dadurch wird dem Objekt, das unser Verschiebesymbol darstellen soll, ein Name zugewiesen. Solange dieses Element fehlt, kann die Linie nicht verschoben werden. Wenn dieses Element vorhanden ist, kann die Linie verschoben werden. Vorerst werden wir uns jedoch noch nicht mit dem Verschieben der Linie befassen. Schauen wir uns zunächst einmal an, wie man die Auswahl verwaltet.

Bitte beachten Sie, dass sich der Code nur geringfügig geändert hat. So können Sie den gesamten Prozess Schritt für Schritt wirklich verstehen. Wenn Sie möchten, können Sie also ganz einfach ändern, was wir anzeigen.

In Zeile 40 legen wir die Position unseres neuen Objekts auf der X-Achse fest. Bitte beachten Sie, dass wir zwischen diesem Objekt und der Schließen-Schaltfläche einen kleinen Abstand gelassen haben. Jetzt gut aufpassen: In Zeile 35 habe ich den Versatz der Objekte so angepasst, dass sie sich nicht überlappen. Dadurch entsteht ein kleiner Abstand zwischen ihnen, sodass es keine Probleme geben wird, wenn dieser Indikator im Chart angezeigt wird.

Um zukünftige Änderungen noch einfacher zu gestalten, habe ich die Prozeduren, die Objekte erstellen, aus dem Konstruktor ausgelagert. So sind die Prozeduren „CreateLinePrice“ und „CreateButtonClose“ entstanden. Die Logik dieser Prozeduren befand sich früher im Konstruktor. Daher werde ich nicht näher darauf eingehen. Da die Prozedur „CreateBoxMove“ jedoch neu ist, ist eine kurze Erläuterung angebracht. In dieser Prozedur erstellen wir einfach ein OBJ_LABEL-Objekt und weisen ihm Text zu. Eigentlich ist es nur ein Zeichen. Dadurch wird angezeigt, ob wir die Preislinie auswählen und folglich verschieben können. Da der Code sehr einfach ist, halte ich eine ausführliche Erklärung nicht für notwendig.

Sehen Sie sich nun die folgenden Details im Konstruktor an. Um genauer zu sein: Schauen Sie sich Zeile 87 an. In dieser Zeile prüfen wir, ob das erstellte Steuerelement zum Schließen der Position dient. Ist dies nicht der Fall, können wir das Verschiebeobjekt für die Preislinie erstellen. Super, jetzt können wir zur Prozedur „DispatchMessage“ übergehen. In dieser Prozedur wurden einige weitere wesentliche Änderungen vorgenommen. Diese Änderungen sollen jedoch Code-Duplikate vermeiden, da bestimmte Aufgaben kaskadierend abgewickelt werden können.

Das lässt sich anhand des Ereignisses in Zeile 109 erkennen: In diesem Ereignis setzen wir in Zeile 111 den Status des Mausklicks auf „false“. Doch dieses Ereignis in Zeile 109 endet nicht so, wie viele es erwarten würden. Tatsächlich läuft die Ausführung ohne Unterbrechung in den nächsten case-Zweig, CHARTEVENT_CHART_CHANGE in Zeile 112, weiter. Aber warum sollte man das tun oder zulassen, dass so etwas passiert? Der Grund dafür ist einfach. Wenn sich die Linienstärke ändert, muss die Linie im Chart neu gezeichnet werden. Würden wir die Ausführung nach dem benutzerdefinierten Ereignis nicht in den Zweig zum Neuzeichnen weiterlaufen lassen, müssten wir innerhalb des benutzerdefinierten Ereignisses einen gesonderten Aufruf zum Neuzeichnen der Linie einfügen. Das können wir jedoch durch eine kaskadierende Ereignisbehandlung vermeiden.

Beachten Sie, dass wir im Ereignis „CHARTEVENT_OBJECT_CLICK“ nicht prüfen, ob ein Klick auf eine Preislinie erfolgt ist. Nun prüfen wir, ob auf das Verschiebeobjekt geklickt wurde. Verschwenden Sie also keine Zeit mit der Auswahl der Preislinie. Klicken Sie direkt auf die kleine Raute, die darauf erscheint. Auf diese Weise wird die Linie zusammen mit der Raute ausgewählt.

Eine weitere neue Funktion befindet sich speziell im Ereignis CHARTEVENT_MOUSE_MOVE. Bitte beachten Sie, dass nun in Zeile 140 eine neue Überprüfung durchgeführt wird. Damit soll sichergestellt werden, dass keine anderen Linien im Chart ausgewählt sind. Ist diese Bedingung erfüllt, wird ein Ereignis ausgelöst, das die aktuelle Auswahl aufhebt. Diese Umsetzung ist recht interessant, denn wenn eine Linie ausgewählt ist und Sie auf eine beliebige Stelle im Chart klicken, wird die Auswahl dieser Linie aufgehoben. Und wir müssen uns keine Gedanken darüber machen, welche Linie ausgewählt wird. Die Auswahl wird für alle Linien aufgehoben.

Gut, mit dem, was ich Ihnen gerade gezeigt habe, können Sie zwar eine Preislinie auswählen oder hervorheben, aber darüber hinaus noch nichts Nützlicheres tun. Lassen Sie uns einen Moment darüber nachdenken. Ich versichere Ihnen, das wird sehr interessant.

Wenn Sie sich den obigen Code ansehen und die Erklärung zu seiner Funktionsweise lesen, können Sie dann eine einfache und schnelle Möglichkeit vorschlagen, diese Preislinien zu verschieben? Es spielt keine Rolle, ob der Handelsserver dies akzeptiert oder nicht. Ich möchte nur, dass Sie mir sagen, ob sich die Linien mit dem verschieben lassen, was wir gerade implementiert haben. Denken Sie daran, dass wir dem System Code hinzufügen müssen, damit dies möglich wird. Die Frage ist, ob wir das mit möglichst wenig Code schaffen können. Ich habe keine Lust, viel Code zu schreiben. Ist das also möglich oder nicht?

Wenn Sie mit „NEIN“ geantwortet haben, verstehen Sie möglicherweise noch nicht ganz, wie das alles funktioniert. Sie werden wahrscheinlich denken, dass das nicht möglich ist, ohne sich etwas Zeit zum Nachdenken zu nehmen, aber wir schaffen das. Natürlich nur unter der Voraussetzung, dass wir unserem Hauptsystem noch ein wenig mehr Code hinzufügen. Zur Erinnerung: In früheren Artikeln haben wir bereits zwei neue Nachrichten zum System hinzugefügt. Allerdings waren diese Nachrichten zu diesem Zeitpunkt noch nicht im Code implementiert, da dies damals nicht praktikabel war. Nun haben wir jedoch eine einfache und schnelle Möglichkeit, Preislinien auszuwählen. Somit können wir dieses Nachrichtensystem nutzen und implementieren. Bevor wir damit anfangen, möchte ich erklären, was wir vorhaben. Auf diese Weise können Sie die Umsetzung der Lösung nachvollziehen oder sich ein Bild davon machen, noch bevor Sie sie tatsächlich sehen.

Wenn Sie die Header-Datei „C_ElementsTrade.mqh“ durch den Code ersetzen, den wir zu Beginn dieses Themas besprochen haben, werden Sie feststellen, dass die Auswahl der Linie aufgehoben wird, wenn Sie eine Preislinie auswählen und anschließend auf einen Punkt klicken. Genau das ist die Idee. Wenn wir den Positionsindikator anweisen, die Auswahl der Preislinie aufzuheben, muss er eine Nachricht an den Expert Advisor senden, die angibt, dass die ausgewählte Linie an eine neue Position verschoben werden soll. Diese neue Position entspricht genau der Stelle, an der mit der Maus geklickt wird. Verstehen Sie es jetzt?

Dennoch ist die Idee noch nicht ausgereift. Aber darüber machen wir uns jetzt erst einmal keine Gedanken; wir machen einfach das, was ich gesagt habe: Sobald eine Preislinie ausgewählt ist und wir auf einen anderen Punkt klicken, sollte sich diese Linie zu diesem Punkt verschieben. Dies lässt sich erreichen, indem man den Code der Prozedur „DispatchMessage“ wie folgt ändert:

138.     case CHARTEVENT_MOUSE_MOVE:
139.         m_Info.bClick = (CheckClick(C_Mouse::eClickLeft) ? true : m_Info.bClick);
140.         if (m_Info.bClick && (m_Info.weight > 1))
141.         {
142.             switch (m_Info.ev)
143.             {
144.                 case evMsgCloseTakeProfit:
145.                     EventChartCustom(0, evMsgNewTakeProfit, m_Info.ticket, GetPositionsMouse().Position.Price, PositionGetString(POSITION_SYMBOL));
146.                     break;
147.                 case evMsgCloseStopLoss:
148.                     EventChartCustom(0, evMsgNewStopLoss, m_Info.ticket, GetPositionsMouse().Position.Price, PositionGetString(POSITION_SYMBOL));
149.                     break;
150.             }
151.             EventChartCustom(0, evMsgSetFocus, 0, 0, "");
152.         }
153.         break;

Ausschnitt aus der Datei „C_ElementsTrade.mqh“

Sehen Sie sich an, was hier passiert ist. Wenn Sie dieses Codefragment zur Klasse „C_ElementsTrade“ hinzufügen, können Sie die Take-Profit- und Stop-Loss-Linien mit dem Mauszeiger verschieben. Werfen Sie jedoch einen Blick auf die folgenden Details. Wir verschieben keine Linien oder zugehörigen Objekte; wir halten uns genau an den Plan. Mit anderen Worten: Die Linie wird über das Verschiebeobjekt markiert. Bewegen Sie den Mauszeiger an eine neue Position und klicken Sie erneut. In diesem Fall sollte die Überprüfung in Zeile 140 schließlich durchgeführt werden.

Daraufhin wird in Zeile 142 das entsprechende Ereignis ausgewählt. Wurde die Take-Profit-Linie ausgewählt, kann das Ereignis in Zeile 145 ausgelöst werden; bei der Stop-Loss-Linie das Ereignis in Zeile 148. Beachten Sie, dass die an MetaTrader 5 gesendete Nachricht praktisch identisch sein wird. Sie unterscheidet sich jedoch in ihrem zweiten Parameter.

Diese Nachricht wird von MetaTrader 5 an den Chart weitergeleitet, auf dem der Indikator geladen ist, und vom Expert Advisor abgefangen. Im Code der Klasse „C_Orders“, die Teil des Expert Advisors ist, wird diese Nachricht als Aufforderung interpretiert, die Position einer Preislinie zu ändern, unabhängig davon, ob es sich um die Stop-Loss-Linie oder die Take-Profit-Linie handelt. Sobald der Server das Ergebnis unserer Anfrage zurückgibt, sendet der Expert Advisor eine weitere Nachricht, die vom Positionsindikator abgefangen wird. Daraufhin zeigt dieser die neue Position der Preislinie an. Auf diese Weise wissen wir jedes Mal, wenn wir uns den Chart ansehen, genau, wo sich die Linien auf dem Server befinden. Das liegt daran, dass wir stets genau das wiedergeben, was sich auf dem Server befindet. So können wir Linien ganz einfach und mit möglichst wenig Code verschieben.

Dieses System, das wir gerade implementiert haben, funktioniert so gut, dass Sie sogar die in MetaTrader 5 verfügbare Trailing-Stop-Funktion nutzen können, um die Stop-Loss-Linie zu verschieben – dieser Positionsindikator folgt ihr dabei und bleibt stets mit den Daten auf dem Handelsserver synchron.

Obwohl dieses System äußerst gut funktioniert, haben wir ein weiteres Problem noch nicht gelöst. Das Problem ist Folgendes: Wie können wir Take-Profit- oder Stop-Loss-Linien erstellen, wenn diese vom Server und damit auch aus dem Chart entfernt wurden? Okay, das scheint viel schwieriger zu sein. Aber folgen Sie einfach unserer Erklärung, und Sie werden sehen, dass es genauso einfach ist wie das, was wir gerade gemacht haben. Um die Themen voneinander zu trennen und Verwirrung zu vermeiden, wenden wir uns nun einem neuen Thema zu.


Ohne Stop-Loss- und Take-Profit-Linien. Wie können wir sie erneut platzieren?

Nun haben wir ein etwas anderes Problem. Das Problem ist Folgendes: Nehmen wir an, wir entfernen die Stop-Loss- und Take-Profit-Werte auf dem Server, beschließen aber nach einer Weile, sie wieder einzurichten. Dafür gibt es mehrere Möglichkeiten. An dieser Stelle möchte ich Ihnen jedoch zeigen, wie Sie den Positionsindikator so anpassen können, dass Sie Stop Loss oder Take Profit wieder direkt im Chart festlegen können.

Dazu müssen wir den Indikator ein wenig anpassen. Das liegt daran, dass der Indikator, wenn Stop Loss oder Take Profit aus einer Position entfernt werden, auch die Elemente entfernt, die den Stop-Loss- bzw. Take-Profit-Linien entsprechen. Genau dieses Verhalten müssen wir ändern. Auf diese Weise können wir denselben Mechanismus nutzen, den wir im vorherigen Abschnitt besprochen haben. Das heißt, klicken Sie auf eines der Elemente, sei es Stop Loss oder Take Profit. Bewegen Sie den Mauszeiger an die gewünschte Stelle und klicken Sie erneut. Dadurch ändert sich das Preisniveau, auf dem die Position geschlossen wird. Das ist der Kerngedanke.

Aber wie lässt sich das ganz einfach bewerkstelligen? Vielleicht ist Ihnen eine ziemlich verrückte Lösung eingefallen. Ich weiß nicht, ob dies einfacher oder schwieriger sein wird als die vorgeschlagene Lösung, aber wie schon im vorherigen Thema geht es darum, so wenige Änderungen wie möglich am Code vorzunehmen.

Na gut, machen wir noch einmal eine Pause und denken wir einen Moment darüber nach: Was wäre die einfachste Lösung für unser Problem? Da wir dasselbe Modell verwenden möchten, das wir im vorherigen Abschnitt besprochen haben, wäre die einfachste Lösung, das Verschiebeobjekt der Preislinie auf dem Chart zu belassen. Wenn Sie daran gedacht haben, dann haben Sie genauso gedacht wie ich. Aber wo können wir das Objekt platzieren, wenn es keine Preislinie gibt, sei es eine Take-Profit- oder eine Stop-Loss-Linie? Na gut, in diesem Fall wäre es meiner Meinung nach am besten, das Verschiebeobjekt direkt auf der Linie zu platzieren, auf der die Position eröffnet wurde. Ich weiß nicht, ob Sie diese Meinung teilen, lieber Leser. Es steht Ihnen frei, zu denken, was Sie wollen – vorausgesetzt natürlich, Sie wissen, was Sie tun.

Machen wir es doch so. Wenn eine Stop-Loss- oder Take-Profit-Linie einer Position entfernt wird, wird die Schaltfläche zum Verschieben neben der Linie des Eröffnungspreises platziert. Aber jetzt haben wir ein Problem. Wird diese Linie gelöscht, löscht der Positionsindikator auch die damit verbundenen Objekte. Wir wollen unseren Code nicht noch komplizierter machen, also schauen wir uns einmal an, an welcher Stelle im Code der Indikator diese Objekte löscht. Dies wird im folgenden Codeausschnitt veranschaulicht.

45. //+------------------------------------------------------------------+
46.         void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam)
47.         {
48.             double value;
49.             
50.             if (Open != NULL) (*Open).DispatchMessage(id, lparam, dparam, sparam);
51.             if (Take != NULL) (*Take).DispatchMessage(id, lparam, dparam, sparam);
52.             if (Stop != NULL) (*Stop).DispatchMessage(id, lparam, dparam, sparam);
53.             switch (id)
54.             {
55.                 case CHARTEVENT_CUSTOM + evUpdate_Position:
56.                     if (lparam != m_Infos.ticket) return;
57.                     if (!PositionSelectByTicket(m_Infos.ticket))
58.                     {
59.                         ChartIndicatorDelete(0, 0, m_Infos.szShortName);
60.                         return;
61.                     };
62.                     if (Open == NULL) Open = new C_ElementsTrade(m_Infos.ticket, evMsgClosePositionEA, clrRoyalBlue, ePriorityNull, StringFormat("%I64u : Position opening price.", m_Infos.ticket));
63.                     if (Take == NULL) Take = new C_ElementsTrade(m_Infos.ticket, evMsgCloseTakeProfit, clrForestGreen, ePriorityDefault, StringFormat("%I64u : Take Profit price.", m_Infos.ticket));
64.                     if (Stop == NULL) Stop = new C_ElementsTrade(m_Infos.ticket, evMsgCloseStopLoss, clrFireBrick, ePriorityDefault, StringFormat("%I64u : Stop Loss price.", m_Infos.ticket));
65.                     (*Open).UpdatePrice(PositionGetDouble(POSITION_PRICE_OPEN));
66.                     if ((value = PositionGetDouble(POSITION_TP)) > 0) (*Take).UpdatePrice(value); else
67.                     {
68.                         delete Take;
69.                         Take = NULL;
70.                     }
71.                     if ((value = PositionGetDouble(POSITION_SL)) > 0) (*Stop).UpdatePrice(value);    else
72.                     {
73.                         delete Stop;
74.                         Stop = NULL;
75.                     }
76.                     break;
77.             }
78.             ChartRedraw();
79.         }
80. //+------------------------------------------------------------------+

Ausschnitt aus der Datei „C_IndicatorPosition.mqh“

Dieser Codeausschnitt ist Teil der Klasse „C_IndicatorPosition“. Dies ist der Quellcode für diese Klasse. Werfen wir nun einen Blick auf die folgenden Punkte. In den Zeilen 66 und 71 befinden sich zwei Prüfungen: eine für Take Profit und die andere für Stop Loss. Passen Sie jetzt gut auf, damit Sie verstehen, was wir tun müssen. Diese Prüfungen teilen dem Positionsindikator mit, dass wir die Zeiger auf die Klasse „C_ElementsTrade“ entfernen müssen. Dies geschieht, wenn der Positionswert null oder kleiner ist. Ich denke, Sie haben alles bestens verstanden.

An dieser Stelle müssen wir den Code jedoch anpassen. Lassen Sie uns einen Moment darüber nachdenken. Wenn wir, anstatt den Zeiger auf die Klasse „C_ElementsTrade“ zu entfernen, die Werte der Take-Profit- und Stop-Loss-Linien an diese Klasse übergeben, können wir einen Mechanismus schaffen, mit dem wir das Gewünschte erreichen. In diesem Fall muss genau dieser Codeausschnitt angepasst werden, um den angegebenen Mechanismus zu implementieren. Diese Änderung ist im Folgenden dargestellt:

45. //+------------------------------------------------------------------+
46.         void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam)
47.         {
48.             double value;
49.             
50.             if (Open != NULL) (*Open).DispatchMessage(id, lparam, dparam, sparam);
51.             if (Take != NULL) (*Take).DispatchMessage(id, lparam, dparam, sparam);
52.             if (Stop != NULL) (*Stop).DispatchMessage(id, lparam, dparam, sparam);
53.             switch (id)
54.             {
55.                 case CHARTEVENT_CUSTOM + evUpdate_Position:
56.                     if (lparam != m_Infos.ticket) return;
57.                     if (!PositionSelectByTicket(m_Infos.ticket))
58.                     {
59.                         ChartIndicatorDelete(0, 0, m_Infos.szShortName);
60.                         return;
61.                     };
62.                     if (Open == NULL) Open = new C_ElementsTrade(m_Infos.ticket, evMsgClosePositionEA, clrRoyalBlue, ePriorityNull, StringFormat("%I64u : Position opening price.", m_Infos.ticket));
63.                     if (Take == NULL) Take = new C_ElementsTrade(m_Infos.ticket, evMsgCloseTakeProfit, clrForestGreen, ePriorityDefault, StringFormat("%I64u : Take Profit price.", m_Infos.ticket));
64.                     if (Stop == NULL) Stop = new C_ElementsTrade(m_Infos.ticket, evMsgCloseStopLoss, clrFireBrick, ePriorityDefault, StringFormat("%I64u : Stop Loss price.", m_Infos.ticket));
65.                     (*Open).UpdatePrice(0, value = PositionGetDouble(POSITION_PRICE_OPEN));
66.                     (*Take).UpdatePrice(value, PositionGetDouble(POSITION_TP));
67.                     (*Stop).UpdatePrice(value, PositionGetDouble(POSITION_SL));
68.                     break;
69.             }
70.             ChartRedraw();
71.         }
72. //+------------------------------------------------------------------+

Ausschnitt aus der Datei „C_IndicatorPosition.mqh“

Beachten Sie, dass der Code praktisch unverändert geblieben ist. Wir haben jedoch die bisher durchgeführten Prüfungen deaktiviert. Der jeweilige Wert für Stop Loss oder Take Profit wird nun unabhängig von seiner Höhe an die Klasse „C_ElementsTrade“ übergeben. Dadurch können wir die Preislinienobjekte ordnungsgemäß verwalten.

Super, schauen wir uns nun den Code in der Klasse „C_ElementsTrade“ an. Der Quellcode ist im folgenden Ausschnitt dargestellt:

095. //+------------------------------------------------------------------+
096. inline void UpdatePrice(const double price)
097.         {
098.             m_Info.price = price;
099.             UpdateViewPort();
100.         }
101. //+------------------------------------------------------------------+

Ausschnitt aus der Datei „C_ElementsTrade.mqh“

Wenden wir uns nun dem vorherigen Codeausschnitt zu – hier spielt sich das Wesentliche ab. Beachten Sie jedoch, dass wir ursprünglich davon ausgegangen waren, nur einen Parameter zu erhalten. In den Änderungen an der Klasse „C_IndicatorPosition“ ist jedoch zu erkennen, dass zwei Parameter an diese Prozedur übergeben werden. Das wird die erste Änderung sein. Bevor wir uns jedoch damit befassen, wie der Code aussehen sollte, wollen wir noch ein paar weitere Details zusammenstellen. Okay, das erste Argument gibt die Position der Eröffnungspreislinie an. Das zweite Argument ist der Preis der zu erstellenden Linie.

Denken Sie doch mal einen Moment darüber nach. Wir müssen lediglich die überflüssigen Objekte entfernen, in diesem Fall das Objekt, das die Preislinie darstellt, und die Schließen-Schaltfläche, während die Schaltfläche zum Verschieben erhalten bleibt. Dieses Verschiebeobjekt wird jedoch an eine neue Position verschoben. Diese neue Position entspricht dem Eröffnungspreis der Position. Daher ist es am einfachsten, diese Änderung vorzunehmen, indem man den vorherigen Codeausschnitt so anpasst, dass er wie im folgenden Beispiel aussieht:

095. //+------------------------------------------------------------------+
096. inline void UpdatePrice(const double open, const double price)
097.         {
098.             m_Info.price = (price > 0 ? price : open);
099.             if (price == 0)
100.             {
101.                 ObjectDelete(0, def_NameBtnClose);
102.                 ObjectDelete(0, def_NameHLine);
103.             }
104.             UpdateViewPort();
105.         }
106. //+------------------------------------------------------------------+

Ausschnitt aus der Datei „C_ElementsTrade.mqh“

Mit diesem Codeausschnitt würde unser Positionsindikator zwar ordnungsgemäß funktionieren, allerdings gibt es dabei einen kleinen Nachteil. Beachten Sie: Wenn der Trader die Stop-Loss- oder Take-Profit-Linie einer offenen Position entfernt, entfernt der Positionsindikator auch die horizontale Linie und die Schließen-Schaltfläche. Das liegt an den Zeilen 101 und 102 des vorherigen Codeausschnitts. Wenn der Trader jedoch eine Änderung der Position der Stop-Loss- oder Take-Profit-Linie bei einer offenen Position anfordert, wird nur die Schaltfläche „Verschieben“ korrekt verschoben. Die übrigen Objekte werden aus der Objektliste entfernt. Sie werden unter keinen Umständen im Chart erscheinen. Das Ergebnis ist in der folgenden Abbildung dargestellt:

Das ist kein ernstes Problem, sondern nur eine kleine Unannehmlichkeit, die behoben werden muss. Es ist genauso einfach wie das, was wir bisher gemacht haben. Allerdings müssen wir noch einige größere Änderungen am Klassencode vornehmen. Nachfolgend finden Sie den endgültigen, korrigierten Code:

001. //+------------------------------------------------------------------+
002. #property copyright "Daniel Jose"
003. //+------------------------------------------------------------------+
004. #define def_NameHLine       m_Info.szPrefixName + "#HLINE"
005. #define def_NameBtnClose    m_Info.szPrefixName + "#CLOSE"
006. #define def_NameBtnMove     m_Info.szPrefixName + "#MOVE"
007. //+------------------------------------------------------------------+
008. #define macro_LineInFocus(A) ObjectSetInteger(0, def_NameHLine, OBJPROP_YSIZE, m_Info.weight = (A ? 3 : 1));
009. //+------------------------------------------------------------------+
010. #define def_PathBtns "Images\\Market Replay\\Orders\\"
011. #define def_Btn_Close def_PathBtns + "Btn_Close.bmp"
012. #resource "\\" + def_Btn_Close;
013. //+------------------------------------------------------------------+
014. #include "..\Auxiliar\C_Mouse.mqh"
015. //+------------------------------------------------------------------+
016. class C_ElementsTrade : private C_Mouse
017. {
018.     private    :
019. //+------------------------------------------------------------------+
020.         struct st00
021.         {
022.             ulong       ticket;
023.             string      szPrefixName,
024.                         szDescr;
025.             EnumEvents  ev;
026.             double      price;
027.             bool        bClick;
028.             char        weight;
029.             color       _color;
030.         }m_Info;
031. //+------------------------------------------------------------------+
032.         void UpdateViewPort(void)
033.         {
034.             int x, y;
035.             
036.             ChartTimePriceToXY(0, 0, 0, m_Info.price, x, y);            
037.             x = (m_Info.ev == evMsgClosePositionEA ? 150 : (m_Info.ev == evMsgCloseTakeProfit ? 220 : 290));
038.             ObjectSetInteger(0, def_NameHLine, OBJPROP_XDISTANCE, x);
039.             ObjectSetInteger(0, def_NameHLine, OBJPROP_YDISTANCE, y - (m_Info.weight > 1 ? (int)(m_Info.weight / 2) : 0));
040.             ObjectSetInteger(0, def_NameBtnClose, OBJPROP_XDISTANCE, x);
041.             ObjectSetInteger(0, def_NameBtnClose, OBJPROP_YDISTANCE, y);
042.             ObjectSetInteger(0, def_NameBtnMove, OBJPROP_XDISTANCE, x + 30);
043.             ObjectSetInteger(0, def_NameBtnMove, OBJPROP_YDISTANCE, y);
044.         }
045. //+------------------------------------------------------------------+
046. inline void CreateLinePrice(void)
047.         {
048.             string szObj;
049.             
050.             CreateObjectGraphics(szObj = def_NameHLine, OBJ_RECTANGLE_LABEL, m_Info._color, (EnumPriority)(ePriorityDefault));
051.             macro_LineInFocus(false);
052.             ObjectSetInteger(0, szObj, OBJPROP_BGCOLOR, m_Info._color);
053.             ObjectSetInteger(0, szObj, OBJPROP_XSIZE, TerminalInfoInteger(TERMINAL_SCREEN_WIDTH));
054.             ObjectSetInteger(0, szObj, OBJPROP_BORDER_TYPE, BORDER_FLAT);
055.             ObjectSetInteger(0, szObj, OBJPROP_CORNER, CORNER_LEFT_UPPER);
056.             ObjectSetString(0, szObj, OBJPROP_TOOLTIP, m_Info.szDescr);
057.         }
058. //+------------------------------------------------------------------+
059. inline void CreateBoxMove(void)
060.         {
061.             string szObj;
062.             
063.             CreateObjectGraphics(szObj = def_NameBtnMove, OBJ_LABEL, m_Info._color, (EnumPriority)(ePriorityDefault));
064.             ObjectSetString(0, szObj, OBJPROP_FONT, "Wingdings");
065.             ObjectSetString(0, szObj, OBJPROP_TEXT, "u");
066.             ObjectSetInteger(0, szObj, OBJPROP_FONTSIZE, 17);
067.             ObjectSetInteger(0, szObj, OBJPROP_ANCHOR, ANCHOR_CENTER);
068.             ObjectSetInteger(0, szObj, OBJPROP_XSIZE, 21);
069.             ObjectSetInteger(0, szObj, OBJPROP_YSIZE, 23);
070.         }
071. //+------------------------------------------------------------------+
072. inline void CreateButtonClose(void)
073.         {
074.             string szObj;
075.             
076.             CreateObjectGraphics(szObj = def_NameBtnClose, OBJ_BITMAP_LABEL, clrNONE, (EnumPriority)(ePriorityDefault));
077.             ObjectSetString(0, szObj, OBJPROP_BMPFILE, 0, "::" + def_Btn_Close);
078.             ObjectSetInteger(0, szObj, OBJPROP_ANCHOR, ANCHOR_CENTER);
079.         }
080. //+------------------------------------------------------------------+
081.     public    :
082. //+------------------------------------------------------------------+
083.         C_ElementsTrade(const ulong ticket, const EnumEvents ev, color _color, EnumPriority ePrio, string szDescr = "\n")
084.             :C_Mouse(0, "")
085.         {        
086.             ZeroMemory(m_Info);
087.             m_Info.szPrefixName = StringFormat("%I64u@%03d", m_Info.ticket = ticket, (int)(m_Info.ev = ev));
088.             m_Info._color = _color;
089.             m_Info.szDescr = szDescr;
090.         }
091. //+------------------------------------------------------------------+
092.         ~C_ElementsTrade()
093.         {
094.             ObjectsDeleteAll(0, m_Info.szPrefixName);
095.         }
096. //+------------------------------------------------------------------+
097. inline void UpdatePrice(const double open, const double price)
098.         {
099.             m_Info.price = (price > 0 ? price : open);
100.             if (price > 0)
101.             {
102.                 CreateLinePrice();
103.                 CreateButtonClose();
104.             }else
105.                 ObjectsDeleteAll(0, m_Info.szPrefixName);
106.             if (m_Info.ev != evMsgClosePositionEA) CreateBoxMove();
107.             UpdateViewPort();
108.         }
109. //+------------------------------------------------------------------+
110.         void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam)
111.         {
112.             string sz0;
113.             
114.             C_Mouse::DispatchMessage(id, lparam, dparam, sparam);
115.             switch (id)
116.             {
117.                 case CHARTEVENT_CUSTOM + evMsgSetFocus:
118.                     macro_LineInFocus((m_Info.ticket == (ulong)(lparam)) && ((EnumEvents)(dparam) == m_Info.ev));
119.                     m_Info.bClick = false;
120.                 case CHARTEVENT_CHART_CHANGE:
121.                     UpdateViewPort();
122.                     break;
123.                 case CHARTEVENT_OBJECT_CLICK:
124.                     sz0 = GetPositionsMouse().szObjNameClick;
125.                     if (m_Info.bClick) switch (m_Info.ev)
126.                     {
127.                         case evMsgClosePositionEA:
128.                             if (sz0 == def_NameBtnClose)
129.                                 EventChartCustom(0, evMsgClosePositionEA, m_Info.ticket, 0, "");
130.                             break;
131.                         case evMsgCloseTakeProfit:
132.                             if (sz0 == def_NameBtnClose)
133.                                 EventChartCustom(0, evMsgCloseTakeProfit, m_Info.ticket, PositionGetDouble(POSITION_SL), PositionGetString(POSITION_SYMBOL));
134.                             else if (sz0 == def_NameBtnMove)
135.                                 EventChartCustom(0, evMsgSetFocus, m_Info.ticket, evMsgCloseTakeProfit, "");
136.                             break;
137.                         case evMsgCloseStopLoss:
138.                             if (sz0 == def_NameBtnClose)
139.                                 EventChartCustom(0, evMsgCloseStopLoss, m_Info.ticket, PositionGetDouble(POSITION_TP), PositionGetString(POSITION_SYMBOL));
140.                             else if (sz0 == def_NameBtnMove)
141.                                 EventChartCustom(0, evMsgSetFocus, m_Info.ticket, evMsgCloseStopLoss, "");
142.                             break;
143.                     }
144.                     m_Info.bClick = false;
145.                     break;
146.                 case CHARTEVENT_MOUSE_MOVE:
147.                     m_Info.bClick = (CheckClick(C_Mouse::eClickLeft) ? true : m_Info.bClick);
148.                     if (m_Info.bClick && (m_Info.weight > 1))
149.                     {
150.                         switch (m_Info.ev)
151.                         {
152.                             case evMsgCloseTakeProfit:
153.                                 EventChartCustom(0, evMsgNewTakeProfit, m_Info.ticket, GetPositionsMouse().Position.Price, PositionGetString(POSITION_SYMBOL));
154.                                 break;
155.                             case evMsgCloseStopLoss:
156.                                 EventChartCustom(0, evMsgNewStopLoss, m_Info.ticket, GetPositionsMouse().Position.Price, PositionGetString(POSITION_SYMBOL));
157.                                 break;
158.                         }
159.                         EventChartCustom(0, evMsgSetFocus, 0, 0, "");
160.                     }
161.                     break;
162.             }
163.         }
164. //+------------------------------------------------------------------+
165. };
166. //+------------------------------------------------------------------+
167. #undef macro_LineInFocus
168. //+------------------------------------------------------------------+
169. #undef def_Btn_Close
170. #undef def_PathBtns
171. //+------------------------------------------------------------------+
172. #undef def_NameBtnMove
173. #undef def_NameBtnClose
174. #undef def_NameHLine
175. //+------------------------------------------------------------------+

C_ElementsTrade.mqh

Das Ergebnis wird in der folgenden Animation gezeigt.

Beachten Sie, dass das System nun einwandfrei funktioniert, genau wie erwartet. Da der Code einige Änderungen erfahren hat – von denen viele nur sehr geringfügig sind –, besteht keine Notwendigkeit, diese gesondert hervorzuheben. Ich möchte Sie jedoch, lieber Leser, bitten, zwei Punkte in diesem Code besonders zu beachten. Der erste Punkt ist der Konstruktor. Beachten Sie, dass er sich geringfügig von der vorherigen Version unterscheidet. Die zweite Prozedur heißt „UpdatePrice“. Beachten Sie, dass sich die Prozeduren zur Objekterstellung, die zuvor im Konstruktor enthalten waren, nun in dieser Prozedur befinden. Da der Code recht einfach ist, besteht kein Grund, näher darauf einzugehen. Im Grunde wurde lediglich das, was zuvor im Konstruktor ausgeführt wurde, entfernt und in diese Prozedur verschoben. Nichts Besonderes.

Ich möchte Sie jedoch bitten, sich auf etwas anderes zu konzentrieren – nämlich auf die obige Animation. Antworten Sie mir ehrlich. Wenn Sie als Trader versuchen würden, das System zu nutzen, das wir gerade implementiert haben, würden Sie dann beim Anpassen der Take-Profit- oder Stop-Loss-Niveaus zögern? Wissen Sie, ob Sie die Linie mit dem Mauszeiger zu einem höheren oder niedrigeren Preis verschieben müssen, um die Preislinie erneut auf dem Server zu platzieren? Vielleicht war die letzte Frage nicht klar genug formuliert. Versuchen wir, die Situation ein wenig zu klären, damit Sie verstehen, welches Problem wir noch lösen müssen.

Schon beim Betrachten der Animation wird deutlich, dass wir eine Short-Position halten. Das liegt daran, dass die Take-Profit-Linie unter dem Eröffnungspreis der Position liegt. Gut, aber nehmen wir einmal an, Sie hätten als Trader beide Linien aus dem Chart entfernt. Oder, genauer gesagt, dass Sie sie aus der auf dem Server gespeicherten Position entfernt haben. Wenn Sie in diesem Fall dieselbe Animation betrachten und sich ausschließlich auf den Positionsindikator konzentrieren würden, könnten Sie nicht erkennen, ob es sich um eine Short- oder eine Long-Position handelt. Das ist der erste Punkt.

Der zweite Punkt ist folgender: Wenn wir verkauft haben und die Take-Profit- und Stop-Loss-Werte für die Position nicht festgelegt sind – sich also beide Objekte, mit denen die Preislinie verschoben werden kann, am Eröffnungspreis befinden –, wie könnten Sie dann allein anhand des Charts feststellen, ob die Stop-Loss-Linie über oder unter dem aktuellen Preis platziert werden sollte? Das ist eine schwer zu beantwortende Frage, nicht wahr? Wir haben jedoch eine recht einfache Lösung für dieses Problem. Wie Sie sehen können, greifen wir in der Klasse „C_ElementsTrade“ zu keinem Zeitpunkt auf die Positionsdaten zu. Die Daten stammen aus der Klasse „C_IndicatorPosition“. Und ich möchte die Klasse „C_ElementsTrade“ nicht mit Daten überladen, die ich später wieder daraus entfernen müsste. Das liegt daran, dass wir diese Klasse auch bei der Arbeit mit ausstehenden Orders verwenden werden. Also müssen wir uns noch ein bisschen mehr Mühe geben. Darauf werden wir im nächsten Artikel eingehen.


Abschließende Gedanken

In diesem Artikel habe ich Ihnen gezeigt, wie Sie den Positionsindikator so anpassen können, dass er mit minimalem Aufwand viel mehr Aktionen ausführen kann als ursprünglich möglich. Wir haben gesehen, wie sich die Möglichkeit implementieren lässt, Preisniveaus zu verschieben und Preislinien direkt im Chart zu erstellen. Vielen mag das schwierig erscheinen. Wie Sie vielleicht bemerkt haben, haben wir das alles jedoch ganz einfach und mit minimalem Aufwand erledigt. Man musste nur einen Moment innehalten und nachdenken.

Genau das ist der Zweck dieser Artikelserie. Ich bin nicht hier, um Ihnen beizubringen, wie man Anwendungen entwickelt. Das Programmierenlernen wird jedoch viel interessanter, wenn wir erkennen, dass wir etwas Neues erschaffen. Ich hoffe, dass Sie den Zweck dieser Artikel verstehen und dass sie Ihnen eine solide theoretische Grundlage bieten und Sie zum Weiterlernen motivieren. Schließlich gibt es keine unlösbaren Probleme; es gibt nur Menschen, die keine einfache Lösung für komplexe Probleme erkennen können.

Datei Beschreibung
Experts\Expert Advisor.mq5
Zeigt die Interaktion zwischen Chart Trade und dem Expert Advisor im Chart an. (Für diese Interaktion ist Mouse Study erforderlich.)
Indicators\Chart Trade.mq5 Erstellt ein Fenster zur Konfiguration der zu sendenden Order. (Für diese Interaktion ist „Mouse Study“ erforderlich.)
Indicators\Market Replay.mq5 Erstellt Steuerelemente für die Interaktion mit dem Dienst zur Marktwiedergabe und Marktsimulation. (Für die Interaktion ist Mouse Study erforderlich.)
Indicators\Mouse Study.mq5 Ermöglicht die Interaktion mit grafischen Steuerelementen und mit dem Benutzer. (Dies ist sowohl für das System zur Marktwiedergabe und Marktsimulation als auch für den Live-Handel erforderlich.)
Indicators\Order Indicator.mq5 Ist für die Anzeige von Marktorders zuständig und ermöglicht es den Benutzern, mit diesen zu interagieren und sie zu verwalten.
Indicators\Position View.mq5 Ist für die Anzeige von Marktpositionen zuständig und ermöglicht es den Benutzern, mit diesen zu interagieren und sie zu steuern.
Services\Market Replay.mq5 Erstellt und verwaltet den Dienst zur Marktwiedergabe und Marktsimulation. (Hauptdatei des Systems)

Übersetzt aus dem Portugiesischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/pt/articles/13295

Beigefügte Dateien |
Anexo.zip (779.24 KB)
Die Übertragung der Trading-Signale in einem universalen Expert Advisor. Die Übertragung der Trading-Signale in einem universalen Expert Advisor.
In diesem Artikel wurden die verschiedenen Möglichkeiten beschrieben, um die Trading-Signale von einem Signalmodul des universalen EAs zum Steuermodul der Positionen und Orders zu übertragen. Es wurden die seriellen und parallelen Interfaces betrachtet.
Von den Grundlagen zur Mittelstufe: Warteschlangen, Listen und Bäume (III) Von den Grundlagen zur Mittelstufe: Warteschlangen, Listen und Bäume (III)
In diesem Artikel werden wir den nächsten Schritt unternehmen, um zu verstehen, was eine verkettete Liste ist und wie sie funktioniert. Auch wenn der Inhalt dieses Artikels für Anfänger vielleicht recht komplex und verwirrend erscheint, werde ich versuchen, ihn so einfach wie möglich zu erklären. So können Sie besser verstehen, warum und wann man verkettete Listen verwendet.
Eine alternative Log-datei mit der Verwendung der HTML und CSS Eine alternative Log-datei mit der Verwendung der HTML und CSS
In diesem Artikel werden wir eine sehr einfache, aber leistungsfähige Bibliothek zur Erstellung der HTML-Dateien schreiben, dabei lernen wir auch, wie man eine ihre Darstellung einstellen kann (nach seinem Geschmack) und sehen wir, wie man es leicht in seinem Expert Advisor oder Skript hinzufügen oder verwenden kann.
Neuronale Netze im Handel: Robuste Handelssignale in jedem Marktregime (Attention-Module) Neuronale Netze im Handel: Robuste Handelssignale in jedem Marktregime (Attention-Module)
In diesem Artikel setzen wir die Umsetzung der Ansätze des ST-Expert-Frameworks fort und konzentrieren uns dabei auf die praktischen Aspekte ihrer Anwendung mit MQL5. Zuvor haben wir die theoretischen Grundlagen und die wichtigsten Komponenten des Modells untersucht; nun wenden wir uns der direkten Arbeit mit Graph-Attention-Algorithmen sowie der lokalen und globalen Attention-Verteilung zu. Das Hauptziel dieser Arbeit besteht darin, aufzuzeigen, wie die konzeptionellen Ideen von ST-Expert in praxistaugliche Lösungen zur Analyse und Prognose von Finanzzeitreihen umgesetzt werden.