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

Marktsimulation: Positionsansicht (IX)

MetaTrader 5 — Tester |
19 0
Daniel Jose
Daniel Jose

Einleitung

Hallo, liebe Leser! Willkommen zu einem neuen Artikel über die Entwicklung eines Wiedergabe- und Simulationssystems.

Im vorherigen Artikel „Marktsimulation: Positionsansicht (VIII)“ haben wir gezeigt, wie dies umgesetzt werden kann – oder, genauer gesagt, wie wir den Code des Positionsindikators so anpassen sollten, dass er durch Interaktion Take-Profit- und Stop-Loss-Linien entfernen kann und es uns zudem ermöglicht, eine Position ganz einfach zu schließen. Für diejenigen, die diese Serie verfolgt haben, dürfte es nicht schwer sein zu verstehen, was hier genau umgesetzt wird. Bislang haben wir jedoch noch nichts im Hinblick auf die Handelssimulation unternommen. Aber machen Sie sich darüber vorerst keine Gedanken. Wir bewegen uns in diese Richtung, auch wenn das nicht immer offensichtlich ist.

Nun stehen wir vor einem Problem, das einerseits ziemlich unangenehm, andererseits aber sehr interessant ist. Das Problem ist Folgendes: Wie können wir die Take-Profit- und Stop-Loss-Linien wiederherstellen, nachdem sie gelöscht wurden, und zwar ohne das Terminal zu verwenden, indem wir den Vorgang direkt im Chart durchführen? Auf den ersten Blick scheint es ganz einfach zu sein. Allerdings gibt es einige Hindernisse, die überwunden werden müssen.


Die Lösung des Problems durchdenken

Im Grunde lässt sich dieses Problem wie folgt lösen: Durch Klicken auf die Preislinie im Chart können wir dem Chart eine neue Linie hinzufügen. Diese Linie kann dann auf das gewünschte Niveau gezogen werden, und sobald sie losgelassen wird, sollte der Expert Advisor erkennen, dass genau dort die Take-Profit- oder Stop-Loss-Linie liegen soll. Im Grunde genommen ist das schon alles. Im Übrigen ist das ganz einfach.

Aber lassen Sie uns noch ein wenig genauer über diesen Ansatz nachdenken. Zunächst müssen wir ein System hinzufügen oder implementieren, das die Linie korrekt verschieben kann, da es hier nicht darum geht, sie einfach wahllos zu verschieben. Beachten Sie, dass der Preis, bei dem die Linie losgelassen wird, bestimmte Kriterien erfüllen muss, damit der Handelsserver die vom Expert Advisor gesendete Anfrage nicht ablehnt. Das Problem an dieser Stelle besteht darin, dass jede Anlageklasse eine bestimmte Tickgröße haben kann. In manchen Fällen kann der Wert 0,01 Dollar betragen, in anderen 0,50 Dollar und in manchen Situationen 0,20 Dollar. Auf den ersten Blick scheint das sehr kompliziert zu sein, aber glücklicherweise haben wir bereits eine Lösung für dieses Problem umgesetzt. Dies wurde bereits im Mausindikator umgesetzt. Wir müssen uns also keine Gedanken mehr über Preisanpassungen machen. Wir müssen lediglich die Position des Mausindikators ablesen und diesen Punkt als Wert verwenden, der an den Expert Advisor übergeben werden soll. Auf diese Weise weiß der Expert Advisor, welchen Kurs er an den Handelsserver senden muss, um die Stop-Loss- oder Take-Profit-Linie zu erstellen. Gut, damit haben wir ein Problem weniger.

Aber es gibt noch weitere Probleme, die analysiert und gelöst werden müssen. Die nächste Frage ist, welche Linie erstellt wird, wenn für diese Position beide Linien fehlen. In dieser Anfangsphase ist dieses Problem eines der interessantesten. Der Punkt ist: Wenn eine Long-Position offen ist und wir die Linie auf einen höheren Kurs ziehen, können wir sie als Take-Profit-Linie definieren. Wenn wir die Linie hingegen bei einer Short-Position auf dieselbe Weise ziehen, also in Richtung eines höheren Kurses, können wir sie als Stop-Loss-Linie definieren. Das Gleiche gilt auch für Bewegungen in die entgegengesetzte Richtung: In diesem Fall wird die Linie entweder als Stop-Loss-Linie oder als Take-Profit-Linie interpretiert. Wir können aber auch den aktuellen Marktpreis heranziehen. Mit anderen Worten: Wenn wir eine Linie für eine Long-Position bis zu einem Punkt oberhalb des aktuellen Marktpreises ziehen, ordnen wir sie als Take-Profit-Linie ein. Wenn es sich um eine Short-Position handeln würde, würden wir einen Stop-Loss festlegen. Wird die Linie jedoch – selbst bei einer Long-Position – unter den aktuellen Handelskurs verschoben, ordnen wir sie als Stop-Loss ein. Und wenn es sich um eine Short-Position handeln würde, würden wir sie als Take-Profit-Linie einordnen.

Diese Erklärung hat Sie vielleicht ein wenig verwirrt, lieber Leser. Es ist jedoch von entscheidender Bedeutung, zu verstehen, was ich zu erklären versuche, um nachzuvollziehen, warum ich mich dafür entscheide, das System auf die eine oder andere Weise zu implementieren. Es gibt nicht den einen richtigen Weg, dies zu tun. Es gibt nur eine Methode, die zu dem passt, was ich entwickeln möchte. Sollten Sie jedoch aus dem einen oder anderen Grund anders vorgehen wollen, müssen Sie verstehen, was ich hier erkläre, da Sie das System auf diese Weise konsistenter und unkomplizierter umsetzen können.

Doch trotz dieser offenbar verwirrenden Erklärung gibt es dabei noch ein weiteres kleines Problem. Um die Erklärung verständlicher zu machen, stellen Sie sich bitte einmal kurz folgende Situation vor: Als Trader handeln Sie ein beliebiges Symbol und beschließen, es zu einem Kurs von beispielsweise 100 Dollar zu kaufen. Die Order wurde also mithilfe des Indikators Chart Trade als Marktorder gesendet. Der Expert Advisor sendet dann eine Anfrage, bei der die Take-Profit- und Stop-Loss-Linien bereits festgelegt sind. Nach einer Weile beschließen Sie, diese Linien zu löschen. Dazu verwenden Sie die in den vorherigen Artikeln implementierten Schaltflächen zusammen mit dem Positionsindikator. Okay, der Expert Advisor hat Ihre Anfrage verstanden und einen Befehl an den Handelsserver gesendet, die Take-Profit- und Stop-Loss-Niveaus zu löschen. Jetzt haben wir das gewünschte Szenario. Mit anderen Worten: eine offene Position ohne Take-Profit- oder Stop-Loss-Linien. An dieser Stelle möchte ich, dass Sie darüber nachdenken und versuchen, meinem Gedankengang logisch zu folgen.

