Marktsimulation: Positionsansicht (XI)
Einleitung
Hallo, liebe Freunde! Willkommen zu einem weiteren Artikel unserer Reihe über die Erstellung eines Systems zur Marktwiedergabe und Marktsimulation.
Im vorherigen Artikel „Marktsimulation: Positionsansicht (X)“ haben wir erläutert, wie wir mithilfe von MetaTrader 5 die Objekte auswählen können, die wir im Chart erstellen. Bis zu diesem Zeitpunkt bestand die größte Herausforderung darin, eine zufriedenstellende Methode zur Auswahl von Objekten im Chart zu finden. Ohne die Hilfe von MetaTrader 5 und die Verwendung der Eigenschaft „ZOrder“ wäre diese Aufgabe ziemlich schwierig. Wie wir jedoch im vorherigen Artikel gezeigt haben, haben wir einen recht praktischen und effektiven Weg gefunden, MetaTrader 5 zu unserem Vorteil zu nutzen.
Sobald wir dieses Ergebnis erreicht hatten, wurde klar, dass wir noch ein weiteres Problem zu lösen hatten. Die konkrete Herausforderung besteht darin, Preislinien auszuwählen. Auch wenn diese Linien vergleichsweise dick sind, ist ihre Auswahl dennoch keine leichte Aufgabe. Vor allem, wenn es relativ schnell gehen muss und die Linien sehr dicht beieinander liegen.
Es ist absolut unerlässlich, die richtige Linie auszuwählen, und zwar so schnell wie möglich; dabei müssen wir jedoch auch wohlüberlegt vorgehen. Wir werden nicht nur eine Linie auswählen, sondern möchten auch die Möglichkeit bieten, direkt im Chart eine Preislinie zu erstellen, sei es eine Take-Profit-Linie oder eine Stop-Loss-Linie. Für einen Trader sollte dieser Vorgang so einfach wie möglich sein. Nicht aus Sicht des Codes, sondern aus Sicht des Traders.
Vor einiger Zeit haben wir in diesen Artikeln ein Modell vorgestellt, das meiner Meinung nach für unsere Anforderungen sehr gut geeignet ist. Dieses Modell war jedoch vollständig an den Expert Advisor gebunden, sodass es schwierig war, es aus dessen interner Struktur herauszulösen. Da dies jedoch für unsere Zwecke relevant ist, werden wir erklären, wie man dabei vorgeht. Diesmal werden wir dies jedoch als Indikator umsetzen. Na gut, dann fangen wir mal an.
Erstellen einer Schaltfläche zum Verschieben von Preisniveaus
Die Idee hinter diesem schon recht alten Modell bestand darin, die gewünschte Linie über eine spezielle Schaltfläche auszuwählen. Mit dieser Schaltfläche können Sie nicht nur eine Linie auswählen, sondern auch eine Linie erstellen, falls sie im Chart noch nicht vorhanden ist. Außerdem erfüllt sie weitere kleinere Funktionen, auf die wir in diesem Artikel ebenfalls eingehen werden. Das Erste, was Sie also tun müssen, ist im folgenden Code dargestellt:
001. //+------------------------------------------------------------------+ 002. #property copyright "Daniel Jose" 003. //+------------------------------------------------------------------+ 004. #define def_NameHLine m_Info.szPrefixName + "#HLINE" 005. #define def_NameBtnClose m_Info.szPrefixName + "#CLOSE" 006. #define def_NameBtnMove m_Info.szPrefixName + "#MOVE" 007. //+------------------------------------------------------------------+ 008. #define macro_LineInFocus(A) ObjectSetInteger(0, def_NameHLine, OBJPROP_YSIZE, m_Info.weight = (A ? 3 : 1)); 009. //+------------------------------------------------------------------+ 010. #define def_PathBtns "Images\\Market Replay\\Orders\\" 011. #define def_Btn_Close def_PathBtns + "Btn_Close.bmp" 012. #resource "\\" + def_Btn_Close; 013. //+------------------------------------------------------------------+ 014. #include "..\Auxiliar\C_Mouse.mqh" 015. //+------------------------------------------------------------------+ 016. class C_ElementsTrade : private C_Mouse 017. { 018. private : 019. //+------------------------------------------------------------------+ 020. struct st00 021. { 022. ulong ticket; 023. string szPrefixName; 024. EnumEvents ev; 025. double price; 026. bool bClick; 027. char weight; 028. }m_Info; 029. //+------------------------------------------------------------------+ 030. void UpdateViewPort(void) 031. { 032. int x, y; 033. 034. ChartTimePriceToXY(0, 0, 0, m_Info.price, x, y); 035. x = (m_Info.ev == evMsgClosePositionEA ? 150 : (m_Info.ev == evMsgCloseTakeProfit ? 220 : 290)); 036. ObjectSetInteger(0, def_NameHLine, OBJPROP_XDISTANCE, x); 037. ObjectSetInteger(0, def_NameHLine, OBJPROP_YDISTANCE, y - (m_Info.weight > 1 ? (int)(m_Info.weight / 2) : 0)); 038. ObjectSetInteger(0, def_NameBtnClose, OBJPROP_XDISTANCE, x); 039. ObjectSetInteger(0, def_NameBtnClose, OBJPROP_YDISTANCE, y); 040. ObjectSetInteger(0, def_NameBtnMove, OBJPROP_XDISTANCE, x + 30); 041. ObjectSetInteger(0, def_NameBtnMove, OBJPROP_YDISTANCE, y); 042. } 043. //+------------------------------------------------------------------+ 044. inline void CreateLinePrice(const color _color, const string szDescr) 045. { 046. string szObj; 047. 048. CreateObjectGraphics(szObj = def_NameHLine, OBJ_RECTANGLE_LABEL, _color, (EnumPriority)(ePriorityDefault)); 049. macro_LineInFocus(false); 050. ObjectSetInteger(0, szObj, OBJPROP_BGCOLOR, _color); 051. ObjectSetInteger(0, szObj, OBJPROP_XSIZE, TerminalInfoInteger(TERMINAL_SCREEN_WIDTH)); 052. ObjectSetInteger(0, szObj, OBJPROP_BORDER_TYPE, BORDER_FLAT); 053. ObjectSetInteger(0, szObj, OBJPROP_CORNER, CORNER_LEFT_UPPER); 054. ObjectSetString(0, szObj, OBJPROP_TOOLTIP, szDescr); 055. } 056. //+------------------------------------------------------------------+ 057. inline void CreateBoxMove(const color _color) 058. { 059. string szObj; 060. 061. CreateObjectGraphics(szObj = def_NameBtnMove, OBJ_LABEL, _color, (EnumPriority)(ePriorityDefault)); 062. ObjectSetString(0, szObj, OBJPROP_FONT, "Wingdings"); 063. ObjectSetString(0, szObj, OBJPROP_TEXT, "u"); 064. ObjectSetInteger(0, szObj, OBJPROP_FONTSIZE, 17); 065. ObjectSetInteger(0, szObj, OBJPROP_ANCHOR, ANCHOR_CENTER); 066. ObjectSetInteger(0, szObj, OBJPROP_XSIZE, 21); 067. ObjectSetInteger(0, szObj, OBJPROP_YSIZE, 23); 068. } 069. //+------------------------------------------------------------------+ 070. inline void CreateButtonClose(void) 071. { 072. string szObj; 073. 074. CreateObjectGraphics(szObj = def_NameBtnClose, OBJ_BITMAP_LABEL, clrNONE, (EnumPriority)(ePriorityDefault)); 075. ObjectSetString(0, szObj, OBJPROP_BMPFILE, 0, "::" + def_Btn_Close); 076. ObjectSetInteger(0, szObj, OBJPROP_ANCHOR, ANCHOR_CENTER); 077. } 078. //+------------------------------------------------------------------+ 079. public : 080. //+------------------------------------------------------------------+ 081. C_ElementsTrade(const ulong ticket, const EnumEvents ev, color _color, EnumPriority ePrio, string szDescr = "\n") 082. :C_Mouse(0, "") 083. { 084. ZeroMemory(m_Info); 085. m_Info.szPrefixName = StringFormat("%I64u@%03d", m_Info.ticket = ticket, (int)(m_Info.ev = ev)); 086. CreateLinePrice(_color, szDescr); 087. if (ev != evMsgClosePositionEA) CreateBoxMove(_color); 088. CreateButtonClose(); 089. } 090. //+------------------------------------------------------------------+ 091. ~C_ElementsTrade() 092. { 093. ObjectsDeleteAll(0, m_Info.szPrefixName); 094. } 095. //+------------------------------------------------------------------+ 096. inline void UpdatePrice(const double price) 097. { 098. m_Info.price = price; 099. UpdateViewPort(); 100. } 101. //+------------------------------------------------------------------+ 102. void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam) 103. { 104. string sz0; 105. 106. C_Mouse::DispatchMessage(id, lparam, dparam, sparam); 107. switch (id) 108. { 109. case CHARTEVENT_CUSTOM + evMsgSetFocus: 110. macro_LineInFocus((m_Info.ticket == (ulong)(lparam)) && ((EnumEvents)(dparam) == m_Info.ev)); 111. m_Info.bClick = false; 112. case CHARTEVENT_CHART_CHANGE: 113. UpdateViewPort(); 114. break; 115. case CHARTEVENT_OBJECT_CLICK: 116. sz0 = GetPositionsMouse().szObjNameClick; 117. if (m_Info.bClick) switch (m_Info.ev) 118. { 119. case evMsgClosePositionEA: 120. if (sz0 == def_NameBtnClose) 121. EventChartCustom(0, evMsgClosePositionEA, m_Info.ticket, 0, ""); 122. break; 123. case evMsgCloseTakeProfit: 124. if (sz0 == def_NameBtnClose) 125. EventChartCustom(0, evMsgCloseTakeProfit, m_Info.ticket, PositionGetDouble(POSITION_SL), PositionGetString(POSITION_SYMBOL)); 126. else if (sz0 == def_NameBtnMove) 127. EventChartCustom(0, evMsgSetFocus, m_Info.ticket, evMsgCloseTakeProfit, ""); 128. break; 129. case evMsgCloseStopLoss: 130. if (sz0 == def_NameBtnClose) 131. EventChartCustom(0, evMsgCloseStopLoss, m_Info.ticket, PositionGetDouble(POSITION_TP), PositionGetString(POSITION_SYMBOL)); 132. else if (sz0 == def_NameBtnMove) 133. EventChartCustom(0, evMsgSetFocus, m_Info.ticket, evMsgCloseStopLoss, ""); 134. break; 135. } 136. m_Info.bClick = false; 137. break; 138. case CHARTEVENT_MOUSE_MOVE: 139. m_Info.bClick = (CheckClick(C_Mouse::eClickLeft) ? true : m_Info.bClick); 140. if (m_Info.bClick && (m_Info.weight > 1)) EventChartCustom(0, evMsgSetFocus, 0, 0, ""); 141. break; 142. } 143. } 144. //+------------------------------------------------------------------+ 145. }; 146. //+------------------------------------------------------------------+ 147. #undef macro_LineInFocus 148. //+------------------------------------------------------------------+ 149. #undef def_Btn_Close 150. #undef def_PathBtns 151. //+------------------------------------------------------------------+ 152. #undef def_NameBtnMove 153. #undef def_NameBtnClose 154. #undef def_NameHLine 155. //+------------------------------------------------------------------+
C_ElementsTrade.mqh
An dieser Stelle beginnen wir mit der weiteren Verbesserung der Objektverwaltung. Beachten Sie, dass wir in Zeile 06 eine neue Definition erstellt haben. Dadurch wird dem Objekt, das unser Verschiebesymbol darstellen soll, ein Name zugewiesen. Solange dieses Element fehlt, kann die Linie nicht verschoben werden. Wenn dieses Element vorhanden ist, kann die Linie verschoben werden. Vorerst werden wir uns jedoch noch nicht mit dem Verschieben der Linie befassen. Schauen wir uns zunächst einmal an, wie man die Auswahl verwaltet.
Bitte beachten Sie, dass sich der Code nur geringfügig geändert hat. So können Sie den gesamten Prozess Schritt für Schritt wirklich verstehen. Wenn Sie möchten, können Sie also ganz einfach ändern, was wir anzeigen.
In Zeile 40 legen wir die Position unseres neuen Objekts auf der X-Achse fest. Bitte beachten Sie, dass wir zwischen diesem Objekt und der Schließen-Schaltfläche einen kleinen Abstand gelassen haben. Jetzt gut aufpassen: In Zeile 35 habe ich den Versatz der Objekte so angepasst, dass sie sich nicht überlappen. Dadurch entsteht ein kleiner Abstand zwischen ihnen, sodass es keine Probleme geben wird, wenn dieser Indikator im Chart angezeigt wird.
Um zukünftige Änderungen noch einfacher zu gestalten, habe ich die Prozeduren, die Objekte erstellen, aus dem Konstruktor ausgelagert. So sind die Prozeduren „CreateLinePrice“ und „CreateButtonClose“ entstanden. Die Logik dieser Prozeduren befand sich früher im Konstruktor. Daher werde ich nicht näher darauf eingehen. Da die Prozedur „CreateBoxMove“ jedoch neu ist, ist eine kurze Erläuterung angebracht. In dieser Prozedur erstellen wir einfach ein OBJ_LABEL-Objekt und weisen ihm Text zu. Eigentlich ist es nur ein Zeichen. Dadurch wird angezeigt, ob wir die Preislinie auswählen und folglich verschieben können. Da der Code sehr einfach ist, halte ich eine ausführliche Erklärung nicht für notwendig.
Sehen Sie sich nun die folgenden Details im Konstruktor an. Um genauer zu sein: Schauen Sie sich Zeile 87 an. In dieser Zeile prüfen wir, ob das erstellte Steuerelement zum Schließen der Position dient. Ist dies nicht der Fall, können wir das Verschiebeobjekt für die Preislinie erstellen. Super, jetzt können wir zur Prozedur „DispatchMessage“ übergehen. In dieser Prozedur wurden einige weitere wesentliche Änderungen vorgenommen. Diese Änderungen sollen jedoch Code-Duplikate vermeiden, da bestimmte Aufgaben kaskadierend abgewickelt werden können.
Das lässt sich anhand des Ereignisses in Zeile 109 erkennen: In diesem Ereignis setzen wir in Zeile 111 den Status des Mausklicks auf „false“. Doch dieses Ereignis in Zeile 109 endet nicht so, wie viele es erwarten würden. Tatsächlich läuft die Ausführung ohne Unterbrechung in den nächsten case-Zweig, CHARTEVENT_CHART_CHANGE in Zeile 112, weiter. Aber warum sollte man das tun oder zulassen, dass so etwas passiert? Der Grund dafür ist einfach. Wenn sich die Linienstärke ändert, muss die Linie im Chart neu gezeichnet werden. Würden wir die Ausführung nach dem benutzerdefinierten Ereignis nicht in den Zweig zum Neuzeichnen weiterlaufen lassen, müssten wir innerhalb des benutzerdefinierten Ereignisses einen gesonderten Aufruf zum Neuzeichnen der Linie einfügen. Das können wir jedoch durch eine kaskadierende Ereignisbehandlung vermeiden.
Beachten Sie, dass wir im Ereignis „CHARTEVENT_OBJECT_CLICK“ nicht prüfen, ob ein Klick auf eine Preislinie erfolgt ist. Nun prüfen wir, ob auf das Verschiebeobjekt geklickt wurde. Verschwenden Sie also keine Zeit mit der Auswahl der Preislinie. Klicken Sie direkt auf die kleine Raute, die darauf erscheint. Auf diese Weise wird die Linie zusammen mit der Raute ausgewählt.
Eine weitere neue Funktion befindet sich speziell im Ereignis CHARTEVENT_MOUSE_MOVE. Bitte beachten Sie, dass nun in Zeile 140 eine neue Überprüfung durchgeführt wird. Damit soll sichergestellt werden, dass keine anderen Linien im Chart ausgewählt sind. Ist diese Bedingung erfüllt, wird ein Ereignis ausgelöst, das die aktuelle Auswahl aufhebt. Diese Umsetzung ist recht interessant, denn wenn eine Linie ausgewählt ist und Sie auf eine beliebige Stelle im Chart klicken, wird die Auswahl dieser Linie aufgehoben. Und wir müssen uns keine Gedanken darüber machen, welche Linie ausgewählt wird. Die Auswahl wird für alle Linien aufgehoben.
Gut, mit dem, was ich Ihnen gerade gezeigt habe, können Sie zwar eine Preislinie auswählen oder hervorheben, aber darüber hinaus noch nichts Nützlicheres tun. Lassen Sie uns einen Moment darüber nachdenken. Ich versichere Ihnen, das wird sehr interessant.
Wenn Sie sich den obigen Code ansehen und die Erklärung zu seiner Funktionsweise lesen, können Sie dann eine einfache und schnelle Möglichkeit vorschlagen, diese Preislinien zu verschieben? Es spielt keine Rolle, ob der Handelsserver dies akzeptiert oder nicht. Ich möchte nur, dass Sie mir sagen, ob sich die Linien mit dem verschieben lassen, was wir gerade implementiert haben. Denken Sie daran, dass wir dem System Code hinzufügen müssen, damit dies möglich wird. Die Frage ist, ob wir das mit möglichst wenig Code schaffen können. Ich habe keine Lust, viel Code zu schreiben. Ist das also möglich oder nicht?
Wenn Sie mit „NEIN“ geantwortet haben, verstehen Sie möglicherweise noch nicht ganz, wie das alles funktioniert. Sie werden wahrscheinlich denken, dass das nicht möglich ist, ohne sich etwas Zeit zum Nachdenken zu nehmen, aber wir schaffen das. Natürlich nur unter der Voraussetzung, dass wir unserem Hauptsystem noch ein wenig mehr Code hinzufügen. Zur Erinnerung: In früheren Artikeln haben wir bereits zwei neue Nachrichten zum System hinzugefügt. Allerdings waren diese Nachrichten zu diesem Zeitpunkt noch nicht im Code implementiert, da dies damals nicht praktikabel war. Nun haben wir jedoch eine einfache und schnelle Möglichkeit, Preislinien auszuwählen. Somit können wir dieses Nachrichtensystem nutzen und implementieren. Bevor wir damit anfangen, möchte ich erklären, was wir vorhaben. Auf diese Weise können Sie die Umsetzung der Lösung nachvollziehen oder sich ein Bild davon machen, noch bevor Sie sie tatsächlich sehen.
Wenn Sie die Header-Datei „C_ElementsTrade.mqh“ durch den Code ersetzen, den wir zu Beginn dieses Themas besprochen haben, werden Sie feststellen, dass die Auswahl der Linie aufgehoben wird, wenn Sie eine Preislinie auswählen und anschließend auf einen Punkt klicken. Genau das ist die Idee. Wenn wir den Positionsindikator anweisen, die Auswahl der Preislinie aufzuheben, muss er eine Nachricht an den Expert Advisor senden, die angibt, dass die ausgewählte Linie an eine neue Position verschoben werden soll. Diese neue Position entspricht genau der Stelle, an der mit der Maus geklickt wird. Verstehen Sie es jetzt?
Dennoch ist die Idee noch nicht ausgereift. Aber darüber machen wir uns jetzt erst einmal keine Gedanken; wir machen einfach das, was ich gesagt habe: Sobald eine Preislinie ausgewählt ist und wir auf einen anderen Punkt klicken, sollte sich diese Linie zu diesem Punkt verschieben. Dies lässt sich erreichen, indem man den Code der Prozedur „DispatchMessage“ wie folgt ändert:
138. case CHARTEVENT_MOUSE_MOVE: 139. m_Info.bClick = (CheckClick(C_Mouse::eClickLeft) ? true : m_Info.bClick); 140. if (m_Info.bClick && (m_Info.weight > 1)) 141. { 142. switch (m_Info.ev) 143. { 144. case evMsgCloseTakeProfit: 145. EventChartCustom(0, evMsgNewTakeProfit, m_Info.ticket, GetPositionsMouse().Position.Price, PositionGetString(POSITION_SYMBOL)); 146. break; 147. case evMsgCloseStopLoss: 148. EventChartCustom(0, evMsgNewStopLoss, m_Info.ticket, GetPositionsMouse().Position.Price, PositionGetString(POSITION_SYMBOL)); 149. break; 150. } 151. EventChartCustom(0, evMsgSetFocus, 0, 0, ""); 152. } 153. break;
Ausschnitt aus der Datei „C_ElementsTrade.mqh“
Sehen Sie sich an, was hier passiert ist. Wenn Sie dieses Codefragment zur Klasse „C_ElementsTrade“ hinzufügen, können Sie die Take-Profit- und Stop-Loss-Linien mit dem Mauszeiger verschieben. Werfen Sie jedoch einen Blick auf die folgenden Details. Wir verschieben keine Linien oder zugehörigen Objekte; wir halten uns genau an den Plan. Mit anderen Worten: Die Linie wird über das Verschiebeobjekt markiert. Bewegen Sie den Mauszeiger an eine neue Position und klicken Sie erneut. In diesem Fall sollte die Überprüfung in Zeile 140 schließlich durchgeführt werden.
Daraufhin wird in Zeile 142 das entsprechende Ereignis ausgewählt. Wurde die Take-Profit-Linie ausgewählt, kann das Ereignis in Zeile 145 ausgelöst werden; bei der Stop-Loss-Linie das Ereignis in Zeile 148. Beachten Sie, dass die an MetaTrader 5 gesendete Nachricht praktisch identisch sein wird. Sie unterscheidet sich jedoch in ihrem zweiten Parameter.
Diese Nachricht wird von MetaTrader 5 an den Chart weitergeleitet, auf dem der Indikator geladen ist, und vom Expert Advisor abgefangen. Im Code der Klasse „C_Orders“, die Teil des Expert Advisors ist, wird diese Nachricht als Aufforderung interpretiert, die Position einer Preislinie zu ändern, unabhängig davon, ob es sich um die Stop-Loss-Linie oder die Take-Profit-Linie handelt. Sobald der Server das Ergebnis unserer Anfrage zurückgibt, sendet der Expert Advisor eine weitere Nachricht, die vom Positionsindikator abgefangen wird. Daraufhin zeigt dieser die neue Position der Preislinie an. Auf diese Weise wissen wir jedes Mal, wenn wir uns den Chart ansehen, genau, wo sich die Linien auf dem Server befinden. Das liegt daran, dass wir stets genau das wiedergeben, was sich auf dem Server befindet. So können wir Linien ganz einfach und mit möglichst wenig Code verschieben.
Dieses System, das wir gerade implementiert haben, funktioniert so gut, dass Sie sogar die in MetaTrader 5 verfügbare Trailing-Stop-Funktion nutzen können, um die Stop-Loss-Linie zu verschieben – dieser Positionsindikator folgt ihr dabei und bleibt stets mit den Daten auf dem Handelsserver synchron.
Obwohl dieses System äußerst gut funktioniert, haben wir ein weiteres Problem noch nicht gelöst. Das Problem ist Folgendes: Wie können wir Take-Profit- oder Stop-Loss-Linien erstellen, wenn diese vom Server und damit auch aus dem Chart entfernt wurden? Okay, das scheint viel schwieriger zu sein. Aber folgen Sie einfach unserer Erklärung, und Sie werden sehen, dass es genauso einfach ist wie das, was wir gerade gemacht haben. Um die Themen voneinander zu trennen und Verwirrung zu vermeiden, wenden wir uns nun einem neuen Thema zu.
Ohne Stop-Loss- und Take-Profit-Linien. Wie können wir sie erneut platzieren?
Nun haben wir ein etwas anderes Problem. Das Problem ist Folgendes: Nehmen wir an, wir entfernen die Stop-Loss- und Take-Profit-Werte auf dem Server, beschließen aber nach einer Weile, sie wieder einzurichten. Dafür gibt es mehrere Möglichkeiten. An dieser Stelle möchte ich Ihnen jedoch zeigen, wie Sie den Positionsindikator so anpassen können, dass Sie Stop Loss oder Take Profit wieder direkt im Chart festlegen können.
Dazu müssen wir den Indikator ein wenig anpassen. Das liegt daran, dass der Indikator, wenn Stop Loss oder Take Profit aus einer Position entfernt werden, auch die Elemente entfernt, die den Stop-Loss- bzw. Take-Profit-Linien entsprechen. Genau dieses Verhalten müssen wir ändern. Auf diese Weise können wir denselben Mechanismus nutzen, den wir im vorherigen Abschnitt besprochen haben. Das heißt, klicken Sie auf eines der Elemente, sei es Stop Loss oder Take Profit. Bewegen Sie den Mauszeiger an die gewünschte Stelle und klicken Sie erneut. Dadurch ändert sich das Preisniveau, auf dem die Position geschlossen wird. Das ist der Kerngedanke.
Aber wie lässt sich das ganz einfach bewerkstelligen? Vielleicht ist Ihnen eine ziemlich verrückte Lösung eingefallen. Ich weiß nicht, ob dies einfacher oder schwieriger sein wird als die vorgeschlagene Lösung, aber wie schon im vorherigen Thema geht es darum, so wenige Änderungen wie möglich am Code vorzunehmen.
Na gut, machen wir noch einmal eine Pause und denken wir einen Moment darüber nach: Was wäre die einfachste Lösung für unser Problem? Da wir dasselbe Modell verwenden möchten, das wir im vorherigen Abschnitt besprochen haben, wäre die einfachste Lösung, das Verschiebeobjekt der Preislinie auf dem Chart zu belassen. Wenn Sie daran gedacht haben, dann haben Sie genauso gedacht wie ich. Aber wo können wir das Objekt platzieren, wenn es keine Preislinie gibt, sei es eine Take-Profit- oder eine Stop-Loss-Linie? Na gut, in diesem Fall wäre es meiner Meinung nach am besten, das Verschiebeobjekt direkt auf der Linie zu platzieren, auf der die Position eröffnet wurde. Ich weiß nicht, ob Sie diese Meinung teilen, lieber Leser. Es steht Ihnen frei, zu denken, was Sie wollen – vorausgesetzt natürlich, Sie wissen, was Sie tun.
Machen wir es doch so. Wenn eine Stop-Loss- oder Take-Profit-Linie einer Position entfernt wird, wird die Schaltfläche zum Verschieben neben der Linie des Eröffnungspreises platziert. Aber jetzt haben wir ein Problem. Wird diese Linie gelöscht, löscht der Positionsindikator auch die damit verbundenen Objekte. Wir wollen unseren Code nicht noch komplizierter machen, also schauen wir uns einmal an, an welcher Stelle im Code der Indikator diese Objekte löscht. Dies wird im folgenden Codeausschnitt veranschaulicht.
45. //+------------------------------------------------------------------+ 46. void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam) 47. { 48. double value; 49. 50. if (Open != NULL) (*Open).DispatchMessage(id, lparam, dparam, sparam); 51. if (Take != NULL) (*Take).DispatchMessage(id, lparam, dparam, sparam); 52. if (Stop != NULL) (*Stop).DispatchMessage(id, lparam, dparam, sparam); 53. switch (id) 54. { 55. case CHARTEVENT_CUSTOM + evUpdate_Position: 56. if (lparam != m_Infos.ticket) return; 57. if (!PositionSelectByTicket(m_Infos.ticket)) 58. { 59. ChartIndicatorDelete(0, 0, m_Infos.szShortName); 60. return; 61. }; 62. if (Open == NULL) Open = new C_ElementsTrade(m_Infos.ticket, evMsgClosePositionEA, clrRoyalBlue, ePriorityNull, StringFormat("%I64u : Position opening price.", m_Infos.ticket)); 63. if (Take == NULL) Take = new C_ElementsTrade(m_Infos.ticket, evMsgCloseTakeProfit, clrForestGreen, ePriorityDefault, StringFormat("%I64u : Take Profit price.", m_Infos.ticket)); 64. if (Stop == NULL) Stop = new C_ElementsTrade(m_Infos.ticket, evMsgCloseStopLoss, clrFireBrick, ePriorityDefault, StringFormat("%I64u : Stop Loss price.", m_Infos.ticket)); 65. (*Open).UpdatePrice(PositionGetDouble(POSITION_PRICE_OPEN)); 66. if ((value = PositionGetDouble(POSITION_TP)) > 0) (*Take).UpdatePrice(value); else 67. { 68. delete Take; 69. Take = NULL; 70. } 71. if ((value = PositionGetDouble(POSITION_SL)) > 0) (*Stop).UpdatePrice(value); else 72. { 73. delete Stop; 74. Stop = NULL; 75. } 76. break; 77. } 78. ChartRedraw(); 79. } 80. //+------------------------------------------------------------------+
Ausschnitt aus der Datei „C_IndicatorPosition.mqh“
Dieser Codeausschnitt ist Teil der Klasse „C_IndicatorPosition“. Dies ist der Quellcode für diese Klasse. Werfen wir nun einen Blick auf die folgenden Punkte. In den Zeilen 66 und 71 befinden sich zwei Prüfungen: eine für Take Profit und die andere für Stop Loss. Passen Sie jetzt gut auf, damit Sie verstehen, was wir tun müssen. Diese Prüfungen teilen dem Positionsindikator mit, dass wir die Zeiger auf die Klasse „C_ElementsTrade“ entfernen müssen. Dies geschieht, wenn der Positionswert null oder kleiner ist. Ich denke, Sie haben alles bestens verstanden.
An dieser Stelle müssen wir den Code jedoch anpassen. Lassen Sie uns einen Moment darüber nachdenken. Wenn wir, anstatt den Zeiger auf die Klasse „C_ElementsTrade“ zu entfernen, die Werte der Take-Profit- und Stop-Loss-Linien an diese Klasse übergeben, können wir einen Mechanismus schaffen, mit dem wir das Gewünschte erreichen. In diesem Fall muss genau dieser Codeausschnitt angepasst werden, um den angegebenen Mechanismus zu implementieren. Diese Änderung ist im Folgenden dargestellt:
45. //+------------------------------------------------------------------+ 46. void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam) 47. { 48. double value; 49. 50. if (Open != NULL) (*Open).DispatchMessage(id, lparam, dparam, sparam); 51. if (Take != NULL) (*Take).DispatchMessage(id, lparam, dparam, sparam); 52. if (Stop != NULL) (*Stop).DispatchMessage(id, lparam, dparam, sparam); 53. switch (id) 54. { 55. case CHARTEVENT_CUSTOM + evUpdate_Position: 56. if (lparam != m_Infos.ticket) return; 57. if (!PositionSelectByTicket(m_Infos.ticket)) 58. { 59. ChartIndicatorDelete(0, 0, m_Infos.szShortName); 60. return; 61. }; 62. if (Open == NULL) Open = new C_ElementsTrade(m_Infos.ticket, evMsgClosePositionEA, clrRoyalBlue, ePriorityNull, StringFormat("%I64u : Position opening price.", m_Infos.ticket)); 63. if (Take == NULL) Take = new C_ElementsTrade(m_Infos.ticket, evMsgCloseTakeProfit, clrForestGreen, ePriorityDefault, StringFormat("%I64u : Take Profit price.", m_Infos.ticket)); 64. if (Stop == NULL) Stop = new C_ElementsTrade(m_Infos.ticket, evMsgCloseStopLoss, clrFireBrick, ePriorityDefault, StringFormat("%I64u : Stop Loss price.", m_Infos.ticket)); 65. (*Open).UpdatePrice(0, value = PositionGetDouble(POSITION_PRICE_OPEN)); 66. (*Take).UpdatePrice(value, PositionGetDouble(POSITION_TP)); 67. (*Stop).UpdatePrice(value, PositionGetDouble(POSITION_SL)); 68. break; 69. } 70. ChartRedraw(); 71. } 72. //+------------------------------------------------------------------+
Ausschnitt aus der Datei „C_IndicatorPosition.mqh“
Beachten Sie, dass der Code praktisch unverändert geblieben ist. Wir haben jedoch die bisher durchgeführten Prüfungen deaktiviert. Der jeweilige Wert für Stop Loss oder Take Profit wird nun unabhängig von seiner Höhe an die Klasse „C_ElementsTrade“ übergeben. Dadurch können wir die Preislinienobjekte ordnungsgemäß verwalten.
Super, schauen wir uns nun den Code in der Klasse „C_ElementsTrade“ an. Der Quellcode ist im folgenden Ausschnitt dargestellt:
095. //+------------------------------------------------------------------+ 096. inline void UpdatePrice(const double price) 097. { 098. m_Info.price = price; 099. UpdateViewPort(); 100. } 101. //+------------------------------------------------------------------+
Ausschnitt aus der Datei „C_ElementsTrade.mqh“
Wenden wir uns nun dem vorherigen Codeausschnitt zu – hier spielt sich das Wesentliche ab. Beachten Sie jedoch, dass wir ursprünglich davon ausgegangen waren, nur einen Parameter zu erhalten. In den Änderungen an der Klasse „C_IndicatorPosition“ ist jedoch zu erkennen, dass zwei Parameter an diese Prozedur übergeben werden. Das wird die erste Änderung sein. Bevor wir uns jedoch damit befassen, wie der Code aussehen sollte, wollen wir noch ein paar weitere Details zusammenstellen. Okay, das erste Argument gibt die Position der Eröffnungspreislinie an. Das zweite Argument ist der Preis der zu erstellenden Linie.
Denken Sie doch mal einen Moment darüber nach. Wir müssen lediglich die überflüssigen Objekte entfernen, in diesem Fall das Objekt, das die Preislinie darstellt, und die Schließen-Schaltfläche, während die Schaltfläche zum Verschieben erhalten bleibt. Dieses Verschiebeobjekt wird jedoch an eine neue Position verschoben. Diese neue Position entspricht dem Eröffnungspreis der Position. Daher ist es am einfachsten, diese Änderung vorzunehmen, indem man den vorherigen Codeausschnitt so anpasst, dass er wie im folgenden Beispiel aussieht:
095. //+------------------------------------------------------------------+ 096. inline void UpdatePrice(const double open, const double price) 097. { 098. m_Info.price = (price > 0 ? price : open); 099. if (price == 0) 100. { 101. ObjectDelete(0, def_NameBtnClose); 102. ObjectDelete(0, def_NameHLine); 103. } 104. UpdateViewPort(); 105. } 106. //+------------------------------------------------------------------+
Ausschnitt aus der Datei „C_ElementsTrade.mqh“
Mit diesem Codeausschnitt würde unser Positionsindikator zwar ordnungsgemäß funktionieren, allerdings gibt es dabei einen kleinen Nachteil. Beachten Sie: Wenn der Trader die Stop-Loss- oder Take-Profit-Linie einer offenen Position entfernt, entfernt der Positionsindikator auch die horizontale Linie und die Schließen-Schaltfläche. Das liegt an den Zeilen 101 und 102 des vorherigen Codeausschnitts. Wenn der Trader jedoch eine Änderung der Position der Stop-Loss- oder Take-Profit-Linie bei einer offenen Position anfordert, wird nur die Schaltfläche „Verschieben“ korrekt verschoben. Die übrigen Objekte werden aus der Objektliste entfernt. Sie werden unter keinen Umständen im Chart erscheinen. Das Ergebnis ist in der folgenden Abbildung dargestellt:

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

