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

Marktsimulation: Positionsanzeige (X)

MetaTrader 5 — Tester |
8 0
Daniel Jose
Daniel Jose

Einleitung

Hallo zusammen und herzlich willkommen zu einem neuen Artikel in unserer Reihe zum Thema „Erstellung eines Replikations-/Simulationssystems“.

Im vorherigen Artikel „Marktsimulation: Positionsanzeige (IX)“ haben wir begonnen zu untersuchen, wie die Verschiebung der Take-Profit- und Stop-Loss-Linien umgesetzt werden sollte. Da ich allen erklären möchte – und zwar so verständlich wie möglich –, wie und warum Änderungen am Code vorgenommen werden, werden wir in diesem Artikel versuchen, das im vorherigen Artikel vorgestellte Problem zu lösen. Das Problem liegt bei ZOrder. Wenn Sie sich nicht sicher sind, was die Eigenschaft „ZOrder“ für Objekte bedeutet, machen Sie sich keine Sorgen – schauen Sie sich einfach die vorherigen Artikel dieser Reihe an, in denen ich erkläre, wie wichtig es ist, diese Eigenschaft korrekt einzustellen.

Darüber hinaus stellt sich die Frage: Wie können wir ZOrder zu unserem Vorteil nutzen? Die Antwort ist einfach: Das können wir nicht. Das erscheint absurd und völlig sinnlos. Dennoch, lieber Leser, ganz gleich, wie erfahren Sie als Programmierer auch sein mögen: Sie werden nicht in der Lage sein, das zu übertreffen, was in MetaTrader 5 für die Verwaltung von ZOrder bereits programmiert ist.

Dennoch benötigen wir Werkzeuge zur Verwaltung der von uns erstellten grafischen Objekte. Der im vorherigen Artikel vorgestellte Ansatz funktioniert in bestimmten Szenarien sehr gut. In diesem Fall benötigen wir angesichts der Besonderheiten des vorliegenden Problems eine komplexere Lösung. Daher werden wir nicht versuchen, die in MetaTrader 5 vorhandenen ZOrder-Verwaltungsmechanismen zu ersetzen, und wir werden natürlich auch nicht prüfen, welches Objekt im Vordergrund liegt oder von einem anderen Objekt verdeckt wird. Wir werden etwas ganz anderes machen. Hier zeige ich Ihnen, welche Änderungen am Code vorgenommen werden müssen, um einige der Funktionen zu nutzen, die MetaTrader 5 bereits für uns bereitstellt. Mit anderen Worten: um festzustellen, mit welchem Objekt nach einem Klick interagiert werden soll und mit welchem nicht.

Damit Sie besser verstehen, was wir vorhaben, müssen wir uns zunächst einen recht einfachen Codeausschnitt ansehen, der dennoch äußerst hilfreich ist, um zu verstehen, wie wir unser Problem angehen können.


Der einfachste Code

Um das Prinzip zu verstehen, sollten Sie ein Beispiel verwenden, das Sie nachvollziehen können. Viele Menschen neigen zu der Annahme, dass wir zur Lösung eines Problems eine verworrene oder äußerst komplexe Lösung finden müssen. In der Praxis sollten wir das jedoch nicht tun. In der Praxis müssen wir etwas schaffen, das so einfach wie möglich ist. Wir müssen die Anwendung nutzen und verstehen, was sie uns mitteilt. Um dies zu veranschaulichen, verwenden wir den folgenden Code:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property indicator_chart_window
04. #property indicator_plots 0
05. //+------------------------------------------------------------------+
06. #define debug(A) Print(__FILE__, " ", __LINE__, " ", __FUNCTION__ + " " + #A + " = " + (string)(A));
07. //+------------------------------------------------------------------+
08. int OnInit()
09. {
10.     string sz1 = "Object #01";
11.     
12.     ObjectCreate(0, sz1, OBJ_BUTTON, 0, 0, 0);
13.     ObjectSetInteger(0, sz1, OBJPROP_XDISTANCE, 100);
14.     ObjectSetInteger(0, sz1, OBJPROP_YDISTANCE, 100);
15.     
16.     sz1 = "Object #02";
17.     ObjectCreate(0, sz1, OBJ_BUTTON, 0, 0, 0);
18.     ObjectSetInteger(0, sz1, OBJPROP_XDISTANCE, 200);
19.     ObjectSetInteger(0, sz1, OBJPROP_YDISTANCE, 200);
20.     
21.     ChartSetInteger(0, CHART_EVENT_MOUSE_MOVE, true);
22.         
23.     return INIT_SUCCEEDED;
24. }
25. //+------------------------------------------------------------------+
26. int OnCalculate(const int rates_total,
27.                 const int prev_calculated,
28.                 const int begin,
29.                 const double &price[])
30. {
31.     return rates_total;
32. }
33. //+------------------------------------------------------------------+
34. void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
35. {
36.     switch(id)
37.     {
38.         case CHARTEVENT_OBJECT_CLICK:
39.             debug(sparam);
40.             break;
41.         case CHARTEVENT_MOUSE_MOVE:
42.             if (sparam != "0")
43.                 debug(sparam);
44.             break;
45.     }
46. };
47. //+------------------------------------------------------------------+
48. void OnDeinit(const int reason)
49. {
50.     ObjectsDeleteAll(0, "Object", -1, OBJ_BUTTON);
51. }
52. //+------------------------------------------------------------------+

Indikator zum Testen

Dieser Code ist äußerst einfach. Es werden lediglich zwei Objekte mit dem Standardwert für „ZOrder“ – also Null – erstellt und eine Meldung angezeigt, wenn ein Ereignis eintritt. Das ist ganz einfach. Das mag albern oder sogar naiv erscheinen, aber es kann uns etwas äußerst Wichtiges und Nützliches aufzeigen.

Wenn wir diesen Code auf dem Chart ausführen, erhalten wir das in der folgenden Animation gezeigte Ergebnis:

In dieser Animation liegt der Schwerpunkt auf den angezeigten Meldungen. Vergessen Sie alles andere und konzentrieren Sie sich auf die Meldungen. Beachten Sie, dass sich hier ein Muster abzeichnet. Was passiert nun, wenn wir ein Objekt hinzufügen, das die Schaltflächen überlappt? Was wird passieren? Um diese Frage zu beantworten, schauen Sie sich einfach die folgende Animation an:

Achten Sie bitte erneut auf die angezeigten Meldungen. Vergleichen Sie sie nun miteinander und sagen Sie mir: Welches Muster lässt sich hier erkennen? Falls es Ihnen noch nicht aufgefallen ist, schauen Sie sich doch einmal die Meldungen und den Code an. Und denken Sie darüber nach: Welches Muster lässt sich hier erkennen?

Falls dies nicht klar sein sollte, hier eine Erklärung: Wenn wir auf ein Objekt im Chart klicken, löst MetaTrader 5 zunächst das Ereignis CHARTEVENT_MOUSE_MOVE und anschließend das Ereignis CHARTEVENT_OBJECT_CLICK aus. Das sollte man wissen. Warum? Da wir das wissen, können wir dasselbe Muster zu unserem Vorteil nutzen, um das Problem zu lösen, das auftritt, wenn sich viele Objekte auf einem Chart befinden. Entgegen der Erwartung vieler werden wir daher nicht versuchen, den bestehenden Mechanismus in MetaTrader 5 zu ersetzen. Das werden wir zu unserem Vorteil nutzen. Zu diesem Zweck wird diese Vorlage, die Sie auf Ihrer Plattform testen können, von unseren Anwendungen gesteuert. Wenn wir also eine Überprüfung mithilfe des Mausindikators durchführen, können wir Klicks auf Objekte ignorieren, deren Ereignisse in unseren Anwendungen verarbeitet werden.