Nehmen wir einmal an, der Preis sei auf 150 Dollar gestiegen. Sie entscheiden, dass es an der Zeit ist, einen Stop-Loss zu setzen. Diese Linie wird der Position zugeordnet; es handelt sich nicht um eine neue Order, die ins Orderbuch eingetragen wird und darauf wartet, dass der Kurs wieder auf das entsprechende Niveau zurückkehrt. Das ist wichtig, weil es sich um unterschiedliche Situationen handelt. Was müssen Sie als Trader also tun, um einer Position eine Stop-Loss-Linie hinzuzufügen? Für einen Trader ist es ganz selbstverständlich, auf die Positionslinie zu klicken und sie zu ziehen. Super. Aber wohin sollen Sie die Linie ziehen, und auf welches Preisniveau? Das ist das Problem. Aber lassen Sie uns die Sache ein wenig vereinfachen. Als Trader planen Sie, den Stop-Loss bei 140 Dollar zu setzen. Gut, genau das möchten Sie als Trader tun. Aber wie wollen Sie das machen? Oder, um es genauer zu sagen: Wie sollten Sie als Programmierer dies umsetzen? Und genau da fangen die Schwierigkeiten erst an. Denn wenn Sie als Programmierer solche Situationen nicht richtig einplanen, können selbst Ihnen bei der Nutzung eines selbst implementierten Systems Fehler unterlaufen – obwohl Sie das Programm selbst geschrieben haben.

Einfach ausgedrückt: Wenn Sie ein System implementiert haben, bei dem Sie zunächst auf die horizontale Preislinie bei 100 Dollar klicken, die Maus beispielsweise auf einen Kurs von 90 Dollar ziehen und die Maustaste loslassen müssen, damit der Expert Advisor versteht, dass er eine Anfrage zum Erstellen einer Stop-Loss-Linie an den Handelsserver senden muss, und erst danach dieselbe Linie bei 90 Dollar greifen und auf 140 Dollar ziehen können, machen Sie möglicherweise einen Fehler, wenn Sie die Linie direkt von 100 auf 140 Dollar ziehen. Das liegt daran, dass der Expert Advisor dies als Aufforderung zum Erstellen einer Take-Profit-Linie interpretiert und nicht, wie man erwarten würde, als Aufforderung zum Erstellen einer Stop-Loss-Linie.

Anscheinend sollte das kein großes Problem darstellen, da diese Preislinie absolut nichts bedeutet. An dieser Stelle müssen wir kurz abschweifen, um etwas zu erklären. Was viele Händler für wahr halten, ist in Wirklichkeit nichts weiter als ein großes Missverständnis. Take-Profit- und Stop-Loss-Linien – NEIN, und ich sage es noch einmal: SIE SIND NICHT DER ORT, AN DEM ALLES PASSIERT. Die Position wird dann und nur dann geschlossen, wenn ein Handelsgeschäft zu genau diesem Kurs ausgeführt wird. Und das dort ausgeführte Handelsvolumen muss ausreichen, um alle Lots auszuführen, bevor sich der Kurs ändert. Ändert sich der Kurs, bevor das gesamte dort verfügbare Volumen ausgeführt wurde, wird die Order übersprungen. Mit anderen Worten: Die Position bleibt offen. Dies ist ein ziemlich ernstes Problem, von dem viele weniger erfahrene Trader betroffen sind, da viele von ihnen Handelsroboter einsetzen und davon ausgehen, dass Take-Profit- und Stop-Loss-Orders immer ausgelöst werden, ohne dass sie durch Kursbewegungen übersprungen werden.

In einer unserer früheren Artikelserien haben wir ähnliche Probleme erläutert. Falls Sie diese Reihe noch nicht gelesen haben, empfehle ich Ihnen die Lektüre ausdrücklich. Dies sind 15 relativ einfache Artikel, in denen ich erkläre, wie man einen Expert Advisor entwickelt, der zu 100 % automatisch arbeitet. In dieser Artikelserie zeige ich, wie man dieses konkrete Problem übersprungener Orders löst. In dieser Phase der Entwicklung des Wiedergabe- und Simulationssystems kann Ihnen die Reihe dabei helfen, auch andere Lösungen in Betracht zu ziehen. Beispielsweise durch die Verwendung einer Gegenorder mit demselben Volumen, die in jedem Fall ausgeführt würde, selbst wenn der Kurs das Preisniveau der Order überspringt, da sie als Marktorder ausgeführt würde. Den ersten Artikel dieser Reihe finden Sie unter folgendem Link:

So erstellen Sie einen Expert Advisor, der automatisch arbeitet (Teil 01): Konzepte und Strukturen

Da eine Order übersprungen werden kann, habe ich gesagt, dass wir eine Umsetzung nicht in Betracht ziehen können, bei der der Stop-Loss oder Take-Profit eine im Orderbuch platzierte Gegenorder ist. Stimmt, denn das würde den Ansatz zur Lösung des Problems völlig verändern. Ich weiß also nicht, ob Sie, lieber Leser, vollständig verstanden haben, was umgesetzt werden muss. Meine Lösung für dieses Problem ist einfach. Warum sollten wir die Dinge komplizieren, wenn wir dem Trader oder Nutzer die Möglichkeit geben können, im Voraus festzulegen, ob es sich bei der zu verschiebenden Linie um eine Stop-Loss-Linie oder eine Take-Profit-Linie handelt? In einer früheren Artikelserie habe ich bereits gezeigt, wie das umgesetzt wurde. Damals hatte diese Artikelserie jedoch einen anderen Schwerpunkt. Ich hätte nie gedacht, dass sie auch von Menschen genutzt werden könnte, die gerade erst mit dem Programmieren anfangen. Obwohl die Umsetzung damals funktionierte, half die Erklärung in den Artikeln also denjenigen überhaupt nicht weiter, die lernen wollten, selbst etwas auf der Grundlage dieses Systems zu entwickeln.

Glücklicherweise hat sich diese Herangehensweise inzwischen geändert. An dieser Stelle, lieber Leser, möchte ich, dass Sie erfahren und verstehen, warum die Umsetzung auf die eine oder andere Weise erfolgt. Aber vor allem möchte ich, dass Sie sich mit dem Stoff auseinandersetzen und mithilfe des Wissens, das ich Ihnen vermitteln möchte, Ihre eigenen Lösungen entwickeln.

Na gut, dann fangen wir mal an. In allen oben beschriebenen Situationen ist eines ganz klar geworden: Wir müssen einen Weg finden, die Linien auf dem Chart durch Ziehen zu verschieben. Schon durch einfaches Ziehen können wir die Werte der Take-Profit- und Stop-Loss-Niveaus ändern. Daher müssen wir zum jetzigen Zeitpunkt mit der Umsetzung beginnen. Also können wir nun zum nächsten Thema übergehen.


Vorbereitung auf das Verschieben von Preislinien