Beachten Sie, dass das System nun einwandfrei funktioniert, genau wie erwartet. Da der Code einige Änderungen erfahren hat – von denen viele nur sehr geringfügig sind –, besteht keine Notwendigkeit, diese gesondert hervorzuheben. Ich möchte Sie jedoch, lieber Leser, bitten, zwei Punkte in diesem Code besonders zu beachten. Der erste Punkt ist der Konstruktor. Beachten Sie, dass er sich geringfügig von der vorherigen Version unterscheidet. Die zweite Prozedur heißt „UpdatePrice“. Beachten Sie, dass sich die Prozeduren zur Objekterstellung, die zuvor im Konstruktor enthalten waren, nun in dieser Prozedur befinden. Da der Code recht einfach ist, besteht kein Grund, näher darauf einzugehen. Im Grunde wurde lediglich das, was zuvor im Konstruktor ausgeführt wurde, entfernt und in diese Prozedur verschoben. Nichts Besonderes.
Ich möchte Sie jedoch bitten, sich auf etwas anderes zu konzentrieren – nämlich auf die obige Animation. Antworten Sie mir ehrlich. Wenn Sie als Trader versuchen würden, das System zu nutzen, das wir gerade implementiert haben, würden Sie dann beim Anpassen der Take-Profit- oder Stop-Loss-Niveaus zögern? Wissen Sie, ob Sie die Linie mit dem Mauszeiger zu einem höheren oder niedrigeren Preis verschieben müssen, um die Preislinie erneut auf dem Server zu platzieren? Vielleicht war die letzte Frage nicht klar genug formuliert. Versuchen wir, die Situation ein wenig zu klären, damit Sie verstehen, welches Problem wir noch lösen müssen.
Schon beim Betrachten der Animation wird deutlich, dass wir eine Short-Position halten. Das liegt daran, dass die Take-Profit-Linie unter dem Eröffnungspreis der Position liegt. Gut, aber nehmen wir einmal an, Sie hätten als Trader beide Linien aus dem Chart entfernt. Oder, genauer gesagt, dass Sie sie aus der auf dem Server gespeicherten Position entfernt haben. Wenn Sie in diesem Fall dieselbe Animation betrachten und sich ausschließlich auf den Positionsindikator konzentrieren würden, könnten Sie nicht erkennen, ob es sich um eine Short- oder eine Long-Position handelt. Das ist der erste Punkt.
Der zweite Punkt ist folgender: Wenn wir verkauft haben und die Take-Profit- und Stop-Loss-Werte für die Position nicht festgelegt sind – sich also beide Objekte, mit denen die Preislinie verschoben werden kann, am Eröffnungspreis befinden –, wie könnten Sie dann allein anhand des Charts feststellen, ob die Stop-Loss-Linie über oder unter dem aktuellen Preis platziert werden sollte? Das ist eine schwer zu beantwortende Frage, nicht wahr? Wir haben jedoch eine recht einfache Lösung für dieses Problem. Wie Sie sehen können, greifen wir in der Klasse „C_ElementsTrade“ zu keinem Zeitpunkt auf die Positionsdaten zu. Die Daten stammen aus der Klasse „C_IndicatorPosition“. Und ich möchte die Klasse „C_ElementsTrade“ nicht mit Daten überladen, die ich später wieder daraus entfernen müsste. Das liegt daran, dass wir diese Klasse auch bei der Arbeit mit ausstehenden Orders verwenden werden. Also müssen wir uns noch ein bisschen mehr Mühe geben. Darauf werden wir im nächsten Artikel eingehen.
Abschließende Gedanken
In diesem Artikel habe ich Ihnen gezeigt, wie Sie den Positionsindikator so anpassen können, dass er mit minimalem Aufwand viel mehr Aktionen ausführen kann als ursprünglich möglich. Wir haben gesehen, wie sich die Möglichkeit implementieren lässt, Preisniveaus zu verschieben und Preislinien direkt im Chart zu erstellen. Vielen mag das schwierig erscheinen. Wie Sie vielleicht bemerkt haben, haben wir das alles jedoch ganz einfach und mit minimalem Aufwand erledigt. Man musste nur einen Moment innehalten und nachdenken.
Genau das ist der Zweck dieser Artikelserie. Ich bin nicht hier, um Ihnen beizubringen, wie man Anwendungen entwickelt. Das Programmierenlernen wird jedoch viel interessanter, wenn wir erkennen, dass wir etwas Neues erschaffen. Ich hoffe, dass Sie den Zweck dieser Artikel verstehen und dass sie Ihnen eine solide theoretische Grundlage bieten und Sie zum Weiterlernen motivieren. Schließlich gibt es keine unlösbaren Probleme; es gibt nur Menschen, die keine einfache Lösung für komplexe Probleme erkennen können.
| Datei | Beschreibung |
|---|---|
| Experts\Expert Advisor.mq5 | Zeigt die Interaktion zwischen Chart Trade und dem Expert Advisor im Chart an. (Für diese Interaktion ist Mouse Study erforderlich.) |
| Indicators\Chart Trade.mq5 | Erstellt ein Fenster zur Konfiguration der zu sendenden Order. (Für diese Interaktion ist „Mouse Study“ erforderlich.) |
| Indicators\Market Replay.mq5 | Erstellt Steuerelemente für die Interaktion mit dem Dienst zur Marktwiedergabe und Marktsimulation. (Für die Interaktion ist Mouse Study erforderlich.) |
| Indicators\Mouse Study.mq5 | Ermöglicht die Interaktion mit grafischen Steuerelementen und mit dem Benutzer. (Dies ist sowohl für das System zur Marktwiedergabe und Marktsimulation als auch für den Live-Handel erforderlich.) |
| Indicators\Order Indicator.mq5 | Ist für die Anzeige von Marktorders zuständig und ermöglicht es den Benutzern, mit diesen zu interagieren und sie zu verwalten. |
| Indicators\Position View.mq5 | Ist für die Anzeige von Marktpositionen zuständig und ermöglicht es den Benutzern, mit diesen zu interagieren und sie zu steuern. |
| Services\Market Replay.mq5 | Erstellt und verwaltet den Dienst zur Marktwiedergabe und Marktsimulation. (Hauptdatei des Systems) |
Übersetzt aus dem Portugiesischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/pt/articles/13295
Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.
Dieser Artikel wurde von einem Nutzer der Website verfasst und gibt dessen persönliche Meinung wieder. MetaQuotes Ltd übernimmt keine Verantwortung für die Richtigkeit der dargestellten Informationen oder für Folgen, die sich aus der Anwendung der beschriebenen Lösungen, Strategien oder Empfehlungen ergeben.