Vielleicht fragen Sie sich: „Aber wie sollen wir das denn machen? Wir haben beim Programmcode bereits einiges erreicht. Müssen wir wirklich wieder ganz von vorne anfangen und alles, was bereits geschaffen wurde, komplett über Bord werfen?“ Nein, lieber Leser. Wie ich bereits erwähnt habe, soll diese Artikelserie nicht genau aufzeigen, wie man ein Replikations-/Simulationssystem entwickelt, sondern vielmehr verdeutlichen, wie ein Programmierer die dabei auftretenden Probleme angehen sollte. Viele Menschen glauben, dass die Erstellung einer Anwendung ein einfacher und unkomplizierter Vorgang ist. Doch wer wirklich in diese Welt eintaucht, weiß, dass die Dinge in Wirklichkeit ziemlich verworren sind. Wir müssen oft Probleme unterschiedlicher Komplexität lösen.

Dieses Problem mit ZOrder kann in vielen Fällen eine ziemliche Herausforderung darstellen. Sie, lieber Leser, könnten nun vielleicht einfach annehmen, dass ich als Programmierer zu keinem Zeitpunkt während des Entwicklungsprozesses auf Probleme oder Schwierigkeiten gestoßen bin. Der Grund dafür ist: Hätte ich den Code einfach korrigiert und fehlerfrei veröffentlicht, hätten Sie vielleicht den falschen Eindruck gewonnen, dass alles reibungslos geklappt hat und Sie, lieber Leser, nur deshalb Probleme beim Programmieren haben, weil Sie – verzeihen Sie den Ausdruck – ein völliger Amateur sind. Das ist jedoch nicht der Fall. Wir alle stehen vor Herausforderungen. Die Art und Weise, wie wir diese Herausforderungen meistern, ermöglicht es uns, dazuzulernen und uns zu Fachkräften mit unterschiedlichem Kompetenzniveau zu entwickeln.

Denken wir also über Folgendes nach, versuchen Sie dabei bitte, dem Gedankengang zu folgen. Wie können wir die Informationen, die wir aus diesem einfachen Programm gewinnen, zu unserem Vorteil nutzen, sodass wir den bereits entworfenen und implementierten Code so wenig wie möglich ändern müssen? Genau bei solchen Fragen würden viele Menschen irgendwann die Suche nach einer Lösung aufgeben, weil ihnen die Aufgabe äußerst schwierig erscheint. Aber wie ich bereits gesagt habe, möchte ich Ihnen, lieber Leser, zeigen, dass Sie, wenn Sie einen Moment innehalten und darüber nachdenken, schließlich erkennen werden, was zu tun ist.


Aktualisierung des Codes

Bevor wir fortfahren, hoffe ich, dass Sie sich wirklich bemüht haben, eine Lösung für das Problem zu finden. Denn so unglaublich es auch klingen mag: Es ist tatsächlich einfacher, als sich viele Menschen vorstellen können.

Zunächst werden wir die ZOrder-Ebenen entfernen. Wir werden sie allerdings nicht vollständig entfernen, sondern neu definieren, um die integrierte Unterstützung von MetaTrader 5 voll auszuschöpfen. Auf diese Weise kann uns MetaTrader 5 problemlos mitteilen, welches Objekt das Klickereignis tatsächlich empfangen hat. Deshalb werden wir die unten gezeigte Datei ändern.

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.                         };
59. //+------------------------------------------------------------------+

Defines.mqh

Beachten Sie, dass „EnumPriority“ nun weniger Aufzählungswerte enthält. Somit erhalten wir einen Standard- bzw. Vorgabetyp mit dem Wert null. Außerdem gibt es einen weiteren Typ: ePriorityNull. Dieser Typ sollte auf alle Objekte angewendet werden, die an keiner Interaktion teilnehmen sollen. Nun, nachdem wir diese Änderung vorgenommen haben, müssen wir unseren gesamten Code neu kompilieren. Dies trägt dazu bei, die vollständige Stabilität des Codes zu gewährleisten. Wenn Sie versuchen, den Indikator Chart Trade zu kompilieren, treten Fehler im Zusammenhang mit der Klasse „C_ChartFloatingRAD“ auf. Sie können sie auf dem folgenden Bild sehen:

In dieser Phase fangen viele Leute an, sich die Haare zu raufen, und denken: „Was haben wir nur angerichtet? Jetzt wird nichts mehr funktionieren.“ Aber wird das wirklich so sein? Wenn wir zu der Stelle gehen, an der der erste Fehler gemeldet wird – also zu Zeile 169 der Klasse „C_ChartFloatingRAD“ –, sehen wir die Ursache des Fehlers. Um dies zu beheben, ersetzen Sie einfach den ursprünglichen Code durch den Code im folgenden Ausschnitt:

164. //+------------------------------------------------------------------+
165.         template <typename T >
166.         void CreateObjectEditable(eObjectsIDE arg, T value)
167.             {
168.                 DeleteObjectEdit();
169.                 CreateObjectGraphics(m_Info.szObj_Editable, OBJ_EDIT, clrBlack, ePriorityDefault);
170.                 ObjectSetInteger(m_Init.id, m_Info.szObj_Editable, OBJPROP_XDISTANCE, m_Info.Regions[arg].x + m_Info.x + 3);
171.                 ObjectSetInteger(m_Init.id, m_Info.szObj_Editable, OBJPROP_YDISTANCE, m_Info.Regions[arg].y + m_Info.y + 3);
172.                 ObjectSetInteger(m_Init.id, m_Info.szObj_Editable, OBJPROP_XSIZE, m_Info.Regions[arg].w);
173.                 ObjectSetInteger(m_Init.id, m_Info.szObj_Editable, OBJPROP_YSIZE, m_Info.Regions[arg].h);
174.                 ObjectSetInteger(m_Init.id, m_Info.szObj_Editable, OBJPROP_BGCOLOR, m_Info.Regions[arg].bgcolor);
175.                 ObjectSetInteger(m_Init.id, m_Info.szObj_Editable, OBJPROP_ALIGN, ALIGN_CENTER);
176.                 ObjectSetInteger(m_Init.id, m_Info.szObj_Editable, OBJPROP_FONTSIZE, m_Info.Regions[arg].FontSize - 1);
177.                 ObjectSetString(m_Init.id, m_Info.szObj_Editable, OBJPROP_FONT, m_Info.Regions[arg].FontName);
178.                 ObjectSetString(m_Init.id, m_Info.szObj_Editable, OBJPROP_TEXT, (typename(T) == "double" ? DoubleToString(value, 2) : (string) value));
179.                 ChartRedraw();
180.             }
181. //+------------------------------------------------------------------+

Ausschnitt aus der Datei „C_ChartFloatingRAD.mqh“

Nachdem wir die Änderungen vorgenommen hatten, haben wir versucht, den Indikator Chart Trade neu zu kompilieren. Und das Ergebnis ist unten zu sehen:

Mit anderen Worten: Es hat geklappt. Wir können zum nächsten Indikator übergehen. Beim Mausindikator sind keine Änderungen nötig, da sein ZOrder unverändert geblieben ist. Daher kompilieren wir als Nächstes den Positionsindikator. Da jedoch Probleme mit ZOrder speziell im Code der Klasse „C_ElementsTrade“ auftreten werden – und dieser Code noch weiter geändert wird –, werde ich den geänderten Code vorerst noch nicht zeigen. Kommen wir nun dazu, die im vorigen Abschnitt gewonnenen Informationen anzuwenden. Mit anderen Worten: Wir werden die Unterstützung nutzen, die uns MetaTrader 5 bietet. Auf diese Weise können wir, wenn wir auf etwas klicken, genau feststellen, welches Objekt angeklickt wurde. Bei dieser Überprüfung sollte der Klick jedoch ignoriert werden.

Dies wird tiefgreifende und radikale Veränderungen erfordern. Es ist extrem schwer, sich das überhaupt vorzustellen. Etwas, das sich nur ein großer Guru hätte ausdenken und umsetzen können. Achten Sie also darauf, wie unglaublich komplex und verworren diese Lösung ist. Das lässt sich im folgenden Code erkennen:

001. //+------------------------------------------------------------------+
002. #property copyright "Daniel Jose"
003. //+------------------------------------------------------------------+
004. #include "Macros.mqh"
005. #include "..\Defines.mqh"
006. //+------------------------------------------------------------------+
007. class C_Terminal
008. {
009. //+------------------------------------------------------------------+        
010.     public    :
011. //+------------------------------------------------------------------+        
012.         struct st_Mouse
013.         {
014.             struct st00
015.             {
016.                 short    X_Adjusted,
017.                          Y_Adjusted,
018.                          X_Graphics,
019.                          Y_Graphics;
020.                 double   Price;
021.                 datetime dt;
022.             }Position;
023.             uchar     ButtonStatus;
024.             bool      ExecStudy;
025.             string    szObjNameClick;
026.         };
027. //+------------------------------------------------------------------+
028.     protected:
029.         enum eErrUser {ERR_Unknown, ERR_FileAcess, ERR_PointerInvalid, ERR_NoMoreInstance};
030. //+------------------------------------------------------------------+
031.         struct st_Terminal
032.         {
033.             ENUM_SYMBOL_CHART_MODE   ChartMode;
034.             ENUM_ACCOUNT_MARGIN_MODE TypeAccount;
035.             long    ID;
036.             string  szSymbol;
037.             int     Width,
038.                     Height,
039.                     nDigits,
040.                     SubWin,
041.                     HeightBar;
042.             double  PointPerTick,
043.                     ValuePerPoint,
044.                     VolumeMinimal,
045.                     AdjustToTrade;
046.         };
047. //+------------------------------------------------------------------+
048.         void CurrentSymbol(bool bUsingFull)
049.             {
050.                 MqlDateTime mdt1;
051.                 string sz0, sz1;
052.                 datetime dt = macroGetDate(TimeCurrent(mdt1));
053.                 enum eTypeSymbol {WIN, IND, WDO, DOL, OTHER} eTS = OTHER;
054.         
055.                 sz0 = StringSubstr(m_Infos.szSymbol = _Symbol, 0, 3);
056.                 for (eTypeSymbol c0 = 0; (c0 < OTHER) && (eTS == OTHER); c0++) eTS = (EnumToString(c0) == sz0 ? c0 : eTS);
057.                 switch (eTS)
058.                 {
059.                     case DOL :
060.                     case WDO : sz1 = "FGHJKMNQUVXZ"; break;
061.                     case IND :
062.                     case WIN : sz1 = "GJMQVZ";       break;
063.                     default  : return;
064.                 }
065.                 sz0 = EnumToString((eTypeSymbol)(((eTS & 1) == 1) ? (bUsingFull ? eTS : eTS - 1) : (bUsingFull ? eTS + 1: eTS)));
066.                 for (int i0 = 0, i1 = mdt1.year - 2000, imax = StringLen(sz1);; i0 = ((++i0) < imax ? i0 : 0), i1 += (i0 == 0 ? 1 : 0))
067.                     if (dt < macroGetDate(SymbolInfoInteger(m_Infos.szSymbol = StringFormat("%s%s%d", sz0, StringSubstr(sz1, i0, 1), i1), SYMBOL_EXPIRATION_TIME))) break;
068.             }
069. //+------------------------------------------------------------------+
070. inline void DecodeMousePosition(int xi, int yi)
071.             {
072.                 int w = 0;
073. 
074.                 xi = (xi > 0 ? xi : 0);
075.                 yi = (yi > 0 ? yi : 0);
076.                 ChartXYToTimePrice(m_Infos.ID, m_Mouse.Position.X_Graphics = (short)xi, m_Mouse.Position.Y_Graphics = (short)yi, w, m_Mouse.Position.dt, m_Mouse.Position.Price);
077.                 m_Mouse.Position.dt = AdjustTime(m_Mouse.Position.dt);
078.                 m_Mouse.Position.Price = AdjustPrice(m_Mouse.Position.Price);
079.                 ChartTimePriceToXY(m_Infos.ID, w, m_Mouse.Position.dt, m_Mouse.Position.Price, xi, yi);
080.                 yi -= (int)ChartGetInteger(m_Infos.ID, CHART_WINDOW_YDISTANCE, m_Infos.SubWin);
081.                 m_Mouse.Position.X_Adjusted = (short) xi;
082.                 m_Mouse.Position.Y_Adjusted = (short) yi;
083.             }
084. //+------------------------------------------------------------------+
085.     private    :
086.         st_Terminal m_Infos;
087.         st_Mouse    m_Mouse;
088.         struct mem
089.         {
090.             long  Show_Descr,
091.                   Show_Date;
092.             bool  AccountLock;
093.         }m_Mem;
094. //+------------------------------------------------------------------+
095. inline void ChartChange(void)
096.             {
097.                 int x, y, t;
098.                 
099.                 m_Infos.Width  = (int)ChartGetInteger(m_Infos.ID, CHART_WIDTH_IN_PIXELS);
100.                 m_Infos.Height = (int)ChartGetInteger(m_Infos.ID, CHART_HEIGHT_IN_PIXELS);
101.                 ChartTimePriceToXY(m_Infos.ID, 0, 0, 0, x, t);
102.                 ChartTimePriceToXY(m_Infos.ID, 0, 0, m_Infos.PointPerTick * 100, x, y);
103.                 m_Infos.HeightBar = (int)(t - y) / 100;
104.             }
105. //+------------------------------------------------------------------+
106.     public    :
107. //+------------------------------------------------------------------+        
108.         C_Terminal(const long id = 0, const uchar sub = 0, const bool bFull = false)
109.             {
110.                 m_Infos.ID = (id == 0 ? ChartID() : id);
111.                 m_Mem.AccountLock = false;
112.                 m_Infos.SubWin = (int) sub;
113.                 CurrentSymbol(bFull);
114.                 ZeroMemory(m_Mouse);
115.                 m_Mem.Show_Descr = ChartGetInteger(m_Infos.ID, CHART_SHOW_OBJECT_DESCR);
116.                 m_Mem.Show_Date  = ChartGetInteger(m_Infos.ID, CHART_SHOW_DATE_SCALE);
117.                 ChartSetInteger(m_Infos.ID, CHART_SHOW_OBJECT_DESCR, false);
118.                 ChartSetInteger(m_Infos.ID, CHART_EVENT_OBJECT_DELETE, true);
119.                 ChartSetInteger(m_Infos.ID, CHART_EVENT_OBJECT_CREATE, true);
120.                 ChartSetInteger(m_Infos.ID, CHART_SHOW_DATE_SCALE, false);
121.                 m_Infos.nDigits = (int) SymbolInfoInteger(m_Infos.szSymbol, SYMBOL_DIGITS);
122.                 m_Infos.Width   = (int)ChartGetInteger(m_Infos.ID, CHART_WIDTH_IN_PIXELS);
123.                 m_Infos.Height  = (int)ChartGetInteger(m_Infos.ID, CHART_HEIGHT_IN_PIXELS);
124.                 m_Infos.PointPerTick  = SymbolInfoDouble(m_Infos.szSymbol, SYMBOL_TRADE_TICK_SIZE);
125.                 m_Infos.ValuePerPoint = SymbolInfoDouble(m_Infos.szSymbol, SYMBOL_TRADE_TICK_VALUE);
126.                 m_Infos.VolumeMinimal = SymbolInfoDouble(m_Infos.szSymbol, SYMBOL_VOLUME_STEP);
127.                 m_Infos.AdjustToTrade = m_Infos.ValuePerPoint / m_Infos.PointPerTick;
128.                 m_Infos.ChartMode    = (ENUM_SYMBOL_CHART_MODE) SymbolInfoInteger(m_Infos.szSymbol, SYMBOL_CHART_MODE);
129.                 if(m_Infos.szSymbol != def_SymbolReplay) SetTypeAccount((ENUM_ACCOUNT_MARGIN_MODE)AccountInfoInteger(ACCOUNT_MARGIN_MODE));
130.                 ChartChange();
131.             }
132. //+------------------------------------------------------------------+
133.         ~C_Terminal()
134.             {
135.                 ChartSetInteger(m_Infos.ID, CHART_SHOW_DATE_SCALE, m_Mem.Show_Date);
136.                 ChartSetInteger(m_Infos.ID, CHART_SHOW_OBJECT_DESCR, m_Mem.Show_Descr);
137.                 ChartSetInteger(m_Infos.ID, CHART_EVENT_OBJECT_DELETE, false);
138.                 ChartSetInteger(m_Infos.ID, CHART_EVENT_OBJECT_CREATE, false);
139.             }
140. //+------------------------------------------------------------------+
141. inline void SetTypeAccount(const ENUM_ACCOUNT_MARGIN_MODE arg)
142.             {
143.                 if (m_Mem.AccountLock) return; else m_Mem.AccountLock = true;
144.                 m_Infos.TypeAccount = (arg == ACCOUNT_MARGIN_MODE_RETAIL_HEDGING ? arg : ACCOUNT_MARGIN_MODE_RETAIL_NETTING);
145.             }
146. //+------------------------------------------------------------------+
147. inline const st_Terminal GetInfoTerminal(void) const
148.             {
149.                 return m_Infos;
150.             }
151. //+------------------------------------------------------------------+
152. inline const st_Mouse GetPositionsMouse(void) const
153.             {
154.                 return m_Mouse;
155.             }
156. //+------------------------------------------------------------------+
157. const double AdjustPrice(const double arg) const
158.             {
159.                 return NormalizeDouble(round(arg / m_Infos.PointPerTick) * m_Infos.PointPerTick, m_Infos.nDigits);
160.             }
161. //+------------------------------------------------------------------+
162. inline datetime AdjustTime(const datetime arg)
163.             {
164.                 int nSeconds= PeriodSeconds();
165.                 datetime dt = iTime(m_Infos.szSymbol, PERIOD_CURRENT, 0);
166.                 
167.                 return (dt < arg ? ((datetime)(arg / nSeconds) * nSeconds) : iTime(m_Infos.szSymbol, PERIOD_CURRENT, Bars(m_Infos.szSymbol, PERIOD_CURRENT, arg, dt)));
168.             }
169. //+------------------------------------------------------------------+
170. inline double FinanceToPoints(const double Finance, const uint Leverage)
171.             {
172.                 double volume = m_Infos.VolumeMinimal + (m_Infos.VolumeMinimal * (Leverage - 1));
173.                 
174.                 return AdjustPrice(MathAbs(((Finance / volume) / m_Infos.AdjustToTrade)));
175.             };
176. //+------------------------------------------------------------------+
177.         void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam)
178.             {
179.                 static string st_str = "";
180.                 
181.                 switch (id)
182.                 {
183.                     case CHARTEVENT_CHART_CHANGE:
184.                         m_Infos.Width  = (int)ChartGetInteger(m_Infos.ID, CHART_WIDTH_IN_PIXELS);
185.                         m_Infos.Height = (int)ChartGetInteger(m_Infos.ID, CHART_HEIGHT_IN_PIXELS);
186.                         ChartChange();
187.                         break;
188.                     case CHARTEVENT_MOUSE_MOVE:
189.                         DecodeMousePosition((int)lparam, (int)dparam);
190.                         break;
191.                     case CHARTEVENT_OBJECT_CLICK:
192.                         m_Mouse.szObjNameClick = sparam;
193.                         if (st_str != sparam) ObjectSetInteger(m_Infos.ID, st_str, OBJPROP_SELECTED, false);
194.                         if (ObjectGetInteger(m_Infos.ID, sparam, OBJPROP_SELECTABLE) == true)
195.                             ObjectSetInteger(m_Infos.ID, st_str = sparam, OBJPROP_SELECTED, true);
196.                         break;
197.                     case CHARTEVENT_OBJECT_CREATE:
198.                         if (st_str != sparam) ObjectSetInteger(m_Infos.ID, st_str, OBJPROP_SELECTED, false);
199.                         st_str = sparam;
200.                         break;
201.                 }
202.             }
203. //+------------------------------------------------------------------+
204. inline void CreateObjectGraphics(const string szName, const ENUM_OBJECT obj, const color cor = clrNONE, const EnumPriority zOrder = ePriorityNull) const
205.             {
206.                 ChartSetInteger(m_Infos.ID, CHART_EVENT_OBJECT_CREATE, 0, false);
207.                 ObjectCreate(m_Infos.ID, szName, obj, m_Infos.SubWin, 0, 0);
208.                 ObjectSetString(m_Infos.ID, szName, OBJPROP_TOOLTIP, "\n");
209.                 ObjectSetInteger(m_Infos.ID, szName, OBJPROP_BACK, false);
210.                 ObjectSetInteger(m_Infos.ID, szName, OBJPROP_COLOR, cor);
211.                 ObjectSetInteger(m_Infos.ID, szName, OBJPROP_SELECTABLE, false);
212.                 ObjectSetInteger(m_Infos.ID, szName, OBJPROP_SELECTED, false);
213.                 ObjectSetInteger(m_Infos.ID, szName, OBJPROP_ZORDER, zOrder);
214.                 ChartSetInteger(m_Infos.ID, CHART_EVENT_OBJECT_CREATE, 0, true);
215.             }
216. //+------------------------------------------------------------------+
217.         bool IndicatorCheckPass(const string szShortName)
218.             {
219.                 string szTmp = szShortName + "_TMP";
220.                 
221.                 IndicatorSetString(INDICATOR_SHORTNAME, szTmp);
222.                 m_Infos.SubWin = ((m_Infos.SubWin = ChartWindowFind(m_Infos.ID, szShortName)) < 0 ? 0 : m_Infos.SubWin);
223.                 if (ChartIndicatorGet(m_Infos.ID, m_Infos.SubWin, szShortName) != INVALID_HANDLE)
224.                 {
225.                     ChartIndicatorDelete(m_Infos.ID, 0, szTmp);
226.                     Print("Only one instance is allowed...");
227.                     SetUserError(C_Terminal::ERR_NoMoreInstance);
228.                     
229.                     return false;
230.                 }
231.                 IndicatorSetString(INDICATOR_SHORTNAME, szShortName);
232.     
233.                 return true;
234.             }
235. //+------------------------------------------------------------------+
236. };