Um die Preislinien verschieben zu können (und wenn ich im Positionsindikator von „Preislinien“ spreche, meine ich damit die Stop-Loss- und Take-Profit-Linien), müssen wir zunächst ein neues Ereignis zum System hinzufügen. Das ist ganz einfach, wie im Folgenden gezeigt wird:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #define def_VERSION_DEBUG
05. //+------------------------------------------------------------------+
06. #ifdef def_VERSION_DEBUG
07.     #define macro_DEBUG_MODE(A) \
08.                     Print(__FILE__, " ", __LINE__, " ", __FUNCTION__ + " " + #A + " = " + (string)(A));
09. #else
10.     #define macro_DEBUG_MODE(A)
11. #endif
12. //+------------------------------------------------------------------+
13. #define def_SymbolReplay          "RePlay"
14. #define def_MaxPosSlider          400
15. #define def_MaskTimeService       0xFED00000
16. #define def_IndicatorTimeFrame    (_Period < 60 ? _Period : (_Period < PERIOD_D1 ? _Period - 16325 : (_Period == PERIOD_D1 ? 84 : (_Period == PERIOD_W1 ? 91 : 96))))
17. #define def_IndexTimeFrame        4
18. //+------------------------------------------------------------------+
19. union uCast_Double
20. {
21.     double   dValue;
22.     long     _long;                                  // 1 Information
23.     datetime _datetime;                              // 1 Information
24.     uint     _32b[sizeof(double) / sizeof(uint)];    // 2 Informations
25.     ushort   _16b[sizeof(double) / sizeof(ushort)];  // 4 Informations
26.     uchar    _8b [sizeof(double) / sizeof(uchar)];   // 8 Informations
27. };
28. //+------------------------------------------------------------------+
29. enum EnumEvents     {
30.             evTicTac,                        //Event of tic-tac
31.             evHideMouse,                     //Hide mouse price line
32.             evShowMouse,                     //Show mouse price line
33.             evHideBarTime,                   //Hide bar time
34.             evShowBarTime,                   //Show bar time
35.             evHideDailyVar,                  //Hide daily variation
36.             evShowDailyVar,                  //Show daily variation
37.             evHidePriceVar,                  //Hide instantaneous variation
38.             evShowPriceVar,                  //Show instantaneous variation
39.             evCtrlReplayInit,                //Initialize replay control
40.             evChartTradeBuy,                 //Market buy event
41.             evChartTradeSell,                //Market sales event 
42.             evChartTradeCloseAll,            //Event to close positions
43.             evChartTrade_At_EA,              //Event to communication
44.             evEA_At_ChartTrade,              //Event to communication
45.             evChatWriteSocket,               //Event to Mini Chat
46.             evChatReadSocket,                //Event To Mini Chat
47.             evUpdate_Position,               //Event to communication
48.             evMsgClosePositionEA,            //Event to communication
49.             evMsgCloseTakeProfit,            //Event to communication
50.             evMsgCloseStopLoss,              //Event to communication
51.             evMsgNewTakeProfit,              //Event to communication
52.             evMsgNewStopLoss                 //Event to communication
53.                         };
54. //+------------------------------------------------------------------+
55. enum EnumPriority {                          //Priority list on objects
56.             ePriorityNull = -1,
57.             ePriorityDefault = 0,
58.             ePriorityChartTrade = 5,
59.             ePriorityOrders = 10
60.                         };
61. //+------------------------------------------------------------------+

Defines.mqh

Bitte beachten Sie, dass zwei neue Ereignisse zur Liste hinzugefügt wurden. Das wird uns bei der Interaktion zwischen dem Positionsindikator und dem Expert Advisor helfen. Sobald wir das erledigt haben, können wir uns der Klasse „C_Orders“ im Expert Advisor zuwenden und diese beiden Ereignisse implementieren. Der neue Klassencode sieht somit wie folgt aus:

001. //+------------------------------------------------------------------+
002. #property copyright "Daniel Jose"
003. //+------------------------------------------------------------------+
004. #include "..\Defines.mqh"
005. //+------------------------------------------------------------------+
006. class C_Orders
007. {
008.     protected:
009. //+------------------------------------------------------------------+
010. inline const ulong GetMagicNumber(void) const { return m_Base.MagicNumber; }
011. //+------------------------------------------------------------------+
012.         bool ClosePosition(const ulong ticket)
013.             {
014.                 bool   IsBuy;
015.                 string szContract;
016.                 
017.                 if  (!PositionSelectByTicket(ticket)) return false;
018.                 IsBuy = PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY;
019.                 szContract = PositionGetString(POSITION_SYMBOL);
020.                 ZeroMemory(m_Base.TradeRequest);
021.                 m_Base.TradeRequest.action    = TRADE_ACTION_DEAL;
022.                 m_Base.TradeRequest.type      = (IsBuy ? ORDER_TYPE_SELL : ORDER_TYPE_BUY);
023.                 m_Base.TradeRequest.price     = NormalizeDouble(SymbolInfoDouble(szContract, (IsBuy ? SYMBOL_BID : SYMBOL_ASK)), (int)SymbolInfoInteger(szContract, SYMBOL_DIGITS));
024.                 m_Base.TradeRequest.position  = ticket;
025.                 m_Base.TradeRequest.symbol    = szContract;
026.                 m_Base.TradeRequest.volume    = PositionGetDouble(POSITION_VOLUME);
027.                 m_Base.TradeRequest.deviation = 1000;
028.                 
029.                 return SendToPhysicalServer() != 0;
030.             };
031. //+------------------------------------------------------------------+    
032.     private    :
033. //+------------------------------------------------------------------+
034.         struct stBase
035.         {
036.             MqlTradeRequest TradeRequest;
037.             ulong           MagicNumber;
038.             bool            bTrash;
039.         }m_Base;
040. //+------------------------------------------------------------------+
041.         struct stChartTrade
042.         {
043.             struct stEvent
044.             {
045.                 EnumEvents  ev;
046.                 string      szSymbol,
047.                             szContract;
048.                 bool        IsDayTrade;
049.                 ushort      Leverange;
050.                 double      PointsTake,
051.                             PointsStop;
052.             }Data;
053. //---
054.             bool Decode(const EnumEvents ev, const string sparam)
055.                 {
056.                     string Res[];
057.         
058.                     if (StringSplit(sparam, '?', Res) != 7) return false;
059.                     stEvent loc = {(EnumEvents) StringToInteger(Res[0]), Res[1], Res[2], (bool)(Res[3] == "D"), (ushort) StringToInteger(Res[4]), StringToDouble(Res[5]), StringToDouble(Res[6])};
060.                     if ((ev == loc.ev) && (loc.szSymbol == _Symbol)) Data = loc;
061.                     else return false;
062.                     
063.                     return true;
064.                 }
065. //---
066.         }m_ChartTrade;
067. //+------------------------------------------------------------------+
068.         ulong SendToPhysicalServer(void)
069.             {
070.                 MqlTradeCheckResult  TradeCheck;
071.                 MqlTradeResult       TradeResult;
072.                 
073.                 ZeroMemory(TradeCheck);
074.                 ZeroMemory(TradeResult);
075.                 if (!OrderCheck(m_Base.TradeRequest, TradeCheck))
076.                 {
077.                     PrintFormat("Order System - Check Error: %d", GetLastError());
078.                     return 0;
079.                 }
080.                 m_Base.bTrash = OrderSend(m_Base.TradeRequest, TradeResult);
081.                 if (TradeResult.retcode != TRADE_RETCODE_DONE)
082.                 {
083.                     PrintFormat("Order System - Send Error: %d", TradeResult.retcode);
084.                     return 0;
085.                 };
086.                 
087.                 return TradeResult.order;
088.             }
089. //+------------------------------------------------------------------+    
090.         ulong ToMarket(const ENUM_ORDER_TYPE type)
091.             {
092.                 double price  = SymbolInfoDouble(m_ChartTrade.Data.szContract, (type == ORDER_TYPE_BUY ? SYMBOL_ASK : SYMBOL_BID));
093.                 double vol    = SymbolInfoDouble(m_ChartTrade.Data.szContract, SYMBOL_VOLUME_STEP);
094.                 uchar  nDigit = (uchar)SymbolInfoInteger(m_ChartTrade.Data.szContract, SYMBOL_DIGITS);
095.                 
096.                 ZeroMemory(m_Base.TradeRequest);
097.                 m_Base.TradeRequest.magic         = m_Base.MagicNumber;
098.                 m_Base.TradeRequest.symbol        = m_ChartTrade.Data.szContract;
099.                 m_Base.TradeRequest.price         = NormalizeDouble(price, nDigit);
100.                 m_Base.TradeRequest.action        = TRADE_ACTION_DEAL;
101.                 m_Base.TradeRequest.sl            = NormalizeDouble(m_ChartTrade.Data.PointsStop == 0 ? 0 : price + (m_ChartTrade.Data.PointsStop * (type == ORDER_TYPE_BUY ? -1 : 1)), nDigit);
102.                 m_Base.TradeRequest.tp            = NormalizeDouble(m_ChartTrade.Data.PointsTake == 0 ? 0 : price + (m_ChartTrade.Data.PointsTake * (type == ORDER_TYPE_BUY ? 1 : -1)), nDigit);
103.                 m_Base.TradeRequest.volume        = NormalizeDouble(vol + (vol * (m_ChartTrade.Data.Leverange - 1)), nDigit);
104.                 m_Base.TradeRequest.type          = type;
105.                 m_Base.TradeRequest.type_time     = (m_ChartTrade.Data.IsDayTrade ? ORDER_TIME_DAY : ORDER_TIME_GTC);
106.                 m_Base.TradeRequest.stoplimit     = 0;
107.                 m_Base.TradeRequest.expiration    = 0;
108.                 m_Base.TradeRequest.type_filling  = ORDER_FILLING_RETURN;
109.                 m_Base.TradeRequest.deviation     = 1000;
110.                 m_Base.TradeRequest.comment       = "Order Generated by Experts Advisor.";
111. 
112.                 MqlTradeRequest TradeRequest[1];
113. 
114.                 TradeRequest[0] = m_Base.TradeRequest;
115.                 ArrayPrint(TradeRequest);
116. 
117.                 return (((type == ORDER_TYPE_BUY) || (type == ORDER_TYPE_SELL)) ? SendToPhysicalServer() : 0);
118.             };
119. //+------------------------------------------------------------------+
120.         void CloseAllsPosition(void)
121.             {
122.                 for (int count = PositionsTotal() - 1; count >= 0; count--)
123.                 {
124.                     if (PositionGetSymbol(count) != m_ChartTrade.Data.szContract) continue;
125.                     if (PositionGetInteger(POSITION_MAGIC) != m_Base.MagicNumber) continue;
126.                     ClosePosition(PositionGetInteger(POSITION_TICKET));
127.                 }
128.             };
129. //+------------------------------------------------------------------+    
130.         void ModifyValueSLTP(const ulong ticket, const string symbol, const double sl, const double tp)
131.             {
132.                 ZeroMemory(m_Base.TradeRequest);            
133.                 MqlTradeRequest TradeRequest[1];
134. 
135.                 if ((sl < 0) || (tp < 0)) if (!PositionSelectByTicket(ticket)) return;
136.                 m_Base.TradeRequest.magic     = m_Base.MagicNumber;
137.                 m_Base.TradeRequest.action    = TRADE_ACTION_SLTP;
138.                 m_Base.TradeRequest.symbol    = symbol;
139.                 m_Base.TradeRequest.position  = ticket;
140.                 m_Base.TradeRequest.sl        = (sl < 0 ? PositionGetDouble(POSITION_SL) : sl);
141.                 m_Base.TradeRequest.tp        = (tp < 0 ? PositionGetDouble(POSITION_TP) : tp);
142.                 
143.                 TradeRequest[0] = m_Base.TradeRequest;
144.                 ArrayPrint(TradeRequest);
145.                 
146.                 SendToPhysicalServer();
147.             }
148. //+------------------------------------------------------------------+    
149.     public    :
150. //+------------------------------------------------------------------+
151.         C_Orders(const ulong magic)
152.             {
153.                 m_Base.MagicNumber = magic;
154.             }
155. //+------------------------------------------------------------------+    
156.         void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam)
157.             {
158.                 switch (id)
159.                 {
160.                     case CHARTEVENT_CUSTOM + evChartTradeBuy     :
161.                     case CHARTEVENT_CUSTOM + evChartTradeSell    :
162.                     case CHARTEVENT_CUSTOM + evChartTradeCloseAll:
163.                         if (m_ChartTrade.Decode((EnumEvents)(id - CHARTEVENT_CUSTOM), sparam)) switch (m_ChartTrade.Data.ev)
164.                         {
165.                             case evChartTradeBuy:
166.                                 ToMarket(ORDER_TYPE_BUY);
167.                                 break;
168.                             case evChartTradeSell:
169.                                 ToMarket(ORDER_TYPE_SELL);
170.                                 break;
171.                             case evChartTradeCloseAll:
172.                                 CloseAllsPosition();
173.                                 break;
174.                         }
175.                         break;
176.                     case CHARTEVENT_CUSTOM + evMsgClosePositionEA:
177.                         ClosePosition((ulong)(lparam));
178.                         break;
179.                     case CHARTEVENT_CUSTOM + evMsgCloseTakeProfit:
180.                         ModifyValueSLTP((ulong)(lparam), sparam, dparam, 0);
181.                         break;
182.                     case CHARTEVENT_CUSTOM + evMsgCloseStopLoss:
183.                         ModifyValueSLTP((ulong)(lparam), sparam, 0, dparam);
184.                         break;
185.                     case CHARTEVENT_CUSTOM + evMsgNewTakeProfit:
186.                         ModifyValueSLTP((ulong)(lparam), sparam, -1, dparam);
187.                         break;
188.                     case CHARTEVENT_CUSTOM + evMsgNewStopLoss:
189.                         ModifyValueSLTP((ulong)(lparam), sparam, dparam, -1);
190.                         break;
191.                 }
192.             }
193. //+------------------------------------------------------------------+    
194. };
195. //+------------------------------------------------------------------+

C_Orders.mqh

Es mag sinnlos erscheinen, den gesamten Klassencode anzugeben, da die Änderungen nur einen Teil davon betrafen. Aber das ist kein Problem; schauen wir uns die Änderungen einmal an. Bitte beachten Sie, dass wir in den Zeilen 185 und 188 die neuen Ereignisse genau auf diese Weise implementiert haben, damit der Expert Advisor weiß, wie er damit umgehen muss. Beachten Sie bitte: Wir haben genau dieselbe Prozedur wie zuvor verwendet, nämlich „ModifyValueSLTP“. Im Gegensatz zu früher übergeben wir nun jedoch in einem der Felder einen negativen Wert. Der neue Wert des Nachrichtenfelds wird wie zuvor im Parameter „dparam“ übergeben. Was hat es mit diesem negativen Wert auf sich? Was ist der Grund dafür? Um das zu verstehen, müssen Sie sich den Code in Zeile 130 ansehen; dort implementieren wir die Prozedur „ModifyValueSLTP“.

Bitte beachten Sie, dass es innerhalb dieser Prozedur nun einige geringfügige Unterschiede gibt. Zunächst prüfen wir in Zeile 135, ob der Wert „sl“ oder „tp“ negativ ist. In diesem Fall rufen wir die Funktion „PositionSelectByTicket“ auf. Dieser Aufruf ist erforderlich, um die aktuellen Positionswerte zu laden. Aber warum? Den Grund dafür finden Sie in den Zeilen 140 und 141. Ist der Wert eines der Argumente negativ, wird der aktuellste für die Position gespeicherte Wert verwendet, damit der Server den bestehenden Wert nicht löscht. Ist der Wert jedoch null – wie dies beim Löschen einer Linie der Fall ist – oder ein anderer nicht-negativer Wert, verwendet der Server genau diesen Wert, um die Stop-Loss- oder Take-Profit-Linie auf dem vom Händler festgelegten Niveau zu platzieren. Damit ist der Code des Expert Advisors aktualisiert und erfordert keine weiteren Änderungen an seiner Struktur mehr.