C_Terminal.mqh

Die Lösung ist im oben gezeigten Code implementiert. Ist Ihnen aufgefallen, wo? Wenn Sie diese Reihe nicht verfolgen oder die von mir bereitgestellten Materialien nicht durcharbeiten, werden Sie die Lösung definitiv nicht finden können. Tatsächlich habe ich den vollständigen Code der Klasse C_Terminal absichtlich eingefügt, damit Sie völlig verwirrt sind und nicht genau verstehen, wo die Lösung implementiert wurde.

Aber mal im Ernst. Tatsächlich besteht die Lösung darin, MetaTrader 5 zu unserem Vorteil zu nutzen. Dazu müssen wir jedoch auf einen kleinen Trick zurückgreifen. Diese Technik kann hier in der Klasse C_Terminal implementiert werden oder dort, wo der hier implementierte Code tatsächlich verwendet wird. Vielleicht denken Sie jetzt: „Sollte die Implementierung nicht in der Klasse C_Mouse erfolgen, da diese dafür zuständig ist, Klickereignisse an unsere Anwendungen weiterzuleiten?“ Ja, das stimmt, aber wenn wir das versuchen, stoßen wir auf ein kleines Problem. Schauen Sie sich die Animation noch einmal an. Beachten Sie, dass das Ereignis CHARTEVENT_MOUSE_MOVE vor dem Ereignis CHARTEVENT_OBJECT_CLICK auftritt. Und wenn wir prüfen, ob auf ein Objekt geklickt wurde, geraten die Ereignisse etwas aus dem Takt – oder anders ausgedrückt: Wenn Sie auf ein Objekt klicken, verweist die Klasse C_Mouse noch auf das Objekt, das den vorherigen Klick erhalten hat. Das mag seltsam erscheinen. Wenn wir uns jedoch die Klasse C_ElementsTrade ansehen, wird alles klarer.