Nun können wir uns auf den Positionsindikator konzentrieren, da der Code des Expert Advisors jetzt Anfragen zur Änderung des Preises erkennen kann, sei es für Take-Profit oder Stop-Loss. Bevor wir jedoch mit der Analyse des Codes des Indikators beginnen, möchte ich Sie, lieber Leser, daran erinnern, dass der Indikator den Preis automatisch anzeigt, sobald dieser aktualisiert wird. Mit anderen Worten: Wir müssen uns keine Gedanken darüber machen, wo sich die Preislinie im Chart befindet. Wir müssen lediglich eine Prozedur erstellen, die ein Ereignis auslöst, damit der Expert Advisor die horizontale Preislinie anpasst.

Was ich Ihnen nun zeigen werde, wird also nicht in der endgültigen Version enthalten sein. Ich möchte Ihnen nur zeigen, wie man die Preislinie verschiebt. Dazu müssen wir einige kleinere Anpassungen am Quellcode vornehmen. Und da ich Sie, lieber Leser, mit so vielen Änderungen nicht verwirren möchte, gehen wir Schritt für Schritt vor. Zunächst passen wir den Code des Indikators so an, dass Aktionen nur über den Mausindikator ausgeführt werden. Dazu müssen wir einige Änderungen an dem Code vornehmen, den wir in den vorherigen Artikeln behandelt haben. Den neuen Code sehen Sie unten:

001. //+------------------------------------------------------------------+
002. #property copyright "Daniel Jose"
003. //+------------------------------------------------------------------+
004. #define def_NameHLine        m_Info.szPrefixName + "#HLINE"
005. #define def_NameBtnClose     m_Info.szPrefixName + "#CLOSE"
006. //+------------------------------------------------------------------+
007. #define def_PathBtns "Images\\Market Replay\\Orders\\"
008. #define def_Btn_Close def_PathBtns + "Btn_Close.bmp"
009. #resource "\\" + def_Btn_Close;
010. //+------------------------------------------------------------------+
011. #include "..\Auxiliar\C_Mouse.mqh"
012. //+------------------------------------------------------------------+
013. class C_ElementsTrade : private C_Mouse
014. {
015.     private    :
016. //+------------------------------------------------------------------+
017.         enum eObjects {LINE_PRICE, BTN_CLOSE, ELEM_NULL};
018. //+------------------------------------------------------------------+
019.         struct st00
020.         {
021.             ulong        ticket;
022.             string       szPrefixName;
023.             EnumEvents   ev;
024.             double       price;
025.             struct st01
026.             {
027.                 short xi, xf, yi, yf;
028.             }Positions[ELEM_NULL];
029.         }m_Info;
030. //+------------------------------------------------------------------+
031.         void UpdateViewPort(void)
032.         {
033.             int x, y;
034.             
035.             ChartTimePriceToXY(0, 0, 0, m_Info.price, x, y);
036.             ObjectSetDouble(0, def_NameHLine, OBJPROP_PRICE, m_Info.price);
037.             x = 130;
038.             m_Info.Positions[BTN_CLOSE].xi = (short)(x - 8);
039.             m_Info.Positions[BTN_CLOSE].xf = (short)(x + 8);
040.             m_Info.Positions[BTN_CLOSE].yi = (short)(y - 8);
041.             m_Info.Positions[BTN_CLOSE].yf = (short)(y + 8);
042.             ObjectSetInteger(0, def_NameBtnClose, OBJPROP_XDISTANCE, x);
043.             ObjectSetInteger(0, def_NameBtnClose, OBJPROP_YDISTANCE, y);
044.         }
045. //+------------------------------------------------------------------+
046.         eObjects CheckMousePosition(double &price)
047.             {
048.                 short x, y;
049.                 st_Mouse loc;
050.                 
051.                 loc = GetPositionsMouse();
052.                 price = loc.Position.Price;
053.                 x = loc.Position.X_Graphics;
054.                 y = loc.Position.Y_Graphics;
055.                 for (eObjects c0 = LINE_PRICE; c0 < ELEM_NULL; c0++)
056.                     if ((x > m_Info.Positions[c0].xi) && (x < m_Info.Positions[c0].xf) &&
057.                         (y > m_Info.Positions[c0].yi) && (y < m_Info.Positions[c0].yf)) return c0;
058.                 return ELEM_NULL;
059.             }
060. //+------------------------------------------------------------------+
061.     public    :
062. //+------------------------------------------------------------------+
063.         C_ElementsTrade(const ulong ticket, const EnumEvents ev, color _color, EnumPriority ePrio, string szDescr = "\n")
064.             :C_Mouse(0, "")
065.         {
066.             string szObj;
067.             
068.             ZeroMemory(m_Info);
069.             m_Info.szPrefixName = StringFormat("%I64u@%d", m_Info.ticket = ticket, (int)(m_Info.ev = ev));
070.             CreateObjectGraphics(szObj = def_NameHLine, OBJ_HLINE, _color, ePrio);
071.             ObjectSetInteger(0, szObj, OBJPROP_WIDTH, 2);
072.             ObjectSetString(0, szObj, OBJPROP_TEXT, szDescr);
073.             ObjectSetString(0, szObj, OBJPROP_TOOLTIP, szDescr);
074.             ObjectSetInteger(0, szObj, OBJPROP_SELECTABLE, ePrio != ePriorityNull);
075.             CreateObjectGraphics(szObj = def_NameBtnClose, OBJ_BITMAP_LABEL, clrNONE, (EnumPriority)(ePriorityOrders + 1));
076.             ObjectSetString(0, szObj, OBJPROP_BMPFILE, 0, "::" + def_Btn_Close);
077.             ObjectSetInteger(0, szObj, OBJPROP_ANCHOR, ANCHOR_CENTER);
078.         }
079. //+------------------------------------------------------------------+
080.         ~C_ElementsTrade()
081.         {
082.             if (m_Info.szPrefixName != "")
083.                 ObjectsDeleteAll(0, m_Info.szPrefixName);
084.         }
085. //+------------------------------------------------------------------+
086.         inline void UpdatePrice(const double price)
087.         {
088.             m_Info.price = price;
089.             UpdateViewPort();
090.         }
091. //+------------------------------------------------------------------+
092.         void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam)
093.         {
094.             double price;
095.             
096.             C_Mouse::DispatchMessage(id, lparam, dparam, sparam);
097.             switch (id)
098.             {
099.                 case CHARTEVENT_MOUSE_MOVE:
100.                     if (CheckClick(C_Mouse::eClickLeft)) switch(CheckMousePosition(price))
101.                     {
102.                         case LINE_PRICE:
103.                             break;
104.                         case BTN_CLOSE:
105.                             if (PositionSelectByTicket(m_Info.ticket)) switch (m_Info.ev)
106.                             {
107.                                 case evMsgClosePositionEA:
108.                                     EventChartCustom(0, evMsgClosePositionEA, m_Info.ticket, 0, "");
109.                                     break;
110.                                 case evMsgCloseTakeProfit:
111.                                     EventChartCustom(0, evMsgCloseTakeProfit, m_Info.ticket, PositionGetDouble(POSITION_SL), PositionGetString(POSITION_SYMBOL));
112.                                     break;
113.                                 case evMsgCloseStopLoss:
114.                                     EventChartCustom(0, evMsgCloseStopLoss, m_Info.ticket, PositionGetDouble(POSITION_TP), PositionGetString(POSITION_SYMBOL));
115.                                     break;
116.                             }
117.                             break;
118.                     }
119.                     break;
120.                 case CHARTEVENT_CHART_CHANGE:
121.                     UpdateViewPort();
122.                     break;
123.             }
124.         }
125. //+------------------------------------------------------------------+
126. };
127. //+------------------------------------------------------------------+
128. #undef def_Btn_Close
129. #undef def_PathBtns
130. //+------------------------------------------------------------------+
131. #undef def_NameBtnClose
132. #undef def_NameHLine
133. //+------------------------------------------------------------------+