Noch einmal: Die Lösung bestand darin, eine neue Variable hinzuzufügen. Sie befindet sich in Zeile 25 und wird nur in Zeile 192 verwendet. Wie bereits erwähnt, könnten wir die Lösung direkt in den Code integrieren, der sie nutzen wird. Da ich aber möchte, dass alles gut strukturiert ist, platzieren wir die Lösung hier. Das heißt, in der Klasse „C_Terminal“. Somit können wir uns nun den Code für den Positionsindikator ansehen.


Aktualisierung des Positionsindikators

Nachdem wir Änderungen an den anderen, oben gezeigten Codeausschnitten vorgenommen haben, können wir sehen, was im Positionsindikator geändert werden musste. Zunächst wurde beschlossen, dass der Händler oder Nutzer die Farben der Linien nicht mehr ändern kann. Sie werden innerhalb des Indikators standardisiert. Infolgedessen hat sich der Code in der Hauptdatei geändert; Sie können ihn unten sehen.

//+------------------------------------------------------------------+
01. #property copyright "Daniel Jose"
02. #property icon "/Images/Market Replay/Icons/Positions.ico"
03. #property description "Indicator for tracking an open position on the server."
04. #property description "This should preferably be used together with an Expert Advisor."
05. #property description "For more details see the same article."
06. #property version   "1.122"
07. #property link "https://www.mql5.com/pt/articles/13274"
08. #property indicator_chart_window
09. #property indicator_plots 0
10. //+------------------------------------------------------------------+
11. #define def_ShortName "Position View"
12. //+------------------------------------------------------------------+
13. #include <Market Replay\Order System\C_IndicatorPosition.mqh>
14. #include <Market Replay\Defines.mqh>
15. //+------------------------------------------------------------------+
16. input ulong user00 = 0;        //For Expert Advisor use
17. //+------------------------------------------------------------------+
18. C_IndicatorPosition *Positions = NULL;
19. //+------------------------------------------------------------------+
20. int OnInit()
21. {
22.     IndicatorSetString(INDICATOR_SHORTNAME, def_ShortName);
23.     Positions = new C_IndicatorPosition();
24.     if (!Positions.CheckCatch(user00))
25.     {
26.         ChartIndicatorDelete(0, 0, def_ShortName);
27.         return INIT_FAILED;
28.     }
29. 
30.     return INIT_SUCCEEDED;
31. }
32. //+------------------------------------------------------------------+
33. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
34. {
35.     return rates_total;
36. }
37. //+------------------------------------------------------------------+
38. void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
39. {
40.     (*Positions).DispatchMessage(id, lparam, dparam, sparam);
41. };
42. //+------------------------------------------------------------------+
43. void OnDeinit(const int reason)
44. {
45.     delete Positions;
46. }
47. //+------------------------------------------------------------------+

Positionsindikator:

Infolgedessen hat sich der Code für die Klasse „C_IndicatorPosition“ geringfügig geändert. Der vollständige neue Code ist nachstehend aufgeführt:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #include "C_ElementsTrade.mqh"
05. //+------------------------------------------------------------------+
06. class C_IndicatorPosition
07. {
08.     private    :
09.         struct st00
10.         {
11.             ulong   ticket;
12.             string  szShortName;
13.         }m_Infos;
14.         C_ElementsTrade *Open, *Stop, *Take;
15. //+------------------------------------------------------------------+
16.     public    :
17. //+------------------------------------------------------------------+
18.         C_IndicatorPosition()
19.         {
20.             ZeroMemory(m_Infos);
21.             Open = Take = Stop = NULL;
22.         }
23. //+------------------------------------------------------------------+
24.         ~C_IndicatorPosition()
25.         {
26.             delete Open;
27.             delete Take;
28.             delete Stop;
29.         }
30. //+------------------------------------------------------------------+
31.         bool CheckCatch(ulong ticket)
32.         {
33.             m_Infos.szShortName = StringFormat("%I64u", m_Infos.ticket = ticket);
34.             if (!PositionSelectByTicket(m_Infos.ticket)) return false;
35.             if (ObjectFind(0, m_Infos.szShortName) >= 0)
36.             {
37.                 m_Infos.ticket = 0;
38.                 return false;
39.             }
40.             IndicatorSetString(INDICATOR_SHORTNAME, m_Infos.szShortName);
41.             EventChartCustom(0, evUpdate_Position, ticket, 0, "");
42.             
43.             return true;
44.         }
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. //+------------------------------------------------------------------+
81. };
82. //+------------------------------------------------------------------+

C_IndicatorPosition.mqh

Vor diesem Hintergrund ist es nun an der Zeit, endlich einen Blick auf den neuen Code für die Klasse „C_ElementsTrade“ zu werfen. Er ist unten dargestellt. Beachten Sie, dass sich der Code erheblich von dem unterscheidet, den wir im vorherigen Artikel betrachtet haben. Dennoch enthält er dieselben Elemente und funktioniert genau auf dieselbe Weise.

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.         struct st00
018.         {
019.             ulong      ticket;
020.             string     szPrefixName;
021.             EnumEvents ev;
022.             double     price;
023.             bool       bClick;
024.         }m_Info;
025. //+------------------------------------------------------------------+
026.         void UpdateViewPort(void)
027.         {
028.             int x, y;
029.             
030.             ChartTimePriceToXY(0, 0, 0, m_Info.price, x, y);
031.             ObjectSetDouble(0, def_NameHLine, OBJPROP_PRICE, m_Info.price);
032.             ObjectSetInteger(0, def_NameBtnClose, OBJPROP_XDISTANCE, 130);
033.             ObjectSetInteger(0, def_NameBtnClose, OBJPROP_YDISTANCE, y);
034.         }
035. //+------------------------------------------------------------------+
036.     public    :
037. //+------------------------------------------------------------------+
038.         C_ElementsTrade(const ulong ticket, const EnumEvents ev, color _color, EnumPriority ePrio, string szDescr = "\n")
039.             :C_Mouse(0, "")
040.         {
041.             string szObj;
042.             
043.             ZeroMemory(m_Info);
044.             m_Info.szPrefixName = StringFormat("%I64u@%d", m_Info.ticket = ticket, (int)(m_Info.ev = ev));
045.             CreateObjectGraphics(szObj = def_NameHLine, OBJ_HLINE, _color, ePrio);
046.             ObjectSetInteger(0, szObj, OBJPROP_WIDTH, 2);
047.             ObjectSetString(0, szObj, OBJPROP_TEXT, szDescr);
048.             ObjectSetString(0, szObj, OBJPROP_TOOLTIP, szDescr);
049.             ObjectSetInteger(0, szObj, OBJPROP_SELECTABLE, ePrio != ePriorityNull);
050.             CreateObjectGraphics(szObj = def_NameBtnClose, OBJ_BITMAP_LABEL, clrNONE, (EnumPriority)(ePriorityDefault));
051.             ObjectSetString(0, szObj, OBJPROP_BMPFILE, 0, "::" + def_Btn_Close);
052.             ObjectSetInteger(0, szObj, OBJPROP_ANCHOR, ANCHOR_CENTER);
053.         }
054. //+------------------------------------------------------------------+
055.         ~C_ElementsTrade()
056.         {
057.             if (m_Info.szPrefixName != "")
058.                 ObjectsDeleteAll(0, m_Info.szPrefixName);
059.         }
060. //+------------------------------------------------------------------+
061.         inline void UpdatePrice(const double price)
062.         {
063.             m_Info.price = price;
064.             UpdateViewPort();
065.         }
066. //+------------------------------------------------------------------+
067.         void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam)
068.         {            
069.             C_Mouse::DispatchMessage(id, lparam, dparam, sparam);
070.             switch (id)
071.             {
072.                 case CHARTEVENT_OBJECT_CLICK:
073.                     if ((m_Info.bClick) && (GetPositionsMouse().szObjNameClick == def_NameBtnClose)) switch (m_Info.ev)
074.                     {
075.                         case evMsgClosePositionEA:
076.                             EventChartCustom(0, evMsgClosePositionEA, m_Info.ticket, 0, "");
077.                             break;
078.                         case evMsgCloseTakeProfit:
079.                             EventChartCustom(0, evMsgCloseTakeProfit, m_Info.ticket, PositionGetDouble(POSITION_SL), PositionGetString(POSITION_SYMBOL));
080.                             break;
081.                         case evMsgCloseStopLoss:
082.                             EventChartCustom(0, evMsgCloseStopLoss, m_Info.ticket, PositionGetDouble(POSITION_TP), PositionGetString(POSITION_SYMBOL));
083.                         break;
084.                     }
085.                     m_Info.bClick = false;
086.                     break;
087.                 case CHARTEVENT_MOUSE_MOVE:
088.                     m_Info.bClick = (CheckClick(C_Mouse::eClickLeft) ? true : m_Info.bClick);
089.                     break;
090.                 case CHARTEVENT_CHART_CHANGE:
091.                     UpdateViewPort();
092.                     break;
093.             }
094.         }
095. //+------------------------------------------------------------------+
096. };
097. //+------------------------------------------------------------------+
098. #undef def_Btn_Close
099. #undef def_PathBtns
100. //+------------------------------------------------------------------+
101. #undef def_NameBtnClose
102. #undef def_NameHLine
103. //+------------------------------------------------------------------+