C_ElementsTrade.mqh

Wenn Sie sich diesen Code ansehen, denken Sie wahrscheinlich: „Aber im Code hat sich doch gar nichts geändert.“ Das stimmt allerdings nicht ganz, mein Freund. Das Verhalten des Codes hat sich vollständig geändert. Bitte beachten Sie, dass wir die Klasse „C_Terminal“ nicht mehr verwenden; stattdessen nutzen wir die Klasse „C_Mouse“. Dies geschieht in Zeile 11. Ebenso ist die Klasse nicht mehr von C_Terminal abgeleitet. Die Klasse erbt von C_Mouse und umfasst daher auch die Klasse C_Terminal. Daher beginnen wir nun damit, den Mausindikator zur Interaktion mit dem Positionsindikator zu verwenden. Die bloße Umsetzung der oben genannten Änderungen reicht jedoch nicht aus, um dieses Ziel zu erreichen. Es sind weitere Änderungen am Code erforderlich. Daher wird in Zeile 17 ein Aufzählungstyp eingeführt. Mit dieser Aktualisierung sollen die bisher in MetaTrader 5 ausgeführten Abläufe ersetzt werden. Mit anderen Worten: Wir haben nun etwas mehr Kontrolle über den Code.

Infolge dieser Ersetzung haben wir in Zeile 25 eine neue Struktur deklariert. Sie enthält vier Variablen, die in Zeile 27 deklariert sind. Tatsächlich handelt es sich bei dieser Struktur jedoch um ein Array von Positionen, wie aus Zeile 28 hervorgeht, in der festgelegt ist, dass das Array aus X Elementen bestehen soll. In diesem Fall gibt es 3 Elemente. Gut, jetzt müssen wir diesem Array Elemente hinzufügen. Dies geschieht in der in Zeile 31 definierten Prozedur. Bitte beachten Sie, dass wir zwischen den Zeilen 38 und 41 eine Position bzw. einen Trefferbereich (den Bereich, in dem ein Klick erkannt wird) für die Schaltfläche „Schließen“ festgelegt, in dem ein Mausklick erkannt wird. Die Werte „8“, die in diesen Zeilen vorkommen, entsprechen der halben Größe der Bitmap. Nur zur Erinnerung: Die Bitmap ist 16 mal 16 Pixel groß. Und da sie zentriert ist, müssen wir diesen Trefferbereich richtig konfigurieren. Super, jetzt wissen wir, wo sich die Schaltfläche „Schließen“ befindet.

Bevor wir jedoch zu Zeile 46 übergehen, schauen wir uns zunächst den Konstruktor der Klasse an. Diesen finden Sie in Zeile 63. Bitte beachten Sie, dass wir in Zeile 64 nun die Klasse „C_Mouse“ initialisieren. Zuvor war es die Klasse „C_Terminal“. Diese Methode zur Initialisierung der Klasse C_Mouse teilt MetaTrader 5 mit, dass wir kein Mouse-Objekt erstellen möchten. Wir müssen lediglich auf den Mausindikator zugreifen können, sofern er auf dem Chart vorhanden ist.

Nun können wir zu Zeile 46 zurückkehren und nachsehen, was dort passiert. Bitte beachten Sie, dass diese Funktion viel komplizierter erscheint, als sie tatsächlich ist. Hier, in Zeile 51, erfassen wir lediglich die Position des Mausindikators. Unmittelbar danach, in Zeile 52, speichern wir den Preiswert, damit wir ihn an den aufrufenden Code zurückgeben können, den wir uns gleich ansehen werden. Uns interessieren jedoch insbesondere die folgenden Zeilen. Sie überprüfen den Trefferbereich, um das Objekt zurückzugeben, auf das geklickt wurde. Wenn kein Objekt identifiziert wurde, geben wir in Zeile 58 einen ungültigen Wert an den Aufrufer zurück.

Nun können wir endlich das Objekt sehen, das die Funktion „CheckMousePosition“ aufruft. Genauer gesagt handelt es sich um die Prozedur „DispatchMessage“, die in Zeile 92 steht. Jetzt kommt der interessanteste Teil, denn als Allererstes rufen wir den Ereignisbehandler der Klasse C_Mouse auf. Das geschieht in Zeile 96. Der Grund dafür ist, dass wir sicherstellen müssen, dass die Daten korrekt sind, da wir kein Puffersystem verwenden, um Daten vom Mausindikator abzurufen. Nachdem Ereignisse in der Klasse „C_Mouse“ verarbeitet wurden, wird bei Auftreten eines Mausereignisses die Zeile 99 ausgeführt.

Bitte beachten Sie: Die Mausereignisse hier entsprechen nicht dem, was Sie vielleicht erwarten würden, wenn Sie vorhaben, dieselbe Methode zur Programmierung von Mausereignissen zu verwenden, die üblicherweise in MQL5 zum Einsatz kommt. Hier werden Mausereignisse gefiltert und anders verarbeitet. Um dies zu verstehen, schauen Sie sich noch einmal diese Artikelserie zum Wiedergabe- und Simulationssystem an und sehen Sie sich an, wie der Mausindikator implementiert wurde. Dort werden Sie feststellen, dass bei Verwendung des Mausindikators manche Klickereignisse möglicherweise ignoriert werden. Das liegt daran, dass dieser Indikator für Analysezwecke entwickelt wurde. In derselben Artikelserie habe ich gezeigt, wie Sie den Indikator so anpassen können, dass Sie Ihren eigenen Analysemodus erstellen können, um direkt mit dem Chart zu interagieren, ohne Analyseobjekte konfigurieren zu müssen. Der Mauszeiger erledigt das für Sie.

Daher gilt der Test in Zeile 100 nur dann als erfolgreich, wenn während der Nutzung des Analysemodus nicht geklickt wurde. Sollten Sie während der Analyse versehentlich auf ein Objekt klicken, das von diesem Code der Klasse C_ElementsTrade überwacht wird, wird dieser Klick ignoriert. Wenn Sie also gerade keine grafischen Zeichnungen erstellen und an einer beliebigen Stelle im Chart klicken, ist die Prüfung erfolgreich und die Funktion „CheckMousePosition“ wird aufgerufen. Es gibt jedoch ein wichtiges Detail, das erwähnenswert ist. Bei dieser Überprüfung wird die Anzeigereihenfolge im Chart, also der Wert der Eigenschaft „ZOrder“, vollständig ignoriert. Mit anderen Worten: Seien Sie vorsichtig. Selbst wenn Sie auf ein Objekt mit einem niedrigeren ZOrder-Wert klicken, kann es dennoch Vorrang haben, da die Reihenfolge hier durch den Aufzählungstyp in Zeile 17 bestimmt wird. Und zwei Objekte erhalten dieses Ereignis, wenn ihre Trefferbereiche an derselben Position liegen, selbst wenn sie zu unterschiedlichen Indikatoren gehören. In diesem Fall spielt es keine Rolle, welches Objekt den höheren ZOrder-Wert hat oder welches sich im Vordergrund befindet. Seien Sie damit vorsichtig, bis eine Lösung bereitgestellt wird.

Später werden wir uns damit befassen, wie das geht. Aber seien Sie vorerst vorsichtig. Zurück zum Code: Sobald die Funktion CheckMousePosition ihre Ausführung beendet hat, gibt sie genau an, welches Objekt den Klick erhalten hat. An dieser Stelle unterscheiden wir zwischen diesen Fällen. Bitte beachten Sie, dass wir in Zeile 102 bereits damit begonnen haben, festzulegen, dass beim Anklicken des LINE_PRICE-Objekts ein bestimmtes Ereignis ausgelöst wird. In Zeile 104 haben wir genau denselben Code eingefügt, der dort zuvor stand, als MetaTrader 5 diese Aufgabe noch für uns übernommen hat. Nun haben wir also alles, was zuvor von der MetaTrader-5-Plattform gesteuert wurde, vollständig durch unseren eigenen Code ersetzt.

Der übrige Code des Indikators bleibt unverändert, daher muss er hier nicht wiedergegeben werden.


Abschließende Gedanken

In diesem Artikel wurde ein Thema behandelt, auf das wir im nächsten Artikel näher eingehen werden. Bevor ich jedoch zum Schluss komme, möchte ich Ihnen eine kleine Änderung im Code des Expert Advisors zeigen. Das Ziel besteht darin, dass der Expert Advisor ein Ereignis auslöst, wenn eine Position geschlossen wird – das heißt, wenn der Kurs die Stop-Loss-Linie oder die Take-Profit-Linie erreicht. Ohne diese Anpassung erhält der Positionsindikator keine Benachrichtigung, dass er aus dem Chart entfernt werden kann. Der korrigierte Code ist unten aufgeführt:

001. //+------------------------------------------------------------------+
002. #property copyright "Daniel Jose"
003. #property icon "/Images/Market Replay/Icons/Replay - EA.ico"
004. #property description "Demo version between interaction"
005. #property description "of Chart Trade and Expert Advisor"
006. #property version   "1.121"
007. #property link "https://www.mql5.com/pt/articles/13265"
008. //+------------------------------------------------------------------+
009. #include <Market Replay\Order System\C_Orders.mqh>
010. #include <Market Replay\Auxiliar\C_Terminal.mqh>
011. //+------------------------------------------------------------------+
012. enum eTypeContract {MINI, FULL};
013. //+------------------------------------------------------------------+
014. input eTypeContract user00 = MINI;         //Cross order in contract
015. //+------------------------------------------------------------------+
016. C_Orders    *Orders;
017. C_Terminal  *Terminal;
018. //+------------------------------------------------------------------+
019. int OnInit()
020. {
021.     Terminal = NULL;
022.     Orders = new C_Orders(0xC0DEDAFE78514269);
023.     
024.     return INIT_SUCCEEDED;
025. }
026. //+------------------------------------------------------------------+
027. void OnTick() {}
028. //+------------------------------------------------------------------+
029. void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
030. {
031.     int handle;
032.     
033.     (*Orders).DispatchMessage(id, lparam, dparam, sparam);
034.     switch (id)
035.     {
036.         case CHARTEVENT_CHART_CHANGE:
037.             if (Terminal != NULL) break;
038.             else
039.             {
040.                 ulong ul;
041.                 Terminal = new C_Terminal(0, 0, user00);
042.                 for (int count = PositionsTotal() - 1; count >= 0; count--)
043.                 {
044.                     ul = PositionGetTicket(count);
045.                     if (PositionGetString(POSITION_SYMBOL) != (*Terminal).GetInfoTerminal().szSymbol)
046.                     {
047.                         ChartIndicatorDelete(0, 0, IntegerToString(ul));
048.                         continue;
049.                     }
050.                     handle = iCustom(NULL, PERIOD_CURRENT, "\\Indicators\\Position View.ex5", ul);
051.                     ChartIndicatorAdd(0, 0, handle);
052.                     IndicatorRelease(handle);
053.                 }
054.             }
055.         case CHARTEVENT_CUSTOM + evChartTrade_At_EA:
056.             EventChartCustom(0, evEA_At_ChartTrade, user00, 0, "");
057.             break;
058.     }
059. }
060. //+------------------------------------------------------------------+
061. void OnTradeTransaction(const MqlTradeTransaction &trans, const MqlTradeRequest &request, const MqlTradeResult &result)
062. {    
063.     static ulong ticket = 0;
064.     
065.     if (Terminal == NULL) return;
066.     switch (trans.type)
067.     {
068.         case TRADE_TRANSACTION_HISTORY_ADD:
069.             EventChartCustom(0, evUpdate_Position, trans.position, 0, "");
070.             ticket = (trans.order != trans.position ? trans.position : 0);
071.             break;
072.         case TRADE_TRANSACTION_REQUEST:
073.             if ((request.symbol == (*Terminal).GetInfoTerminal().szSymbol) && (result.retcode == TRADE_RETCODE_DONE)) switch (request.action)
074.             {
075.                 case TRADE_ACTION_DEAL:
076.                     if (ticket > 0) EventChartCustom(0, evUpdate_Position, ticket, 0, "");
077.                     else
078.                     {
079.                         int handle = iCustom(NULL, PERIOD_CURRENT, "\\Indicators\\Position View.ex5", result.order);
080.                         ChartIndicatorAdd(0, 0, handle);
081.                         IndicatorRelease(handle);
082.                     }
083.                     ticket = 0;
084.                     break;
085.                 case TRADE_ACTION_SLTP:
086.                     EventChartCustom(0, evUpdate_Position, request.position, 0, "");
087.                     break;
088.             }
089.             break;
090.     };
091. }
092. //+------------------------------------------------------------------+
093. void OnDeinit(const int reason)
094. {
095.     ulong ul;
096.     
097.     switch (reason)
098.     {
099.         case REASON_REMOVE:
100.         case REASON_INITFAILED:
101.             EventChartCustom(0, evEA_At_ChartTrade, -1, 0, "");
102.             break;
103.     }
104.     if (Terminal != NULL) for (int count = PositionsTotal() - 1; count >= 0; count--)
105.     {
106.         ul = PositionGetTicket(count);
107.         if (PositionGetString(POSITION_SYMBOL) != (*Terminal).GetInfoTerminal().szSymbol) continue;
108.         ChartIndicatorDelete(0, 0, IntegerToString(ul));
109.     }
110.     delete Orders;
111.     delete Terminal;
112. }
113. //+------------------------------------------------------------------+