C_ElementsTrade.mqh

Mehrere der zuvor enthaltenen Elemente wurden entfernt, was beim Vergleich der beiden Codeausschnitte deutlich wird. Beachten Sie jedoch, dass in Zeile 23 eine neue Variable aufgetaucht ist. Sie wird in der Prozedur „DispatchMessage“ verwendet. Ansonsten hat sich nichts geändert. Aber schauen wir uns doch einmal an, wie die Prozedur „DispatchMessage“ nun funktioniert, da sie sich ab jetzt auf MetaTrader 5 stützt.

Beachten Sie, dass wir in Zeile 67, wo die Prozedur „DispatchMessage“ beginnt, keine wesentlichen Änderungen vorgenommen haben. Wir haben den bestehenden Code einfach angepasst. Beachten Sie, dass wir im Ereignisbehandler für CHARTEVENT_MOUSE_MOVE in Zeile 87 – zusätzlich zum Mausindikator – prüfen, ob der Klick gültig ist oder nicht. Wir gehen dabei recht einfach und unkompliziert vor. Somit wird die Variable aus Zeile 23 bei einem gültigen Mausklick auf „true“ gesetzt oder auf „false“, wenn der Mausindikator irgendeine Art von Analyse durchführt. Dies ist der Teil, den unsere Anwendung verarbeiten wird. Der Teil, bei dem uns MetaTrader 5 helfen kann, ist im Abschnitt zum Ereignis CHARTEVENT_OBJECT_CLICK ab Zeile 72 zu sehen.

Beachten Sie ein Detail in diesem Code, insbesondere beim Ereignis CHARTEVENT_OBJECT_CLICK. Das ist genau dasselbe wie im vorherigen Artikel. Dies geschah jedoch im Ereignis CHARTEVENT_MOUSE_MOVE. Aber werden wir dabei auf Probleme stoßen? Eigentlich nicht, denn ein Mausbewegungsereignis tritt vor dem Klickereignis ein. Und wenn ein Klick erfolgt, prüfen wir, ob er gültig ist oder nicht. Wie im vorherigen Artikel gezeigt, wird nur eine Aktion ausgeführt – allerdings nur, wenn der Klick gültig ist und der Name des Objekts mit dem Namen übereinstimmt, der gerade verarbeitet wird. Mit anderen Worten: das Objekt, das die Schließen-Schaltfläche darstellt. Alles andere wurde bereits ausführlich erläutert, sodass keine weiteren Erläuterungen erforderlich sind.

Bevor wir diesen Artikel jedoch abschließen, werden wir eine kleine Änderung am System vornehmen. Das liegt daran, dass es wenig Sinn ergibt, eine horizontale Linie zu haben, die sich über die gesamte Breite des Charts erstreckt und auf der sich irgendwo eine Schließen-Schaltfläche befindet. Wir können das so verbessern, dass die Linie an der Schließen-Schaltfläche endet, was etwas sinnvoller wäre. Damit wird jedoch die Grundlage für eine weitere Änderung geschaffen, die in Zukunft umgesetzt werden soll. Um dem gewünschten Ergebnis jedoch näher zu kommen, müssen wir die Klasse anpassen. Da ich mir nicht ganz sicher bin, wie es von hier aus weitergeht, betrachten Sie das, was wir gleich erläutern, daher nicht als endgültige Lösung, versuchen Sie aber, zu verstehen, wie es funktioniert. Das könnte Ihnen in Zukunft nützlich sein.


Vorbereitung auf die nächsten Schritte

Der nächste Schritt, den wir unternehmen werden, mag etwas absurd und sogar unnötig erscheinen. Dies ist jedoch im Hinblick auf das, was wir als Nächstes umsetzen werden, von Bedeutung. Was ist also der wichtigste Punkt in dieser Phase? Die Idee dahinter ist, eine visuelle und hinreichend eindeutige Möglichkeit zu schaffen, genau zu erkennen, welche Linie wir gerade steuern. Und warum ist das wichtig? Der Grund dafür ist, dass wir ein System nutzen können, bei dem die Linie mit einem Klick ausgewählt und mit einem weiteren Klick wieder freigegeben wird. Und ohne genau zu wissen, mit welcher Linie wir gerade arbeiten, ist es sehr schwierig, dies korrekt zu bewerkstelligen. Deshalb brauchen wir eine einfache und effektive Möglichkeit, diese Informationen bereitzustellen.

Viele denken vielleicht: „Da wir eine offene Position haben, können wir einfach ein internes Umschaltsystem einrichten.“ Und auch hier stimme ich Ihnen zu, lieber Leser. Die Implementierung eines internen Umschaltsystems ist die sinnvollste Lösung. Betrachten wir das Ganze jedoch einmal etwas allgemeiner. Bedenken Sie Folgendes: Wenn Sie ein Hedging-Konto nutzen, ist das Umschaltsystem nicht effektiv genug, da möglicherweise zwei oder mehr Positionsindikatoren gleichzeitig auf demselben Chart angezeigt werden. Dies macht die Umsetzung einer solchen Umschaltung recht kompliziert, da Sie möglicherweise zunächst auf die Linie einer Position und anschließend auf die Linie einer anderen Position klicken. Mit anderen Worten: In diesem Fall werden wir auf ein Problem stoßen.

Darüber hinaus gibt es ein weiteres Problem, das zwar derzeit keine Auswirkungen auf unsere Arbeit hat, in Zukunft jedoch enorme Schwierigkeiten mit sich bringen wird, wenn wir die Architektur nicht universeller gestalten. Wir sprechen hier von Pending Orders. Pending Orders werden ein System nutzen, das dem System, das wir jetzt entwickeln werden, sehr ähnlich ist. Folglich reicht eine interne Umschaltung nicht aus, um die entsprechenden Änderungen vorzunehmen. Glücklicherweise haben wir jedoch eine ebenso einfache Lösung, die alle möglichen Szenarien vollständig abdeckt. Dabei kommt der Nachrichtenaustausch zwischen den Indikatoren zum Einsatz. Sie könnten meinen, dass dies eine äußerst komplexe Aufgabe ist, die sich nur schwer umsetzen lässt. Aber wird das wirklich so sein? Bevor wir uns die erforderlichen Änderungen ansehen, wollen wir zunächst einen Blick darauf werfen, was sich in der Headerdatei „Defines.mqh“ geändert hat. Sie ist im Folgenden zu sehen:

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.             evMsgSetFocus                    //Event to communication
54.                         };
55. //+------------------------------------------------------------------+
56. enum EnumPriority {                          //Priority list on objects
57.             ePriorityNull = -1,
58.             ePriorityDefault = 0
59.                         };
60. //+------------------------------------------------------------------+

Defines.mqh