Expert Advisor.mq5

Die Korrektur besteht konkret darin, Zeile 69 in den Code einzufügen. Ohne diese Zeile wird das Aktualisierungsereignis nicht ausgelöst, wenn eine Position beim Erreichen einer der Preislinien geschlossen wird. Und noch eine kurze Anmerkung am Rande: Es gibt einen Punkt, der beim Lesen dieses Artikels vielleicht nicht sofort ins Auge gefallen ist. Dieser Punkt betrifft insbesondere die Verschiebung der Stop-Loss- und Take-Profit-Linien. Sie könnten sich durchaus fragen – und das völlig zu Recht –, warum ich mir die Mühe mache, eine solche Verschiebung zu implementieren, wenn sie ohnehin schon möglich ist, sobald wir versuchen, die vom Positionsindikator erstellten Linien zu ziehen.

Aber in Wirklichkeit sieht die Sache nicht ganz so aus, lieber Leser. Die Sache ist die: Wenn Sie ein handelbares Symbol verwenden, verschieben Sie höchstwahrscheinlich die von MetaTrader 5 erstellten Linien. Die von uns geplante Verschiebefunktion kommt genau dann zum Einsatz, wenn die von MetaTrader 5 erstellten Linien nicht vorhanden sind. Oder wenn das Verschieben dieser Linien in den Einstellungen von MetaTrader 5 nicht erlaubt ist.

Wenn Sie nicht wissen, wo Sie diese Einstellung finden, schauen Sie sich einfach das folgende Bild an:

Standardmäßig verwendet MetaTrader 5 die in der obigen Abbildung gezeigte Einstellung. Wenn Sie diese Einstellung jedoch wie in der folgenden Abbildung gezeigt ändern, lassen sich diese Linien nicht mehr verschieben.

Genau an dieser Stelle würden wir MetaTrader 5 so verwenden, als wäre das Symbol auf dem Chart ein nicht handelbares Instrument. Mit anderen Worten: Dies ist ein typisches Szenario, auf das wir stoßen werden, wenn wir dasselbe System oder dieselben Indikatoren bei der Wiedergabe oder Simulation verwenden. Daher ist es wichtig, alle Prozesse im Zusammenhang mit dem Verschieben von Preislinien zu implementieren. Die Frage ist nicht, ob wir das tun sollten oder nicht, sondern lediglich, wie und wann wir es tun werden. Für alle, die die Artikel verfolgen, den Quellcode aber nicht kompilieren können, habe ich im Anhang modifizierte ausführbare Dateien beigefügt. Im nächsten Artikel werden wir mit einer detaillierteren Beschreibung der Implementierung des Wiedergabe- und Simulationssystems fortfahren.

Datei Beschreibung
Experts\Expert Advisor.mq5
Veranschaulicht die Interaktion zwischen Chart Trade und dem Expert Advisor (für diese Interaktion ist „Mouse Study“ erforderlich).
Indicators\Chart Trade.mq5 Erstellt ein Fenster zur Konfiguration der zu sendenden Order (für die Interaktion ist „Mouse Study“ erforderlich)
Indicators\Market Replay.mq5 Erstellt Steuerelemente für die Interaktion mit dem Wiedergabe- und Simulationsdienst (für diese Interaktion ist „Mouse Study“ erforderlich).
Indicators\Mouse Study.mq5 Ermöglicht die Interaktion zwischen grafischen Bedienelementen und dem Benutzer (die sowohl für das Wiedergabe- und Simulationssystem für den Markt als auch im realen Markt erforderlich ist).
Indicators\Order Indicator.mq5 Zuständig für das Platzieren von Marktorders sowie für die damit verbundene Interaktion und Steuerung.
Indicators\Position View.mq5 Zuständig für die Erkennung und Verwaltung offener Marktpositionen sowie für die zugehörige Interaktion und Steuerung.
Services\Market Replay.mq5 Erstellt und pflegt den Wiedergabe-/Simulationsdienst für den Markt (die Hauptdatei des gesamten Systems).

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

Beigefügte Dateien |
Anexo.zip (779.24 KB)
Neuronale Netze im Trading: Das adaptive Graphdiffusionsmodell (Fazit) Neuronale Netze im Trading: Das adaptive Graphdiffusionsmodell (Fazit)
In diesem Artikel schließen wir unsere Arbeit an der Entwicklung des SAGDFN-Frameworks mit MQL5 ab, fassen den Entwicklungsprozess zusammen und stellen die Ergebnisse der praktischen Tests vor. Lassen Sie uns die bereits implementierten Module zu einem einzigen System zusammenführen, die Stärken dieses Ansatzes hervorheben, auf seine Schwächen hinweisen und mögliche Wege zu seiner Verbesserung erörtern.
Handelsroboter auf Basis eines GPT-Modells für Finanzzeitreihen Handelsroboter auf Basis eines GPT-Modells für Finanzzeitreihen
Der Artikel stellt eine vollständige Implementierung von TimeGPT vor, einer spezialisierten transformer-basierten Architektur zur Prognose von Finanzzeitreihen auf der MetaTrader-5-Plattform. Es werden die Anpassung des Aufmerksamkeitsmechanismus an Finanzdaten, die selektive Tokenisierung von Kursänderungen, hardwareorientierte Optimierungen sowie fortschrittliche Lernverfahren erörtert. Enthalten sind praktische Testergebnisse, die eine Prognosegenauigkeit von 87 % bei einem Prognosehorizont von 24 Balken und einer Trainingszeit von 15 Minuten auf der CPU zeigen. Außerdem stellen wir einen einsatzbereiten Expert Advisor mit automatischem erneuten Training vor.
Algorithmischer Arbitragehandel mithilfe der Graphentheorie Algorithmischer Arbitragehandel mithilfe der Graphentheorie
In diesem Artikel wird die Dreiecksarbitrage als Problem der Suche nach Zyklen in einem gerichteten Graphen dargestellt, dessen Knoten Währungen und dessen Kanten Währungspaare mit Wechselkursen als Kantengewichten darstellen. Rentabler Zyklus: Produkt der Gewichte > 1. Unser Floyd-Warshall-Algorithmus und unser DFS-Algorithmus ermitteln optimale Wechselpfade, die mit einem Gewinn zum Ausgangspunkt zurückführen.
Neuronale Netze im Handel: Das adaptive Graphdiffusionsmodell (Attention-Modul) Neuronale Netze im Handel: Das adaptive Graphdiffusionsmodell (Attention-Modul)
In diesem Artikel werden wir uns eingehend mit der praktischen Umsetzung der Schlüsselkomponenten des SAGDFN-Frameworks befassen. Wir werden zeigen, wie dünn besetzte Attention und die Auswahl signifikanter Nachbarn für die Zeitreihenprognose organisiert sind. Die vorgestellten Ansätze schaffen einen Ausgleich zwischen Prognosegenauigkeit und Recheneffizienz.