Beachten Sie, dass in Zeile 53 ein neues Ereignis definiert wird. Wir werden dieses Ereignis nutzen, um die gewünschte Aufgabe zu erfüllen. Als Nächstes können wir uns den Code der Klasse „C_ElementsTrade“ ansehen, um die Änderungen zu erkennen, die erforderlich waren, um das erwartete Ergebnis zu erzielen. Den gesamten Klassencode finden 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 macro_LineInFocus(A) ObjectSetInteger(0, def_NameHLine, OBJPROP_YSIZE, m_Info.weight = (A ? 7 : 3));
008. //+------------------------------------------------------------------+
009. #define def_PathBtns "Images\\Market Replay\\Orders\\"
010. #define def_Btn_Close def_PathBtns + "Btn_Close.bmp"
011. #resource "\\" + def_Btn_Close;
012. //+------------------------------------------------------------------+
013. #include "..\Auxiliar\C_Mouse.mqh"
014. //+------------------------------------------------------------------+
015. class C_ElementsTrade : private C_Mouse
016. {
017.     private    :
018. //+------------------------------------------------------------------+
019.         struct st00
020.         {
021.             ulong       ticket;
022.             string      szPrefixName;
023.             EnumEvents  ev;
024.             double      price;
025.             bool        bClick;
026.             char        weight;
027.         }m_Info;
028. //+------------------------------------------------------------------+
029.         void UpdateViewPort(void)
030.         {
031.             int x, y;
032.             
033.             ChartTimePriceToXY(0, 0, 0, m_Info.price, x, y);            
034.             x = (m_Info.ev == evMsgClosePositionEA ? 150 : (m_Info.ev == evMsgCloseTakeProfit ? 200 : 250));
035.             ObjectSetInteger(0, def_NameHLine, OBJPROP_XDISTANCE, x);
036.             ObjectSetInteger(0, def_NameHLine, OBJPROP_YDISTANCE, y - (m_Info.weight / 2));
037.             ObjectSetInteger(0, def_NameBtnClose, OBJPROP_XDISTANCE, x);
038.             ObjectSetInteger(0, def_NameBtnClose, OBJPROP_YDISTANCE, y);
039.         }
040. //+------------------------------------------------------------------+
041.     public    :
042. //+------------------------------------------------------------------+
043.         C_ElementsTrade(const ulong ticket, const EnumEvents ev, color _color, EnumPriority ePrio, string szDescr = "\n")
044.             :C_Mouse(0, "")
045.         {
046.             string szObj;
047.             
048.             ZeroMemory(m_Info);
049.             m_Info.szPrefixName = StringFormat("%I64u@%03d", m_Info.ticket = ticket, (int)(m_Info.ev = ev));
050.             CreateObjectGraphics(szObj = def_NameHLine, OBJ_RECTANGLE_LABEL, _color, (EnumPriority)(ePriorityDefault));
051.             macro_LineInFocus(false);
052.             ObjectSetInteger(0, szObj, OBJPROP_BGCOLOR, _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, szDescr);
057.             ObjectSetInteger(0, szObj, OBJPROP_SELECTABLE, ePrio != ePriorityNull);
058.             CreateObjectGraphics(szObj = def_NameBtnClose, OBJ_BITMAP_LABEL, clrNONE, (EnumPriority)(ePriorityDefault));
059.             ObjectSetString(0, szObj, OBJPROP_BMPFILE, 0, "::" + def_Btn_Close);
060.             ObjectSetInteger(0, szObj, OBJPROP_ANCHOR, ANCHOR_CENTER);
061.         }
062. //+------------------------------------------------------------------+
063.         ~C_ElementsTrade()
064.         {
065.             ObjectsDeleteAll(0, m_Info.szPrefixName);
066.         }
067. //+------------------------------------------------------------------+
068.         inline void UpdatePrice(const double price)
069.         {
070.             m_Info.price = price;
071.             UpdateViewPort();
072.         }
073. //+------------------------------------------------------------------+
074.         void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam)
075.         {
076.             string sz0;
077.             
078.             C_Mouse::DispatchMessage(id, lparam, dparam, sparam);
079.             switch (id)
080.             {
081.                 case CHARTEVENT_CUSTOM + evMsgSetFocus:
082.                     macro_LineInFocus((m_Info.ticket == (ulong)(lparam)) && ((EnumEvents)(dparam) == m_Info.ev));
083.                     break;
084.                 case CHARTEVENT_OBJECT_CLICK:
085.                     sz0 = GetPositionsMouse().szObjNameClick;
086.                     if (m_Info.bClick) switch (m_Info.ev)
087.                     {
088.                         case evMsgClosePositionEA:
089.                             if (sz0 == def_NameBtnClose)
090.                                 EventChartCustom(0, evMsgClosePositionEA, m_Info.ticket, 0, "");
091.                             else if (sz0 == def_NameHLine)
092.                                 EventChartCustom(0, evMsgSetFocus, 0, 0, "");
093.                             break;
094.                         case evMsgCloseTakeProfit:
095.                             if (sz0 == def_NameBtnClose)
096.                                 EventChartCustom(0, evMsgCloseTakeProfit, m_Info.ticket, PositionGetDouble(POSITION_SL), PositionGetString(POSITION_SYMBOL));
097.                             else if (sz0 == def_NameHLine)
098.                                 EventChartCustom(0, evMsgSetFocus, m_Info.ticket, evMsgCloseTakeProfit, "");
099.                             break;
100.                         case evMsgCloseStopLoss:
101.                             if (sz0 == def_NameBtnClose)
102.                                 EventChartCustom(0, evMsgCloseStopLoss, m_Info.ticket, PositionGetDouble(POSITION_TP), PositionGetString(POSITION_SYMBOL));
103.                             else if (sz0 == def_NameHLine)
104.                                 EventChartCustom(0, evMsgSetFocus, m_Info.ticket, evMsgCloseStopLoss, "");
105.                             break;
106.                     }
107.                     m_Info.bClick = false;
108.                     break;
109.                 case CHARTEVENT_MOUSE_MOVE:
110.                     m_Info.bClick = (CheckClick(C_Mouse::eClickLeft) ? true : m_Info.bClick);
111.                     break;
112.                 case CHARTEVENT_CHART_CHANGE:
113.                     UpdateViewPort();
114.                     break;
115.             }
116.         }
117. //+------------------------------------------------------------------+
118. };
119. //+------------------------------------------------------------------+
120. #undef macro_LineInFocus
121. //+------------------------------------------------------------------+
122. #undef def_Btn_Close
123. #undef def_PathBtns
124. //+------------------------------------------------------------------+
125. #undef def_NameBtnClose
126. #undef def_NameHLine
127. //+------------------------------------------------------------------+

C_ElementsTrade.mqh

Das erwartete Ergebnis sehen Sie in der folgenden Animation.

Ich zeige dieses Ergebnis, bevor ich den Code erkläre, damit Sie, lieber Leser, bereits erkennen, worum es in der folgenden Erklärung geht. Dieser Mechanismus könnte in Zukunft noch etwas verändert werden. Sollten Sie jedoch irgendwann einmal etwas Derartiges tun müssen, sollten Sie wissen, dass es dafür mehrere Möglichkeiten gibt. Aber Sie müssen verstehen, warum diese Methoden funktionieren. Nach diesen Erläuterungen sind Sie vermutlich neugierig, wie wir die vorherige Animation ohne einen herkömmlichen Umschaltmechanismus implementieren konnten. Schauen wir uns also einmal an, wie und warum das geschieht.

Beachten Sie zunächst, dass wir in Zeile 07 ein Makro definiert haben, um die Linie, die den Fokus erhält, besonders deutlich hervorzuheben. In Zeile 26 habe ich eine neue Variable definiert, in der der in dieser Klasse festgelegte Wert für die Linienstärke gespeichert wird. In Zeile 36 zentrieren wir die hier erstellte Linie. Um diesen Vorgang korrekt auszuführen, muss die Linienstärke auf eine ungerade Zahl eingestellt werden. Wenn Sie eine gerade Zahl angeben, beispielsweise zwei oder vier, wird die Linie leicht gegenüber ihrer idealen Position versetzt. Beachten Sie noch etwas: In Zeile 34 legen wir die Position der einzelnen Schaltflächen fest. Dadurch wird verhindert, dass sie zu nahe beieinander liegen oder sich überlappen. Ein zu geringer Abstand oder eine Überlappung würden die Bedienung der Schaltflächen erschweren. Diese Werte sind zwar noch nicht endgültig, erfüllen aber bereits ihren Zweck.

So weit, so gut. Schauen Sie sich nun die Änderung im Konstruktor der Klasse an. Bisher wurde das HLINE-Objekt verwendet, um eine Kurslinie darzustellen. Nun verwenden wir jedoch das Objekt OBJ_RECTANGLE_LABEL. Diese Änderung ermöglicht es uns, eine Obergrenze für die Länge der horizontalen Linien festzulegen. Auf diese Weise erstrecken sie sich nicht von einem Rand des Charts zum anderen. Der Grund, OBJ_RECTANGLE_LABEL anstelle von OBJ_TREND zu verwenden, liegt genau darin, dass Trendlinien eine Zeitverankerung benötigen. Das lässt sich in manchen Situationen nur schwer richtig einrichten. Im Gegensatz dazu verwendet das Objekt OBJ_RECTANGLE_LABEL kartesische Koordinaten. Das eignet sich perfekt für unsere Zwecke.

Der Großteil des Codes bleibt unverändert, obwohl wir ein anderes Objekt als horizontale Linie verwenden. Die eigentlichen Änderungen wurden jedoch in der Prozedur in Zeile 74 vorgenommen, d. h. in der Funktion „DispatchMessage“. In dieser Phase mag die Situation zunächst etwas verwirrend erscheinen, aber es besteht kein Grund zur Panik. Passen Sie einfach gut auf, dann wird Ihnen alles klar.

Beachten Sie, dass in Zeile 81 die Nachricht verarbeitet wird, die wir in der Datei „Defines.mqh“ erstellt haben. Diese Nachricht gibt es hier jedoch nur, weil wir die Verallgemeinerung auf die Spitze treiben. Denken Sie daran, dass die Nachrichtenverarbeitung sehr einfach ist. Wenn die Klasse „C_ElementsTrade“ die Nachricht „evMsgSetFocus“ empfängt, prüft sie, ob der Wert von „lparam“ mit dem Ticket übereinstimmt, das von der Klasse verfolgt wird. Außerdem muss der Parameter „dparam“ einen der Ereigniswerte enthalten. Ist dies nicht der Fall, wird die Linienstärke wieder verringert. Ist die Bedingung erfüllt, wird die Linienstärke erhöht. Das ist ganz einfach.

„Aber Moment mal. Woran erkennt die Klasse, wann die Linie dicker oder dünner wird? Sollte das nicht irgendwo definiert sein?“ Ja, lieber Leser. Die eigentliche Aufgabe, dies zu signalisieren, wird von den in den Zeilen 92, 98 und 104 beschriebenen Ereignissen übernommen. Jedes dieser Ereignisse wird nur ausgelöst, wenn ein gültiger Mausklick auf den Indikator erfolgt. Beachten Sie, dass das Auslösen dieser Ereignisse konkret vom Namen des angeklickten Objekts abhängt. „Ja, aber warum gerade so? Wäre es nicht schneller, einfacher und praktischer, ein Makro zu verwenden, anstatt diese Ereignisse auszulösen?“ Und wieder einmal haben Sie recht, lieber Leser.

Dies würde uns jedoch genau zu dem Problem führen, das auftritt, wenn mehr als ein Positionsindikator im Chart angezeigt wird. Oder wenn wir Indikatoren für Pending Orders haben. In diesem Fall könnte ein Indikator einem anderen nicht mitteilen, dass er den Fokus verloren hat und nicht mehr der aktive Indikator ist. Durch diesen speziellen Mechanismus zum Nachrichtenaustausch ermöglichen wir jedoch allen Indikatoren, perfekt zusammenzuarbeiten und genau zu wissen, was sie tun sollen und was nicht. Auch wenn dieser Mechanismus hinsichtlich der Umsetzung vielleicht nicht besonders effizient ist, ist er doch recht praktisch und sicher. Zudem ist er aus Sicht der Umsetzung wesentlich einfacher als ein effizienterer Mechanismus.


Abschließende Gedanken

Mit einem Demokonto können Sie sich selbst ein Bild davon machen, wie dieser Mechanismus funktioniert. Ich empfehle Ihnen, ein MetaQuotes-Demokonto zu nutzen, damit Sie sehen können, wie der Mechanismus funktioniert, wenn Sie mehrere offene Positionen haben. Glauben Sie mir, es wird sehr interessant sein, das näher zu untersuchen.

Wenn Sie das tun, werden Sie wahrscheinlich feststellen, dass Sie bei der Auswahl von Linien auf Schwierigkeiten stoßen, selbst wenn diese dicker als 1 Pixel sind. Manchmal ist es ziemlich schwierig, Linien auszuwählen. Um die Sache noch einfacher zu machen, werden wir sie im nächsten Artikel ein wenig verbessern. Außerdem werden wir natürlich direkt im Chart arbeiten, ohne das Terminalsystem nutzen zu müssen, um Stop-Loss- und Take-Profit-Linien zu erstellen.

In der angehängten Datei finden Sie ausführbare Dateien, mit denen Sie die behandelten Inhalte ausprobieren können. Dies richtet sich an diejenigen, die nicht wissen, wie man das gesamte System kompiliert.

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 Replikations-/Simulationsdienst (für diese Interaktion ist „Mouse Study“ erforderlich).
Indicators\Mouse Study.mq5 Ermöglicht die Interaktion zwischen grafischen Steuerelementen und dem Benutzer (was sowohl für das Replikations-/Simulationssystem als auch für den Live-Handel erforderlich ist).
Indicators\Order Indicator.mq5 Zuständig für die Anzeige von Market Orders sowie für die Interaktion mit ihnen und ihre Steuerung.
Indicators\Position View.mq5 Zuständig für die Darstellung von Marktpositionen sowie für die Interaktion mit diesen und deren Steuerung.
Services\Market Replay.mq5 Erstellt und verwaltet den Dienst für die Marktreplikation/-simulation (die Hauptdatei des gesamten Systems).

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

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 bis zur Mittelstufe: Warteschlangen, Listen und Bäume (II) Von den Grundlagen bis zur Mittelstufe: Warteschlangen, Listen und Bäume (II)
Dies ist ein Artikel, den Sie, lieber Leser, sorgfältig durcharbeiten sollten. Das liegt an der Art des hier vorgestellten Materials. Obwohl wir uns bemüht haben, den Stoff so einfach und informativ wie möglich darzustellen, können die hier bereitgestellten Informationen für diejenigen, die gerade erst mit dem Programmieren beginnen, durchaus recht komplex erscheinen. Dennoch ist dies kein Grund, den Mut zu verlieren oder das hier Erläuterte zu ignorieren, da dieser Artikel eine Verbindung zwischen zwei völlig unterschiedlichen, wenn auch eng miteinander verbundenen Themen herstellen wird.
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: Eine einheitliche Betrachtung von Raum und Zeit (Extralonger) Neuronale Netze im Handel: Eine einheitliche Betrachtung von Raum und Zeit (Extralonger)
Das Extralonger-Framework veranschaulicht einen Ansatz zur Integration räumlicher und zeitlicher Faktoren in ein einziges Modell, wodurch es möglich wird, sowohl lokale Muster als auch langfristige Zyklen gleichzeitig zu berücksichtigen. Diese Architektur macht Zeitreihenprognosen widerstandsfähiger gegenüber Marktrauschen und ermöglicht die Datenanalyse über verschiedene Zeithorizonte hinweg. Der Artikel befasst sich eingehend damit, wie diese Ideen mithilfe von OpenCL und MQL5 in die Praxis umgesetzt werden.